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.

  • 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


[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/