Study Path

This study path is released under the CC BY-SA 4.0 license

Introduction

Welcome to this Study Path on Software Development: a curated, open, and ever-evolving learning path focused on practices of software development, principles of software design, and software architecture.

Whether you are interested in Clean Code, Test-Driven Development, Refactoring, Clean Architecture, Legacy Code, Domain-Driven Design, Microservices, or other essential topics, I hope you will find structured, high-quality resources here to guide with your growth.

The study path is organized into themed sections. There is no strict order to follow, you are free to:

• Browse through all the sessions
• Dive into topics that interest you most
• Follow the entire path from start to finish

How you use it is entirely up to you.

This project started years ago when I mentored an intern in Agile Software Development. At that time I wanted to offer a clear, practical roadmap for learning foundational concepts, like clean code and TDD. Over time, with the support of other people, this study path has grown - and continues to grow - into a broader resource for developers at all levels.

I am committed keeping this path up to date and valuable. If you have suggestions or resources to contribute, your input is more than welcome!

Enjoy the journey, and happy learning!

🧭 Getting Started

Kick off your journey by learning how to stay focused, work iteratively, and embrace the mindset of continuous improvement through Agile values and time management techniques.

• Get familiar with the Pomodoro Technique (read the paper)
• Read TODO List: One thing at a time!
• Read the Manifesto for Agile Software Development
• Read the Principles behind the Agile Manifesto
• Read the Manifesto for Software Craftsmanship

📐 Session 1: SOLID and Clean Code

Discover the core design principles that help you write code that is easy to understand, change, and grow: the building blocks of sustainable software

• Watch Core Design Principles for Software Developers
• Read the SOLID principles
  • SRP: Single Responsibility Principle
  • OCP: Open-Closed Principle
  • LSP: Liskov Substitution Principle
  • ISP: Interface Segregation Principle
  • DIP: Dependency Inversion Principle
• Exercise: Look at the Racing Car Katas
  • Try to find where the SOLID principles are violated
• Read the Clean Code: A Handbook of Agile Software Craftsmanship
  • Chapter 1: Clean Code
  • Chapter 2: Meaningful Names
  • Chapter 3: Functions
  • Chapter 6: Objects and Data Structures
  • Chapter 7: Error Handling
  • Chapter 10: Classes
• Read The Pragmatic Programmer: From Journeyman to Master
  • Chapter 2: A Pragmatic Approach
  • Chapter 5: Bend or Break
  • Chapter 6: While You Are Coding
• Read The Art of Enbugging: Tell, don't ask / Law of Demeter
• Read YAGNI
• Watch SOLID for functional programming (a case study of SOLID principles applied in Elixir)

🔴🟢🔵 Session 2: Test-Driven Design (TDD)

Learn how tests can help to drive the design of your code, how tests can lead to a better feedback loop, and less code! A key skill in modern development workflows.

• Read Test-Driven Development: By Example
  • Study the Part I: The Money Example
  • Exercise: Try to repeat it with a programming language at your choice.
• Read Growing Object-Oriented Software, Guided by Tests
  • Chapter 1: What is the point of Test-Driven Development?
  • Chapter 2: Test-Driven Development with Objects
  • Chapter 4: Kick-Starting the Test-Driven Cycle
  • Chapter 5: Maintaining the Test-Driven Cycle
• Unit Tests
  • Read Chapter 9: Unit Tests of Clean Code
  • Watch The Clean Code Talks - Unit Testing
  • Read Effective Unit Testing
    • Part 1: Foundations
    • Part 2: Catalog
• Read desirable properties of tests
  • Watch the video playlist
• Read Working Effectively with Unit Tests

🌱 Session 3: Refactoring

Sharpen your ability to improve the design of your code without changing its behavior. Recognize code smells, apply refactoring techniques, and keep your systems clean over time.

• Watch Workflows of Refactoring
• Read Refactoring: Improving the design of existing code
  • Chapter 1: Refactoring, a First Example
    • Try to repeat the example code
  • Chapter 2: Principles in Refactoring
  • Chapter 3: Bad Smells in Code
• Exercise: Try to find and refactor the code smells in these Code Katas:
  • Tennis Refactoring Kata
  • Gilded Rose Kata
  • What Code Smells you have found?
    • What steps you followed to remove them?
    • What difficulties you have faced?
• Try the Refactoring Golf: Explore your IDE to see what's really possible using shortcuts and automation.

🧓🏻 Session 4: Working with Legacy Code

Master strategies and techniques to safely work in large, untested, or unfamiliar codebases. One of the most valuable real-world development skills for people who are dealing with legacy code at daily basis.

• Read Working Effectively with Legacy Code
  • Chapter 1: Changing Software
  • Chapter 2: Working with Feedback
  • Chapter 4: The Seam Model
  • Chapter 8: How Do I Add a Feature ?
  • Chapter 13: I Need to Make Changes, but I Don't Know What Tests to Write
  • Chapter 25: Dependency-Breaking Techniques
• Read Working Effectively with Legacy Tests
• Exercise: Try the Gilded Rose Kata
  • Add code coverage
  • Add the new feature
  • Refactor the code
• Watch how other tackled the Gilded Rose Kata:
  • Watch All the Little Things
  • Watch "Writing test cases using Approval Tests" (Part I, Part II, Part III)
• Watch Testing and Refactoring Legacy Code
  • Exercise: Try to repeat the Code Kata
  • Watch the alternative version Testing and Refactoring Legacy Code - The Trip Service Kata - Part I
    • And Testing and Refactoring Legacy Code - The Trip Service Kata - Part II: on OCP, Seam Model, and DIP.
• Read more about Approval Testing and some examples:
  • Characterization Testing
  • Mutation Testing
  • Golden Master and Sampling
    • How Not To Write Golden Master Tests
  • Exercise: Try to test and refactor the Ugly trivia game
    • Which is the approach you prefer to apply? Why?
• Watch Surviving a legacy codebase: tactics and tools
  • Read the Slides of the talk
  • Have access to the example code for further practice

🔄 Session 5: Testing, Design and Test-Driven Development

_Explore the deeper relationship between testing and good design. Learn how testability often leads to better archite