Tag Archives: Scott W. Ambler

Architecture: 2 n-dimensional layers

Original Sin: Unidimensional Asymmetry

Back in the day, I was delighted when I first found this three layers’ architectural pattern:

layers

Finally, some order in the chaos!

 … but, trying to use something like this in practice was somehow difficult: there are other aspects that does not fit to any of these layers.

The next interesting thing that come up to me was “Layered class type architecture” from Scott W. Ambler “Building Object Applications That Work”:  Interface, Process, Domain, Persistence, System.

Now was clear that, unfortunately, something is wrong with the 3-Layers Architectural Model. … and the “original sin” is the unidimensional asymmetry: the UI-Persistence “line” is the unique dimensions and many other software areas cannot fit here.

The fix: Symmetry!

On of the first actionable and symmetrical model was the UML (Jacobson) robustness diagram. Any use cases could be represented as being realized by objects that are instances of three categories of classes boundary, control and entity

  • Boundary, Control, Entity

That is simple, beautiful and symmetric: UI and other I/O (Input/Output) aspects are managed in non- discriminatory manner.  One problem: too few guidance.

Koni Buhrer “Universal Design Patterns” goes a little further – four design elements & their recommended interaction could describe everything and offer a symmetrical model:

  • Data Entities, I/O servers, Transformation Servers, Data Flow Managers

It is symmetric, it is logical, actionable, but still too few guidance.

What we could need more?

Robert C. Martin and with Clean Architecture and Alistair Cockburn with Hexagonal Architecture have some beautiful answers and guidance (see Uncle Bob biblio for other authors similar works).

With Hexagonal Architecture name, Alistair Cockburn want to make clear the main defect of classical model  – unidimensional  lack of symmetry: <Allow an application to equally be driven by users, programs, automated test or batch scripts, and to be developed and tested in isolation from its eventual run-time devices and databases. > . This architecture model will decouple use-cases (~ the application) and the I/O dependent on technology: “When the application has something to send out, it sends it out through a port to an adapter, which creates the appropriate signals needed by the receiving technology (human or automated).”  (quotes from mentioned A. Cockburn post)

Robert C. Martin Clean Architecture make a step further on strategically separating the concerns and present these software areas (quotes from Uncle Bob recommended article )

  • Entities – representing the functional part that is application-independent, working at a higher level: domain or enterprise
  • Use cases – representing the functional part that is application-dependent, and realize the flow of data using the business domain and enterprise rules
  • Interface Adapters – “set of adapters that convert data from the format most convenient for the use cases and entities, to the format most convenient for some external agency such as the Database or the Web”; on Uncle Bob View MVC and MVP parts goes here
  • Framework and drivers – “frameworks and tools such as the Database, the Web Framework, etc.” And what is most important, according to Uncle Bob, – “This layer is where all the details go. The Web is a detail. The database is a detail.”. Yes, technologies & deployment mode is not the core of your application, it is what will change independently and do you want to decouple them.

I strongly recommend all above described symmetrical models: Robustness Analysis (Jacobson), Universal Design Pattern (Koni Buhrer), Hexagonal Architecture (Alistair Cockburn), Clean Architecture (Robert C. Martin) or Layered Class Typed Architecture (Scott W. Ambler) that are logically equivalent with more or less details.

Simplified representation of symmetrical models:

one-flow

Comments

  • Flow control orchestrate I/O parts (symmetrically) and Business Logic, where Entities are the exchanged data
  • If the Inversion of Control it is used and the participants to the flow are represented by interfaces, the design will be more adaptable and testable

What we could need more?

There is some asymmetry!

generic

There is some asymmetry in logic architectural areas that is skipped somehow by current models of Hexagonal or Clean Architecture, and this is the reason behind the original mistake of unidimensional linear model:

  • There are two kind of interactions for the systems
    • The client level interaction – the one with the systems actors
    • The resources level interaction – the one to access the its resources (such databases, heavy processing)
  • The client level interaction
    • Contain – links the system with its clients/actors
    • Dedicated flow control to manage (possible) client session state (interaction state)
  • The resources level interaction
    • Contain – link the system with its resources
    • Dedicated flow control to manage (rather) stateless access to these resources

asimetric_2

Comments

  • Each layer is represented in a simplified form here. In fact, it could contains full set of software areas: Entities (Business/Enterprise), Flow Control (Use Case) and I/O adapters.
  • Each layer is symmetrical, but the aggregate is asymmetrical, based on actor-resources vectorization

