Overview

This training helps you learn how to make a code design that minimize the cost of change in large projects. You'll discover how to structure your code so that it remains enjoyable to work with, long after the initial lines are written. You'll learn how to identify volatilities and sources of change to drive the code design decisions.

In any software project there will always be a large amount 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.

By sharing experiences from real life projects and by showing how widely known practices can be applied, you will learn how following proven design principles and practices can help you create code structures that are maintainable, reusable, and extensible—ultimately boosting productivity, efficiency, and delivery.

Motivation

When projects fail for technical reasons, uncontrolled complexity is often the root cause.

Separation of Concerns is the key technique to control complexity and build maintainable systems. All Software Design Principles and Practices are there to
help achieving an effective Separation of Concerns.

Rather than relying solely on theory, we distill best practices from real-world project experiences and proven design techniques to create a code design that is inexpensive to change.

Practical methods and design recipes that focus on the critical aspects of software development are easier to learn and use compared to just reading books.

Learning Objectives

• Increase team efficiency and productivity
• Manage project size and complexity effectively
• Reduce the cost of change
• Lower the cost of adding new features
• Desing for Long-Term Development

Target Audience

Any Software Architect or Software Developer would benefit greatly from this training.

Standard Format

This training is available both onsite and online in a Standard Format:
➟ onsite: two full days
➟ online: four days with 4-hour sessions each

Custom formats are also available, providing extended durations to meet specific participant needs. A commonly recommended customization is to combine it with the 'Application Infrastructure for Clean Architecture' course into an integrated training program, as the two are complementary to each other.

Outline

Lesson: Why Code Quality and Code Design

• Activities in software development
• Code Design
• Functions, Classes, Modules
• Total Cost of Owning a Mess
• Technical Debt and Refactoring
• What is a Good Design

Lesson: Clean Code

• What is Clean Code
• Meaningful Names
• The Boy Scout Rule
• Coding Standards
• Comments
• The Newspaper Metaphor

Lesson: Separation of Concerns (SoC)

• SoC the Core of Programming Principles and Practices
• Architectural Styles
• Cross-Cutting Concerns
• Data Access Concerns
• SoC for Components, Classes and Functions

Lesson: Managing Dependencies with Dependency Injection

• Define Dependencies
• Acyclic Dependencies Principle
• Separating Construction from Use
• Dependency Injection
• Service Locator
• Using Dependency Injection and Service Locator

Lesson: Good Design Practices

• Good Classes
• Cohesion and coupling
• Inheritance vs Composition
• Error Handling
• Code at Boundaries
• Defensive Programming
• Planning and Team Implications