Agile architect

From Pearl Language
Jump to navigation Jump to search

…creating and evolving a product while embracing change.

✣  ✣  ✣

The best architectures, requirements, and designs emerge from self-organizing teams.


Grow a system, don't build it.

✣  ✣  ✣

✣  ✣  ✣


Agile Architect Role

At Spotify, they have a Chief Agile Architect role, a person who coordinates work on high-level architectural issues that cut across multiple systems. The Chief Agile Architect reviews development of new systems to make sure they avoid common mistakes, and that they are aligned with our architectural vision. The feedback is always just suggestions and input—the decision for the final design of the system still lies with the squad building it.

The agile architect leads and coordinates technical activities and social objects throughout the product's lifecycle. The agile architect establishes the overall structure for each architectural view:

  • the decomposition of the view;
  • the grouping of elements; and
  • the interfaces between these major groupings.

Thus, in contrast with the other crew members, the agile architect's view is one of breadth, as opposed to depth. breadth first, then depth.

"The ideal architect should be a person of letters, a mathematician, familiar with historical studies, a diligent student of philosophy, acquainted with music, not ignorant of medicine, learned in the responses of jurisconsults, familiar with astronomy and astronomical calculations."
—Vitruvius, circa 25 BC.

In short, the architect:

  • must be well-rounded;
  • posses maturity;
  • radiate vision; and
  • show a depth of experience.

These traits allow the agile architect to grasp issues quickly andmake educated, critical judgements in the absence of complete information.

More specifically, the agile architect must combine the skills of:

  • Experience, both in the problem domain (through a thorough understanding of the requirements) and the software engineering domain. If there is a team, these qualities can be spread across the team members, but at least one architect must provide the global vision for the product.
  • Leadership, in order to drive the technical effort across the various teams, and to make critical decisions under pressure and make those decisions stick. In order to be effective, the agile architect and the product owner must work closely together, with the agile architect leading on the technical issues and theproduct owner leading on the product issues. The agile architect must have the authority to make critical technical decisions.
  • Communication, to earn trust, to persuade, to motivate, to mentor. The agile architect cannot lead by decree, but only by merit and consent. In order to be effective, the agile architect must earn the respect of the product team, the product owner, the on site customer and the user community, and the leadership team.
  • Goal-oriented and proactive, with a relentless focus on results. The agile architect is the technical driving force behind the product, not a visionary or dreamer. The career of a successful agile architect is a long series of, potentially sub-optimal, decisions made in uncertainty and under pressure. Only those who can focus on doing what needs to be done can be successful in the environment of the product.

From an expertise stand-point, the agile architect must encompass all the capabilities of the Engineer and Designer.

If the product is large enough to warrant an architecture board, the goal should be to have a good mix of talents, covering a wide spectrum of experience and sharing a common understanding of product engineering process. The architecture board should not be a committee of representatives from various teams, domains or contractors. Architecture is a full-time function, with staff permanently dedicated to it.

Engineer/Designer Architect
Depth Breadth and some depth
Is it makeable? Risk mitigation
The code What is important besides the code
Problem solving by accounting for details Problem solving by ignoring details
Up-to-date general knowledge Up-to-date general and product knowledge
Self or small team Keeping big team together:
  • Maintain Architectural Integrity
  • Communicate & Lead
  • Buffer techies vs. non-techies

The product owner allocates resources, shapes priorities, coordinates interactions with the customers and users, and generally tries to keep the product team focused on the right goal. The product owner also establishes a set of practices that ensure the integrity and quality of product's social objects.


The engineer/designer role defines the responsibilities, operations, attributes, and relationships of one or several classes, and determines how they will be adjusted to the implementation environment. In addition, the engineer/designer role may have responsibility for one or more design packages, or design subsystems, including any classes owned by the packages or subsystems.

The engineer/designer must:

  • have a solid working knowledge of:
    • user story or story board modeling techniques;
    • system requirements;
    • design techniques and practices;
    • technologies with which the system will be implemented.
  • understand the architecture of the system;
  • understand the role of system testing;
  • have a working knowledge of configuration management principles.

