hminhit / study-path

An organized learning path about Clean Code, Test-Driven Development, Legacy Code, Refactoring, Domain-Driven Design and Microservice Architecture

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

Getting Started

• The Pomodoro Technique (paper)
• Manifesto for Agile Software Development
• Principles behind the Agile Manifesto
• Manifesto for Software Craftsmanship

Session 1: SOLID and Clean Code

• Core Design Principles for Software Developers by Venkat Subramaniam
• SOLID principles
  • SRP: Single Responsibility Principle
  • OCP: Open-Closed Principle
  • LSP: Liskov Substitution Principle
  • ISP: Interface Segregation Principle
  • DIP: Dependency Inversion Principle
• Start the Racing Car Katas
  • find SOLID violations
• Clean Code
  • Chapter 1: Clean Code
  • Chapter 2: Meaningful Names
  • Chapter 3: Functions
  • Chapter 6: Objects and Data Structures
  • Chapter 7: Error Handling
  • Chapter 10: Classes
• The Pragmatic Programmer
  • Chapter 2: A Pragmatic Approach
  • Chapter 5: Bend or Break
  • Chapter 6: While You Are Coding
• The Art of Enbugging: Tell, don't ask / Law of Demeter
• YAGNI

Session 2: Test-Driven Development

• TDD by example
  • Study the Part I: The Money Example and try to practically follow the same exercise with a programming language at your choice.
• 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
• Clean Code
  • Chapter 9: Unit Tests
• The Clean Code Talks - Unit Testing
• Effective Unit Testing
  • Part 1: Foundations
  • Part 2: Catalog

Session 3: Refactoring

• Martin Fowler @ OOP2014 "Workflows of Refactoring"
• 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
• 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?

Session 4: Working with Legacy Code

• 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
• Working Effectively with Legacy Tests
• Try the Gilded Rose Kata
  • Code Coverage
  • Add the new feature
  • Refactor
• Watch at these approaches to tackle the Gilded Rose Kata:
  • All the Little Things by Sandi Metz
  • Writing test cases using Approval Tests, by Emily Bache (Part I, Part II, Part III)
• Watch Testing and Refactoring Legacy Code
  • Try to repeat the Code Kata
• More about Approval Testing and some examples:
  • Characterization Testing
  • Mutation Testing
  • Golden Master and Sampling
    • How Not To Write Golden Master Tests
  • 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, by Paolo D'Incau and Pietro Di Bello
  • Slides of the talk
  • Example code to practice

Session 5: TDD and "Friends"

• How to Write Clean, Testable Code
• Good Design is Easily-Learned
• Try to learn and repeat these Katas autonomously
  • The Bowling Game Kata
  • The Roman Numerals Kata
• Unit Testing
• Growing Object Oriented Software, Guided by Tests
  • Chapter 6: Object-Oriented Style
  • Chapter 7: Achieving Object-Oriented Design
  • Chapter 8: Building on Third-Party Code
• Clean Code
  • Chapter 8: Boundaries
• The Magic Tricks of Testing by Sandi Metz
• Mocks Aren't Stubs
• Try the String Calculator Kata
  • With interactions
• Try the Game Of Life Kata
• Try the Tic Tac Toe Kata

Session 6: Practice with a new Programming Language

Principles and Practices are not dependent on any particular programming language, rather they act as support or enabler to learn and get comfortable with programming languages and tools we never used before.

Now that you have learned something about the good principles and practices of software development, try to grab a new programming language which you never used before and try to repeat some of the Code Katas you already have done previously:

• Fizz Buzz Kata
• The Bowling Game Kata
• String Calculator Kata
• The Roman Numerals Kata
• Game Of Life Kata
• Tic Tac Toe Kata
• Opening Hours Kata
• Racing Car Katas
• Repeat the Money Example of TDD by Example
• Gilded Rose Kata

If you are looking for more Code Katas to learn and practice with your new programming language, try to give a look at Kata-Log.

Session 7: Deploy your application

