Modernizing Application Modernization

The transformation to a digital business is causing many organizations to place a higher priority on modernizing legacy applications and replacing outdated packages with modern, adaptable solutions. Many organizations are faced with a difficult dilemma – how to modernize legacy applications that run the business when 75% of available funds are devoted to keeping these systems running and the processing they provide cannot be interrupted. In the past it was common to see modernization efforts take a back seat due to insufficient funds or lack of priority. Or, the efforts failed because the task was so complex that costs escalated uncontrollably. However, organizations are now finding that the legacy maintenance and enhancement cycle is not able to keep up with the pace of changes they face – be they from regulatory mandates or market pressures.  And, when combined with digital business pressures, modernization becomes a critical business need. 

IT organizations are now looking for ways to roll out new business capabilities to their customers and stakeholders that leverage the data embedded in the legacy systems.  However, these are hardened, mission-critical systems that provide the core processing for the business – and are resistant to change. As a result, they are recognizing that they will have to retire them and replace them with much more flexible IT capabilities.  The caveat is that this must be done in a manner that does not jeopardize the daily business operations the systems support.  

Too often, modernization has meant wholesale replacement via a lengthy, expensive and disruptive “big-bang approach which failed to meet expectations.  Today’s modernization approach is radically different from conventional application modernization which replicates yesterday’s architecture in a new technology. Today’s best practice:

·        Modularizes the functionality and delivers a set of services that map directly to the business model

·        Separates business rules from code

·        Uses enterprise-level Agile and Lean practices that allow rapid delivery and continuous improvement

·        Uses a factory framework that standardizes all nonfunctional and common code in a design platform that radically improves cost, quality and delivery time

·        Deploys as a series of incremental releases that may be vertical slices (areas of functionality) or horizontal slices (end to end processes for specific types of processing, such as application types, claim types, financial transaction types, etc.).  

Rather than converting code (where the resulting codebase represents the same tangled mess in another language), the approach replaces the legacy application with a layered, modularized architecture based on the principles of Service Oriented Architecture (SOA). In the past few years SOA has become the default architecture for modern applications to support the need for flexibility and continuous integration/deployment.

To achieve this, legacy applications must be understood from the perspective of the business and technical capabilities they provide.  Business rules must be harvested from legacy applications (or new ones derived where the requirements have changed).  Transition planning must define release points that include existing functionality (e.g., wrapped transactions) as well as new services.  During the transition, legacy interfaces must be preserved or replaced to maintain operational continuity.  Ultimately, the modernized application should reflect modern IT best practices and patterns, such as maximizing the configurability of the system via parameters (moving change points out of the code) where flexibility is desired.  Examples of these best practices include the implementation of software services, business rule management (rules engines) and business process management (BPM) tools. 

Everware-CBDI’s Service Oriented Application Modernization (SOAM™) methodology is a comprehensive approach that combines multiple leading edge, but proven, techniques to deliver flexible modernization.  Key features include: incremental evolution of capabilities, modular architectures to limit the impact of change, and separation of infrastructure platform and data stores from functional code so that each may evolve independent of the other. We combine the modularity of SOA and the rapid development and stakeholder feedback from agile development with automated techniques to efficiently produce, test, and deploy code. We have developed an end to end process that minimizes the gap between when business requirements are identified and when the functionality is deployed into production.  A key component of our approach is our project-configurable Agile Service Factory (ASF) which standardizes and accelerates the task of specifying services and automates the transformation of those specifications into fully-open, industry-standard code targeting popular platforms and frameworks.  Combining this with a DevOps capability closes the loop in rapidly delivering needed functionality.

The result of this approach for application modernization is the ability to incrementally modernize legacy systems that is rapid, priority based, and lower risk.  Ultimately, this approach enables the IT organization to move from a maintenance focus to continuous modernization.

Agile Estimation: Are We Asking the Right Question?

August, 2013 

 

There seems to be considerable debate and confusion surrounding the concept of estimation as applied in the agile world.  Many appear to argue that estimation has no meaning outside of the agile team, but sponsors and stakeholders need something to base their decisions on and estimation is a key component of it.  Perhaps we need to reengineer our definitions and objectives at the higher level. 

Typically, management wants to know how much X will cost and how long it will take to deliver before making the investment; where X is some bundle of deployed functionality with an associated business value.  Not an unreasonable request in a traditional environment where the application is the focus of attention. The investment decision is how much greater is the value than the cost (the ROI). Unfortunately, the estimation process is subject to considerable uncertainty prior to the initial stages of architecture and design (the uncertainty decreases with subsequent stages but does not reach zero until completion and deployment – and then the estimation of the O&M stage begins) – not a good foundation to base investment decisions on.  

If we change our focus from applications to delivering business capabilities and adopt an agile development process, the concept of estimation changes as well.  For example, in traditional (stovepiped) development much of the development is actually producing redundant functionality (in terms of delivering business and technical capabilities), but this is obscured by the focus on the app.  For example, all apps provide error handling and audit logging as well as security (authentication and authorization) – how many times have these been (re)developed?  The same applies to business-related capabilities.  If we can take a broad view of the capabilities required and identify sources for providing them, much of the development may be avoided altogether.  This, of course, is the benefit from adopting a SOA approach.  If we adopt an agile development methods and establish an agile team with an associated cadence, the estimation question should be something more like: how much value can we produce in a given amount of time?   Given that the team has a cost for a given period of time (say, a year), and each delivered business capability has a known value, we can still make investment decisions – what is the net value produced from the investment cost.  