Scaling aspects (performance and others)

Service Layer

  • can manage the access to resources with the benefits of its stateless model, using various patterns and tools that are based on this aspect.

Interaction Layer

  • can manage in a decoupled way the possible scaling issues of clients’ data cache
  • idem for managing the external interaction aspects

 

Examples – same services with various forms of interaction

  • Generic Model

generic

  • UI based Module
    • Interaction with the Human User Client is designed with MVP pattern and provide access to system resources via a set of three services, where interaction layer also orchestrates the calls of these (resources access) services

example-ui

  • “Flat” Flow Background Module
    • The client/actor is an internal timer. When it is invoked a single (resource) access server, the interaction layer flow could be “flat” (just redirect the call)

example-back-simple

  • Complex Flow Background Module
    • In a similar case, but when the background run it is similar with one or more actions from UI based module: the interaction flow will keep also the state of the client session between successive services calls

example-back-complex

Notes about Microservices

Microservices could be a choice for architecture decisions, but my problem is all the talk about “monolith-application” versus “microservices”. I recommend to read first these Robert Martin articles:

 In the above proposed model, the “service”

  • Has a clear responsibility – manage the access to the system resources
  • Has a rather “plain interface” – the service itself is decoupled from its deployment mode
  • These areas are decoupled: the services, the way how actors interact to the systems to access them, and their deployment mode. Services are reusable for more types of interactions and more type of deployment

How the microservices fit with this model:

  • The service it is in the same micro-monolith (sic!) with its deployment mode
  • The client interaction flow mode is out of scope, but it is forced to access a fixed deployment mode (with afferent technology)

Update (May 15, 2017)

Just find from an Alistair Cockburn tweet (see bellow) that he has updated his “Hexagonal Architecture” with a similar “asymmetry” concept:

<<New note on at . Primary/ secondary actor asymmetry (end of the article) Take look if you like>>

Few comments about the difference between the two similar viewpoints:

  • I still believe that main split is between cell related to “client interaction flow” and the cell related to “resource access service(s) flow”
  • The case when we have primary actors and secondary actors it is just a particular case when the resource access flow could be assimilated to an internal use case and/or with a distinct component
  • In a generic case, there is the possibility that “client interaction flow” to be in the same use case and in the same component as the “resource access service(s) flow”
  • 2 cell architecture is never about <<UI and back-end services decisions>> (see Cockburn post section “Separating Development of UI and Application Logic“): we have in the same time flow control, business and technology in both “front-end”, interaction cell and in “back end” resources access cell
  • UI is not the only way for interaction with system clients: we can have, for example, external request/response interactions or scheduling/timers, listeners etc.
  • 2 cell architecture it is not only about separating adapters and ports, it is about separating also the flows in these two categories: client interaction flow and resource access orchestration flow. The whole application is split in two cells, not only the port and adapters.

 

Bibliography

“Layered class type architecture” from Scott W. Ambler

Universal Design Pattern – by Koni Buhrer

Hexagonal Architecture – by Alistair Cockburn

Clean Architecture – by Robert C. Martin

Microservices – by Martin Fowler

Roadmap to an agile design

“You can’t have a culture without practices; and the practices you follow identify your culture.”  
(Robert C. Martin) 

BROKEN PROMISE

Eng versus practiceThere is a huge imbalance between the Agile promise and what it is obtained with the usual set of Agile engineering practices.

 Why?

The common approach is to use the Agile methods such Scrum and XP as recipes or as a “closed universes”, by using only the engineering practices prescribed by the methods. Any other proven and outstanding practices are rather rarely used.

The standard set of practices – Simple Design, Refactoring, TDD – does not cover some significant problems:

  • Refactoring is not effective & efficient if the first code is too dirty.
  • None of these practices specify how to protect the business representation inside the software system against the changes related to technologies
  • None of these practices can guarantee that changes in the customer business could be introduced in the software product with high efficiency/effectiveness

We need to go outside the methods and discover what the industry could offer for an Agile Design in order to keep that promise.

.

SUMMARY

generic, specific Introduction – we need to go outside the recipes to put together all the industry strength, in order to fix the imbalance between the used practices and the Agile promise.

AGILE PROMISE – an Agile approach should offer good (sustainable, available, effective, efficient) results for adaptive problems/adaptive context (quick, often, even late) (See Agile Manifesto).

