Title: Code Design the Basics, the Principles and the Practices
Author: Florin Coroş
Trainer: Florin Coroş
This training is focused on learning how to minimize the cost of change on large projects, by doing a code design that embraces change. By participating to this training you will understand how to use the Design Patterns and the Design Principles to structure your code in a way that you will enjoy working on it, long after the first lines were written in your project. You will learn how to drive all the code design decisions to minimize the effect of change on your code.
In any software project there is and there will be a lot of code. The code needs to handle every aspect of the product in very small details. To assure the long life of a project, it is crucial that the code is structured in a clear way. It is like arranging and sorting sheets of papers, in files, folders, drawers and closets, so we can find what we need. Developers arrange code in functions, classes, modules and deployable packages. Any developer spends most of her time on reading and changing the existent code, rather than writing new code. Designing the structures in which we place our code, by following some principles and widely known patterns makes a huge difference in increasing our efficiency, productivity and happiness by achieving a high quality code which is maintainable, reusable and extensible.
None of the engineering principles or design patterns is meant to be applied as they are described in books. There, they lack the context. However, by knowing them, understanding them and following them you are going to be able tweak and combine them to fit your context and you will get better ideas on how to design your code.
There are studies showing that raising the overall code quality in a software project will increase productivity, efficiency and shorten schedules.
You should invest in having high quality code design because:
- it increases your team efficiency and productivity
- it gives you the means to handle in a manageable way the size and complexity of the project
- it reduces the cost of change
- it reduces the cost of adding features to your product
- it makes your product to stand the test of time
Motivating someone to adopt new practices implies that she needs to know how to apply them, and then she needs to see that by applying them she can get the desired results. This training as a class course covers the first part, by teaching code design concepts, patterns and principles. Follow-up workshops and coaching sessions can address the second part, by exercising the practices on specific contexts and by showing how quality code emerges.
- Understand the importance of quality code design
- Learn to write clean code that works
- Understand the Separation of Concerns as the root of Design Patterns and Programming Principles
- Know and understand main Design Patterns
- Know and understand Object Oriented Design Principles
- Learn and understand how to use Dependency Injection
- Learn the best practices of doing good code design in large projects
- Understand the Application Infrastructure as the tool to manage and control complexity and size in large projects
Any software architect or software developer would benefit greatly from this training.
Object Oriented Programming basics (inheritance; encapsulation; polymorphism; interfaces; abstract classes; virtual methods; overriding; overloading).
The training is structured in eight course class lessons, which target one or more learning objectives. The lessons focus on explaining, exemplifying, discussing and exercising the technical concepts to reach the targeted learning objectives. Each lesson is listed below. Here is a more detailed view on the content of each lesson.
- Part 1: Good Code Design and Design Patterns
- Lesson 1: Why Code Quality and Code Design
- Lesson 2: Clean Code
- Lesson 3: Separation of Concerns
- Lesson 4: Design Patterns
- Part 2: Object Oriented Design Principles and Practices
- Lesson 5: Object Oriented Design Principles
- Lesson 6: Dependency Injection
- Lesson 7: From Principles and Patterns to Practices
- Lesson 8: Application Infrastructure
The most recommended format for delivering the entire course is in four full days. This assures a balanced pace between explaining the material, examples and discussions. There is also the possibility to shorten the course to three full and intensive days by taking out few lessons or topics. Some subjects might be skipped or briefly explained during the course, depending on the audience interest on each topic.
The training can be shortened even more by tailoring it to your needs by selecting and combining the above lessons. Most of the lessons can be done individually. When the lessons selection is done to tailor the training, the level of experience of the audience and the duration of the entire training are taken into account. Common ways to tailor the training is to have a reduced form by selecting only two or three lessons for one full day. There is also the possibility to have each lesson done as one coaching session in a half day. Below table summarizes the different possibilities to deliver the training.
|Entire Course Content||4 full days
|Partial Course Content
some topics may be briefly explained or skipped
|3 full days|
|Two or three selected lessons
Recommended: Lesson 1, Lesson 2 and another one
Lesson 8 can only be selected with at most one other
|1 full day|
|One lesson as a coaching session||Half day|
Additionally, this class course training could be followed by workshops or coaching sessions, which focus on practicing, and applying these concepts on a specific problem or context. This would contribute to applying the patterns, principles and practices learned in course in real life projects.
Please contact me for requesting a commercial offer tailored to your needs.
Part 1: Good Code Design and Design Patterns
Lesson 1: Why Code Quality and Code Design
Activities in software development
Functions, Classes, Modules
Total Cost of Owning a Mess
Technical Debt and Refactoring
What is a Good Design
Lesson 2: Clean Code
The Boy Scout Rule
The Newspaper Metaphor
Lesson 3: Separation of Concerns (SoC)
SoC the Core of Programming Principles and Practices
Data Access Concerns
SoC at Module Level
SoC at Class Level
SoC at Function Level
Lesson 4: Design Patterns
Why to know Design Patterns
Chain of Responsibility
Related Patterns in GoF
Part 2: Object Oriented Design Principles and Practices
Lesson 5: Object Oriented Design Principles
Rotting Software Smells
Single Responsibility Principle
Open Closed Principle
Liskov Substitution Principle
Interface Segregation Principle
Dependency Inversion Principle
Don’t Repeat Yourself
Lesson 6: Dependencies Management
The Dependency Rule
Separating Construction from Use
Using Dependency Injection and Service Locator
Lesson 7: From Principles and Patterns to Practices
Cohesion and coupling
Inheritance vs Composition
Singletons and Statics
Planning and Teaming Implications
Lesson 8: Application Infrastructure
What is an Application Infrastructure
Application Infrastructure Elements
Technical and Functional Components
Application Boot Library
Data Access Abstraction
Global Exception Handling
Generic Entity Management Service
Generic Input Validation Engine
In my humble opinion reading great books such as Clean Code and following NDC or other conferences helps broadening our perspective and knowledge base. However, they are more like read-only properties. You cannot interact with the ideas exposed in such ways.
Here comes in Florin. Organizing small-scale (~15 people) experience-sharing intensive courses combining years of experience mixed with beautiful, well known and widely accepted theory. The best in all is the way Florin implements DRY in his course. Participate to figure it out how! 🙂
Kövér Alpár Etele
The principles presented in the Code Design Training help the developer to write better code, the team to be more efficient and the company to save money (lots of money). To learn these principles there are a few ways: one of them is the hard way which in this case is very painful (especially for budgets), another way is to do the course sooner than later as the course may help developers at any maturity level by showing that things can be done better and by pointing the consequences and the costs of the choices they make while coding.
Andrei Craciun (a hard way learner)
Senior Software Engineer
I highly recommend this course. Florin does a fantastic job in teaching about how to create, maintain and handle software projects, not only from the architecture and design point of view, but also from the team management perspective.
Lead Software Engineer
A must for any developer between one to two years of significant experience.
I recommend this course because it will help you write code that you like.
Because it will help you understand what you don’t like about badly written code.
And last, but not least, because it structures concepts you already know so that you can find their place and value.
By connecting the code design related “dots” (points of understanding gained with code writing experience), this course may lead to a series of small revelations, which will in the end offer a good overview and higher level of understanding of good code design and the importance of a well-defined application infrastructure.