Economics would say you should invest up to the point where the marginal value derived equals the marginal cost of producing the next increment of functionality (stories, capabilities).  From this increments perspective, we should expect the marginal value to be decreasing – because we are developing from the product backlog in order of priority – so we build the highest valued items first.  Marginal cost should be flat or decreasing as well – the cost of the team may be constant, but the cost of producing the next item may go down as we build up and consume more (pre-existing) shared services.   

So, the investment decision changes from: is it worth building this app?  to is it worth funding this agile development team for a year?  This approach can be applied to determine how big the team should be and even how many teams should we engage.  The value delivered should be maximized because the most valuable capabilities are delivered first (along with the capabilities they are dependent on).  This should hold even if the priorities change because the product backlog embodies those priorities. 

The Role of EA in Federal IT Development

Dave Mayo, Everware-CBDI

January 2013

“There is more value created with overall alignment than with local excellence.”                                                                                                                                             –                                                              -- Don Reinertsen

As I look back on over a decade of EA in the federal government, I must say I am disappointed in the results so far.  In my experience as an EA practitioner, I have boiled down the role of EA to two areas:  (1) Support decision-making by the business (mission) and IT leadership – EA provides a repository of information about enterprise components and their interrelationships in the form of a set of models that can be queried to gain valuable insights; and (2) Provide guidance to IT to develop & deploy assets that support the business.  The role of EA here is to help eliminate (or at least reduce) redundancy, inconsistency, and inefficiency in IT and to promote alignment, sharing (reuse) and interoperability across the enterprise.  The first of these is an analytical role along the lines of business intelligence (BI), using the EA repository as the knowledgebase.  The second is a prescriptive role to evolve the portfolio of IT assets in the strategic direction of the enterprise (based on the EA Target Architecture).

Unfortunately, EA in practice seems to have come down to two completely different things: (1) A compliance exercise to meet the evaluation criteria of OMB and GAO.  Never mind the fact that both evaluation methods are intended to get agencies to undertake “real” EA.  Agencies seem intent on doing as little as possible to score well on OMB and GAO assessments.   (2) A descriptive exercise that typically focuses on the as-is situation.  Although, “this is what we look like” does have some value, it is limited and the exercise is very costly (ask DoD about the billion dollars spent on the Business Systems Modernization program).  But the primary shortcoming across many EA programs is the lack of the intention to be prescriptive, combined with the governance to make it happen.  It is the second role and shortcoming that I wish to address here – EA should provide the foundation for application development (AD) and modernization. 

The role of EA in AD lies in transforming abstract business requirements from the problem space into concrete solutions that address these requirements – while keeping all of the capabilities and solutions synchronized to provide traceability.  The most successful organizations have adopted the SOA architectural style and apply it at all levels of this transformation.  At the highest level, it involves depicting business requirements as capabilities - discrete units of process, data and technology that allow you to accomplish something of value.  Modeling capabilities (and their dependencies) is an important part of the Business Architecture because it starts the componentization thought-process.    As you move across the problem/solution divide, these capabilities are transformed into the services or solutions that implement them. 

EA has two roles in this transformation.  The first is to establish the rules and parameters to guide the transformation. This includes setting standards, similar to building codes, that must be adopted by development teams. These include standards for development patterns, semantics and deployment platforms, among others.  While constraining, these standards actually foster creativity and accelerate development because the teams don't have to reinvent/readdress these issues – in the same way that inventors of electrical appliances don’t have to worry about how to get electricity to the appliance.  The second role for EA deals with the big picture.  It is to produce the overall (target) architecture of solutions, and the services they consume, so that the development teams can build them out – similar to a “table-top” model of a building or a community that shows how everything fits together without providing the internal detail of each piece.  The overall solution architecture as well as the EA rules and constraints are provided to the acquisition process to be incorporated into contract language that directs the design and development of solutions. The solution architecture from the EA and the services consumed by the solution are provided for incorporation in the RFPs and define what the contractors are to build.

At the Solution Engineering phase of a program, EA should provide the definitional clarity described above (denoting the components of the architecture, their definitions, boundaries, and how they interoperate) as well as more detailed artifacts to guide design and development, including reference architectures and principles that identify patterns and platforms that can/must be used by design/development teams.  An example of a very successful architecture principle at a high level is that all functionality must be service based, that all interactions will occur through the service interfaces and that all service interfaces must be externalizable.  Amazon used this principle to implement all capabilities as services and in the process created a business platform to integrate all internal and external offerings.   (ref. Amazon;  see Steve Yegge’s Rant, 2011).

During design and development, the EA team should perform compliance reviews at appropriate stage gates to determine that the program is building out the components of the architecture and is complying with the rules and constraints.  Today, most EA programs review development progress “from an architectural perspective”.  But without a model to compare it to, the results are weak at best.  In many cases, development programs claim compliance with the EA because they can “map” their application to the Reference Models, rather than demonstrating that they are actually building out a part of a segment/domain architecture that will be reusable by others.

  

The bottom line is that AD should operate in a manner like most construction industries – develop an architecture and then build it, preferably by assembling solutions from pre-built components.  If the architecture is service based, it will be modifiable on an incremental basis and thus should stand the test of time.  If the solution components are specified and modeled in a rigorous manner, then automation (eg, code generation) can accelerate the process and facilitate the maintenance/enhancement process. 

This is the concept that we at Everware-CBDI have based our core competencies on.  We call it Service Oriented Application Modernization (SOAM) and it bridges EA and solution development.  SOAM consists of four disciplines: SOA, Agile Development, Model Driven Development, and Portfolio Transition Engineering.  This approach rapidly evolves the suite of IT assets to a set of rationalized, reusable components that can be reconfigured to address new challenges.   In the process we are able to align development results with the business goals and objectives.