Course content

This master's-level course challenges the assumption that there are universal "best practices" in software architecture. Through three progressive modules, students experience how different system requirements (performance, reliability, integration complexity) fundamentally change architectural decisions.

The course uses a lean technology stack—a systems programming language without garbage collection for performance-critical work, and a modern language with strong type systems for service and client development. Students work on a single codebase throughout the semester, extending it across modules to experience how architectural decisions compound over time.

Module 1 focuses on performance optimization and resource constraints, teaching concepts such as Data-Oriented Design, profiling methodologies, and real-time systems - reflecting requirements typically found in fields such Game development, Graphics and Visual Information Processing.

Module 2 emphasizes reliability and auditability in mission-critical systems, covering aspects such as event sourcing, CQRS patterns, and zero-downtime deployment strategies - reflecting systems typically found in industries such as banking, insurance and the health sector.

Module 3 contrasts and integrates these opposing approaches in distributed systems with offline-first clients and AI/LLM orchestration, requiring students to synthesize contradictory requirements.

The course emphasizes evidence-based reasoning: architectural claims should be supported by qualitative or quantitative evidence, such as profiler data, telemetry, test results, user feedback or deployment evidence. Students learn to instrument systems with distributed tracing frameworks, enforce performance budgets as executable tests, and document architectural decisions (e.g., by using structured Architecture Decision Records (ADRs)).

Assessment centers on deliverables demonstrating technical competence, measurement-driven optimization, and clear articulation of trade-offs. Integration clinics provide peer critique opportunities, requiring students to defend architectural choices and learn from alternative approaches.

This course prepares students for real-world software development where contradictory constraints (speed vs. correctness, modularity vs. performance, consistency vs. availability) require contextual judgment rather than memorized patterns. Graduates develop the ability to analyze complex architectural problems, select appropriate tools and patterns based on problem characteristics, and communicate technical decisions to diverse stakeholders with evidence-backed rationale.

Learning outcome

Legend: R Remember, U Understand, A Apply, An Analyze, E Evaluate, C Create. Master-level emphasis is on An/E/C: analyzing complex trade-offs, defending decisions with evidence, and creating robust solutions under uncertainty.

Knowledge

• Evaluate and analyze dilemmas and justify trade-offs across operational environments (high-performance, real-time, mission-critical, embedded) within the software engineering process. (An,E)
• Compare and contrast Data-Oriented Design vs. Domain-Driven Design and articulate the fundamental trade-offs between these paradigms. (An,E)
• Analyze architectural implications and evaluate trade-offs among conflicting or complementary objectives. (An,E)
• Analyze security implications of architectural choices and prioritize risks/controls with rationale. (An,E)
• Describe and differentiate layered testing strategies and explain how they validate distinct system properties. (U,An)
• Quantify and analyze performance costs of abstraction boundaries using empirical evidence. (An)
• Explain and appraise programming-language principles (e.g., type systems, immutability) and infer implications for robust systems. (U,An)
• Describe and evaluate deployment strategies (blue/green, canary) and match them to operational conditions. (U,E)

Skills

• Refactor brown-field codebases to improve structure without changing behavior, and defend refactoring decisions. (A,E)
• Design CI/CD pipelines and measure their performance/reliability against defined SLOs. (C,An)
• Instrument systems with appropriate frameworks and diagnose bottlenecks from telemetry. (A,An)
• Apply security-by-design with relevant compliance constraints and justify control selection. (A,E)
• Design robust, maintainable system boundaries/APIs and validate them against change scenarios. (C,E)
• Compose layered test suites (unit, property-based, contract, integration) and assess coverage/efficacy. (C,E)
• Conceptualize and specify offline-first clients with conflict resolution for intermittent connectivity, and evaluatetrade-offs. (C,E)
• Orchestrate managed AI/LLM APIs with input/output validation and analyze cost-performance characteristics. (A,An)

General competence

• Synthesize opposing design philosophies based on project context and defend the chosen stance. (C,E)
• Navigate requirement ambiguity by articulating known unknowns and making assumptions explicit. (An,E)
• Recognize and explain that architectural expertise involves judgment under uncertainty, justifying decision criteria. (U,E)
• Diagnose failures in AI-assisted solutions and determine root causes with evidence. (An,E)
• Adapt to unfamiliar stacks (persistence, language, UI) by acquiring knowledge from docs and debuggingeffectively. (A,An)
• Communicate technical decisions to diverse stakeholders using evidence and clear rationale; facilitate alignment. (A,E)
• Collaborate in cross-functional teams, specializing while meeting shared requirements. (A)
• Reflect through structured retrospectives and translate insights into actionable improvements. (E)
• Select tools and languages based on problem characteristics and justify choices beyond mere reasons of familiarity. (E)

Learning methods and activities

• Seminars and studios: Conceptual deep-dives, live demonstrations of profiling and instrumentation tools
• Integration clinics: Peer presentations of module deliverables with constructive critique, requiring students to defend architectural choices and articulate trade-offs
• Iterative development: Students extend codebases throughout the semester, experiencing how architectural decisions compound over time
• Instrumentation-first approach: Early establishment of observability tooling (profilers, distributed tracing, metrics dashboards)
• Evidence-based reasoning: Architectural claims must be supported by measurements, test results, or deployment evidence rather than intuition

Compulsory assignments

• Oblig (Module 1)
• Oblig (Module 2)
• Oblig (Module 3)

Specific conditions

Required previous knowledge

Students should have taken (and passed) the introductory Modern Software Engineering course (IDIG4110). Exceptions can only be granted by the course coordinator or responsible lecturer.

Course materials

• Lecture slides and annotated lab handouts.
• Curated readings: research papers, platform guidelines, and short practitioner articles.
• Official platform docs (architecture, UX, permissions, networking, storage).
• Sample code repositories and starter templates for labs and the project.
• Testing & tooling: unit/UI/property-based testing frameworks, profiling and telemetry guides.
• Accessibility and internationalization checklists; usability heuristics.
• Privacy & security materials: threat-model worksheet, secure-by-design checklist, data-handling policy.
• Offline-first patterns: sync/conflict resolution notes and mock API specs.
• AI/code-generation policy, prompt-logging template, and verification workflow.