Agile Architecture (MAE slides with speaker notes)

Agile
versus?
Architecture
Sunday, November 18, 12 1

This presentation is about Software Architecture and its relationship to Agile practices.

There is often a kind of tension between Agile Concepts and Architecture concepts.
Why is that?
What can be done about it?

• “Who Needs An Architect?” by Martin Fowler
- http://martinfowler.com/ieeeSoftware/whoNeedsArchitect.pdf

• “Architecture” video by Uncle Bob (Robert Martin)
- http://www.cleancoders.com/codecast/clean-code-episode-7/show

• “Emergent Design and Evolutionary Architecture”
by Neal Ford - http://www.thoughtworks.com/emergent-design
• “Design == Code” by Jack Reeves
- http://www.developerdotstar.com/printable/mag/articles/reeves_design_main.html

• Zen and Enterprise Architecture (me at IASA)
- http://richardalexandergreen.wordpress.com/2011/08/17/proﬁl/zen-and-enterprise-architecture/

• Agile SOA, Agile EAI (me at IASA)
- http://richardalexandergreen.wordpress.com/2011/08/17/proﬁl/agilesoa_iasab/


I am putting the links up front instead of out back.

- If you want to understand this subject better,
I can think of no faster way than watching Uncle Bob’s “Architecture” video.
It is well worth the $___ and 90 minutes it will cost you.

Tooting my own horn: I’ve also presented two technical “how to do it” talks at two regional
“International Association of Software Architects” (IASA) conferences.

Deﬁnitions

• Architecture
is an aspect of design.
- It is the aspect
where the designers decide
how the components
will be organized.


Metaphors
• Enterprise Architeture
is like urban planning.
- There is a big-picture plan,
but it has to be developedone project at a time.

• Application Architecture
is like the ﬂoor plan of a building.
- It identiﬁes the major functional areas
and indicates how they communicate.

• Program Architecture
is like the layout of a refrigerator.
- It indicates the design patterns to be used
by those who work on various types of modules.

Sometimes there is tension between
Agile concepts and
Architecture concepts


Now back to our story.

Many people, especially project managers, perceive a tension between Agile practices and Architecture practices.

These tensions are real, not just perceived.

I have been an Enterprise Architect, but I am trying to quit.
My point of view is largely that of an architecture proponent.
But I have also been a project manager, methodologist, business analyst, strategic planning consultant, and still program in
Smalltalk, Java, and Erlang.
So I tend to think I can also think in other contexts.

Later, Suzanne and Scott and you in the audience will have a chance to talk about your experiences in this context.

What
will we
be asked
to do?

One of the drivers of the tension between Agile and Architecture
is that people outside your team feel
that they need some advance notice
so that they can be ready for deployment
or provide budget.

Traditional Planning Needs
• Tradition: Long lead times
for infrastructure purchases and installation
seemed to require early planning.
• Tradition: The stafﬁng of the project
is based on the target framework
for the product.
• Tradition: Once the project is rolling,
service, database, and desktop engineering
all want to know how and when
they will be expected to contribute.
- One of the drivers of the tension between Agile concepts and Architecture concepts
is that traditionally there were long lead times for infrastructure.
- Many companies still have an annual planning cycle that is driven by their budget preparation process.
That means that their average response time is on the order of 180 days.
When I worked for Ford Power-train Engineering, we ﬁgured software time-to-solution
was on order of 3 years for new projects because of the way budgets worked.
- But even if budgeting was not a constraint,
traditionally there were other things that drive planners and managers to want an early forecast of infrastructure needs.
- If you ask your server engineering folks for a host, how long will it take them to provide it?
- Do you need to know what technology will be used for your product before you staff your project?
- Once your project is rolling,
how much lead-time do your infrastructure support groups need or want before you deploy at scale?

HOW MUCH HOW SOON?


The essential question is how much can be known at various stages of the project.

Early on, we can only predict some big picture aspects.
As the project progresses and individual features are created in an Agile process, detail is
developed “just in time” as needed.

Planning process
tends to want
up-front designs
while agile
prefers to keep
options open.
• Traditionally, (pre-agile) Architecture
wants to preview
how the application will be deployed.
• In effect, several stakeholders
want to know the how
before the what is well established.

