Freek.dev

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

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

Sammy Kaye Powers wrote a post on how to contribute to the PHP documentation.

If you've been wanting to contribute to PHP internals, starting with the documentation can be a great entry point; especially because it doesn't require dusting off those old C books from college.

But knowing where to start can be tricky since information on how to contribute to the docs is scattered across the internet.

Phew! After reading this process my intentions of contributing melted away like snow in the sun. Editing the documentation should be much easier. I believe there would be more contributions if the docs would reside in a git-repo as markdown-files.

Read more

A short and very enjoyable read by Uncle Bob on singletons:

Do you recognize this: ``` public class X { private static X instance = null;

private X() {}

public static X instance() { if (instance == null) instance = new X(); return instance; }

// more methods... }

<em>Of course. That's the Singleton pattern from the GOF book. I've always heard we shouldn't use it.</em>

Why shouldn't we use it?

<em>Because it makes our systems hard to test.</em>

It does? Why is that?

....</blockquote>
You can read the whole conversation on <a href="http://blog.cleancoder.com/uncle-bob/2015/07/01/TheLittleSingleton.html">http://blog.cleancoder.com/uncle-bob/2015/07/01/TheLittleSingleton.html</a>

Read more

Mitchell van Wijngaarden and Shawn McCool gave a talk at the Dutch PHP Conference 2015 uncon track about naming things. Shawn afterwards decided to make a video. It's must-see if you're interested in improving the readability of your code.

Read more

It's very easy to port Laravel 5's way of handling environment files to Laravel 4.

You've got to require this package (it's that one that L5 uses): [code]composer require vlucas/phpdotenv```

And then you should update bootstrap/start.php:

...
$dotEnv = new Dotenv\Dotenv(__DIR__ . '/../');
$dotEnv->load();

$env = $app->detectEnvironment(function () {
    return getenv('APP_ENV') ?: 'production';
});
...

And boom, done! Now you can use an .env-file instead of .env.php.

Read more

If you're interested in some dark magic you should watch this talk by Marco Pivetta on Voodoo PHP. I really like these show-me-the-code type of talks.

We've often seen "magic" code, but how does it even work? Let's explore some arguably bad PHP coding techniques that are actually used in real world libraries to solve problems that would otherwise be a huge burden for all of us.

Read more

The sublime Laravel newsletter added a new section to spotlight a developer in a short interview. I had the honor of being the first interviewee.

https://laravel-news.com/2015/06/developer-spotlight-freek-van-der-herten/

Read more

While packages are great for re-use outside of frameworks, dependencies are still an issue. Namespaces resolve conflicts between classnames, but they do not offer a solution to package versioning. Especially in a framework-context, this can become very problematic. A real-world-example for this is Guzzle.

http://blog.frankdejonge.nl/packages-vs-components/

Read more

Mister community explains some shiny new features of PHP7 regarding errors and exceptions.

https://www.youtube.com/watch?v=nNezpSU9toQ

I'm really glad we won't have to work with the clumsy BaseException.

Read more

Christopher Pitt experimented a bit with generators and wrote down the thought process on his blog.

Generators are awesome. If they’re new to you then take some time to read where they come from and what they do. If you’ve come from a particular programming language background, they may be difficult for you to understand.

They were, and continue to be, tricky for me to grasp. So I’ve spent loads of time trying to understand them, and what they can do for my code.

https://medium.com/@assertchris/recursion-and-generators-d56f513ea6ab

Read more

PHP 7 has been slated for release in November of this year (2015). It comes with a number of new features, changes, and backwards compatibility breakages that are outlined below.

https://github.com/tpunt/PHP7-Reference

Read more

There are many ways to modify the behavior of existing code with actually changing the core logic. Some patterns you might be familiar with are the decorator pattern or the observer pattern. Both allow you to take another object and modify the behavior by wrapping your modifications around the original code. One pattern you might not be familiar with though, is the interceptor pattern.

The interceptor pattern is a core concept of what is called aspect oriented programming (AOP). AOP aims to improve the modularity of your code by allowing you to separate cross-cutting concerns from the rest of your code.

http://www.edzynda.com/aspect-oriented-php-and-the-interceptor-pattern/

Read more

Alan Klein created a Laravel 5.1 package that leverages Nginx HTTP Pushstream module to broadcast events. The commenting platform Disqus uses that Nginx module to handle comments in realtime.

You can find Alan's package on GitHub: https://github.com/cmosguy/laravel-http-pushstream-broadcaster

Read more