Engineering support – usually, in the best cases, this support does not go further than these three practices: simple design, refactoring and TDD.

What is missing – good enough support for efficiency/effectiveness on: keeping a clean code, business changes or technology changes. We need to define this support for gettting/maintaining an AGILE DESIGN.

The roadmap to an Agile Design – we need to find the minimal set of indispensable, context agnostic, design related practices to get/maintain an Adaptive Design and an Adaptive Product.

The “recipe” problem – the usual tendency is to use only the “inside methods” design practices and to ignore any other useful practices.

Aspects to be considered – the selected practices must cover capability of being adaptive:

  • For design level and architecture level aspects;
  • For process aspects that support envisioning of the initial design, cleanup of technical debt, quick quality check and adherence to business needs and their changes.
  • For realizing the design principles that support building of adaptive products.

Indispensable practices for an Agile Design – by levels:

  • DESIGN LEVEL
    • Clean Code, Refactoring, Applying Law Of Demeter, Programming Style
  • ARCHITECTURE LEVEL
    • Clean Architecture, Applying Law Of Demeter
  • PROCESS LEVEL
    • Architecture Envisioning, Look Ahead Modeling, Model Storming,  Refactoring, TDD, Simple Design, Non-Solo Development, Product Backlog, Continuous Integration

Indispensable principles for an Agile Design – Single Responsibility (of a design element), Separation of Concerns (in enhanced mode, with Dependency Inversion), Functional Cohesion, Law of Demeter.

Final thoughts: Any of these principles and practices are pillars on getting and maintained an Agile/Adaptive Design Even some of them are rarely used, are already defined and proved by major contributors to Agile knowledge and software industry. Also, my personal experience found the selected practices and principles very useful.

.

AGILE PROMISE

 The promise – Good and Adaptive

Agile approach main promise is to be always ready to respond quick, effective and efficient to often changes, even late, in customer business needs. Thant mean we have two kinds of promises:

  • GENERIC – good results
    • always – sustainable and available
    • effective
    • efficient
  • SPECIFIC – adaptive
      • quick
      • often
      • even late

If you have any doubts about these things, please review the Agile Manifesto (see [B-AM]) and the main original Agile methods as XP-Extreme Programming and Scrum. Can be easy observed that all the engineering and management practices are especially selected (in the principles and methods) to get good results, but for rather adaptive problems (Scrum explicitly declare that).

Engineering support

In order to keep that promise, the used engineering practices must be aligned to the declared goal. In my previous post, I have notified the necessity to build and maintain the software products as Adaptive Product in order to have and maintain the Agile capability. A significant aspect in getting this kind of product is to select and use all necessary design practices to get/maintain this capability: we need an Agile Design as an Adaptive Design.

If an Agile practitioner it is asked about this engineering support, the most probable answer is: “we are successfully using refactoring, test driven development and simple design”. All these are great practices and an engineering process that use them could be also great. The question is: if we are using all these practices we could still have significant problems with adaptability?

Unfortunately, the answer it is “yes” (See “Broken Promise”)

Another question: there are other agile practices that could solve these kinds of problems? The answer is “yes”, but are rarely used.

What is missing to keep the promise?

All the mandatory design practices necessary to keep the promise must be put together in a coherent set. Now, only XP have a set of core design practices, but is incomplete and does not cover all aspects of an adaptive design.

.

ROADMAP TO AN AGILE DESIGN

The roadmap – restoring the balance

restore balanceWe need to restore the balance – to find an Agile Design as an Adaptive Design that keep the Agile Promise. For that we need to find good enough set of design practices that could provide and cover the main design aspects.

praticesWe are looking for design related practices that:

  • Are generic, not context dependent
  • Indispensable for the “adaptive” property of the resulted software system
  • Part of the industry knowledge and experience

Some comments about context dependency: a practice is generic if should be always used and considered and the only context-depended question is “how”.

The problem – methods as recipes

Among the known practices for an Agile design, just a subset are “inside methods” practices, that mean explicitly specified in the Agile methods as XP, Scrum, DAD (Disciplined Agile Delivery). Many other very interesting practices are described by the main contributors to the Agile knowledge, but not as part of some methods.

Practice Proposed by Inside method Degree of usage*
Refactoring XP XP Rather often
Simple Design XP XP Rather often
TDD XP, Scrum XP Sometime
Clean Code Robert C. Martin Rather rare
Clean Architecture Robert C. Martin Rather very rare
Non-Solo Development Scott W. Ambler DAD Rather rare

