Looking for more information on how to do PHP the right way? Check out PHP: The Right Way

Matt Sparks:
Building a PHP Framework Series (Parts 1-4)
May 16, 2018 @ 12:50:42

On this site Matt Sparks has posted the first few parts of a series covering the creation of a custom framework. Why? Well, as he explains in part one of the series:

So with all of that being said, it begs the question: why on Earth would you want to do this?

The extremely short answer: I want to. The less short answer: A PHP framework encompasses many of the areas I want to learn more about.

The first four posts of the series are already on his site (with more to come):

Matt does a great job of laying out some of the fundamentals behind frameworks including structure, design patterns, and commonalities between frameworks. You can follow along with his progress on the project on the AnalyzePHP GitHub repositories.

tagged: build framework tutorial series part1 part2 part3 part4

Link: https://developmentmatt.com/building-a-php-framework-part-4-the-foundation/

StarTutorial.com:
Understanding Design Patterns - Template Method
May 15, 2018 @ 13:07:06

The StarTutorial.com site has continued their series covering common design patterns and their implementation in PHP. In their latest article they cover the Template Method pattern.

[This pattern] defines the skeleton of an algorithm in a method, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.

In their example, they have two workers that have different schedules but with one difference. Instead of having implementations that differ widely between the two workers (represented by classes) they refactor the main class and allow for a doWork method to be defined in the child. This makes the parent class a sort of "template" for handling the processing with the child filling in the blanks.

tagged: designpattern tutorial template method series

Link: https://www.startutorial.com/articles/view/understanding-design-patterns-template-method

Delicious Brains:
WordPress Deployment Part 1: Preparing WordPress
May 09, 2018 @ 11:05:12

The Delicious Brains blog has kicked off a new series of posts walking you through the deployment of a WordPress site with automated (and repeatable) deployments.

Welcome to the first post in a workflow series on deploying WordPress. In this series, we’re going to look at how you can set up automated deployments for your WordPress site in a range of different ways.

They start off by answering the question of "why" for automated deployments. They make the point that automated deployments can help reduce the potential for human error, increase the reliability of the deployments and have many more benefits. Next they start in on the preparation work, helping you get several prerequisites set up before getting to the deployment process:

  • Setting up the site on an accessible Git repository and having plugins/dependencies managed by Composer
  • Deploying configuration files
  • Disable FTP Access & File Editing
  • Disable Auto Updates

The post also includes a section covering the deployment of the database for your application and any other media you might have related to it (images, files, etc).

tagged: wordpress deployment series part1 preparation

Link: https://deliciousbrains.com/wordpress-deployment-workflow-preparing/

Laravel News:
Laracasts: What’s New in Laravel 5.6
May 02, 2018 @ 11:54:59

On the Laravel News site they've posted information about a series of videos on the Laracasts site covering what's new in Laravel 5.6.

Laravel 5.6 has been for a few weeks now and it includes a few nice new features like Broadcast Channel Classes, Collision Reporting, Improved Logging, and more.

In order to get you up to speed on all these new features, Laracasts has started a new free series, “What’s new in Laravel 5.6” that will go through each major feature of this release.

The series includes videos covering how they upgraded the Laracasts' codebase to 5.6, collision reporting, logging improvements and dynamic rate limiting. More videos will be added to the series as it goes along. You can check out the current listing of videos on the Laracasts site.

tagged: laravel release feature laravel56 video laracast series

Link: https://laravel-news.com/laracasts-whats-new-in-laravel-5-6

Mark Baker:
Discharging Static #2
Apr 05, 2018 @ 10:22:09

Mark Baker continues his series looking at the use of static properties and methods in applications and how to test them. In this second part of the series he focuses more on some of the unintentional side-effects that could happen when you're trying to refactor them out.

In the first article in this series, I wrote about the problems with testing static methods in classes, and showed a few approaches that allow us to write mocks for statics. Testing classes where we have static properties is a lot harder to manage, because any changes made in any test to those properties are global, across the entire test suite, not simply the test that we are running. Static properties are part of the global state, and we can’t simply tearDown() those changes in the way that we do with instances — at least we cannot easily do so if the property has a visibility of private or protected.

He goes through an example of a refactor from a static property (essentially in the global scope) to a private property. He points out the issue of setting a static value in what seem to be separate child classes, the fact that it actually changes the base value, not the individual ones, leading to potentially unintended consequences.

His main recommendation is to avoid the use of static properties all together. Where that's no possible (like in a legacy project) he offers two potential solutions: either replace them with constants if they're never changed or changing them to instance properties.

tagged: static property series part2 refactor consequences testing

Link: https://markbakeruk.net/2018/04/03/discharging-static-2/

Auth0 Blog:
Symfony Tutorial: Building a Blog (Part 3)
Mar 27, 2018 @ 11:20:06

The Auth0 blog has posted the third part of their "Building a Blog" series of tutorials showing the use of their authentication technologies coupled with a Symfony framework backend. In this latest article author Greg Holmes shows how to deploy the application created in parts one and two to Heroku.

Symfony is a PHP framework as well as a set of reusable PHP components and libraries. It uses the Model-View-Controller design pattern and can be scaled to be used in any requirement. It aims to speed up the creation and maintenance of web applications, replacing repetitive code. In this part of the series, you will learn how to deploy the blog engine that you have created in the previous parts on Heroku. The final code can be found at this repository.

