An Agile study path for junior to mid level developers

This is a learning path every new graduate or consultant developer can follow.

This path reflects agile culture and values, which have their roots in the agile manifesto, as well as in those of XP, and in the software craftsmanship manifesto.

This study path is not meant to teach specific languages and tech stacks: rather it reflects how to builds all sort of software according to reusable agile, clean code and design principles.

Yes, it is a lot of content. No, you don’t have to have read all of it before you start your career growth to the next level. However, you should at the very least be comfortable explaining each and every topic in this list. If you are not, then that should be considered a knowledge gap.

This study path is adapted from a battle tested one https://github.com/xpeppers/starway-to-orione and is composed of basic reference literature, articles and videos for each topic. After following this, you should be able to hold your own and provide meaningful references in any conversation with your peers.

It is meant to be consumed in sequence.

0) Values

• The Agile Manifesto
• The 12 principles
• The Software Craftsmanship Manifesto

1) Methodology

1.1) Waterfall

• A brief description and history https://beza1e1.tuxen.de/waterfall.html

1.2) Agile

• Read these articles on Iterative and Incremental Development by Robert C. Martin:
  • Waterfall
  • Agile
  • Transition
• Read chapters 1 and 2 from The Agile Samurai book
  • Agile in a nutshell
  • Meet your agile team
• Read this summarized article: What Exactly is the Agile Mindset?
• Watch the talk The Power of an Agile Mindset by Linda Rising (optional)
• Read first chapter of “Applying UML and Patterns” (optional)

1.3) Extreme Programming

• Read these chapters of the Extreme Programming Explained book by Kent Beck
  • Preface
  • The problem
  • A development episode
  • Economics of software development
  • Four variables
  • Cost of change
  • Learning to drive
  • Four values
  • Basic principles
  • Back to basics
  • A quick overview
  • How could this work?
• Read this article about Code Ownership by Martin Fowler

1.4) Lean

• Read the introduction and the first chapter of Lean Software Development: An Agile Toolkit
• Watch this short summary video on the Lean 4 key principles
• Watch this video of How Toyota changed the way we make things (optional)

1.5) Agile Frameworks

1.5.1) Scrum

• Read The Scrum guide
• Read Scrum and XP from the trenches (optional)

1.5.2) Kanban

• Read this introduction to Kanban

2) Day to day Agile

2.1) User Stories

• Check out a typical User Story template
• Read chapters 2 and 14 of User stories applied
  • Writing Stories
  • A Catalog of Story Smells
• Read this article by Ron Jeffries about estimating user stories

2.2) Pair Programming

• Read this article by Martin Fowler on Pair Programming
• Read this other article by Martin Fowler about Pair Programming misconceptions
• Read the paper All I learned about Pair Programming I learned in kindergarten
• Have a look at The effectiveness of Pair Programming: a meta-analysis

2.3) Retrospectives

• Read about the Retrospective Fundamentals from Pat Kua’s Retrospective Handbook
• Chapters 1, 2 and 3 of Agile Retrospective by Diana Larsen – (Chapter 1) Helping Your Team Inspect and Adapt
  • Helping your team inspect and adapt
  • A retrospective custom-fit to your team
  • Leading retrospectives

3) Clean code

3.1) Paradigm-agnostic concepts

• Read the article You Aren’t Gonna Need It
• Watch Venkat Subramaniam’s talk about “Core Design Principles for Software Developers”
• Read about the Principle of Least Astonishment
• Read these chapters from Clean Code
  • Chapter 1: Clean Code
  • Chapter 2: Meaningful Names
  • Chapter 3: Functions
  • Chapter 4: Comments
  • Chapter 5: Formatting
• Read The Four Elements of Simple Design

3.2) OO concepts

• Refresh your memory on Encapsulation, Inheritance and Polymorphism with this article

• Read more about Encapsulation:

  • http://www.natpryce.com/articles/000498.html
  • http://c2.com/cgi/wiki?EncapsulationIsNotInformationHiding

• Read these chapters from the Clean Architecture book

  • Chapter 3 Paradigm overview
  • Chapter 4 Structured programming
  • Chapter 5 Object Oriented programming

• Read the article Keep It DRY, Shy, and Tell the Other Guy

• Learn about the Tell Don’t Ask principle

  • read the article Tell, Don’t Ask
  • read the article The Art of Enbugging