Note (*) – Degree of usage is based on published statistics and by the observable number of references to these practices.

Unfortunately, in most cases, only “inside methods” have a larger adoption, because the Agile methods are used as “recipes” (… not in thein intention of the authors) or “closed universes”, where the practitioners avoid to assuming process responsibilities outside the methods border.

The consequence: some fundamental practices are rarely used and the resulted products are less adaptive because of their less adaptive design. The Agile promise is broken.

 .

SOLUTION – defining a set of indispensables practices

coverageWe need to find the set of indispensable practices for an Agile Design, but we need to be sure that we have enough coverage for all significant design-related aspects that will help us to keep the promise to be adaptive.

ASPECTS OF AN ADAPTIVE DESIGN – selected list:

  • Design principles
    • DPs that contribute to an adaptive design
  • Design level
    • Design context agnostic best practices to keep the product adaptive
    • Architecture context agnostic best practices to keep the product adaptive
  • Design process
    • Cleanup of the technical debt
    • Fast quality checks
    • Adherence to business needs and changes (efficient and effective)
    • Knowledge management in adaptive context
    • Evolving solution and effects on project definition

INDISPENSABLE PRACTICES PER ASPECT – Then, for each aspect, we need to find the sine-qua-non (indispensable) practices to deal with that aspect. This is the proposed list:

Aspects category Aspects Practices
Design level Adaptive design support Clean Code, Refactoring,Programming Style, Law of Demeter (applying)
Architecture level Adaptive design support Clean Architecture, Law of Demeter (applying)
Process level Pay the technical debt Refactoring
Fast quality check TDD
Adherence to business needs Simple Design, Product Backlog, Clean Architecture
Knowledge management Non-Solo Development, Product Backlog
Evolving solution, Project Definition Architecture Envisioning, Look Ahead Modeling, Model Storming, Continuous integration

Observations:

  • From similar practices are selected the ones with higher coverage.
  • Practices are inter-dependent and each of them will contribute to all the aspects and will enhance the results of the others
  • The selected practices must realize the selected design principles

INDISPENSABLE PRINCIPLES FOR AN ADAPTIVE DESIGN – These principles are part of the industry proven experience and are in the top recommendations for a good design a technical excellence. The other reason for including them in an agile related list is the contribution to the “adaptive” property of design.

Single Responsibility (of a design element): isolating responsibilities in functions, classes, components, services, sub-systems will make the system easy to build, change and maintain (… where the reasons are already part of the industry experience).

Separation of Concerns: that it is a higher level aspect of SR principle, where separation is rather considered at architectural level (layers, sub-systems) and the concerns are also high-level responsibilities (presentation, business, persistence, hardware interfaces, cross-cutting concerns). Each of these concerns could independently change and without decoupling them, the system will not be adaptive.

Functional Cohesion – that it is starting architectural/design decision that declares as main subjects of separation and decoupling:

  • Business concerns from technological concerns
  • Business concerns parts/functions from each other
  • Could be applied at any design level sub-systems, components, classes, functions

Law of Demeter – See “Practice – Applying Law of Demeter”

It is impossible to explain that you have an Adaptive Design and you will keep the Agile promise and also do not respect these principles.

 .

PRACTICE – XP practices: this is how Agile works

The good part is that XP (see [B-XP]) it is an wonderful representation about how Agile fundaments are working. Here we will talk just about Simple Design, Refactoring and TDD. These practices are helping to keep the toughest agile promises from the Agile Manifesto:

  • “…satisfy the customer through early and continuous delivery of valuable software.”
  • Welcome changing requirements, even late in development

Each of these practices will have its fundamental role:

Simple design – XP: “always do the simplest thing that could possibly work next”.

  • Request to focus only to current requirements, without trying to extrapolate the future ones. After a sequence of small releases, we will have a design properly adapted only to current business needs, not to hypothetically or obsolete ones (“junk stories”). Simple design means to be both focused and clean.

INDISPENSABLE – If Simple Design it is not used, then:

  • Increasing technical debt and waste caused by guessing future needs instead of waiting the new business context to be relieved. Increasing amount of implemented junk stories

Refactoring – Martin Fowler: “Improving the design of an existing code” by “applying a series of small behavior-preserving transformations

