• PHP.net: Release of PHP 5.4.37, 5.5.21 & 5.6.5
• Community News: Latest PEAR Releases for 01.26.2015
• NetTuts.com: Design Patterns: The Decorator Pattern
• Site News: Popular Posts for the Week of 01.23.2015
• Coder on Code: Design Patterns in PHP: Adapters
• Zend Framework Blog: Announcing the Zend Framework 3 Roadmap
• Three Devs & A Maybe Podcast:Concurrency, Strict type-hinting and PHP 7 with Joe Watkins
• Paul Jones: MVC and ADR are User-Interface Patterns, Not Application Architectures
• NetTuts.com: Design Patterns: The Simple Factory Pattern
• Stephan Hochdörfer: Defining Phing Tasks in PSR-0 style

In the latest show from the Three Devs & A Maybe podcast hosts Michael Budd, Fraser Hart, Lewis Cains and Edd Mann talk about a wide range of topics with a focus on the SOLID development principles.

This week we have a three developer podcast with discussion on a host of topics. We kick off with how Fraser has enjoyed building his first bonus slot game, written entirely in JavaScript and HTML5. Preprocessors are a huge part of the JavaScript ecosystem at this time, with so many to choose from we discuss a couple of the more popular ones. This leads on to Photoshop discussion, ReactJS, the cool features present in ES6 and how you can use them today with transpilers. Following this we move on to the SOLID principles, the overuse of inheritance, technical debt and the concept of Over-DRY vs. Software Value. This then takes us on to a strange 'rubber duck' example Edd conjured up to help try and explain the Liskov substitution and Interface segregation principles. Finally, we discuss Edd's media server setup and how he has got it to a staged that he is finally happy with it.

Other topics include things like:

• Phaser - Desktop and Mobile HTML5 game framework
• Grunt
• Scotch.io
• Implementing Streams in PHP

You can listen to the latest show either through the in-page audio player or by downloading the mp3 of the episode. Also, be sure to subscribe to their feed of you enjoy the show!

The Seattle PHP User Group has decided to follow along with the example set by many other PHP user groups in the past several years. They have officially announced the Pacific Northwest PHP Conference and a Kickstarter campaign to help raise the funding to help make it a reality.

The Seattle PHP User Group (SeaPHP) has been around for over 10 years. We love PHP, and we want to build up our local PHP community even further by hosting a PHP developer conference here in Seattle-the technology hub of the Pacific Northwest and cloud computing capital of the world. We invite PHP developers everywhere, and of all skill levels, to come learn, network, and hack together with us in the Emerald City at the first Pacific Northwest PHP Conference (PNWPHP).

The goal of the campaign is to raise some of the initial funding needed to generate more interest for the event, presell tickets and even attract sponsors. The conference itself is planned for September 11th and 12th of 2015 there in Seattle, Washington at the Impact Hub coworking space. If you'd like more information about the conference and updates as they come along, be sure to subscribe to their mailing list and consider helping the PHP conference community grow and contribute today!

The Voices of the ElePHPant podcast has posted their latest episode in their interviews with members of the PHP community. In this latest show host Cal Evans talks with Jacob Mather, a co-organizer of the San Francisco PHP Meetup group.

They talk some about Jacob's more recent migration into the world of devops and what he enjoys about it. He talks about the work he does to make sure the developers don't have to worry as much about the environment. They also talk about his involvement in the SF.PHP user group and some of the exciting things they're doing.

You can listen to this latest episode either through the in-page audio player or by downloading the mp3 directly. If you enjoy the interview, be sure to subscribe to their feed.

As a part of his involvement in the PHP-FIG standards group, Matthew Weier O'Phinney has been contributing to the PSR-7 proposal. This proposal defines a standardized structure for HTTP message handling. In his latest post he gets into a bit more detail on what this means for the PHP developer and how it might be implemented.

PSR-7 is shaping up nicely. I pushed some updates earlier this week, and we tagged 0.6.0 of the http-message package last week for implementors and potential users to start coding against. I'm still hearing some grumbles both of "simplify!" and "not far enough!" so I'm writing this posts to demonstrate usage of the currently published interfaces, and to illustrate both the ease of use and the completeness and robustness they offer.

He starts with a base definition of what the proposal, well, proposes around HTTP messaging, both the incoming and outgoing. He describes the basic structure of an HTTP message and what each part represents. He talks about message headers, bodies and how the current library could return that content. He then looks at requests vs responses, server-side requests and some various uses cases and more practical examples:

• HTTP Clients
• Middleware
• Frameworks

With the PSR-7 standard in place, all of these different tools could have interchangeable interfaces for HTTP request/responses, easily swappable with any other implementation.

• atyagi/elasticache-laravel (1.1.3) Elasticache Drivers for Laravel Cache and Session
  
  
• bravo3/image-manager (1.1.3, 1.1.2) A PHP 5.4 library to control dynamic image assets in a cloud environment
  
  <

• James Fuller: Use @dataProvider to reduce duplication and improve the maintainability of your tests
• SitePoint PHP Blog: Sending Confirmation Emails with Phalcon and Swift
• Inviqa techPortal: Manage Project Dependencies with Bower and Composer
• Allan MacGregor: Design Patterns in PHP: Singletons
• Matthew Turland: How to be a Great Developer
• NetTuts.com: SOLID: Part 3 - Liskov Substitution & Interface Segregation Principles
• SitePoint PHP Blog: HHVM vs Zend Engine in PHP 6
• NetTuts.com: Setting Up a Local Mirror for Composer Packages With Satis
• Dutch Web Alliance: The definitive remote debug and unittest with PHPStorm guide: part 7
• SitePoint PHP Blog: Arbitrary Precision and Big Numbers in PHP
• Lorna Mitchell: GitHub-Powered Changelog Scripts
• PHP Town Hall: Episode 18: PHPDBG, HHVM and Internals
• php[architect]: January 2014 Issue Released - How to Be a Better Developer
• Community News: Packagist Latest Releases for 01.29.2014
• Matt Frost: Getting Talks Selected

The SitePoint PHP blog continues their "How to Build Your Own PHP Package" series with their latest post (part two of the series) covering the use of test-driven development while working on the package code.

In part 1, we set up our development environment, baked in some rules as inherited from The League, and created two sample but useless classes - Diffbot and DiffbotException. In this part, we'll get started with Test Driven Development.

He starts by briefly introducing PHPUnit, a PHP-based unit testing tool, and how to use it to generate the HTML version of the code coverage report. He helps you define a good phpunit.xml configuration file and how to execute a first sample test (code provided) from inside PHPStorm. From there he adds one some more complex testing of exception handling and checking the class types. With this foundation, he moves into the test-driven development (TDD) practices. TDD means writing the tests before writing the code to make those tests pass. He gives an example of this and shows how test abstract classes too. He then comes back around and writes the code to satisfy the test.

In the next part of his series introducing the upcoming version of the Laravel framework Matt Stauffer has posted part 16, about generating missing events.

Sometimes it can seem like a lot of work to create an event, create its handler, and bind the two. Create a command, create its handler, bind the two. I've often wished for a workflow that handled the whole process together in one. The artisan commands for generating commands and events are a good start--they both create their own entity and (optionally) its handler. But you still can spend an hour writing the command and handler, and then waste another 15 minutes trying to figure out why it's not working, only to realize you never actually bound the two together.

The solution to this in Laravel 5 is the "event:generate" handling with the artisan command line tool. He includes a look at the event handlers directories and files before executing the command and what changes post-execution, including the sample code generated for the event.