top of page


Sevastyan Karpov
Sevastyan Karpov

Software Architecture In Practice 3rd Edition 30

  • A system's software architecture is widely regarded as one of the most important software artifacts. Software professionals routinely make decisions that impact that architecture, yet many times that impact is not fully considered or well understood.Which design decisions will lead to a software architecture that successfully addresses the desired system qualities?

  • How do you know if a given software architecture is deficient or at risk relative to its target system qualities?

This two-day course provides in-depth coverage of the concepts needed to effectively design and analyze a software architecture. The essential considerations for defining any architecture are carefully examined and then illustrated through application of the SEI Attribute-Driven Design (ADD) software architecture design method. This course also explores architecture analysis in-depth and introduces the SEI Quality Attribute Workshop (QAW), the SEI Architecture Tradeoff Analysis Method (ATAM), and several lightweight evaluation techniques. Through multiple exercises, participants get a chance to apply these methods to sample problems.This course is based on the books Designing Software Architectures: A Practical Approach and Software Architecture in Practice, 3rd edition.The prerequisite for this course is the Software Architecture: Principles and Practices course, which is available as instructor-led classroom training and as eLearning.

Software Architecture In Practice 3rd Edition 30

This course provides attendees with in-depth coverage of the concepts needed to effectively design and analyze a software architecture. After attending this course, participants will have a better understanding of

  • life-cycle view of architecture design and analysis methods

  • the QAW, a method for eliciting critical quality attributes, such as availability, performance, security, interoperability, and modifiability

  • the ADD method, a method for designing a software architecture

  • the ATAM, a method for evaluating a software architecture based on a set of attribute-specific measures of the system such as performance, availability, modifiability, and security

  • lightweight architecture evaluation methods

  • the architecture design process in the organization

I'm the author of Software Architecture for Developers; a developer-friendly guide to software architecture, technical leadership and the balance with agility. I'm also the creator of the C4 software architecture model and the founder of Structurizr, a collection of tooling to help software teams visualise, document and explore their software architecture.

I speak at software development conferences, meetups and organisations around the world; delivering keynotes, presentations, training courses and workshops. In 2013, I won the IEEE Software sponsored SATURN 2013 "Architecture in Practice" Presentation Award for my presentation about the conflict between agile and architecture. Some of the slides from past talks are available to view online/download, and there are many videos of my talks available online, most of which can be found on YouTube.

I run software architecture workshops at organisations across the globe, the content of which is based upon my Software Architecture for Developers books. These workshops, aimed at software developers and architects, are a guide to modern software architecture that's pragmatic rather than academic, and lightweight rather than "enterprisey". They are occasionally run publicly via training providers or conferences but most are private, on-site workshops held directly with organisations.

People in the software world have long argued about a definition of architecture. For some it's something like the fundamental organization of a system, or the way the highest level components are wired together. My thinking on this was shaped by an email exchange with Ralph Johnson, who questioned this phrasing, arguing that there was no objective way to define what was fundamental, or high level and that a better view of architecture was the shared understanding that the expert developers have of the system design.

Architecture is a tricky subject for the customers and users of software products - as it isn't something they immediately perceive. But a poor architecture is a major contributor to the growth of cruft - elements of the software that impede the ability of developers to understand the software. Software that contains a lot of cruft is much harder to modify, leading to features that arrive more slowly and with more defects.

This situation is counter to our usual experience. We are used to something that is "high quality" as something that costs more. For some aspects of software, such as the user-experience, this can be true. But when it comes to the architecture, and other aspects of internal quality, this relationship is reversed. High internal quality leads to faster delivery of new features, because there is less cruft to get in the way.

While application architecture concentrates on the architecture within some form of notional application boundary, enterprise architecture looks architecture across a large enterprise. Such an organization is usually too large to group all its software in any kind of cohesive grouping, thus requiring coordination across teams with many codebases, that have developed in isolation from each other, with funding and users that operate independently of each other.

Much of enterprise architecture is about understanding what is worth the costs of central coordination, and what form that coordination should take. At one extreme is a central architecture group that must approve all architectural decision for every software system in the enterprise. Such groups slow down decision making and cannot truly understand the issues across such a wide portfolio of systems, leading to poor decision-making. But the other extreme is no coordination at all, leading to teams duplicating effort, inability for different system to inter-operate, and a lack of skills development and cross-learning between teams.

Software development projects seeking rapid, sustainable delivery are combining agile and architecture practices to manage competing goals of speed in the short term and stability over the long term [1] [2] [3]. A software development lifecycle is essentially a series of steps, or phases including requirement specification; software design; software construction; software verification and validation; and software deployment. These phases provide a model for the development and management of software [4].

Software architectural design is the process of applying various techniques and principle for the purpose of defining a module, a process, or a system in sufficient detail to permit its physical coding. The conventional approach to the software design process focuses on partitioning a problem and its solution into detailed pieces up front before proceeding to the construction phase. These up front software architecture efforts are critical and leave no room to accommodate changing requirements later in the development cycle. Some of the issues faced by organizations involved in up front software design efforts are [5], [6]:

There is an obvious need for a software architectural design approach in agile environments. To the best of our knowledge, no well-established software design methodology has been proposed in any literature. These are issues of software architecture while fully supporting the fundamentals of agile software development methods. The rest of the paper is organized as follows: Section 2 provides an overview of existing agile methods. Section 3 details the software architecture design phase as a key part of the software development life-cycle. Section 4 presents the proposed software architectural design methodology in agile environments. Section 5 discusses the outcomes and limits of the proposed methodology. Finally, Section 6 concludes and presents the future perspectives of this work. 076b4e4f54




bottom of page