INDISPENSABLE – If Refactoring it is not used, then:

  • The technical debt is accumulating in high amounts and the code will NOT be cleaned, easy to read, to understand and change. The productivity will decrease and the product will be more fragile until becoming completely unstable
  • The previous simple design must be adapted to new requirements, and refactoring it is one of the most effective techniques

TDD – automatic tests, with high coverage at unit test level; the tests should be writing first.

INDISPENSABLE – If TDD it is not used, then:

  • There is no other technique to support QA/QC concerns in dealing with changes that occur “late in development” and that could offer quick, effective and efficient safety net for refactoring necessary regression tests
  • There is less separation of concerns

.

PRACTICE – Non-Solo Development (DAD)

XP introduce Pair Programming as essential Agile practices. The main meaning is to have “cooperative programming”. Unfortunately, this practice it is used too literally, only for direct coding activities. Yes, Agile has restored the importance of the coding in the overall development, but let think a little: what is the meaning of “Programming” from XP name? In fact, it is “Development”, where the effective programming/coding has fundamental importance. An XP programmer it is, in fact a multi-role developer involved also in planning, requirements, architecture, and design, coding and testing.

In DAD, Scott W. Ambler has introduced the term “Non-Solo Development” for a cooperative development approach that combines various kind of pair-development with solo-development.

INDISPENSABLE – If cooperative development it is not used, then:

  • All the needed design practices cannot be applied coherently and consistent
  • The needed design decisions will be rather under a minimum threshold of effectiveness and efficiency
  • The skills and the knowledge of the team will not match to the necessities
  • Agile process will not be enabled

.

PRACTICE – Product Backlog (Scrum)

The Product Backlog it is a very used practice, but its impact in the design is less known.

Note: An enhanced variant of the Product Backlog is the (Product) “Work Item List” from DAD.

INDISPENSABLE – If Product Backlog it is not used, then:

  • The work will not be serialized and refined in clear increments before starting the main development effort (iteration level)
    • Consequence: Not enough support for realizing a Simple Design,
    • Consequence: Paying the Technical Debt (using Refactoring or other techniques) has poor support on planning and visibility;
    • Consequence: less support to effectively connect to change requests and customer feedback in order to get and maintain Adaptive Products.

.

PRACTICE – Architecture Envisioning (AM, DAD)

AM (Agile Modeling) make explicit the architectural concern that should be addressed early in the development as Architecture Envisioning. This is the place where should be taken also the initial decision about Clean Architecture and most significant decisions related to Refactoring and TDD. (See [B-SWA])

INDISPENSABLE – If is not used, then:

  • The main technical risks will not be addressed early with all the resulted consequences
  • The planning will have no real support , because the necessary work it is mostly unclear.
  • The Clean Architecture rules cannot be applied (in the envisioning must be clarified how will be applied)
  • Decisions related to significant refactoring and to high level decoupling needs related to TDD cannot be taken at the appropriator time

.

PRACTICE – Look Ahead Modeling (AM, DAD)

AM (Agile Modeling) make explicit the design risks and complexity concerns that should be in advance in the development (as a refining of Architecture Envisioning) , as Look Ahead Modeling. This is the place where should be taken also tin significant decisions related to necessary  Refactoring  and TDD . (See [B-SWA])

INDISPENSABLE – If is not used, then:

  • The undesired complexity of the design will increase in the most sensible places
  • The plan updates and progress tracking are affected because of not updated information about solution
  • The TDD, Refactoring and Clean Code significant decisions will be affected

.

PRACTICE – Model Storming (AM, DAD)

AM (Agile Modeling) make explicit the design complexity concern that should be addressed JIT (Just-In-Time) in the development, when is needed,  as Model Storming . This is the place where should be taken also the possible decisions related to necessary  Refactoring  and TDD . (See [B-SWA])

INDISPENSABLE – If is not used, then:

  • The undesired complexity of the design will increase in the most sensible places
  • The TDD, Refactoring and Clean Code decisions will be affected

.

PRACTICE – Clean Code

The clean code rules are introduced by Robert C. Martin (see [B–CC]). Of course, there is an intersection and similarity with the refactoring rules introduced by Martin Fowler. The difference is rather at process level: Clean Code supposed also to write the proper code from the first time, combining with continuous cleaning and refactoring. In fact, we can combine Clean Code, Refactoring and other similar rules in a one single set where:

  • Clean Code is what we can want to obtain as code state/attribute
  • The first time code must be clean enough
  • Refactoring is the operation to pay some technical debts and get closer to the Clean Code state