• Read The Twelve-Factor App before you start
• Write an example application
• Publish the code on a GitHub repository
• Organize your work in User Stories (e.g. Trello)
• Setup a development environment (e.g. Vagrant/Ansible)
• Setup a CI environment (e.g. Travis)
• Deploy your application (e.g. Heroku)
• Test the deployed application
• Continuous Delivery
  • Anatomy of the Deployment Pipeline
• Describe your Continuous Delivery process (Can it be improved ? How ?)

Session 8: Domain-Driven Design

• Eric Evans - Tackling Complexity in the Heart of Software
• Domain-Driven Design Quickly
  • Chapter 1: What Is Domain-Driven Design
  • Chapter 2: The Ubiquitous Language
  • Chapter 3: Model-Driven Design
  • Chapter 4: Refactoring Toward Deeper Insight
  • Chapter 5: Preserving Model Integrity
• Eric Evans - DDD: Putting the Model to Work
• How to write a Repository
• Eric Evans JAX 2015 Keynote: DDD and Microservices: At last, some boundaries!
• Recommended readings:
  • Domain-Driven Design: Tackling Complexity in the Heart of Software
  • Implementing Domain-Driven Design
  • Domain-Driven Design Reference: Definitions and Pattern Summaries

Session 9: Microservice Architecture

• Microservices: A Definition of This New Architectural Term
• GOTO 2014 • Microservices • Fowler
• Principles Of Microservices by Sam Newman
• Microservice Trade-Offs
• Microservice Architecture: Aligning Principles, Practices, and Culture
  • Chapter 1: The Microservices Way
  • Chapter 2: The Microservices Value Proposition
  • Chapter 3: Designing Microservice Systems
  • Chapter 4: Establishing a Foundation
  • Chapter 5: Service Design
• Building Microservices: Designing Fine-Grained Systems
  • Chapter 1: Microservices
  • Chapter 2: The Evolutionary Architect
  • Chapter 3: How to Model Services
  • Chapter 4: Integration
  • Chapter 5: Splitting the Monolith
  • Chapter 6: Deployment
  • Chapter 7: Testing
  • Chapter 8: Monitoring
  • Chapter 11: Microservices at Scale
  • Book Reading Club: "Building Microservices" [part I - part II - part III]
• Practical Considerations For Microservice Architecture
• Microservices Antipatterns
• Seven Microservices Anti-patterns
• Transactions and consistency in distributed systems
  • Using sagas to maintain data consistency in a microservice architecture
  • GOTO 2015 • Applying the Saga Pattern
• Examples and other resources

Session 10: Further topics

• TDD by example
  • Patterns for Test-Driven Development
• Simple Design
  • Beck Design Rules
  • Emergent Design
  • The Four Elements of Simple Design
  • Putting An Age-Old Battle To Rest
  • Chapter 12 of Clean Code: Emergence
• Outside-in TDD [part I - part II - part III]
• Clean Architecture
  • Sandro Mancuso @ Lean Agile Scotland "Crafted Design"
  • Sandro Mancuso @ Jax London 2014 "Crafted Design"
  • Notes about "Crafted Design"
  • Hexagonal architecture
  • The Clean Architecture
• CQRS and Event Sourcing:
  • Greg Young - CQRS and Event Sourcing - Code on the Beach 2014
  • Bryan Hunter - CQRS with Erlang
  • Greg Young - A Decade of DDD, CQRS, Event Sourcing
  • CQRS Journey
• TDD and Software Design
• Try the Social Networking Kata
• Try the Salary Slip Kata
• Try the Bank Account Kata
• Try the Greeting Service Kata

Recommended Readings

In this section I will provide a list of recommended books readings that have not been mentioned directly in this study path, but of significant importance.

• The Nature of Software Development
• Extreme Programming Explained: Embrace Change (2nd Edition)
• The Agile Samurai: How Agile Masters Deliver Great Software
• Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation
• Release It!: Design and Deploy Production-Ready Software
• Beyond Legacy Code: Nine Practices to Extend the Life (and Value) of Your Software
• The Phoenix Project: A Novel about IT, DevOps, and Helping Your Business Win