pietrobrunetti / study-path

A learning path about Clean Code, TDD, 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 Responsability 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: 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 25: Dependency-Breaking Techniques
• Start the GildedRoseKata
  • Code Coverage
  • Add the new feature
  • Do not try Code Refactoring
• Working Effectively with Legacy Tests

Session 4: Refactoring

• Martin Fowler @ OOP2014 "Workflows of Refactoring"
• Refactoring: Improving the design of existing code
  • Chapter 1: Refactoring, a First Example
    • Example Code
  • Chapter 2: Principles in Refactoring
  • Chapter 3: Bad Smells in Code
• Testing and Refactoring Legacy Code
  • Example Code
• Try the GildedRoseKata
  • Code Coverage
  • Code Refactoring
  • Add the new feature
• Try the TennisRefactoringKata (find code smells)

Session 5: TDD and "Friends"

• How to Write Clean, Testable Code
• Good Design is Easily-Learned
• Try to learn and repeat these Katas autonomously
  • TheBowlingGameKata
  • TheRomanNumeralsKata
• 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 StringCalculatorKata
  • With interactions

Session 6: Hands On Erlang

You are free to replace Erlang with whatever programming language you want to dive in

• Erlang resources
  • Programming Erlang (2nd Edition)
  • Erlang Koans
  • Other useful resources about Erlang: Spawned Shelter!
• Try these Katas in Erlang:
  • TheBowlingGameKata
  • RomanNumeralsKata
  • FizzBuzzKata
  • StringCalculatorKata
    • Follow this video
  • TennisKata
  • OpeningHoursKata

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 Architeture
  • 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

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
• Beyond Legacy Code: Nine Practices to Extend the Life (and Value) of Your Software
• 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
• The Phoenix Project: A Novel about IT, DevOps, and Helping Your Business Win