Fabien Potencier (of the Symfony framework) has a new post to his site talking about a philosophy that the Symfony framework community should work towards, providing stability over features.

Long story short: in the coming months, the Symfony core contributors should focus their efforts toward stabilizing the existing features instead of working on new ones. At this point, backward compatibility and stability are more important than everything else.

He highlights some of the points that come along with this effort including less refactoring for the sake of refactoring, fixing more bugs/edge cases and writing more tests/documentation. He gets into some of the specifics of this kind of thinking and points out the things that can and can't be changed during this time. He talks more about stability and suggests that not only can it help enhance performance but it could also help motivate more projects/corporate users to start using the framework.

Gonzalo Ayuso has a new post today showing how he set up queuing with ZeroMQ and Symfony components and React.

Today I'd like to play with ZeroMQ. ZeroMQ is a great tool to work with sockets. I will show you the problem that I want to solve: One web application needs to execute background processes but I need to execute those processes in order. Two users cannot execute one process at the same time. OK, if we face to this problem we can use Gearman. I've written various posts about Gearman (here and here for example). But today I want to play with ZeroMQ.

He uses React and some ZeroMQ bindings and Symfony's Process component to make a simple client and server for working with the queue and processes. A screencast is included in the post showing them making the connection and adding the new process. The full code can be found on github (or installable via Composer)

Daniel Cousineau has posted a guide to using the Symfony Console component as a part of your application. It introduces you to some of the basics of using the component and has plenty of sample code to get you started.

CLI applications are extremely useful for many, if not most web projects. The Symfony framework even goes so far as to include an extensible CLI console used for everything from running cache cleanup/warmup tasks, to user account management. Many CLI scripts for web projects consist of just a static .php file which works fine but grow unweildy over time. Thankfully, the aforementioned Symfony Console component is released as a decoupled standalone that can be installed and setup easily and provide us with structure and organization (and some powerful features).

He walks you through the installation of the component via Composer and includes the code to make a simple CLI script using it. He shows how to make new commands (like his "TestCommand") and how to attach it to the application. He talks about output and input handling with arguments and options. He also shows an integration with an existing application with a base command class that helps to set up and configure the command objects that inherit it.

On the Symfony blog there's a post from Ryan Weaver about an upcoming event the project is hosting and how you can help - the Symfony Docs Hack Day (on March 30th).

The first commit to the Symfony documentation was over 3 years ago, and since then, we've grown to include a full book, lots of cookbook entries, and sections for most of the individual components. [...] But as we grow, we want to stay aggressive and continue to improve the quality of the docs. This means ensuring that code examples are accurate and pages are easy to understand, balancing the info you need with excess technical clutter. [...] And this is where we need your help! Whether you're a seasoned-Symfony veteran, a beginner, or even if you don't think your English is very good, we'd like you to join us on March 30th for our first ever Symfony Docs Hack Day.

The event is a virtual one - everyone will meet up on the Freenode IRC network in the #symfony-docs channel on March 30th from 9am through 5pm Central EU time. Everyone's invited, not just those who are experts in the framework. Documentation updates are a great way to learn more about a framework too! If you're interested in what kind of updates they're looking for, check out this list of open issues with the docs on Github.

In this new post to DZone.com, Giorgio Sironi kicks off a series that looks at reusable components in the PHP development world. In this first post of that series he looks at the Symfony console component .

Symfony is one of the most popular open source PHP frameworks on the market. The Symfony Components, however, are loosely coupled projects that can be reused as a library outside of an application based on Symfony. The component this article explores is Console (symfony/console on Packagist and GitHub), dedicated to quickly build console applications.

He goes on to talk about some of the "pros" of using the component (including built-in argument/input handing and multiple "commands") and some of the "cons" of is use (including its size and some of the built-in features you can't really work around).

As is mentioned in this new post to the Symfony Blog, it's "time to start a new season" of Symfony-related events (both at other events and Symfony Live).

I'm so happy to announce to all of you Symfony folks, the super exciting Symfony Live year that is waiting for you! This time I promise, this is going to be "Great News" for all of you!

Events mentioned for this year (so far) are:

• The Symfony track at this year's SunshinePHP conference (happening next week!)
• The US edition of Symfony Live in Portland
• Three other Symfony Live events to happen in Eurpoe

The largest announcement, though, is the SymfonyCon Europe that will be new this year, an all Symfony conference to be held somewhere in Europe later in 2013.

On PHPMaster.com there's a new tutorial showing you how to use Pimple (the dependency injection container from the Symfony folks) in your application to manage objects and resources.

In application development, we try to create independent modules so that we can reuse code in future projects. But, it's difficult to create completely independent modules which provide useful functionality; their dependencies can cause maintenance nightmares unless they are managed properly. This is where Dependency Injection comes in handy, as it gives us the ability to inject the dependencies our code needs to function properly without hard coding them into the modules.

They start with a look at the problem with working with "concerete dependencies", ones that are hard-coded into your classes making them not only hard to test but potentially difficult to maintain. They include an example of this (a "SocialFeeds" class and friends) and then one of two ways to fix the situation. They start with using constructor-based injection, injecting the Twitter service into the main feeds object. They also talk about another method - setter-based injection - where the objects are injected via specific methods on the object.

As a third alternative, though, they get to using Pimple to manage the objects, making it easier to inject just the one resource into your classes and extract the objects you need from there. There's also a bit of "advanced" usage of Pimple showing the use of the "share" and "extend" methods.

In this new post to his site Paul Jones talks a bit more about coupling in frameworks (see some of his recent Aura posts for more), this time looking at how the Symfony framework defines "decoupled" based on its object structure.

Previously, on decoupling and dependencies, I said: "Some [Symfony] commenters were dissatsifed with my use of unit testing requirements to discover what a package really depends on, as opposed to what its composer.json file states." I'm willing to allow that the Symfony commenters here might be right. Let's try looking at Symfony's claims and see how they stack up.

Based on a list of components Symfony says don't have mandatory dependencies, he finds that - out of the fifteen given - four of them do have dependencies.

Does having mandatory dependencies make it a bad project? Not at all. It just means their statement of "no mandatory dependencies" (and related statements) is not true for all the components listed. Now, it may be that the Symfony folk have a different idea of what "decoupled" and "standalone" mean.

On the Symfony blog, there's two new posts highlighting some recent improvements to the Symfony2 framework - the addition of static page caching and payment validators:

• Static page caching support in the routing configuration
• Payment validators with docblock assertions, including error messages for failures.

These features are all a part of the upcoming Symfony 2.2 release that's planned to be moved in the "stabilization" status in early 2013. It should be able two months following that when the stable version will be released.

In this new post Paul Jones has reprinted an interview he did with PHP Magazin about the recent 1.0 release of the PHP framework project he is a lead on - the Aura project.

I did an email interview with the folks at PHP Magazin; their German version is here. What follows is our original email exchange in English.

They talked about some of the core principles behind the framework, its origins from the Solar framework, the team's "libraries first, framework second" methods and its push to be a PHP 5.4-focused framework. There's also a bit that compares the framework to two other popular options - Zend Framework and Symfony.