• Do the Kata String Calculator

• Read these chapters from Clean Code

  • Chapter 6: Objects and Data Structures

  • Chapter 7: Error Handling

  • Chapter 10: Classes

• Read about 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 (find SOLID violations in the code)

• Read Names objects after things, not actions! by Matteo Vaccari

• Read about why You should not use Exceptions for flow control

• Read Object Calisthenics (optional)

3.3) Functional concepts

• Read this article by Robert Martin about OOP vs FP
• Read these chapters from the Clean Architecture book
  • Chapter 6 Functional programming
• Watch this video about the main concepts of functional programming
• Read this article to learn how to use map, filter and reduce and their benefits
  • Try to apply the examples to a few languages like JavaScript, Java, Python, Ruby, Kotlin etc. using their collection API
• Read this article about mutability and immutability
• Read this series of short articles about
  • First class functions
  • Pure functions
  • Currying
  • Functional composition
• Read these chapters from Professor Frisby’s Mostly Adequate Guide to Functional Programming
  • What ever are we doing?
  • First class functions
  • Pure happiness with pure functions
  • Currying
  • Coding by composing
  • Tupperware
• Read this article about Railway Oriented Programming

4) Testing and TDD

4.1) Practicing TDD

• Read these chapters from Clean Code
  • 8: “Boundaries”
  • 9: “The Three Laws of TDD”
• Do the String calculator Kata with TDD
• Read these chapters from of 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
• Watch Ian Cooper – TDD, where did it all go wrong (optional)

4.2) Writing good unit tests

• Watch The Magic Tricks of Testing by Sandi Metz
• Read these chapters from Effective Unit Testing
  • Part 1: Foundations
  • Part 2: Catalog
• Read these articles about test doubles
  • Mocks Aren’t Stubs by Martin Fowler
  • The Little Mocker by Robert C Martin
  • Mock Roles, not Objects
• Watch J.B. Rainsberger – Integrated Tests Are A Scam (optional)

4.3) Writing testable code

• Watch The deep synergy between testability and good design

• Watch TDD and Software Design

• Read the article Good Design is Easily-Learned

• Read about The Four Elements of Simple Design

• Watch the Clean Code Talks series: these four videos (and the related blogpost series) are really valuable to learn how to design for testability.

  • Watch “The Clean Code Talks – Unit Testing” video (~ 30 minutes) [slides]. Then read his blogpost.

  • Watch “The Clean Code Talks – Inheritance, Polymorphism, & Testing” video (~ 40 minutes). Then read his blogpost (there you can find the slides too).

  • Watch “The Clean Code Talks – Don’t Look For Things!” video (~ 35 minutes) which talks about the Dependency Injection pattern. Then read his blogpost (there you can find the slides too).

  • Watch “The Clean Code Talks – “Global State and Singletons” video (~ 55 minutes). Then read his blogpost (there you can find the slides too).

• Read Miško Hevery’s guide on “Writing Testable Code”

• Do the Bowling game Kata in TDD

• Try to learn and repeat these Katas autonomously (optional)

  • TheBowlingGameKata
  • TheRomanNumeralsKata (video)

5) Refactoring

• Watch Martin Fowler @ OOP2014 “Workflows of Refactoring”
• Read these chapters from Refactoring: Improving the design of existing code
  • Chapter 1: Refactoring, a First Example
  • Chapter 2: Principles in Refactoring
  • Chapter 3: Bad Smells in Code
• Watch Testing and Refactoring Legacy Code (Example Code)
• Try the GildedRoseKata
  • Find the code smells
  • Add the new feature
• Try the TennisRefactoringKata
  • Find the code smells
  • Add the new feature

6) Continuous Integration

• Read the first 3 chapters of Continuous Integration
  • Getting Started
  • Using Continuous Integration
  • Reducing Risks using CI

7) APIs

• Read about REST APIs
  • An Introduction
  • More on the constraints
  • More on how to name REST resources
• Read about the robustness principle, or Postel’s law

8) Security

• Be aware of all the security exploits in this year’s OWASP Top 10

9) Effective collaboration

• Read this article by Eric Raymond on how to ask questions
• Read chapter 1 of The Pragmatic Programmer

Next: Senior Developers →

Table of Contents:

1. Junior to Mid Level Developers
2. Senior Developers
3. Lead Developers