Kurs: Agile Architecture and Design - Robert C. Martin

This course is a deep dive into the well–known SOLID principles of Agile and Object Oriented Design.  Students will learn the characteristics of sound Object–Oriented designs and architecture, and patterns and practices that create them.  Principles include: The Single Responsibility Principle, The Open Closed Principle, The Liskov Substitution Principle, The Interface Segregation Principle, The Dependency Inversion Principle, and many others.  Special attention is paid to Component oriented design, and the principles and patterns of large–scale component architecture.

The course is designed for developers with all levels of experience  using the Java, C# or C++ programming language.. Beginners will obtain a firm grounding in the principles, patterns and practices, while experienced developers will be able to sharpen and refine their skills by learning how to apply the concepts more effectively.

By the end of this course, you will know how to:

Understand and apply the principles of object–oriented design and dependency management

Learn professional practices that make projects succeed

Learn important design patterns and how and when to apply them

Be able to apply Test–Driven Development in the context of Object–Oriented Design Principles and Patterns

The Problems

The Objectives

Forms of Software Rot

Attributes of a Good Design

Clean Code Qualities

Professional Responsibilities

Automated testing, TDD and Refactoring Practices Review

Refactoring

Problems with Procedural Programming

Object–Oriented Programming

Problem addressed by DIP

The Dependency Inversion Principle

Dependency Inversion Heuristics

When is DIP appropriate⁄inappropriate

Example design violating DIP

Example designs conforming to DIP

Problem addressed by OCP

The Open⁄Closed Principle

When is OCP appropriate⁄inappropriate

Several Example designs violating OCP

Several example designs conforming to OCP

Problem addressed by LSP

The Liskov Substitution Principle

Example designs violating LSP

Example designs conforming to LSP

Relationship OCP⁄LSP

When is “instance of is” not an LSP problem

Problem addressed by ISP

The Interface Segregation Principle

Example designs violating ISP

Example designs conforming to ISP

When is ISP appropriate⁄inappropriate

Problem addressed by LoD

Example design violating LoD

Example designs conforming to LoD

When is LoD appropriate⁄inappropriate

Pro⁄Con discussion

Simple Design

Automated Testing

Test–Driven Development

Refactoring

Teamwork

Pair Programming

Collective Ownership

Quick Design Sessions

Continuous Integration

Code⁄Design Reviews

Clean code

Professional Responsibilities

SOLID Principles

Packaging Principles