The reality of today’s highly competitive and customer demand-centric market conditions have pushed software (solution) delivery organizations beyond the traditionally accepted limits of software development and delivery capabilities. There is no argument that Lean methodologies such as Lean Six Sigma and DevOps can help improve operational solution delivery capacities through:
- Streamlining of solution delivery process
- Improved software quality
- Automation of system operations
- Self-administration of system operations by development teams
Agile methodologies, however, help augment such operational improvements with their own enablement of faster time to market (TTM) through transforming the Lean concept of “value-added activities” into “value-added product features.” Agile software architecture must augment solution delivery organizations’ Agile software development lifecycle (SDLC) capability by creating a flexible software architecture that enhances all future product development.
Agile methodologies extend product lifecycles through faster TTM and continuous delivery maintenance in order to ensure its high quality of service (QoS) defined by functional feasibility, business, and technology capabilities. Agile SDLC produces the minimally viable product (MVP), which is continuously enhanced with “value-added product features.” While most architects may not have the ability to envision what the product software may look like in the not-so-distant future, they must still provision for seamless future enhancements throughout the entire product lifecycle. This type of application architecture fits the definition of Agile. Agile application architecture must support and complement Agile SDLC through the following architecture principles derived from the Agile Manifesto:
- Application architecture must be extendable (“Build for Change”)
- Application architecture must enhance developers’ productivity
- Application architecture must not contribute to technical debt
- Application architecture must continuously improve
“Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.” — Agile Manifesto Principle #2
Application Architecture Must Be Extendible (“Build for Change”)
A former CIO of a Fortune 300 company once told me, “Enterprise architects must be at least six months ahead of the solution delivery organization they support.” I initially understood it as advice to enterprise architects to keep current with technology trends and educate their peers in order to influence organizations’ solution delivery capabilities. Although that might have been his intended message, in the context of Agile SDLC, it may be open to another interpretation as well: application architects must produce application architecture that will empower rather than support solution delivery teams (application developers) to deliver and maintain software with most optimal time, cost, and nonfunctional quality.
Application architects must be able to anticipate future trends in product and technology development such as mobile and cloud computing by creating simple — structurally and behaviorally (Figure 1) — loosely coupled application architecture that is agnostic of the client device and hosting infrastructure. Such architecture will respond faster to rapid changes in the mobile industry, and is portable to allow a streamlined migration to a cloud managed platform (CMP), if there is a need.
“Continuous attention to technical excellence and good design enhances agility.” — Agile Manifesto Principle #9
Application Architecture Must Enhance Developers’ Productivity
The Kanban method introduced us to the concept of managed flow constrained by the work-in-progress (WIP) limits, which quantitatively describe an organization’s operational capacity. WIP limits are usually influenced by solution delivery organizations’ head count and SDLC process efficiency. I would like to make an argument that good application architecture can also improve solution delivery capabilities by increasing the WIP limits.
Various studies show that most IT budgets allocate as much as 80% to software maintenance. Application architects must take into consideration that their primary goal is not just to enable fast solution delivery, but also to reduce product maintenance cost throughout software’s entire lifespan by enhancing:
- Application Quality of Service (QoS)
- Application developers’ productivity
Application architecture should strive to free application developers of all nonfunctional coding by allowing them to focus on and efficiently implement customer value-added features.
Agile application architecture design practices include:
Application loose-tier coupling
|Loose coupling of application tiers through JSON/XML allows application developers to program application components simultaneously based on a pre-agreed conceptual document structure rather than data object. Developers can program loosely coupled components in parallel without impacting one another, and reconcile their changes at the end of the development phase.|
Application RESTful API
|Exposing server-side data and business components through stateless RESTful API allows applications to become highly reusable by numerous distributed client applications, significantly reducing server side application’s footprint and technical debt.|
Open source commons libraries
|Popular open source frameworks such as Apache Commons and Google Guava help reduce development effort by eliminating boiler-plate code and reducing application footprint|
Web 2.0 Single Page Application (SPA) design
|Single Page Applications enhance user experience with rich graphical user interface and instant response, are typically engineered with technologies like:
Incorporating responsive design into a Web application UI allows the UI to be accessed from a variety of Web/mobile client devices, further reducing an organization’s technical debt.
|Among other uses, NoSQL databases excel at storing non master data such as transient data and dynamic data structures without extensive support from data architects and database administrators.|
The results are the following:
- Shorter development critical path due to reduced dependencies between application components and tiers
- Smaller development effort due to reusable UI and application API
- Reduced effort/time/cost spent on data architecture and administration
- Improved continuous delivery
“Simplicity — the art of maximizing the amount of work not done — is essential.” — Agile Manifesto Principle #10
Application Architecture Must Not Contribute to Technical Debt
There is a strong demand from business partners and customers to access end-user facing applications from a variety of Web and mobile devices. Modern Web application architecture must incorporate multichannel content delivery and responsive design in order to meet this business demand with relatively minimal development effort and cost. Failure to adapt to customer needs quickly will reduce the solution delivery organization’s competitive advantage and contribute to its technical debt. Application architects need to challenge themselves and embrace new and unfamiliar technologies geared to enhance end-user experience (UX) with minimum redundancy in technology assets (See Figure 2):
- Single-page application design
- Application API (Rest and SOAP)
“At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.” — Agile Manifesto Principle #12
Application Architecture Must Continuously Improve
SCRUM Retrospective is a great concept that encourages Agile organizations to continuously improve their sprint execution capabilities by identifying opportunities to improve either through lessons learned or team brainstorming sessions. EA is not immune to continuous improvement. As new technologies and patterns are adopted, they should be documented and incorporated in the architecture repository section (Standards Information Base) dedicated to maintenance of architecture standards and industry best practices. Enterprise architects together with development teams also need to continuously identify opportunities to improve collaborative architecture development and governance and to respond faster to architecture changes in order to provide value without making the organization any less Agile.
In today’s economy, the business and IT stakeholders often make decisions to buy versus build based on software solution quality, cost and time to market delivery capabilities. Customers’ expectations in regard to user experience have evolved as well. IT organizations can no longer measure application quality by yesterday’s standards without running the risk of producing “legacy apps.”