The workshop will be in English.
Abstract
Most people working in software development are highly motivated to improve their engineering skills and create high-quality software. Learning the technical excellence principles that underpin software development brings satisfaction and a desire to continually do better. For all those driven by this great passion and seeking tools to work better, reduce anxiety, become more aware and effective, we have created the Software Crafting Programme, together with Alessandro Di Gioia and Marco Consolaro of Alcor Academy.
With this course, we aim to incorporate TDD, Refactoring, Code Smells, and more into your daily workflow effectively.
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.
The course is the result of the two instructors’ field experience in software development and design with XP and Domain-Driven Design practices. This experience is extensively covered in the book Agile Technical Practices Distilled, written by Marco Consolaro, Alessandro Di Gioia, and Pedro M. Santos, and in the book 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).
Agenda
A good 70% of the course time is devoted to writing code in Software Teaming (Mob Programming) and sharing solutions with other participants.
It is recommended to dedicate at least an hour of time between one module and another to carry out homework and further study.
Here’s the detail of each session:
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 – What are we gonna learn
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.
How does it work
The training program is highly practical, collaborative, and participatory. Each lesson lasts approximately three and a half hours and consists of a brief theoretical part followed by a collaborative programming session.
The idea is to apply the concepts practically in a safe environment, where you can experiment without fear and work on team spirit.
The entire program is designed based on the principles of Training From the Back of The Room, Micro Learning, and Project Based Learning, allowing you to learn and apply as quickly as possible.
It is required that all participants have their own setup and the camera turned on for the entire duration of the workshop for better engagement and communication.
Why should you join
By the end of this course, you will have acquired a higher level of seniority. You will be able to write maintainable and high-quality software without falling into common overengineering traps. We will help you develop interaction and group communication skills, essential for professional growth in leadership roles.