He starts with a bit of catching up, briefly covering the contents of the first two articles before getting into the main content of this third. He covers some of the basics of Heroku and Travis-CI before getting into the actual deployment flow. He then helps you set up a GitHub account (used as a source for the deployment), set up a local MySQL database for testing and the installation of a few required dependencies. Next is the installation of the Heroku and Travis-CI command line tools, the configuration for each and some basic setup steps for each service.

Finally, he gets back to the Symfony application, setting up a few additional options in the Composer configuration to create a few commands. These commands are then executed as a part of the deployment process. There's also changes to the Symfony configuration files to reference the environment rather than a local path in several locations. The post ends with the setup instructions on the Auth0 side to allow handling to work from the newly deployed Heroku instance.

tagged: auth0 blog symfony tutorial series part3 deploy heroku

Link: https://auth0.com/blog/symfony-tutorial-building-a-blog-part-3/

Christoph Rumpel:
Build a newsletter chatbot in PHP - Part 3
Mar 27, 2018 @ 10:57:24

Christoph Rumpel has continued his series covering the creation of a chatbot using the Botman package in a new post to his site. The latest post, part three in the series, builds on the base created in parts one and two and integrates the bot with his project website.

In part one and two we created a Facebook Messenger chatbot that let your users subscribe to your newsletter. We stored that information in the database and sent out our first newsletter. In the last third part, we integrate this bot to a website and write our first tests.

He then walks you through the process of using the Facebook Customer Chat Plugin to integrate it into the site (using the Facebook JavaScript SDK). He includes instructions on whitelisting your domain and including the plugin into the site's source using a few custom configuration options. With the integration complete he then takes a step back and shows the creation of several tests evaluating the fallback handling and subscription conversation responses.

tagged: chatbot tutorial series part3 integrate facebook testing fallback subscribe

Link: https://christoph-rumpel.com/2018/03/build-a-newsletter-chatbot-in-php-part-3

Pehapkari.cz:
Domain-Driven Design - Alternative Relational Database Mapping
Mar 21, 2018 @ 10:37:16

The Pehapkari.cz blog has continued their series covering domain-driven design with the latest post in the series showing some alternative relational database mapping techniques.

Do you think that multilingual text must always be in a separate database table? Than this article is for you!

We will show that not all arrays have to be mapped as database tables. And we will also show the Doctrine implementation.

The article starts with a bit of background on what they're trying to accomplish: adding internationalization functionality to an e-commerce application. In order to make it simpler to work with the multi-language requirements they show the abstraction of its handling out into a LangValue value object that's used to store the product name value for each language. They then use this and some JSON encoded data to store the different language strings in the database directly with the product record rather than a different table. It then shows how to create the matching Doctrine entity for the LangValueType to work with the serialized column data and extract data from it's JSON blob.

tagged: domaindrivendesign series part4 relational database mapping internationalization doctrine

Link: https://pehapkari.cz/blog/2018/03/21/domain-driven-design-alternative-mapping/

Sergey Zhuk:
Amp Promises: Using Router With ReactPHP Http Component
Mar 13, 2018 @ 09:25:37

Sergey Zhuk has a post on his site that covers using a Router with a ReactPHP component. This router lets you more easily direct the HTTP requests coming into the application to the correct piece of functionality.

Router defines the way your application responds to a client request to a specific endpoint which is defined by URI (or path) and a specific HTTP request method (GET, POST, etc.). With ReactPHP Http component we can create an asynchronous web server. But out of the box the component doesn’t provide any routing, so you should use third-party libraries in case you want to create a web-server with a routing system.

He starts with an example of manual routing, showing the code for a basic server and adding in handlers based on the path+HTTP verb to respond with different content. He expands this basic example out to a more "real world" situation of the usual CRUD handling for "tasks". The post then shows how to change things up and use the FastRoute routing package to remove the manual route definitions from the server and define them in the router instead. It can then dispatch these to the correct location more easily. The post finishes up showing an additional feature: how to use wildcards in these URL definitions.

tagged: reactphp server http router fastroute tutorial series

Link: http://sergeyzhuk.me/2018/03/13/using-router-with-reactphp-http/

Matthias Noback:
Mocking at architectural boundaries: the filesystem and randomness
Mar 06, 2018 @ 09:39:55

Matthias Noback has continued his series of posts covering mocking and testing at the "architectural boundaries" of your application. In this second post he offers two more suggestions of these "edges" where mocking could be useful: filesystem interfaces and randomness.

In a previous article, we discussed "persistence" and "time" as boundary concepts that need mocking by means of dependency inversion: define your own interface, then provide an implementation for it. There were three other topics left to cover: the filesystem, the network and randomness.

He starts with the mocking of the filesystem handling and makes the recommendation of using either vfsStreamor Flysystem to provide an interface that's more easily testable. These libraries abstract away the filesystem and make it easier to mock out the functionality rather than going directly to PHP's filesystem functions. His second example, randomness, is a bit tougher as the output isn't predictable. He still recommends abstracting it out, however, and offers suggestions as to what might be possible to test.

tagged: mocking boarder architecture filesystem randomness series part2

Link: https://matthiasnoback.nl/2018/03/mocking-the-filesystem-and-randomness/