Category Archives: Adaptive Design

The One-Question Programming Interview

What are your concerns when you are writing a function?

New product and Minimum Viable Process with DAD

A live ecosystem

With a new product we will initiate and we must keep “alive” a full ecosystem (see previous post “A product … is not a product“) that involve:

  • business relationships
  • a viable process economics
  • sustainable technical solutions
  • a product team(s)
  • repeatable results
  • an evolving consumable solution and others.

What help me and my collaborators in some real cases were Disciplined Agile practices and some complementary ones such Clean Code and Clean Architecture.

“Temptations” and consequences

The first temptations on building new products were we have observed undesired consequences:

  • Copy-Paste Process: just repeat – without sufficient adaptions – the process from the existing products (more or less similar with the new one). The pressure could compromise more this process “re-usage”.
  • Ad hoc process:  If an existing process is not available, an ad hoc process is adopted without sufficient discipline and many process goals are neglected
  • “Normal” life-cycle: direct re-use a “normal” project life cycle, standard for the past projects/products
  • Ad hoc team: superficial building of product team, without sufficient collaboration and skills

The consequences could be very unpleasant:

  • A fragile product, where the poor design does not allow to reach the opportunities:  cannot deliver required changes, cannot offer a sufficient quality
  • The product is not consumable: not enough user level guidance, integration problems, performance problems
  • A significant mismatch between offered features and customers’ needs

 Different product – different ecosystem

We cannot re-use the process of a previous product as it is – the elements of the necessary ecosystem could vary more or less, and here are some elements that we found to be different:

  • The inherent complexity of business domain or of the solution
  • The customers & associated relationships
  • Derived from complexity: team skills, minimum viable good design
  • Required quality
  • Default performance
  • Others

As a first conclusion – we need to inspect and investigate the new context and adapt our process in order to build the proper ecosystem. Context investigation and adapting the process must be some permanent concerns, but the expected big deviation introduced by a new product must tell us that this is a special case to be considered.

 Risks, incertitude and opportunities

New product means a higher degree of risks, incertitude, but also possible opportunities. Risks and incertitude must be addressed in order to protect the opportunities and in the same time we need to keep the process adaptive enough to respond to these opportunities.

The main question is what practices and approaches we will need in a such context? We have found some that works.

Incertitude adapted life-cycle

For a new product, it is less likely to have a good enough initial envisioning of the requirements (and of the solution).  The DAD option of exploratory lean startup life-cycle propose a more adaptive approach where initial idea could be repeatedly adjusted after getting business domain feedback about what we incrementally build.

Choosing the right process options

As I have mentioned, the process “deviation” from what we know could be significant. Anyway, the process goals will be similar, but is possible to be needed to choose some different options. DAD main logic was built exactly on this idea. Beyond life-cycle approach we can choose various options for goals such: technical strategy, prioritization stakeholder’s needs, requirements elicitation methods, prove architecture early, validate release.

Some examples of options per goals described by DAD guidance:

  • Architectural spikes and/or end-to-end skeleton for proving the architecture early
  • Business values, Risks, dependencies as criteria for prioritization stakeholder’s needs
  • Coaching, mentoring, training, pair programming for Improving team members skills

When we begin a new product: best time to start adapting our options to the new context.

Effective practices

Building a new product it is difficult endeavor from many points of views: requirements clarification, solution design, (new) knowledge management. Here some key approaches and associated practices that we have found to be successful/helpful.

Effective/Efficient collaboration – apply Non-solo Development for modeling (Model Storming) and programming (Pair Programming). Active Stakeholders Participation.

  • Non-Solo Work it is critical for high difficult tasks related with initiating a new product
  • Because knowledge is just newly created we need to efficient/effective distribute that knowledge to the other team members and to the stakeholders

Opportunistic envisioning – Look Ahead

  • We cannot solve complexity and incertitude only with normal milestone-based forms of looking ahead – Inception Envisioning and Iteration Modeling. It was very useful to opportunistically use Look Ahead Modeling.

