Leading companies and employers are now looking for clean software architects. Because they basically generate a significantly high-quality code. This, in turn, is in high demand today. After all, it is easily extendable - without having to adapt many places. This increases productivity in the long term, shortens development time in parallel and also ensures high quality and greater customer satisfaction.

The Clean Software Architect seminar is held regularly at the Coding Academy in Munich. It lasts three days and is therefore a highly intensive training course to become a Clean Software Architect. After a quick theoretical introduction, we move directly to practical applications. We look specifically at the important object-oriented design concepts and principles. After all, a Clean Software architecture is one level higher and more abstract than pure C# Clean Code.

Our Clean Code seminar is more about writing clean, high-quality code. The Clean Software Architect seminar, on the other hand, focuses on classes according to SOLID principles as well as proven design patterns and their interactions. Basic questions like: Which classes belong in the same module? How do the modules interact with each other? Where are the boundaries between modules to be set? And what are the interfaces between the modules? How do I test the whole thing? Besides many examples and small programming tasks, we will model and largely implement an entire system in the Clean Software Architect seminar.

What do you learn on the first day?

we start with an introduction to the most important UML diagram: class diagram and sequence diagram. After that you will learn the most important Clean Code rules about names and functions. Right after that the 5 SOLID principles. Focuses on object-oriented analysis and design with C#. Already on the first day you will learn the first two proven and important patterns: Observer and Strategy Pattern and why SOLID form the basis for such patterns.

What do you learn on the second day?

On the second day you will learn the GRASP principles, which are one level more abstract than the SOLID principles. After that you will learn Hexagonal Architecture. Hexagonal Architecture. A similar model to Layered Architecture. However, the dependencies between layers are completely different. Dependencies always go in one direction: from outside layers to inside layers. This is only possible if we use SOLID's Dependency Inversion Principle correctly. For each layer, one or more even design patterns can also occur. The interesting thing is to master the interplay and interactions of multiple design patterns in this model, then usually a very good and flexible software architecture is created. Hexagonal Architecture is a higher abstraction than Design Patterns. Hexagonal Architecture manages the design and dependencies between adjacent layers, while Design Patterns can solve the tasks at each layer. Many examples and small programming tasks help you to internalize the important principles. You will also learn some design patterns like Adapter, Builder, Factory and Command Pattern.

What do you learn on the third day?

On this day you will learn more Design Patterns like Proxy, Bridge, Decorator, Facade, Singletone and Visitor Patterns. The goal is not to learn all Design Patterns, but to understand the principle behind Design Patterns and how you can improve your software architecture by skillful use of Design Patterns significantly and make it more flexible. Nevertheless, the basic rule is always: "Keep it simple and easy". Design patterns bring enormous flexibility and are very powerful. Nevertheless, they also bring a lot of complexity. That is the downside! The art is to decide if and when we should use such Design Patterns. Through many exercises and tasks you first learn the design patterns individually and still relatively easy and relaxed. If there is time, we will also show you how Test Driven Development can simplify the software architecture significantly, if TDD is implemented reasonably and well.

In the end we would like to master a big project together with you. Unfortunately, experience shows that there is not enough time to implement a very large project here. Because such architecture and design rules make quite sense for large projects. Nevertheless you learn the principles and the ideas with the small examples and tasks also quite well and you are able to transfer the acquired knowledge also to large projects. We would even start with a big project on the third day. Your task will be to continue the project with the learned clean SW architecture rules.

CERTIFICATE

Of course, as a participant in the Clean Software Architecture with C# you will receive a certificate. Prerequisite for this is the complete participation in all course units and programming tasks and the successful programming of a small final project. This, however, will give you more pleasure than stress after this intensive Clean Software Architecture with C#.

AGENDA

The agenda is written in English due to the numerous technical terms. Descriptions as well as course material will be provided in German. You can book the course either in German or English.

All seminar contents are individually adapted to the wishes of our participants. They can vary depending on the level of knowledge and will be defined together with the seminar leader on day 1. In this Clean Software Architecture with C# seminar you can choose from the following topics:

Design Patterns

• Proxy Pattern
• Bridge Pattern
• Decorator Pattern
• Facade Pattern
• Singletone Pattern
• Visitor Pattern

Pattern Combination

• Game Programming
• Use Hexagonal Architecture
• Use different Design Patterns
• Interaction between Patterns