==InfoQ » Coplien & Henney » Agile Architecture Is Not Fragile Architecture Free interpretation of InfoQ: Agile Architecture Is Not Fragile Architecture by Martien van Steenbergen.

By James Coplien and Kevlin Henny.

  • Agile Architecture is not a blueprint.
  • Agile Architecture is about what changes you can ignore.
  • Agile Architecture is about impactful choices up front that will make later chioces easy..
  • Agile Architecture is not laissez fair.
  • Agile Architecture embodies the critical design decisions that typify a system: relates to cost of change, organisational structure (isomorph; ...'s law)m structure of code, capabilities of a system, etc.
  • Agile Architecture is about the significance of decisions that need to be understood and assessed.
  • Agile Architecture is about to see the forest for the trees.
  • Agile Architecture is subject to change.
  • Agile Architecture is not about insuring fear.
  • Agile Architecture is about stable ground, but not frozen (static) ground.
  • CAT DOG—Component Architecture Group and Distributed Objects Group
  • Agile Architecture is about a shared vision that educes the best out of smart knowledgeable developers and delivers (business) value in the most effective and efficient way.
  • Agile Architecture is not about big (outdated buggy) documents.
  • Agile Architecture is about the documentation that packs the punch, that describes what matters.
  • Agile Architecture is about writing that what matters in a way that matters (go, have a writing course).
  • Agile Architecture is about getting a Mercenary Analist.
  • Agile Architecture is about empowering local decisions (decision makers near the action).
  • Agile Architecture is about patterns and principles.
  • Agile Architecture is about team conversations and communication and team effort and team organisation and team structure.
  • Agile Architecture is about minimal coupling and maximum cohesion.
  • Agile Architecture is about speeding up, getting velocity in your team.
  • Agile Architecture is the foundation for interaction design (GUI)—The Interface is the Program, (Raskin))—the user interacts almost immediately with the architecture (tightly linked through the user interface).
  • Agile Architecture is about separation of concerns, not about divorce—invites to focus on protocol over API.
  • Agile Architecture is guided (driven) by interaction design (and the domain model).
  • Agile Architecture is about understanding the thing you are building, about the process of building it, and about making progress in building it.
  • Agile is an adjective (bijvoegelijk naamwoord)—having the faculty of quick motion, nimble, active, ready. Latin: to do. (You actually have to do something.) Agilious.
  • Agile is not a method, a religion. (Although, in the English language, you can verb any noun and noun any verb.)
  • Agile can describe a process, an organisation, an architecture, a mentality, an attitude, a mindset, a skill set, etc.
  • Agile is not "done" (you cannot "do" agile).
  • Agile does not sound scary.
  • Agile Architecture makes you ready.
  • Agile Architecture makes you active.
  • Agile Architecture makes you nimble.
  • Agile Architecture enables you to move quickly.
  • Agile Architecture is good when it reduces the significance of decisions (so you can have decision makers near the action with confidence).
  • Agile Architecture helps amortising cost of change. (Architectuur helpt met teniet doen van veranderkosten).
  • Agile Architecture helps releasing energy and passion in those who use it, live it or grow on it.
  • Agile Architecture becomes ossified (verbeend, versteend, afgestompt) door FUD (AOT) en bureaucracy.
  • Agile Architecture is about making the hard decisions early so the easy decisions become easier. Doing the easy ones first makes the hard ones harder. Metpahor: fill up a barrel with various size stones: first the big ones, then the small ones: gives more leverage: the small rocks will find the spaces to fit into.
  • Agile Architecture is about discrimination between reversible and irreversible decisions (at the appropriate time; sometimes knowing that it is or will be an important decision, and you are not yet able to decide but know when you must be. So you can safely defer your decision until then).
  • Agile Architecture is about forgiveness and that it is okay to make mistakes.
  • Agile Architecture is about sustainability of people, process and code.
  • Agile Architecture is about feedback at different levels of (time) scale.
  • Agile Architecture is about awareness and visibility of what is being built and how.
  • Agile Architecture is about the right detail at the right time and in the right place (TDD).
  • Agile Architecture facilitates and guides test-driven development.
  • Agile Architecture is about the engagement of the people in the process.
  • Agile Architecture is about failing comfortably fast (rather than slow and in an agonizing and painful) and knowing about it.
  • Agile Architecture is about fashionable systems.
  • Agile Architecture is about dramatically reducing risk at all levels.
  • Agile Architecture is about dramatically reducing evolutionary costs (operations and maintenance, even demolition).
  • To Architect is not a verb. To Design is. Architecture is a product of design.
  • Architects are developers, coders and designers.
  • Agile Architecture is about (SSSUFD) Some Short Small Design Up Front.
    • Ten minutes is good, half an hour is max.
    • Let the code participate in the design session.
    • BUFD the project slayer.
    • Analyze This To Death (ATTD).
    • Fear-driven design (FDD) vs. Courage Driven Design (CDD) with TDD at different levels of (time) scale for your feedback loops.
    • Niels Bohr: Be careful about predicting things, especially if they concern the future. The joy of quantum mechanics.
    • BUFD is on one extreme.
    • NUFD (No Up Front Design) is the other extreme.
    • Can work under condition (circumstances) degree of familiarity.
    • There is no such thing as NUFD—your years of experience do count as UFD.
    • Architectural patterns are UFD based on up front experience.
    • NUFD needs YNUFE (You Need Up Front Experience)).
    • Risky paths do need SSSUFD.
    • RUFD (Rough Design Up Front): give me the map, the whole elephant, the countours, the vision, the overview, that's enough. I can then figure out the right details at the right time.
    • How much of RUFD is enough?
      • It depends.
      • Develop your feel about it.
      • It can take as long as two sprints and as short as about a week.
      • A nice packaging is to use a single sprint.
      • Must have working code at the end of this sprint.
      • Deliver your architecture as code, as abstract base classes and some base-lined documents.
      • It grounds you in reality and gives you the platform to take off and implement the user stories as you go forward.
      • Spike it.
  • Agile Architecture is about pay now or pay later:
    • Especially in the financial market.
    • Second or third to market are often more successful thant first to market.
    • Marktonderzoek wijst uit dat sterftecijfer onder first to market is veel hoger dan onder second or third to market.
    • Als tweede of derde in de markt zijn geeft je de mogelijkheid te leren van de fouten van anderen.
    • Zie bijvoorbeeld AltaVista -> Yahoo -> Google.
  • Agile Architecture is about a single up front sprint doing inception, cranking out abstract base classes and some relevant baselined documentation.
    • Accelerating during the third and subsequent sprints.
  • Agile Architecture is about doing RUFD and poetry or short stories as documentation during the first sprint.
  • Agile Architecture is about continuously evolving the architecture after the first sprint.
  • Agile Architecture is about having it finished at the end of each sprint.
  • Agile Architecture is about structure that aligns with the domain and its organization (and its ecosystem).
  • Agile Architecture is about efficient refactoring—Not about being first to market, then redesigning your whole system during the fourth sprint after you had the "Oh, shit" experience during the third sprint, taking a three-month slip, and ending up as last and loser.
  • Agile Architecture is about the critical things that we currently do not know enough and will inform (give form and shape to) our system and take responsibility for it now, and defer the less critical ones to a subsequent sprint and handle them at the right time.
  • Agile Architecture is about interfaces: locality, dependancy horizon: put yourself in a class and look for its boundaries:
    • Where do you enter the system classes?
    • How much and how far can you see?
    • It's really worrying if you can see yourself—strange loops.
    • How distant is it?
    • How much do you need to know (of the world) in order to implement yourself?
    • You want the world to be relatively small in order to be good at your responsibilities.
    • You want the horizon to be fairly close. Interfaces are a very useful way to increase locality (as well as decision makers near the action).
  • Agile Architecture is about having the courage to change architecture
    • Don't be afraid of changing architecture—tt's software.
    • Hindsight often shows that it wasn't so hard after all—it's software. It's malleable.
    • Be suprised by how soft you can make it, especially the coupling—make it loose.
    • Hardware is relatively easy to change too.
    • Decompose it and rearrange it in new, innovative ways and be surprised.
    • Decompose with respect to time.