Knowledge evolution – Document Continuously, Document Late

  • Knowledge is just created – we have suffered when we forgot to capture, at least the essential – Document Continuously help us on this aspect
  • From time to time, we have extracted later some overview information (System Metaphor, Architecture Handbook), when our view and results has been stabilized – Document Late

Adaptive process –now is the best time to do that

  • The process was rather fluid and was defined/clarified as we advanced and saw what really works in the new context.
  • Good options were demonstrated by
  • Do Just barely good enough and refine not only your work, but also your process in rolling wave. Use events as architecture envisioning, look ahead modeling, iteration modeling to adapt your process

Minimal good design

When a new product was started, before and after the Minimum Viable Product, we were forced to keep change the product quick and with a sustainable pace. In order to “chase” the opportunities, we had to pay legacy technical debt and avoid as much is possible a new one. A minimal good design, it is necessary to deal with this continuous changes in the case of context complexity.  In this case, Refactoring,  Clean Code, Clean Architecture practices were the backbone for an agile, adaptive design and finally of an adaptive product.

Each distinct product will need a specific Minimal Good Design!

Some conclusions

DAD is built to offer context-adapting guidance. Using Disciplined Agile and outstanding practices as Clean Code and Clean Architecture it was be what we need to build a new product and to define the Minimum Viable Process necessary for that.

DAD and Agile Modeling practices are described here.

Bonus!

Software architecture – searching for a better definition

 Software architecture – land of confusion

Architecture it is still a big elephant in the room for software engineering in general and agile in particular. We do not want to make supplementary mistakes because of unappropriated definition or understanding.

Possible problems:

  • Focus on “paper architecture” instead of proven architecture by working software
  • Focus on structural aspects and disregards others because lack of understanding for the behavioral dimension or the needed consistency using an architectural style
  • Poor real architecture because the goals of the architecture are not understood very well

You can find below some comments about some definitions from significant sources, similarities with construction domain and Uncle Bob notes about “fundamental architecture”.

Wikipedia definition

 “Software architecture refers to the high level structures of a software system, the discipline of creating such structures, and the documentation of these structures. It is the set of structures needed to reason about the software system. Each structure comprises software elements, relations among them, and properties of both elements and relations. The architecture of a software system is a metaphor, analogous to the architecture of a building.” (https://en.wikipedia.org/wiki/Software_architecture)

 According to this source, architecture is the:

  • Structure of the system ….
  • Process of creating …
  • The documentation …
  • A metaphor …

Strange, I could bet that is none of these things! Here are some comments.

Structure … A software solution (“system”) it is represented by both structural and behavioral dimensions. Of course, if there are sub-systems and components, encapsulating both structure and behavior, we could metaphorically (!) say that these subsystems/components are the “structure”.

Process … it is not – it is just a language convention to use “architecture” term also for the “process of creating the architecture”.

Documentation…it is not. Only if the documentation is 1:1 with the real architecture, we could use the term “architecture” for the documentation. For most of the software systems, there are significant differences between paper architecture and real architecture. A better term it is “architectural description”.

A metaphor… we can use metaphors, but if we will implement them, we will build a poem, not a software system.

MSDN definition

 “Software application architecture is the process of defining a structured solution that meets all of the technical and operational requirements, while optimizing common quality attributes such as performance, security, and manageability. It involves a series of decisions based on a wide range of factors, and each of these decisions can have considerable impact on the quality, performance, maintainability, and overall success of the application.” (https://msdn.microsoft.com/en-us/library/ee658098.aspx)

Process … see above comments.

Quality attributes … another metaphor. Usability, Performance, and others are non-functional requirements, and the quality is the degree of adherence to any kind of requirements. The architecture must fulfill all types of requirements, including the non-functional ones.

IEEE Standard 1471-200 definition

3.5 architecture: The fundamental organization of a system embodied in its components, their relationships to each other, and to the environment, and the principles guiding its design and evolution.”

Components … This definition could work for a component-based architecture, where both structure and behavior are intuitively represented using components. In many cases, various structures and behaviors are mixed, “melted” in a single component, and this definition it is unusable.

SEI definition

 “The software architecture of a program or computing system is a depiction of the system that aids in the understanding of how the system will behave.

Software architecture serves as the blueprint for both the system and the project developing it, defining the work assignments that must be carried out by design and implementation teams. The architecture is the primary carrier of system qualities such as performance, modifiability, and security, none of which can be achieved without a unifying architectural vision. Architecture is an artifact for early analysis to make sure that a design approach will yield an acceptable system. By building effective architecture, you can identify design risks and mitigate them early in the development process.” (http://www.sei.cmu.edu/architecture/)

 A description, a blueprint… See “Documentation”

Defining the work … see “Process”

Artifact … see “Documentation”

A better definition

Philippe Kruchten, Grady Booch, Kurt Bittner, and Rich Reitman, Rational ( starting from the work of Mary Shaw and David Garlan) are using this definition:

 “Software architecture encompasses the set of significant decisions about the organization of a software system including the selection of the structural elements and their interfaces by which the system is composed; behavior as specified in collaboration among those elements; composition of these structural and behavioral elements into larger subsystems; and an architectural style that guides this organization. Software architecture also involves functionality, usability, resilience, performance, reuse, comprehensibility, economic and technology constraints, tradeoffs and aesthetic concerns.”

(See https://pkruchten.files.wordpress.com/2009/07/kruchten-090608-agile-architecture-usc.pdf)

This seems to be a much better definition. Architecture encompasses the set of significant decisions about the software system organization, including more aspects: structural elements, behavior, composition of these structural and behavioral elements and an architectural style.

 Summary & Conclusions

Definition – Architecture is about the most important decisions related to the software system (the software solution), including various aspects (see Krutchen& definition)

Requirements and quality – Architecture should address all kind of requirements: functional, non-functional and constraints. The architecture contribute to the system quality, that it is adherence to all these requirements. A modern approach for a better quality is to have a “built-in quality”, and architecture has a major role here.

Process – There is a process of realizing the architecture – “architecting” – that could be different for various software process and design approaches

Documentation – We could document the software solution less or more. Representing the most significant decisions related to the software solution, architectural aspects are the first candidates for a such documentation. A good approach is to have also all architectural intents and decisions directly visible in resulted product.

Similarities with construction domain (?)

In construction, the architecture it is usually split from engineering aspects: structural engineering, mechanical, electrical. In software domain, all the aspects of the solution are part of the architecture. More: the solution in the construction domain is less evolutionary, and the documented architecture & documented engineering (the artifacts), are less likely to be different than the final result.

Uncle Bob: fundamental architecture and details

For Robert C. Martin, the architecture seems to be very similar with the one from construction domain, but in fact I think he use a metaphor to point out what matter most on creating a software architecture.

 “Is the web an architecture? Does the fact that your system is delivered on the web dictate the architecture of your system? Of course not! The Web is a delivery mechanism, and your application architecture should treat it as such. The fact that your application is delivered over the web is a detail and should not dominate your system structure. Indeed, the fact that your application is delivered over the web is something you should defer. Your system architecture should be as ignorant as possible about how it is to be delivered. You should be able to deliver it as a console app, or a web app, or a thick client app, or even a web service app, without undue complication or change to the fundamental architecture.” (See http://blog.8thlight.com/uncle-bob/2011/09/30/Screaming-Architecture.html)

This is my translation: Martin try to correct those interpretations, where the Web – a delivery mechanism, as he mentioned – it is considered an “architecture”. And it is not! It is a detail (an architectural detail). This “detail” should not affect the rest of the architectural decisions, which could be far more important. Forr this reason details should be decoupled (“as ignorant is possible”) from the “fundamental architecture”.

What is this “fundamental architecture” ?

We can consider the part that realize the functional requirements as fundamental and should not be mixed with frameworks, delivery mechanism and other “details”. That it is the “Form follow function” principle applied in software engineering. If we search carefully, we can discover that many recommendations for a good software design contains a such approach.

Just in time and Envisioning versus complexity

Principles for reducing complexity:

Apply envisioning for accessible information and just-in-time for what is far from certainty.

That is matching with the logic of Stacey Matrix.  Just-in-time is not (always) a silver bullet.  We need process approaches that effectively cover both dimensions #agilemodeling #DAD

%d bloggers like this: