If you are interested in going through this program with me as a mentor, please reach out to me on mentorcruise.com and book a session
The program is structured like a journey. As with every journey into a new territory, the beginning is slow and safe, but it is crucial for setting the stage for what comes next. The adventure gains momentum as confidence grows, learning new subjects that introduce new techniques and principles to advance more steadily. In the last sessions, we are finally ready to tackle bigger problems that require the application of all the learnings together.
Each module is divided into several sessions with a common structure:
- New material
- New concepts are added to the previous materials.
- Katas
- These are exercises to spend some time practising the new material.
- Great habits
- We build up a collection of great habits step-by-step from the concepts (theory) and the katas (practice).
In this module, we learn how to use test-driven development (TDD) and apply TDD to create algorithms. Classic TDD is the original approach to TDD created by Kent Beck also known as the Detroit/Chicago School of TDD.
- Basic TDD
- Effective TDD
- Transformation Priority Premises
In these sessions, we move beyond the basic concepts of OOD (encapsulation, inheritance, and polymorphism) and use TDD to create more complex programs using OOD. we also introduce Acceptance tests.
- Object calisthenics
- Code smells
- Coupling and cohesion
- Connascence
- SOLID
- Design Patterns
In these sessions, we explore techniques to deal with legacy code, namely how to test legacy code and how to refactor legacy code safely.
- Refactor readability
- Characterization tests
- Golden Master, Approval and Mutation Tests
- Using seams
- Parallel change
- Refactoring moves
In these sessions, we move from building things right to creating the right things. Building things right is a more technical journey and revolves around the principles covered. Outside-In is a development mindset, focused by default on the business view, naturally bridging the gap between the two worlds. This mindset derives from the Outside-In TDD approach, called “London school”. It is an alternative approach to Classic TDD, leading us to consider a point of view external to our system, starting with the design of the public interface. This forces the developer to put himself in the user's shoes, considering his needs first.
- Mocks and stubs
- London School of TDD
In this module, we explore advanced design concepts, such as Domain-driven design (DDD), and how to apply DDD in practice using hexagonal architecture. We also explore further acceptance tests and introduce contract and integration tests. We also discuss performance and load tests.
- Domain Driven Design (DDD)
- Hexagonal Architecture
Each bullet point corresponds to a session in the program. This is a very hands-on program. Almost every concept has an associated kata, sometimes multiple katas, to apply the concept and solidify the learning.
| Walking sessions | Katas | Running sessions | Katas | Flying sessions | Katas |
|---|---|---|---|---|---|
| Basic TDD | FizzBuzz, Leap year | Legacy code I - Refactor readability | Tennis | Coupling and cohesion | Theory |
| Effective TDD I | Fibonacci | Legacy code II - Characterization tests | Gilded Rose | Connascence | Theory |
| Effective TDD III | Stack | Legacy code III - Golden master, Approval and Mutation Tests | Gilded Rose | SOLID | Theory |
| Transformation Priority Premises | Roman numerals, prime factors | Legacy Code IV - Seams | Raid Service | Mocks and stubs | Character Copier |
| Object calisthenics I | TicTacToe | Legacy Code VI - Patterns | Gilded Rose | London School of TDD I | ESA Mars Rover |
| Object calisthenics II | Yahtzee | Code smells I - Defining | Theory | London School of TDD II | ESA Mars Rover |
| TDD Final exercise I | Mars Rover | Code smells II - Identifying | Smelly TicTacToe | Domain Driven Design (DDD) | Theory |
| TDD Final exercise II | Mars Rover | Legacy Code V - Refactoring moves | Smelly TicTacToe | Hexagonal Architecture I | Theory |
| Design Patterns I - State and Factory patterns | Mars Rover | Hexagonal Architecture II | Social Network | ||
| Design Pattern II - Command pattern | Mars Rover | Hexagonal Architecture III | Social Network |
In each session, we will discuss a concept and then apply that concept in an exercise (kata).
Each person can start at a different point; you don't need to revisit parts of the program you are already proficient with.
The program can be run in different languages and tech stacks. Students must be proficient with the chosen language and tech stack.
The exercises are on my GitHub account.