Blog

Support for Robust Modular PureMVC Applications has Arrived

Continuing in its commitment to provide the development community with the tools necessary to achieve highly robust and scalable enterprise applications, Futurescale today announced the production release of the MultiCore Version of its popular open source PureMVC Framework.

In addition to providing a scalable solution for application development that taps the potential of modular programming, Futurescale has also released a powerful utility called Pipes for creating more loosely-coupled inter-modular communications within a MultiCore application.

MultiCore enables developers to create robust modular applications. The term ‘core’ (in a MultiCore app) refers to both the main application and the modules it uses, each of which is its own self-contained PureMVC program.

PureMVC Project Architect and Futurescale CEO Cliff Hall had this to say:

“MVC is about loose-coupling, and Modular Programming takes that concept to the extreme. A modular application can dynamically load and unload ‘modules’ at runtime – completely separate applications in their own right, which interact with the main application and other modules to perform some set of tasks.”

Some of the benefits of a modular development approach include:

• Ability to split codebase into smaller, more managable projects.
• Easier to outsource development of parts of the development process.
• Module developers need not understand details of how the main application works.
• Perfect for applications that wish to support third-party plugin or ‘widget’ development.

An inevitable design decision that comes up early in defining the architecture of a modular application in any language is how the cores will collaborate. Generally, the main application will need to communicate with the modules and visa versa, and modules may need to discover (or be introduced) and talk to each other.

The classic and most common way to achieve this in object oriented languages such as AS3, involves the cores having references to each other and exposing predefined interfaces for communication. This approach is fully supported and a detailed demo illustrates best practices for implementation.

Another, even more loosely-coupled way is for the cores communicate is by sending messages to each other over a generic pipeline. Unix variants all use this approach to allow the user to chain the any of the hundreds of small but versatile tools that make up the operating system into a pipeline where each tool processes its input and passes the result to its output, and reports errors on another special pipe.

The MultCore Pipes utility, also created by Mr. Hall, facilitates this pipe-based messaging approach to inter-core communication. An extensive demo called PipeWorks illustrates the best practices for implementing this approach.

Hall explains: “As opposed to cores having references to each other and knowing about the specific methods exposed, with the Pipes Utility the cores need only agree on a common message format. This is great if you really want to isolate the code inside the cores. A good example is when you wish to limit the information and code that third parties or consultants can see, while maximizing ther ability to deliver integrated functionality from a clear and simple specification.”

For more information about PureMVC and the MultiCore release, visit http://puremvc.org.