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)

On the Happy Accidents site there's a new post talking about building a RESTful API (part one of the series) using the Orno dependency injection and MVC components.

have recently been writing a collection of PHP components exploring different design patterns for building applications. With the MVC layer close to completion I decided to write a couple of guides on how these components could be wired together to achieve several different application formats. First in this series will highlight the power of OrnoDi when used to resolve your objects, to do this we will be building a simple RESTful api with the minimal amount of configuration and bootstrap code.

He includes instructions to install the components (via Composer) and configure the DI container with the needed settings. He shows examples of the autoloading setup, how to handle the routing and how to create the sample model and controller to respond to the sample REST requests.

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).

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.

In this new post Matthew Setter has posted about one of the core concepts behind the structure and use of Zend Framework 2, its use of dependency injection to handy object relationships and access (via Zend/Di).

As Zend Framework 2 is well and truly here, before some of us who are new to it dive right on in, whether you're completely new or, like me, migrating from Zend Framework 1, it's really important to ensure that we understand the core concepts on which it's based. [...] In this, the first part in the series, I'm going to go through what dependency injection (DI) is. However, as there are a number of great posts already available on the topic by some very experienced developers, [...] I'm not going to rehash them.

Instead he extracts out useful tips from posts of a few other sources on ZF2 and dependency injection in general: Matthew Weier O'Phinny, the ZF2 manual, Martin Fowler on dependency injection, Wikipedia and more. He also includes lots of links to more great articles on the subject, both ZF2-specific and for DI iin general.

In this new tutorial posted to PHPMaster.com, Hari K T takes a look at internationalization in a Symfony2-based application using its own translation component.

If you've ever worked to develop a site which needed to be available in multiple languages then you know how difficult it can be. With the help of Symfony2′s Translation component you can easily make internationalized sites. I'll show you how with some sample code and some discussion on its API.

He includes a basic example of how the component works with the typical "hello world" translation from English to French. He mentions fallback locales, pluralization and the conversion between translation formats (like converting from a YAML file into a translation object).

In his most recent post Gonzalo Ayuso shows you how to merge Zend Framework 2 and Symfony2 components into the same project using Composer.

Zend Framework 2 is finally stable. I must admit that I'm not a big fan of ZF (or even Symfony2) as a full stack framework. I normally prefer to use micro frameworks, but those two frameworks (ZF2 and SF2) are great as component libraries. Today we are going to build a simple console application (using symfony/console component) to list the database tables (using zendframework/zend-db's Metadata).

He starts with the information you'll need to put into your "composer.json" file to get the needed packages (and set up the autoloader a bit). Included in the post is the code to create his "SchemeCommand" class to make the new CLI command, one that connects to a database and echos out the metadata about the given table. A unit test is also included.

On the Symfony blog there's a new post from Bernhard Schussek about some of the changes that have happened in the Forms component of the Symfony 2 framework (in version 2.1).

Those of you who already upgraded to Symfony 2.1 Beta probably noticed that the new version comes with many backwards compatibility breaks in the Form component. Many of you probably ask yourselves: Why? The simple answer is that the Form component is one of the most complex components in Symfony at all.

They list out some of the improvements (plus code showing then at work) for changes like:

• No more bindRequest()
• Custom field constraints
• Error mapping fu
• Collection improvements

Evan Coury has posted a quick guide to one of the major features of the Zend Framework 2 project so far - the ServiceManager. He introduces the component and talks about some of its key features.

So, what is the ServiceManager? Basically it's a registry, or container (the proper term is service locator) to hold various objects needed by your application, allowing you to easily practice Inversion of Control. The service manager holds just the information needed to lazily instantiate these objects as they're needed. So if you were thinking 'services' such as those composing a service layer, you might be better off thinking of the service manager more as an "object manager" or "instance manager".

He mentons some of the functionality that comes with the component including invokables, factories, aliases, initializers, configuration classes and abstract factories. He also links to the ServiceManager quickstart over in the Zend Framework 2 documentation for more information.

In this new post to his blog, Matthew Weier O'Phinney about some of the recent updates in the latest beta (beta5) of the Zend Framework 2's "Forms" component.

Forms are a nightmare for web development. They break the concept of separation of concerns: they have a display aspect (the actual HTML form), they have a validation aspect and the two mix, as you need to display validation error messages. On top of that, the submitted data is often directly related to your domain models, causing more issues. [...] Add to this that the validation logic may be re-usable outside of a forms context, and you've got a rather complex problem.

He talks about the newly-rewritten form component along with the new InputFilter to accompany it. He includes an example of using this new component - making a User form that, based off of some annotation rules, does some validation on the property values and things like "required" and custom types. He also talks about some of the other features included in the new package like hydration, complex annotation support and tools to work with collections.

You can download this latest beta release from the packages.zendframework.com site.