Practical Clean Software Architecture Course for Java Programmers
You are a Java programmer and can easily convert class and sequence diagrams from existing architecture into Java code? However, do you want to work your way up to a software architect and work effectively on design and software architecture yourself and make good contributions in this field? Then this is the right course for you! Step by step and in a practical way you will learn the most important design principles such as SOLID, GRASP and Hexagonal Architecture as well as the most important design patterns that are often encountered in practice and in large projects. The course is the bridge from a software developer to a software architect. Software developers are plentiful! Real software architects, on the other hand, are rare and therefore in high demand on the market. This course is the ideal introduction for you to the topics of drafting, design and implementation of clean software architecture with Java. Learn more about this exciting software design practical training....
- Learn and apply object-oriented software architecture principles
- Gain a better understanding of good design and software architecture best practices
- Learn to design clean and flexible software architecture
- Learn proven design patterns with Java
- Reduce training time for new employees with comprehensive SW architecture
- Increase productivity with an easily extensible software architecture
This Clean Software Architecture course teaches you the basic concepts and best practices for Clean Software Architecture with Java in a simple and structured way. You will learn different techniques and principles like SOLID, GRASP, Hexagonal Architecture and Design Patterns with Java. This course is the ideal introduction to software architecture with Java.
The course covers a selection of the following topics:
- UML Class and Sequence diagrams
- Introduction to Clean Code
- SOLID Principles
- GRASP Patterns
- Introduction to Unit Testing and TDD
- Hexagonal Architecture
- 7 to 10 Design Patterns
For more details, please see the agenda below.
This Clean Software Architecture course is designed and optimized for programmers with prior knowledge and experience in Java. Participants should have at least Java knowledge to the extent of our Java course for programmers.
Individual: we specifically address your needs and take into account your previous knowledge, desired topics and focal points
Structured and easy to understand
Take your career, studies or training to the next level: with certificate
Safely and independently develop programmes (whether private, professional or for your start-up)
Lots and lots of practice: immediately applicable results
Small groups: max. 8 participants in the 3-day course max. 12 participants in online coaching
Developed by experts according to the Raed Method® & geared to the requirements of tech companies in 2020
E-mail support even after the end of the course
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 Architecture 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 Java Clean Code.
Our Clean Code seminar is more about writing clean, high-quality code. The Clean Software Architecture 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 Architecture seminar.
What do you learn on the first day?
we start with an introduction to the most important UML diagrams: class diagram and sequence diagram. Then you will learn the most important Clean Code rules about names and functions. Directly after that the 5 SOLID principles. Focus on object-oriented analysis and design with Python. On the first day you will also learn the first two proven and important patterns: Observer and Adapter Pattern and why SOLID is the basis for such patterns.
What do you learn on the second day?
On the second day, you will learn more important design patterns and how to implement them in Python, structure them in modules and packages and use them sensibly. These include adapters, builders, factories, adapters and command patterns. The aim is not to learn all design patterns, but to understand the principle behind design patterns and how you can significantly improve your software architecture and make it more flexible through the skilful use of design patterns. Nevertheless, the basic rule always applies: "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 easily and relaxed.
What do you learn on the third day?
Now you can use a few design principles, rules and design patterns as individuals. The real art is to combine them properly with each other! We start with Hexagonal Architecture. A similar model to layered architecture. However, the dependencies between the 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 interaction of several design patterns in this model, then a very good and flexible software architecture usually results. 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. Again, you learn through a running example and a game programming task. Unfortunately, experience shows that there is not enough time to implement a very large project here. Because such architecture and design rules make a lot of sense for large projects. Nevertheless, you learn the principles and ideas quite well with the small examples and tasks and are able to transfer the knowledge gained to large projects.
The Clean Software Architecture course for Java programmers is taught by one of the following trainers:
Dr. Stefan Behnel
Expert: Python, Pytest, Unit Test und TDD, Clean Code, Clean Software Architektur, Fast Python, Cython
- Doctorate at the TU Darmstadt as Dr. Ing. in Software Architecture
References: 15 years of experience as a consultant, software developer and software architect in the financial services, automotive, publishing and tourism industries in the field of high-performance Python and open source, main developer of Cython, the data science library PANDA is based on Cython. Python training for Draeger, Apple, Sky Deutschland, IT companies, ...
Dr. Matthias Hölzl
- Doctorate at LMU in the field of Software Engineering
References: 30 years of teaching and industrial experience. Of which 18 years at Ludwig-Maximilians-Universität Munich, most recently as Professor for Software and Computational Systems Engineering. Training, technical coaching for machine learning, deep learning, process automation as well as review and improvement of software architecture in large IT projects. Python and Java trainings for Deutsche Bank, BMW, BA, VKB, etc. Editor and author of several books at Springer-Verlag and author of numerous scientific publications.
Expert: Java, Python, Clean Code, Clean SW-Architecture, Refactoring, Testing, Train The Trainer
- Doctorate at LMU in the field of programming languages (2022).
References: 17 years of teaching and industry experience, thereof 12 years lecturer at the Ludwig-Maximilians-University Munich for Java, Python, Efficient Algorithms, Multiple awardsfor outstanding teaching at the LMU, book author for Java & soon Python at Springer and Orelly Verlag, developer of the RAED-Teaching Method®, Train the Trainer instructor, team training in Java and Python for BMW, VW, BA, SIEMENS, AGFA-Healthcare, TÜV Süd, Schufa AG, ..
Prof. Dr. Peer Kröger
Expert: Artificial Intelligence, Data Science, Big Data, SQL/NoSQL Database, Python, Java
- Doctorate at LMU in the field of Database and Data Science
References: Many years of practical experience in the implementation of data science projects as well as in consulting and training in the automotive industry, financial service providers and SMEs, among others. Approx. 150 peer-reviewed publications (cited over 8000 times) on the topic of data science, data mining, machine learning and AI. Member of the AI competence centre Munich Center for Machine Learning (MCML) at LMU Munich and professor for information systems and data mining at CAU Kiel.
Of course, as a participant of the Clean Software Architecture course with Java 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 course with Java.
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 course with Java seminar you have the choice of the following topics:
Clean Software Architecture with Java Day 1
- Class Diagrams
- Sequence Diagrams
- Single Responsibility
- Open Close
- Liskov Substitution
- Interface Segregation
- Dependence Principle
- MVS Patterns
- Observer Pattern
- Strategy Pattern
Clean Software Architecture with Java Day 2
- Adapter Pattern
- Factory Pattern
- Command Pattern
- Builder Pattern
- Proxy Pattern
- Visitor Pattern
- Information expert
- Low coupling
- High cohesion
- Protected variations
- Pure fabrication
Clean Software Architecture with Java Day 3
Working with Files
- open file
- close file
- write file
- read file
- rename file
- delete file
- What is an Exception?
- Handling an Exception
- Expect Clause with No Exceptions
Object Oriented Programming
Package and Modules
- Working with PyCharm
- Defining Packages
- Defining Modules
- Locating Modules
- Namespaces und Scoping
Exkurs: Unit Test
- PyTest Example
Working with Database (Options)