As companies move to adopt Service-Oriented Architecture (SOA), their application development process will change. In fact, SOA promises to transform the basic definitions of “application” and “development” themselves as a result of SOA’s promise to shift the responsibility of application development into the hands of the business user. It’s crucial, therefore, for developers, business users of information technology (IT), and the consultants that serve them to understand the changing nature of applications and the process for creating and managing them in the context of SOA.
The SOA context mandates a form of application generally known as a composite application. Composite applications consist of Services orchestrated or otherwise combined into Service-Oriented (SO) processes, which are in turn exposed as Services. The development of such applications therefore involves configuring such processes. As explained in an earlier ZapFlash, most composite application developers are business users who work with tools that enable the configuration of metadata, thus enabling them to create and manage business logic declaratively rather than programmatically above the Services layer of abstraction that SOA provides. Such users may have many different titles, but for the purpose of this ZapFlash, we will refer to them as business analysts.
While moving all business logic to the composite application level is a noble goal to be sure, there’s no question that a large portion of the business logic in today’s organizations will remain locked away in existing business applications. It’s important to keep in mind, therefore, that in the SOA context, there are two basically different kinds of applications: composite applications that business analysts create and manage declaratively, and the “legacy” business applications that will continue to exist below the Services layer of abstraction.
Service Contracts: Beyond WSDL
Clearly, the Services layer of abstraction plays a pivotal role in SOA. This abstraction derives from the contracted nature of Services. A Service contract is metadata that describes all the requirements for how a Service must behave, without specifying how to implement it. WSDL contracts for Web Services specify basic information like the port type and binding information, but the metadata required to fully specify a Service contract go beyond these basic capabilities and includes requirements for policy, governance, consumer characteristics, service levels, semantic requirements, and more. As long as each Service meets its contract, business analysts need only work with the metadata contained in such contracts, without needing to know the implementation details of the Service. Likewise, component developers must only build components with Service interfaces that meet those contracts. They need have no knowledge of the consuming applications beyond the metadata in the contract.
SO architects, however, must have the big picture of the SOA implementation that crosses the Services layer of abstraction. They must create and manage an SOA metamodel that includes models of the business requirements, Services, and the underlying implementation. At the crux of this metamodel is the Service Model, which abstractly represents the Service contract metadata that forms the Services layer of abstraction.
The Two Spheres of SO Development
The Service Model thus represents the Services layer of abstraction that forms a division between the declarative, process-oriented business development on the one hand, and the programmatic, component-oriented infrastructure development on the other. As shown in the figure below, building and managing an SOA implementation involves working in these two spheres, as well as a clear methodology for translating requirements across the Services layer when appropriate.
The Two Spheres of SO Development
One of the challenges of SO development is in following an approach that maintains the business agility benefit, which, after all, is one of the main value propositions of SOA. The secret to building for agility is to assume that business requirements are always in a state of change. So, rather than building applications that address a specific, static set of requirements, a composite application has the “meta-requirement” of a responding flexibly to changes in the business environment. The traditional gather requirements-design-build-test-deploy waterfall methodology for software development fails to address this meta-requirement of agility. SO development, therefore, requires a different approach that depends on the Service model to represent the business requirements to IT, as well as to represent IT capabilities to the business.
As a result, SO development follows one of three basic scenarios. In the first scenario shown in the figure below, business analysts work with business users to understand and gather current business requirements. These analysts then work with composite application tools to declaratively configure Services and processes to meet those requirements. In this scenario the available Services are sufficient to meet the needs of the business; the development process is purely declarative. The analysts work in an iterative fashion with the end-users, adjusting the processes as needed to fine-tune their functionality. In this scenario, business analysts work to satisfy specific business requirements, without the need to involve IT. They are thus able to respond quickly to changing business requirements on an ongoing basis.
Composite Application Development
However, what happens if the line of business requires functionality that current Services are unable to provide? In this second scenario as shown in the figure below, business analysts find that the existing Services in production are insufficient to meet the needs of the current set of business requirements. As a result, they describe the newly required functionality by creating or modifying Service contract metadata as described in the Service model. Basically, they provide instructions to the programming staff by establishing requirements within Service contracts.
The component developers then code to the contract by developing Services that meet contract requirements, without having to know the specific usage scenarios for those Services beyond the information contained in the contract. Service contract metadata therefore form the requirements artifacts necessary to create or modify existing components in order to expose Service interfaces that satisfy those contracts. At that point, the business analysts can incorporate the required working Services into their processes.
Service Creation or Modification
The third scenario only involves component development, as shown in the figure below. In this scenario, there is some technical or infrastructural reason for changing the programming of a Service without changing that Service’s contract, a process known as refactoring. For example, refactoring might be called for if the IT staff determines that they must make changes to satisfy non-functional requirements for levels of Service, say to maintain the scalability or fault tolerance of the underlying components. Another example would be when IT decides to replace a legacy application or other part of the existing infrastructure. Refactoring may also take place to streamline components by removing redundant parts of the code. The critical point to this third scenario is that the business users are none the wiser about any changes, since the contracts remain the same, and ideally, IT addresses any potential performance issues before they affect the business.
The Four Pillars of SO Development
Each of the scenarios above share some common elements that distinguish SO development from other forms of development that typically rely upon the waterfall model. Specifically, there are four pillars of SO development that companies must understand.
Pillar #1: Iterative development — we’re representing each sphere of development with a pair of arrows to indicate the fundamentally iterative nature of SO development. Business analysts must work iteratively with business users, both to satisfy the original requirements as well as to maintain agility as those requirements change. Likewise, component developers must continually iterate their code to satisfy ongoing changes to the Service contracts.
Pillar #2: User involvement — unlike the waterfall model, where users specify requirements at the beginning of a project only, business users continually drive SO development. The meta-requirement is for a system that responds well to change, and as a result, the “requirements definition phase” of any SO project is actually a set of ongoing activities.
Pillar #3: Contract-first development — Business analysts work with users to distill requirements into contracts that then act as the marching orders for component developers. Such metadata both represents the requirements as well as the test plans that analysts can execute to guarantee that Services meet their requirements. In other words, contract-first development is an example of test-first development, and both approaches are examples of metadata-driven application development.
Pillar #4: Refactoring — The Services layer of abstraction affords IT the luxury of a curtain that hides the inner workings of the technology from the business. Rather than an excuse to maintain a poor infrastructure, this abstraction layer actually gives IT more leeway to make continual improvements to the technology. Refactoring is thus the underpinning of reuse, as IT may now work to streamline technology across platforms to meet the needs of the business.
The ZapThink Take
In none of the above scenarios does the IT department determine which Services to build. IT must only build Services that meet the requirements as specified in the contracts, or refactor Services to provide better business return to the organization. Many readers of this ZapFlash will also recognize the four pillars of SO development as belonging to a set of principles known as agile methodologies. This occurrence is no coincidence. Agile development methodologies like Extreme Programming and others espouse iterative development, user involvement, test-first (contract-first) development, and refactoring. These agile methodologies are particularly useful when business requirements are poorly understood or are in flux — a situation that SOA is well-suited for, as well.
Broadly speaking, agile methodologies follow the Agile Manifesto for software, 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. ZapThink believes that to be successful, SO development must follow these principles. SO development, however, is not the same as Extreme Programming or any of the other agile approaches. Instead, the Service model and the associated Service metadata enable a different approach to development that can enable companies to take advantage of the promise of SOA. To build agile SOA, though, companies must follow the four pillars of SO development and the principles in the Agile Manifesto.