Freek.dev

“Don’t Repeat Yourself” was never about code. It’s about knowledge. It’s about cohesion. If two pieces of code represent the exact same knowledge, they will always change together. Having to change them both is risky: you might forget one of them. On the other hand, if two identical pieces of code represent different knowledge, they will change independently. De-duplicating them introduces risk, because changing the knowledge for one object, might accidentally change it for the other object.

The full article contains a nice code example to help you understand the theory:

http://verraes.net/2014/08/dry-is-about-knowledge/

Read more

As software developers we tend to look at things from our own perspective. Assuming everyone else will see it the same way. I’ve spent all this time developing but I didn’t take those extra few minutes to really polish the marketing text. This is the big mistake. I know you are thinking it’s open source, do I really need marketing? Without a doubt yes you do!

http://ericlbarnes.com/open-source-marketing-tips/

Read more

A curated list of amazingly awesome PHP libraries, resources and shiny things.

http://getawesomeness.com/get/php

An epic list indeed!

Read more

Coolblue is a company that sells customer electronics. They are located in The Netherlands. Matthias Noback visited the company earlier this week and wrote an interesting article on the developer culture at the company. There are too many good bits to give you a single quote. Read the entire article on Matthias' blog:

http://php-and-symfony.matthiasnoback.nl/2015/07/behind-the-scenes-at-coolblue/

Read more

Davey Shafik cleary explains the new exception hierarchy in PHP 7.

With PHP 7 errors and exceptions are undergoing major changes. For the first time, the PHP engine will start to emit exceptions instead of standard PHP errors for (previously) fatal, and catchable fatal errors. This means that we can now handle them much more gracefully with `try... catch`.

http://daveyshafik.com/archives/69237-an-exceptional-change-in-php-7-0.html

Read more

Over at the Google Research blog there's an interesting article on how neural networks can be abused to generate very psychedelic images.

The results are intriguing—even a relatively simple neural network can be used to over-interpret an image, just like as children we enjoyed watching clouds and interpreting the random shapes. This network was trained mostly on images of animals, so naturally it tends to interpret shapes as animals. But because the data is stored at such a high abstraction, the results are an interesting remix of these learned features.

Realmac has developed an OSX app to tinker with the technology. You can download a trail version on their website. Here's my current Twitter avatar processed by the "animals" preset:

Read more

Hannes Van de Vreken has written a tutorial on how to display stream progress in PHP.

Opposite to HTTP requests, tasks run from the command line aren’t supposed to return instantly. They can take a very long time. Imagine a task that loops an entire database table or a task that references an external source repetitively, or maybe a taks that performs a large file transfer. It’s very important to show the issuer what is actually going on, or he/she will be left in the dark for minutes/hours. "Is this task still running?", "How long has this thing been running yet?", "Is it almost done?", "Is it running out of memory?"

https://hannesvdvreken.com/2015/05/12/stream-progress/

Read more

If you want to be a better sysadmin, try to be a dev. If you want to be a better dev, try to be a sysadmin.

...

Just understand that you're probably better off focussing on one area and keeping the other as a hobby. It's extremely hard to master both. Make sure you master one and play around with the other.

https://ma.ttias.be/the-worst-possible-devops-advice/

Read more

If you're into Laravel, I recommend taking a look at Laravel Daily. The idea behind the site is that you get one Laravel tip a day. I like the short and sweet format and have already learned a lot.

Read more

I've been enums lately instead of relying on class constants. The myclabs/php-enum package provides a nice implementation. The readme lists the benefits of doing so:

Using an enum instead of class constants provides the following advantages:

• You can type-hint: `function setAction(Action $action) {`
• You can enrich the enum with methods (e.g. `format`, `parse`, …)
• You can extend the enum to add new values (make your enum `final` to prevent it)
• You can get a list of all the possible values (see below)

This Enum class is not intended to replace class constants, but only to be used when it makes sense.

Check it out: https://github.com/myclabs/php-enum

 

Read more

One of the really great things about ORM’s that implement the Active Recordpattern like Eloquent is, they are really easy and really intuitive to use.

With Active Record, you basically just have an object that you can manipulate and then save. Calling save() on the object updates the database, and all of the magic persistence happens behind the scenes.

Having the business logic of the object and the persistence logic of the database tied together definitely makes working with an Active Record ORM easier to pick up.

In this tutorial I want to explore exactly how Doctrine 2, an ORM that implements the Data Mapper pattern, is different to Eloquent.

http://culttt.com/2014/07/07/doctrine-2-different-eloquent/

Read more

Here's a little tip you might find usefull. If you have something in a clipboard that needs sorting, issue this command on the commandline.

pbpaste | sort | pbcopy

When you paste your clipboard somewhere you'll see the contents was sorted.

Read more

A typical request on an dynamic PHP site can do a lot of things. It's highly likely that a bunch database queries are performed. On complex pages executing those queries and hydrating them can slow a site down.

The response time can be improved by caching the entire response. The idea is that when a user visits a certain page the app stores the rendered page. When a second request to the page is made, the app shouldn't bother with rendering the page from scratch but just serve the saved response.

I've made a Laravel package named "laravel-responsecache" that does just that. Installing it is very easy: just add the service provider and facade to the app's configuration. And step two is... there is no step two. In most cases you're done. All successful responses (that is a response with a statuscode in the 200 or 300 range) to a GET-requests will now be cached for a week. If the response of a specific route or controller should never be cached middleware can be added that prevents caching. Furthermore each logged in user will have have it's own separate cache. Cached responses can be stored in any configured repository in Laravel. You could easily share a cache between servers by using memcached.

I think that behaviour will suit a lot of use cases. If you need some other caching behaviour (eg. cache error responses, exempting redirects, using a common cache for users with the same role, changing the expiration time of the cache) you can easily write a custom caching profile.

The package isn't supposed to sweep performance troubles under the rug. All apps should be optimized so that they'll respond in an acceptable timeframe without using response caching. My rule of thumb is that typical pages in a cms should be able to render within a second (and preferably much less). Anything above that is unacceptable. That number is by no means scientific. Make up your own mind what an acceptable responsetime should be. Of course all of this depends on the type of site and the amount of visitors it has to handle. Also keep in mind that that there are a lot of other aspects that need to be considered when trying to deliver a speedy experience.

There are some great alternatives to cache responses. Two well known solutions are Varnish and Nginx caching. They take response caching one step further by not even invoking php when serving a cached request. Both options are very robust and can work on any scale. The benefits the Laravel package has over Varnish-like solutions is that it is easier to set up and that application logic can be used to determine what needs to be cached.

If you're interested in speeding up your Laravel app using the package, go take a look at it on GitHub:

https://github.com/spatie/laravel-responsecache

Read more