Architecture and Design for Agile Development

Arkitektur & Design Agile

Big Upfront Design is a bad idea, as an industry we've learned the consequence of this over the past few decades. Creating design just in time can be a disaster as well. The risk is creating a design that is not extensible and a software system that can get quite hard to evolve and maintain. This is where the principles and the practices we can learn and follow from evolutionary design and architecture comes in. This course will help us avoid the perils of upfront design, and at the same time, keep us away for the traps of inadequate or insufficient design. Learn how to create practical design that can efficiently balance the tradeoffs we face in architecting and designing software.

Why Architecture and Design for Agile Development?
Nature of software
Evolving knowledge of domain and application
Importance of design and architecture
Challenges with design and architecture
When to create architecture?
Strategic design vs. tactical design
Risks of upfront design, insufficient design, and technical debt
Exercises

How to Create Evolutionary Architecture
How much to architect and when?
Good architecture and role of architects and lead programmers
Inherent vs. accidental complexity
Refactoring, designing for reversibility
Tracer Bullet approach
Extensibility, reuse, triangulation
Libraries and frameworks, use, reuse, overuse
Exercises

Refactoring Design and Architecture
How to approach refactoring
When to refactor
What's needed before we refactor
Deciding to refactor or not
Select refactoring techniques
Avoiding death by refactoring
Exercises

Code Quality and Impact on Evolutionary Design
Why care about code quality?
Creating good quality code
Identifying and removing code smells
Common code smells to avoid
Creating readable code
Creating maintainable code
Exercises

Evolutionary Design and Agile Design Principles
Perils of poor design
Design qualities
Cohesion and coupling
YAGNI
Law of Demeter
Tell Don't Ask
DRY Principle
Fundamental SOLID Design Principles
Single Responsibility Principle
Open Closed Principle
Liskov's Substitution Principle
Interface Segregation Principle
Dependency Inversion Principle
Other useful principles
When and how to apply these principles
Objectively measuring quality of Design
Evolving the design with these principles
Exercises

Common Patterns Useful in Evolutionary Design
Relevance of Design Pattern in Evolutionary Design
Pattern that require forethought
Patterns that help with afterthought
Patterns that play critical role in evolutionary design
Strategy, Decorator, Compose Method, Adapter, and Factory
When and how to apply patterns?
Language influence on realizing patterns
Exercise

Test Driven Design
Driving design through tests
Programming with intention
Minimalism and simple design
Making it work and making it better
TDD and evolutionary design
Avoiding brittle tests
Effective ways to create maintainable tests
Exercise

Practices to Sustain and Succeed in Evolutionary Design
Collective Ownership
Continuous review
Effective design and code reviews
Automation testing
Continuous integration
Measuring Design and Code quality metrics
Benefiting from visible metrics
Exercise

Tid

09:00 - 16:15

Emner

Why Evolutionary Design and Architecture?

How to Create Evolutionary Architecture

Refactoring Design and Architecture

Code Quality and Impact on Evolutionary Design

Evolutionary Design and Agile Design Principles

Common Patterns Useful in Evolutionary Design

Test Driven Design

Practices to Sustain and Succeed in Evolutionary Design