Clean Code as a practice should represent all the small design and design level best practices that are generic, context agnostic and address most generic causes of producing the technical debt.

Examples of subjects for clean code rules: meaningful names, functions and class creations, comments, unit tests, building systems, simple emerging design and others. Example of generic rules and (solved) problems: avoid feature envy, misplaced responsibility, make logical dependency physical.

INDISPENSABLE – If clean code rules are not used, then:

  • Will be activated the causes that produce the most amount of technical debt – the code mess is systematically produced in huge amount.
  • The code will be hard and very expensive to read, change and fix

.

PRACTICE – Clean Architecture

The Robert C. Martin concept of Clean Architecture (see [B–CA]) suppose that according to the fundamental design principle of Separation of Concerns we will take from the start some architectural decisions (because it is always useful and it is context agnostic):

  • Functional cohesion – the system functions must be visible in its design: various business concerns are separated by design and the technological concerns from the business concerns. The non-functional aspects must be isolated and should be considered as details (!), because things as the used technologies could always change, but the representation of the core business must survive.
  • Dependency injection – main way used to separate the various concerns

Alistair Cockburn proposes the similar concept of Hexagonal Architecture (see [B-HA]), as opposite to un-balanced architectures where only user-interface and persistence are driving the architecture, beyond the business part: “application communicates over ‘’ports’’ to external agencies”.

Koni Buhrer proposes the Universal Design Pattern (see [B-UDP]),, which gives little more details than the Hexagonal Architecture and could be a good approach to implement a Clean Architecture.

INDISPENSABLE – If clean architecture rules are not used, then:

  • the core business is NOT protected from technological changes, because it is NOT decoupled from those aspects
  • the core business is NOT realized using functional cohesion, the product will NOT have the “business DNA”, and cannot be an Adaptive Product (see my previous post), cannot be changed quick, efficient, effective and sustainable with customer business changes
  • Successive changes related to business change will produce design and architectural level technical debt – affect the overall productivity and quality
  • Similar undesired effects for successive changes caused by technologies aspects
  • (dramatically) Decrease the effectiveness of TDD, because best criteria of decoupling are not applied and both code and tests will be change too often on business and technological changes.

.

PRACTICE – Applying Law of Demeter

The Law of Demeter (LoD) or principle of least knowledge – “The fundamental notion is that a given object should assume as little as possible about the structure or properties of anything else (including its sub-components), in accordance with the principle of “information hiding”.”

It was also subject of more research and has influence development of more patterns. For Demeter project, Karl Lieberherr created a so called “Adaptive Programming” based on this principle (see [B-AP]).

In our days, the Google Talks presentations bring back into public attention the significant advantages of this principle. Using this principle should be a specific way to create objects and functions, a specific way to share and distribute data and information between them: in any part of our code we should not use references to a global context.

Respect of this principle it is fundamental to make possible all other best practices: concerns decoupling and functional cohesion.

INDISPENSABLE – If Law of Demeter is not used, then:

  • Separation of concerns, functional cohesion, clean code, and clean architecture are severely affected by breaking this rule. Consequences:
    • High amount of severe technical debt it is introduced (by using global context anywhere in the code)
    • The code fragility could dramatically increase (any change and fix could produce many new defects)

.

PROLOGUE (sic!)

I have selected these practices and principles for an Agile design from the intersection from what I know  from the industry experience and my personal experience. The starting point was that no Agile process method has included (from what I know) the Clean Code and Clean Architecture practices and, also, the principles aspect was ignored (exception: the above mentioned Adaptive Programming) .

When I tried to categorize the Refactoring and  Non-Solo Development,  I have added also the process aspect. Later, thanks to a feedback from Scott W. Ambler were added the missing Architecture Envisioning and design modeling practices.

I have tried to find past endeavors about:

  • defining some practices as indispensable, where only Adaptive Programming have used a such logic
  • unifying these indispensable practices for an Agile Design

I have found almost nothing, and the searches about “Adaptive Design”  found results only in furniture domain and was similar for “Agile Design.

Better late than never… just yesterday (September 28) I have discovered a previous definition of an Agile Design:

http://agilemodeling.com/essays/agileDesign.htm

