IN4315: Software Architecture

Software Architecture

Arie van Deursen, 2021

Course Content

This TU Delft graduate (master level, see current 2021 edition) course is concerned with the software architecture of software-intensive systems. This relates to:

  1. What the software should do, now and in the future, and how it is to interact with its environment. Here we will look at the problem domain, natural ways to decompose and understand the problem domain, the desired capabilities of the system, required properties (such as privacy, usability, scalability, security, or maintainability) of the system, the context in which the system will operate, and the stakeholders that have an interest in the system.

  2. How the software is designed so that it can reliably meet its objectives. Here we will look at design principles, system decomposition and assembly, quality assurance procedures, architectural styles and patterns, and architectural perspectives on, e.g., configurability, energy consumption, or scalability.

  3. Who is involved in the use, operation, creation, and evolution of the software. Here we will look at all people aspects of software architecting, relating to leadership, team work, trust, bias, collaboration, effective communication, work distribution and Conway’s law, ethics, and people development.

Our aim is to study reliable knowledge in these areas. To that end, we will work with three knowledge sources:

  1. Practice: Where possible, we will try to learn from actual software systems. To that end, students will engage with the architecture of an open source system. Furthermore, the course will involve 3-4 guest lectures by architects responsible for complex commercial software systems. We also intend to invite 3-4 international architects for a 15 minute Ask Me Anything session over skype, in which they offer answers to questions asked by students of the course.

  2. Theory: Little is as applicable as good theory, which is codified practice. We will study various books, articles, and resources on the web. In particular we will look at
    • Cesare Pautasso’s Software Architecture1, offering a broad perspective on software arechitecture including software services, deployment, and scalability, and availability
    • Rozanski and Woods’ Views and Perspectives2 approach to software systems architecture at enterprise level.
  3. Research: There is a lot that we do not know about software architecture. In research we explore theories that may be true, or may turn out to be false. As part of the course we will investigate a number of new research findings, to establish whether they apply to systems under study in this course.

There will be 3-4 lectures for each of the three components (practice, theory, research).

Course Assignments

Since architecture is team work, students will work in teams in this course as well. The team size is four.

Each team will select an open source system (from GitHub or other forges). Teams will conduct an in depth study of the architecture of the system they picked, looking at it from different (theoretical) perspectives. The student findings will be collected in various essays, each of around 1,000 words. Each team is expected to deliver four essays. Three of these will be related to the what, how, and who of the system as highlighted above. The fourth essay can be either a research essay, exploring how one of the research topics discussed in class applies to the system under study, or it can be a topic of choice that is most relevant for the system under study.

Students are encouraged to share their essays publicly: To that end, the course will offer an on line “book” where student essays will be collected and made available, under the overarching title Delft Students on Software Architecture (DESOSA). This book series was inspired by Brown and Wilson’s Architecture of Open Source Applications (AOSA) 3, in which architects themselves explain the history and roadmaps of software applications, and the architecctural decisions made to realize these.

Furthermore, teams will make actual changes to the systems under study, for example by offering pull requests that resolve currently open issues, or issues that they have discovered themselves. While the changes themselves will typically be fairly small, the process of making these changes will offer the students an opportunity to engage with (“feel”) the current architecture of the system.

Course Editions and History

Earlier editions were co-taught with and inspired by a range of people, including Maurício Aniche, Andy Zaidman, Alex Nederlof, Michael de Jong, Eric Bouwers, Rogier Slag, Valentine Mairet, and Sander van den Oever.


  1. Cesare Pautasso. Software Architecture: Visual Lecture Notes. Leanpub, 2020.

  2. Nick Rozanski and Eoin Woods. Software Systems Architecture: Working with Stakeholders Using Viewpoints and Perspectives. Addison-Wesley, 2012, 2nd edition. 

  3. Amy Brown and Greg Wilson (editors). The Architecture of Open Source Applications. Volumes 1-2, 2012.

  4. Arie van Deursen and Rogier Slag (editors). Delft Students on Software Architecture: DESOSA 2015. TU Delft. Available via

  5. Arie van Deursen, Maurício Aniche, Joop Aué (editors). Delft Students on Software Architecture: DESOSA 2016. TU Delft. Available via,, pdf, epub, and doi

  6. Arie van Deursen, Andy Zaidman, Maurício Aniche, Valentine Mairet, Sander van den Oever (editors). Delft Students on Software Architecture: DESOSA 2017. TU Delft. Available via,, pdf

  7. Arie van Deursen, Andy Zaidman, Maurício Aniche, Liam Clark, Gijs Weterings, and Romi Kharisnawan (editors). Delft Students on Software Architecture: DESOSA 2018. TU Delft. Available via,, pdf, and epub 

  8. Arie van Deursen, Maurício Aniche, Andy Zaidman (editors). Delft Students on Software Architecture: DESOSA 2019. TU Delft. Available via (html),, pdf, and epub 

  9. Arie van Deursen and Casper Boone (editors). Delft Students on Software Architecture: DESOSA 2020. TU Delft. Available via,, pdf, and epub 

  10. Arie van Deursen, Maurício Aniche, Joop Aué, Rogier Slag, Michael de Jong, Alex Nederlof, Eric Bouwers. A Collaborative Approach to Teach Software Architecture. 48th ACM Technical Symposium on Computer Science Education (SIGCSE), 2017 (preprint. doi). 

  11. Arie van Deursen, Alex Nederlof, and Eric Bouwers. Teaching Software Architecture: with GitHub!, December 2013.