Are you working in teams that struggle to build sustainable, maintainable software?
Writing and maintaining fragile, bug-ridden code can be frustrating and draining, slowing down progress and increasing technical debt.
Mastering the principles of technical excellence isn’t just about writing better code—it’s about reducing complexity, increasing confidence, and driving continuous improvement. When you develop a deep understanding of software craftsmanship, you gain the tools to build scalable, high-quality solutions while fostering a culture of excellence within your team.
The Software Crafting Programme Workshop will equip you with the techniques and mindset to write clearer, more testable, and sustainable code—while also helping you take on more technical leadership within your team.
If you’re ready to move from Developer to Software Crafter, the Software Crafting Programme Workshop is for you.
Trainers
The Software Crafting Programme is led by Alessandro Di Gioia and Marco Consolaro from Alcor Academy.
The course is the result of their hands-on experience in software development and design using XP practices and Domain-Driven Design.
Their expertise is also extensively shared in the book Agile Technical Practices Distilled, co-authored by Marco Consolaro, Alessandro Di Gioia, and Pedro M. Santos, and in Cronache di Domain-Driven Design, published by Avanscoperta.
Target Audience
The program is designed to accelerate technical skills in software development and help technical teams apply effective engineering practices. It is specifically aimed at:
- Individuals who develop software professionally and want to improve their engineering skills to become Tech Leads.
- Scale-ups or companies rapidly hiring tech people aiming to create a quality-focused engineering culture.
- Teams working on a new project looking to modernize existing systems while avoiding the pitfalls that harmed previous ones.
- Software Developers, QA, Software Engineers, and Freelance Software Developers looking to take the next step in their careers.
Topics
- Test-Driven Development Classic
- Test-Driven Development from the London School
- Object-Oriented Design
- Object Calisthenics
- Refactoring
- Code Smells
- SOLID Principles
- Cohesion and Coupling
- The 4 Elements of Simple Design
- Test Doubles
- Hexagonal Architecture
- Behaviour-Driven Development
- Acceptance Test-Driven Development
- Outside-in Mindset
- Software Teaming (Mob Programming).
Programme
The course consists of 10 sessions lasting 3.5 hours each and is structured with a mix of discussions, theory, and group work. The training program is highly practical and participatory.
Each lesson is built around the practice of Software Teaming (Mob Programming) with the goal of maximizing learning and honing collaborative skills in software development through advanced technical communication.
Agenda
Module 1: Good habits of Classic TDD
- What is TDD: origin of the technique and possible benefits.
- The TDD cycle: red/green/refactor, understanding the steps and their distinctions.
- Advancement techniques: Triangulation, Fake Implementation, Obvious Implementation.
- Test checklist: a fundamental tool to clarify goals and maintain focus during development.
- Properties of a good test: what properties a test must demonstrate to be considered good.
- Anti-patterns: common problems in tests and how to solve them.
- Mob Programming Exercise: String Calculator using Classic TDD.
Module 2: Object Calisthenics
- Object Calisthenics: 10 simple rules to immediately improve your Object-Oriented Design.
- Declarative and Encapsulated Object Code.
- Using the Type System to make invalid state unrepresentable.
- Mob Programming Exercise: Developing a Tic-Tac-Toe game using Classic TDD and Object Calisthenics rules.
Module 3: Code Smells
- Common anti-patterns that make code harder to maintain.
- How to use code smells as feedback to improve your design.
- Improving code reviews through systemic analysis of code smells.
- Group Exercise: Analyzing code full of code smells in a Tic-Tac-Toe application and identifying them.
Module 4: Refactoring
- Main techniques of automatic refactoring using IDE.
- Making the most of the refactoring cycle of Classic Test Driven-Development.
- Applying the Pareto principle in refactoring.
- Refactoring priority sequence.
- Mob Programming Exercise: Refactoring the previous lesson’s application, following the correct priority sequence.
Module 5: SOLID Principles++
- Single Responsibility.
- Open/Closed principle.
- Liskov Substitution.
- Interface Segregation.
- Dependency Inversion.
- Balanced Abstraction.
- Least Astonishment.
- Mob Programming Exercise: Implementing the Mars Rover kata using Classic TDD and applying the Open/Closed principle.
Module 6: Coupling & Cohesion
- Categories of Cohesion: Class Cohesion and Method Cohesion.
- Categories of Coupling: Interaction Coupling and Inheritance Coupling.
- Systemic Cohesion and Coupling.
- Minimizing coupling through public method design.
- Mob Programming Exercise: Completing the implementation of the previous lesson’s Mars Rover kata using Classic TDD and applying the Open/Closed principle.
Module 7: Test Doubles
- Test Doubles Taxonomy: Conceptual distinction between Mock, Stub, Fake, Spy, and Dummy objects.
- Command-Query Separation principle.
- Heuristics for choosing the correct Test Doubles.
- Using Test Doubles to verify object collaboration correctness.
- When not to use Test Doubles, favoring Classic TDD.
- Common anti-patterns in Test Doubles usage.
- Mob Programming Exercise: Character Copier using Classic TDD and collaboration tests. Implementing the solution using both Mock and Stub, and Fake and Spy.
Module 8: The 4 Rules of Simple Design
- Simple design: what is meant by simple design and how to achieve it.
- Applying the 4 Rules of Simple Design.
- Introduction to Hexagonal Architecture with Ports and Adapters.
- Identifying where and which Test Doubles to use within a Hexagonal Architecture.
- Little Design Upfront Exercise: Given a scenario and an acceptance criterion, we will do an “idealized design” exercise to have a starting point for story implementation.
Module 9 and 10: Outside-In Mindset, London School TDD, Applied Outside-In Development
- Learn the double cycle of Acceptance Tests Driven Development.
- Apply Behaviour-Driven Development by defining an automated acceptance criterion.
- Use the outside-in mindset to implement a story in the style of the London School, correctly using mocks and stubs in your tests.
- Final Mob Programming Exercise: Implementing the scenario and acceptance criterion using the agreed-upon design from the previous lesson, starting with an Acceptance test like a real London School team.
Learning Objectives
By the end of this course, you will be able to:
- Write tests that serve as living documentation.
- Utilize the type system to make erroneous states unrepresentable.
- Collaborate with other developers using a professional technical vocabulary.
- Conduct high-value code reviews that encourage design improvement.
- Identify defects that increase maintenance costs.
- Use good design principles to simplify code and achieve modular architecture.
- Communicate with the business to deliver valuable software quickly.
- Reduce feedback loops to develop software incrementally and promote continuous experimentation.
- Use the Outside-In mindset to write code that focuses on user needs.
