Software assembly is a new and agile technique that improves upon the Rapid Application Development (RAD) and iterative software development approaches by providing specific tools to deliver software.
Like the other RAD and agile methodologies, application assembly is an iterative process. Software assembly uses frequent integrations. It incorporates client feedback from viewing working code, requires little formal documentation that takes the form of visual modeling and code commenting, and utilizes frequent drops into production. Assembly differs from the other agile methodologies because it describes not only the process to deliver software iteratively, but also what the software architecture should be.
Assembly's key differentiator and benefits are derived from software not being bought or built, but harvested from existing software components. These reusable components come from existing SOA services and open source software. Look to open source software to build the infrastructure and interface framework and to SOA services to provide the application-level business logic. The software assembly methodology combines iterative development with reusable SOA and open source components to deliver on the promise of agile development. The following diagram shows the high-level architecture of an assembled application:
Architecture of an assembled application
To leverage open source software, it is easiest to think of it as an extension
Open source software should be thought of as high-quality software components that are available at all levels of granularity and capability, from small libraries to large enterprise software, at your disposal. Open source also has the added benefit of passionate engineers and professional support for most of the major solutions, if you require it. Open source should certainly be considered for infrastructure components, as open source dominates at this software tier. This is for two primary reasons: Open source excels in areas where commoditized and standardized solutions are abundant -- such as software infrastructure -- and secondly open source is built by, and often for, software engineers, who universally have software infrastructure challenges they are looking to resolve.
Open source also dominates in operating systems, Web and application servers and increasingly in other software infrastructure such as databases, and of course SOA middleware and Web services.
Application business logic is often custom-built by organizations or is commercially available. Open source is moving up the stack to business solutions, but currently this is the domain of commercial software. No matter how the business logic is procured however, the best way to expose and consume it is via services.
Services are increasingly becoming available from external sources around the Internet from application service providers (ASP) and as software as a service (SaaS) components. Additionally, content can be mashed-up from Really Simple Syndication (RSS) and Atom feeds, which I consider an extension to the assembled services for you to consume. There are hundreds of viable services and content sources on the Internet for you to use. Look to them when assembling an application. Reusing SOA services is nothing new to the SOA architect, but when executed within the iterative assembly methodology and coupled with open source components, SOA gains new potential and agility.
Once the open source infrastructure and SOA services are in place, your application needs an interface. The most popular interface frameworks today are Rich Internet Application tools (such as Ajax and Flex), Web-user interface frameworks (such as Spring, Struts, the Apache Jakarta projects, PHP Symfony, Perl, Ruby, Python, and .Net) and service façades (such as Web services and JMS). Use these technologies to build your interface. Then connect to the SOA services for business logic and implement the infrastructure of your application with open source and you have assembled your first application!
Building from scratch
As an example of the benefits of the assembly methodology, a recent client of mine required a rapidly-developed application to be constructed for a mission-critical application on a modest budget. The application was assembled from 100% open source infrastructure including the operating system, content management system, user interface framework (including AJAX libraries}, development tools, deployment scripts, QA and performance testing tools, and web caching. Although I believe open source's major benefits are agility and transparency rather than total cost of ownership, this application does have the added benefit of not having any licensing fees for its infrastructure.
All business logic and content for the application was provided by assembling internal and external services. The only effort the project required was to identify the open source software and SOA services to assemble and integrate them and finally build a branded user interface to present the new application. We had no extensive requirements documentation. Rather we created some architectural modeling diagrams and creative wireframes and then began to iterate the assembly of the application.
The client viewed the working code frequently and we made adjustments to the application as we went along. As an example of this, halfway through the construction of the application, the client requested that we change the search engine we were using. We had integrated a commercial search engine, but due to contractual issues with the provider, the client requested we switch to an open source engine.
We downloaded Lucerne and Nutch from Apache and had the new search engine developed within a week. The procurement was as simple as downloading and installing the tool, with no lengthy sales or product evaluation process.
And as most organizations are realizing, open source licensing is a relatively easy detail to address. Once a given open source license is validated by an organization's legal department, a host of open source solutions become immediately available for assembly. We also had architected the original search engine as a consumable SOA service and this abstraction helped us to implement the new engine quickly as we were able to honor the original contracts of the service abstraction of the engine.
All surrounding code was able to be left intact as the new engine was implemented. This was very rapid and agile -- there was never a conversation of change orders or updating a requirements definition -- this would have taken longer to execute than the actual coding change! This is the power of assembly, and is at the heart of the agile spirit.
Agility pays off
Agile methodologies and iterative development are great concepts, but without the SOA services and open source components, the methodologies may seem academic. Assembly provides the required tools and architecture to deliver iteratively and with agility. Assembly also provides for rapid prototyping, as the procurement process is expedited to downloading an open source solution or connecting to an existing SOA service.
And changing your mind or making a mistake is not too costly because refactoring is readily encouraged. This is liberating for the engineer because change is easy, relative to other delivery techniques. Your software engineers are not afraid to build the application rather than worry about every small detail of design.
Carelessness is not encouraged, of course. Visual modeling of the technical architecture and wire-framing the interface is part of the methodology, as is the liberal use of design patterns and commenting code. But iterating and refactoring are also encouraged as this seems to be the best way to capture the requirements of an application. Assembly has the same goals as the agile manifesto, which values individuals and interactions over processes and tools, working software over comprehensive documentation, customer collaboration over contract negotiation, and responding to change over following a plan.
Assembly simply looks to enable these ideas with the formal use of reusable components harvested from open source software and SOA services. Now you just need to integrate often, show working code to your users frequently and not be afraid to refactor and you can be a master of the assembly methodology.
About the author
Adam Michelson has more than a decade of technology implementation experience. Adam is currently the director of service-oriented and enterprise architecture for Optaros Inc., an international consulting and systems integration firm that provides enterprises with best-fit solutions to IT business challenges, maximizing the benefits of open source software.
This was first published in August 2006