This study path is released under the CC BY-SA 4.0 license
- The Pomodoro Technique (paper)
- Manifesto for Agile Software Development
- Principles behind the Agile Manifesto
- Manifesto for Software Craftsmanship
- Core Design Principles for Software Developers by Venkat Subramaniam
- SOLID principles
- 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
- 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.
- Study the
- 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
- 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
- Martin Fowler @ OOP2014 "Workflows of Refactoring"
- Refactoring: Improving the design of existing code
- Chapter 1: Refactoring, a First Example
- Chapter 2: Principles in Refactoring
- Chapter 3: Bad Smells in Code
- Testing and Refactoring Legacy Code
- Try the GildedRoseKata
- Code Coverage
- Code Refactoring
- Add the new feature
- Try the TennisRefactoringKata (find code smells)
- How to Write Clean, Testable Code
- Good Design is Easily-Learned
- Try to learn and repeat these Katas autonomously
- 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
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:
- 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
- Describe your Continuous Delivery process (Can it be improved ? How ?)
- 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:
- 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
- Examples and other resources
- 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
- CQRS and Event Sourcing:
- TDD and Software Design
- Try the Social Networking Kata
- Try the Salary Slip Kata
- Try the Bank Account Kata
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