Also, of course, not-so-agile project management traditions
tend to want up-front designs and forecasts.

Those who wish to assure themselves that things are under control
want often follow the idea that there should be a roadmap and schedule
and expect reports that show that the project is on the path and on schedule.

Experienced managers know that this form of control only works for low tech projects.
Military ofﬁcers have a saying: “No plan survives contact with the enemy.”
So other systems of control are needed.
As Agile people we have a control system based on evolution rather than a priori science ﬁction.

Keep
options
open

Being agile in any context requires keeping your options open.

The remainder of this presentation
is mostly about various ways you can keep options open.

A good architecture allows you and your business partners the ability to
experiment,
change you mind,
and respond to changes
without getting in your own way.

Deploy via cloud
until that
becomes
too
expensive.
Risk:
This trades lead-time advantage
for other problems.


Currently, many people are suggesting
that you can work around infrastructure lead times
by deploying in the cloud.

I’ve never done that,
so I can’t really say that I know enough about it to predict the trade-offs.
Again, it is worth some thought.

Have any of you deployed in the cloud?

Design
so that you can
switch frameworks
with minimum costs.

Risk:
Such designs
seem too abstract
to some, and
they will
ignore the design.


Any software architect worthy of the name
will know design patterns and programming practices
that will enable the team to switch to another deployment framework.
However,
many programmers and project managers
will ﬁnd the architecture diagrams too abstract.
As a consequence, they will ignore the design.

This strategy works best with people who have strong object-oriented design experience.

Tell everyone that the early releases
are prototypes
to test usability (or some other quality).

Risk: All too frequently
the "prototype" message
means different things to different people.


One technique that is frequently suggested is . . .

tell everyone that your early releases are prototypes.

My own experience is that this can be very dangerous
but it is worth thinking about.

Let the architecture emerge.
Risk:
Many teams
do not
know how
to do that.
(See next)


An additional strategy is to allow the architecture to emerge
as the implementation is developed.

The basic idea is that early concepts of the architecture
are often wrong
and/or examples of pre-mature optimization.

Uncle Bob says that when he and his co-inventor were developing ﬁtness,
they assumed they would need a database to support persistence.
In the end, they discovered that persistence, in their case, did not require a database.

Agility means
keeping your options open.
Try to remember
that business practice, policy, and strategy
will change.

Defer decisions
to the last responsible moment.

Embrace change
- avoid strategies that constrain the future
of the product.

Define components
and coding practices
that minimize the costs and risks of change.


These are design principles that apply to architecture and agile programming.
- Don’t hard-code a business practice into your product if you can avoid it.
. . What will happen to your product if the practice changes?
. . Don’t hard-code a business policy.
. . What will happen to the investment in your product
if your client changes their business strategy?
- Whenever possible, defer decisions to the last responsible moment.
. . This can be very difﬁcult because it resemble vacillation.
- To embrace change you need to avoid strategies that constrain the future of the product.
. . Try to make sure that a plan B will be available.
- A good architecture allows you to replace components with minimal impact.

Architecture is not about
tools and frameworks.

Architecture is about collaboration
collaborating components
and collaborating teams.

Architecture
defines the roles and responsibilities
of components.

A good architecture (and coding practice)
allows components to be replaced
with minimal costs.


Architects and vendors sometimes cause people to think that architecture
is about the tools and frameworks that you use.
However, think about this:
- An out-house has a certain architecture. Does the architecture change when the construction material changes?
It will have the same essential architecture whether it is build of straw, wood, brick, stone, or ﬁberglass.
- A client-server application should have the same basic architecture
whether it is built using visual basic, or one of three dozen web application frameworks.
- The architecture of any system is really about
assigning roles and responsibilities to the various components of the system.
This is true whether the architecture is for a bridge, a city, an aircraft, a vehicle, a business, or a software product.
But an agile architecture will allow any of those components to be re-engineered at will.

Good architecture
is like good
object-oriented design.
You design for
coherence,
minimal coupling,
potential re-use.

The difference between architecture and object-oriented design
is mainly a matter of context.

Well-designed components are like "black box"
Other components see the interface,
but don't need to know what goes on inside.