That it is part of Agile Modeling method (Scott W. Ambler) and contain: Architecture Envisioning, Iteration Modeling, Model Storming, Test First Design, Refactoring and Continuous Integration. Some comments: I think that Iteration Modeling is a sub-practice of Look Ahead Modeling (but indispensable by itself) and that Continuous Integration is also indispensable.

.

BIBLIOGRAPHY

[B- HA] –Hexagonal Architecture, Alistair Cockburn

[B- UDP] –Universal Design Patterns

[B- AP] – Using Law of Demeter. Adaptive Programming. Brad Appleton

[B- AM]- Agile Manifesto

[B –XP] – Extreme Programming

[B – CA] – Robert C. Martin (Uncle Bob) – Clean Architecture and Design-2012 COHAA The Path to Agility Conference

[B – CC] – Robert C. Martin – Clean Code: A Handbook of Agile Software Craftsmanship, Prentice Hall, 2008

[B – SWA] – Scott W. Ambler – Agile Modeling

Motto – The True corruption of Agile – Robert C. Martin

Agile product = Adaptive product

Product problems compromise value delivery

Agile most marketable and viral aspect it is “value delivery”. That sounds great, but that will not solve all the problems of the software development and also it is just a one-dimensional representation of Agile.

 
The biggest remaining problem for Agile development are the product problems.  Often delivery and small releases will address some well known problems in software development that too often will cause project failures. Small releases, working software and close customer collaboration will reduce the project level complexity, one of the major reasons for these failures. 
 
What about product problems? Generic problems are related with accumulation of technical debt, brittle architectures and loss of intellectual control over the product knowledge. We need a solution also for that aspect.
 .

Technical Excellence

 A great response to such problems it is introduced by Agile Manifesto by demanding “technical excellence” and good design. Jeff Sutherland says that as a conclusion after 10 year of the Agile Manifesto, “technical excellence” it is a key factor of success of Agile teams.
 
The question is if these two principles to follow – close to the customer and technical excellence – are sufficient to cover all kinds’ of possible problems.
 .

Others problems

A tough real-life scenario is related to new products or new significant part of the product that need to be distributed, deployed to more clients. An initial one-time distribution to more clients it is rather Waterfall than Agile despite the fact that developing could use iterations and customer collaboration. There are several reasons for that: a full-new product deployment it is equivalent with a big release (also with a rare delivery) and it is hard to imagine that we will work close with all the customers.  
A great Agile solution for such kind of problem suppose, an (obviously!) incremental approach. Scott W. Ambler has described such solution here (“An Exploratory “Lean Startup” Lifecycle”):
 This problem and the product knowledge problem need supplementary solutions.
 .

Solution step #1 – Inject the business

The main conclusion is that we have a supplementary dimension of Agility beyond often delivery: we need to often and continuously inject back the business into the product. The product should be kept close to the business where will be integrated.   
 
 .

Solution step #2 – Products with “Business DNA”

Other question:  how we could know that that business “injection” will be effective, when some recurrent problems are the loss of the intellectual control over the product knowledge and the product fragility because of increasing technical debt. Let remember what will request Robert C. Martin if will be your CTO (): “We will not ship shit.“, “You will always be Ready.”, “Inexpensive Adaptability.
 
We will always be ready with inexpensive adaptability if will be performed a creative work to model that business before include it in the product.
The deliver product or product change will need to “live” inside the customer business and will need to adapt and evolve in that environment. 
.
 
In order to realize a „natural” evolution inside the target business, the software system must have „Business DNA”. Translating that in engineering measures that mean all architectural aspects must serve that business integration.
.
 .

Solution step #3 – Implementing the “Business DNA”

There are some software engineering instruments that could build and protect the „Business DNA” for a software product.
.
 
Functional cohesion
  • The core structure of the software should match the real business functions. A change in the business will be reflected with minimum effort and with maximum quality in these cases
  • That will be the core representation of Business DNA
Separation of concerns
  • Beyond any particular architectural or design patterns, a basic rule is to kept distinct concerns decoupled. A default separation should be the one between technological aspects and functional aspects
  • That will protect the Business DNA from technological changes
Good design & technical excellence
  • Good design will enhance any software development enterprise  
 .

Solution step #4 – Agile product = Adaptive product

 
The missing link in Agile Development seems to be a principle that requires an “Adaptive Product”, with good design and “business DNA”. We should always think to “Agile Products” as “Adaptive Products”.
%d bloggers like this: