SWAT Lecture

SWAT Lecture


The software architecture and techniques SWAT lecture conveys the basics of systematic agile design for a software architecture. The approach is adequate for the problem of (agile architectural thinking) as well as methods of agile quality assurance. Students apply the learnt principles of their semester or private software projects.

It is particularly suitable for students who are working on a larger software project at the same time. The course with 3 ECTS was taught at Swiss technical universities during this and the last decade. The themes are regularly updated to reflect actual trends and technical possibilities.

Slides and reference literature are in English and published under Slides and Literature.


\$2/3\$ of the lecture is the presentation of new concepts. \$1/3\$ of the lecture is used to discuss the literature and support the students in the application of the concepts for their software project.

The reference books are [1, 2, 3].

Recommended books are [4, 5, 6, 7, 8].

The basics of the domain-driven design approach are presented in the third part of the training [9, 10, 11].

Lecture Content Details

Lecture 1

Why agile architecture and design?

  • Introduction and administrative information

  • Why is software architecture and design a needed discipline?

  • Architecture Styles

  • OOP Anti-Patterns

  • Setup environment for exercises and portfolio

Lecture 2

Evolution of Software Architecture and Design over the last Decades

  • Evolution of software architecture

  • UML, RUP and TOGAF

  • Agile approaches

Lecture 3

What is Agile Architecture?

  • Agile architecture principles

  • Developer vs Architects

  • Domain-Driven Design DDD

Lecture 4

Agile Approaches with Scrum, eXtreme Programming, LeSS

  • Architect roles

  • Technology stacks

  • DevOps impact on continuous integration CI, continuous delivery CD, and continuous deployment CD.

Lecture 5


  • Why refactor?

  • How to refactor?

  • Test driven design TDD, acceptance test driven development ATDD

  • Clean code and clean architecture

Lecture 6

Errors, Vulnerabilities, and Smells in Source Code

  • Definition of smells and how to remove smells.

  • Know the refactoring process with TDD.

  • Evolve architecture to newer versions of programming languages or more modular architecture.

  • Tools to detect non-quality

  • Component quality

Lecture 7

Architecture of Components and Subsystems

  • Patterns, idioms, paradigms

  • SOLID principles

  • Onion architecture

  • Bounded domains

Lecture 8

Verify functional features

  • Functional and non-functional requirements

  • Verification of functional requirements

  • TDD, ATDD, BDD approaches

Lecture 9

Validate Architecture Characteristics

  • Non-functional requirement NFR measurement

  • Architecture Characteristics and fitness functions

  • DevOps and DORA metrics

  • Metrics and Automation

  • Compliance and corporate governance

Lecture 10

Architecture Documentation

  • Why document?

  • Living documentation, architecture document record ADR

  • Documentation as a managed source published in a static website

Lecture 11

Software Architectural Trends (1/2)

  • Functional Programming

  • Reactive Programming

Lecture 12

Software Architectural Trends (2/2)

  • Security

  • Monitoring and Auditing

  • Realtime Data Warehouse DWH

Lecture 13

Domain-Driven Design Workshop

  • Domain-Driven Development, ubiquitous language

  • Bounded domains, entities, aggregates

  • Event Storming

  • Connection to modular monoliths and microservices based architecture

  • Agile and DevOps affiliation

Lecture 14

Team and Technical Excellence for Architects

  • Daily work of architects in agile environment


The teaching years 2023 and 2024 identified empirical facts:

  • Slowly, the students have a better grasp of how digital products are created using agile approaches. All students have training in design thinking and prototyping in the PTA lectures. They have the opportunity to certify in design thinking through an IBM program.

  • Basic knowledge of Scrum is provided through project management mandatory lecture. Most students have a shallow understanding of Scrum values, artifacts and events. The knowledge is insufficient for semester works or successful integration in a professional working environment. The university is very reluctant to define concrete measures to improve knowledge transfer.

  • Most students are fluent in programming. Advanced concepts in Modern Java, Modern Python, or Modern Typescript are direly missing.

  • Continuous delivery was trained in some lectures. Experience in setting up a continuous integration, delivery, and deployment pipelines is missing. The understanding of DevOps concepts is shallow. The university has increased DevOps offering to improve the situation.

  • The students welcome the emphasis of {ref-domain-driven-design} approaches. The event storming workshop is a highlight of the lecture.

We tune the SWAT lecture to deepen understanding of:

  • Deepen the understanding of architecture styles and approaches in an agile context.

  • Provide concrete examples of domain-driven design tactical solutions based on the open source project tangly ERP. The consequence is more emphasis on Modern Java, Gradle Build Tool, Git, and GitHub. We do not have the resources to provide source code examples in other technology stacks.

  • Sharpen the semester project to better apply agile design principles.


[1] N. Ford, R. Parsons, and P. Kua, Building Evolutionary Architectures: Automated Software Governance, Second. O’Reilly Media, 2023 [Online]. Available: https://www.amazon.com/dp/B0BN4T1P27

[2] N. Ford, R. Parsons, and P. Kua, Building Evolutionary Architectures: Support Constant Change, First. O’Reilly Media, 2017 [Online]. Available: https://www.amazon.com/dp/1491986360

[3] M. Fowler, Refactoring, First. Addision-Wesley, 1999 [Online]. Available: https://www.amazon.com/dp/B004PQQRK2

[4] R. C. Martin, Clean Code. Prentice Hall, 2009 [Online]. Available: https://www.amazon.com/dp/0132350882

[5] R. C. Martin, The Clean Coder. Prentice Hall, 2011 [Online]. Available: https://www.amazon.com/dp/0137081073

[6] R. C. Martin, Clean Architecture. Pearson, 2017 [Online]. Available: https://www.amazon.com/dp/0134494164

[7] R. C. Martin, Clean Agile. Prentice Hall, 2020 [Online]. Available: https://www.amazon.com/dp/0135781868

[8] R. C. Martin, Clean Craftsmanship. Addison-Wesley Professional, 2021 [Online]. Available: https://www.amazon.com/dp/B095C16LSW

[9] E. Evans, Domain-driven design. Addison-Wesley, 2004 [Online]. Available: https://www.amazon.com/dp/0321125215

[10] V. Vernon, Implementing Domain driven Design. Addison-Wesley Professional, 2012 [Online]. Available: https://www.amazon.com/dp/B00BCLEBN8

[11] V. Vernon, Domain-Driven Design Distilled. Addison-Wesley Professional, 2016 [Online]. Available: https://www.amazon.com/dp/B01JJSGE5S/