Black boxes are defined by their interfaces.
Defining the interfaces clearly (and early)
will enable and expedite collaboration
between programmers and teams.
- Here is how hardware and software architects think about systems.
They think about the components as black boxes.
- Software architects tend to apply the same concepts that are recommended for good object-oriented design.
They design components that have good coherence, minimal coupling, and potential re-use.
The difference between software architecture design and object-oriented design is mainly a matter of context.
- Back to black boxes.
The essential idea is that you don’t need to know exactly what is going on inside the black box.
You deﬁne the function of the black box by specifying its interfaces with the outside world.
Deﬁning interfaces is the basis basic skill for being agile in architecture.
- A modern automobile has over 3000 parts. They are typically designed by almost as many engineers.
But they come together on the assembly line with very good predictability.
An agile company can bring a new automobile to market in about 24 months from concept to production.
How do they do that?
They focus their attention on the interfaces between the components.

Technique


There are techniques that can be applied at various levels of design.

In an enterprise context,
certain "applications"
(and their corresponding teams)
are the natural candidates
for certain responsibilities.
- Example: Customer contact data
is owned by Customer Relationship Management
(CRM) system.

- Example: Contacting a customer
should involve CRM
when Field Service (another system)
requires some contact.

- As an enterprise architect,
I tend to want a function to be assigned cleanly to a single component.

- But consider this, a field service person might need to contact a customer to confirm an appointment.
It seem natural enough that the field service person might contact the customer using their own cell phone.
But, what if the customer does not get the field service cell phone number and they phone your call center?
Will the call center understand what is going on?

- If something goes wrong, will we have a record of the various conversations so that we can respond intelligently.

Our customer expects us to act as if we are a single brain with some level of intelligence.


Okay. We could say that each customer contact should go through the
Customer Relationship system.

That kind of decision seems obvious enough,
but at the application level,
such assignments are not that obvious.

In an application design context,
there are various techniques for
predicting needed interfaces.
(At first, the designers might not have a clear idea of what the component actors
will be, let alone what they need to say to each other.
But there are team ideation and collaboration techniques
that tend to drive these things out quickly.)

-CRC cards = Class Responsibility Collaboration cards.

- Use Case Scenarios. Story Cards

- There is a variation on Behavior Driven Design (BDD)
where the design team starts from an BDD test
and proceeds to create stub code and interface definitions.
(This is similar to a CRC session,
but it creates interface code instead of cards.
It is slower but more precise.)

- At the level of the application architecture,
it is often not at all obvious how responsibilities for various functions will be assigned.
But there are techniques for quickly making educated guesses.
Here are three techniques that your design team should know.
I won’t explain these because each one could be the subject of an 3 hour tutorial.

- CRC cards provide a way of writing down the basic functions to be performed and identify collaborations.
- Use case scenarios provide a way of writing out the sequence of collaborations.
- A somewhat newer technique is based on behavior driven concepts.
The basic idea is that you start with the original request and work your way to the needed class interfaces.
The advantage of this technique is that you can write the interface speciﬁcations in code.
It gives you a more precise speciﬁcation but it takes more time.

there are design patterns
and programming conventions
that teams discuss and agree to follow.

- Late Binding:
Dependency Injection vs. Class Factory vs. RPC

- Initialization: Automatic / Lazy / Eager / How much?

- Conventions for documenting methods / messages.
(Write an English sentence describing the action / fact.)

- Logging: Which logging framework?
What/When/Why to log at each level of logging.

- How to model a real-world concept in data?
(measurement, money, date, time-stamp, location)

At the level of a program,
teams make decisions about how programs will be organized and written.
These decisions deﬁne patterns
that the team members are expected to follow.

The goal is make all of the programs look alike
so that a team member or future maintainer
can easily read the code.

Agile
Architecture

In summary, if you want to be agile with architecture
and enable collaboration inside and outside your team,
focus everyone’s attention on how interfaces are deﬁned
and in how they evolve over time.


Now for some stories from the front-lines

and from someplace behind the lines.

Agile Architecture (MAE slides with speaker notes)

More Related Content

What's hot (17)

Similar to Agile Architecture (MAE slides with speaker notes) (20)

More from Richard Green (7)

Recently uploaded (20)

Agile Architecture (MAE slides with speaker notes)