Sept 8th, 2023 update
Hello readers
What’s going on, Crafters?
It has certainly been a while since our last update here, primarily because I’ve been deeply engaged with the course students.
Let’s take a moment to recap what’s happened and where the dust has settled.
Let’s recap
Why did I start writing this book again?
The entire reason I started writing solidbook was because it was quite distressing to me, this experience of graduating from 5 years of school only to find I was still unable to do much of what actually mattered.
As you may know, I’ve poured over countless books, applied as much as I could, and started assembling it into this book here!
How did it go?
- What began as a book idea evolved into a wiki.
- I eventually reached a point where I stopped finding new foundational topics to explore, and shifted over to recognizing recurring patterns.
- This knowledge was then passed on to my mentorship students.
- I introduced 'The Software Essentialist' course to continue refining these concepts with real-world developers.
- Now, with over 500 developers in our course community and several content iterations later, I'm excited to present the finalized outline for the course and the book.
But first, I want to share some pivotal lessons from this transformative journey.
I’ll share the outline with you shortly, but first I want to tell you some of the main things I’ve learned throughout this crazy endeavour to piece together and distill the wisdom of the experts from the last 40+ years and create a path for junior developers to master what actually matters.
9 Lessons I’ve Learned
Realized the following things
- The ultimate aim here is design confidence.
- But if you’re don’t know what matters, you’ll always be second guessing yourself
- The foundation lies in understanding the first principles and mental models rooted in reality.
-
A developer's primary mission is to benefit 3 roles: Users, Customers, & Fellow Developers. To elaborate:
- Users seek time saved or enriched.
- Customers pursue revenue growth or protected revenue.
- And Developers crave a versatile codebase that doesn't compromise the goals of the former two.
- Achieving this balance? Quite a challenge, but that's the essence of scalability.
- Scalability hinges on mastering the 4 Pillars: Design, Testing, Architecture & Strategy.
- Acquiring proficiency in the 4 Pillars can span years without the right mental models.
- Abstraction & The Feedback Loop (Systems Thinking) are paramount mental models for every single software developer. Gain a deep understanding of these and how they apply to code, and many of your problems go away with practice.
- To attain Design Confidence means you need to master Problem Decomposition, and those two mental models are the keys.
- This attain Mastery of this skill involves ascending through distinct 5 Phases of Craftship.
And, this forms the backbone of the book's final structure.
The final course & book outline
-
Intro
- Why I Wrote This Book & How It Came To Be — A Quick Recap of the History Of solidbook & The Software Essentialist
- The Roadmap — How to Skip the Status Quo & Master Problem Decomposition & Confidently Write Scalable Code On Any Side of the Stack
- The Software Essentialist Mindset — The Core Mindsets You Need For Success Along The Path
-
The Metaphysics: Developing a solid understanding of the first principles and how to think about code.
- The Mental Models: The 80-20 of Software Design, Testing, Architecture & Strategy — Understand Software Software Design, Testing, Architecture & Strategy from First Principles in 12 Essentials
- The Skills — An Introduction to the Systems Thinking Techniques (FA²STR, The Guess Points, The Stereotypical Architecture) Which Help You Systematically Decompose Design Problems & Approach Your Work in a Consistent Way
-
The Phases of Craftship: A gradual, step-by-step approach to learn how to implement techniques from the 12 essentials of design, testing, architecture & strategy.
- Code-First — Basic practice building an information system from End to End using MVC
- Best Practice-First — Learn build, test & deploy a Walking Skeleton to a Minimal Deployment Pipeline
- Pattern-First — Learn how to use DDD, Hexagonal Architecture & decouple from infrastructure, refactor to patterns to encapsulate complexity & introduce powerful testing strategies on both the frontend and backend
- Responsibility-First — Learn how to balance coupling & cohesion and design anything using the timeless 3-Step Responsibility-Driven Design process
- Value-First — Learn how to use the Systems Thinking-based FA²STR Design Method to Decompose Any Design Problem & Continually Improve Your Skills As a Value-First Developer (5 Feature Demonstrations)
-
The Guess Points: A catalog of Systems to aide in your continued Problem Decomposition
- Understanding the Guess Points: Theoretical & Physical
- The Problem Guess Point — Learn how to ensure you’re building the right thing
- The Solution Guess Point — Learn how to come up with a solution and identify the features and acceptance criteria
- The Architecture Guess Point — Learn how to identify, select, or design the architectural components, libraries, frameworks and tools necessary to meet the functional & non-functional requirements
- The Incoming Guess Point — Learn how to ensure your APIs work and prevent breaking changes
- The System (E2E/Customer Boundary) Guess Point — Learn how to write non-flaky E2E tests using a 4 Layer Testing Strategy and Prevent Regressions using Automated Tests
- The Application (Developer Boundary) Guess Point — Learn how to catch edge cases, model time, events, control, and write High Value Unit tests to give you high levels of confidence
- The Stateful (Domain Modelling) & Stateless Guess Points — Learn how to use events, sagas, and Temporal Decoupling to decompose logic between features and scale behaviour
- The Deployment & Delivery Guess Point — Learn how to improve your Deployment Pipeline
- The Execution Guess Point — Learn logging, error handling, and analytics tracking techniques for production
Frequently asked questions
When are you resuming work on the book?
After I finish the course, my priority shifts back to the book; but in all actuality, the priority has always been the book, because the way to do the book has been to ensure things work with teaching it in the course
What’s going to happen to solidbook?
It’s practically a wiki at the moment, so there’s plans to use parts of it for other projects, that of which I’ll let you know about later
When is the final book going to be released?
I’m only going to do at max 3 feedback cycles of this book and work with an editor to clean it up and publish it.
I’m doing some final drafting this weekend for the course and then I’ll share some new target deadlines.
In summary
To all my loyal readers, thank you for your patience.
The culmination of years of experience, learning, and teaching is soon to be in your hands.
More questions?
Engage with our community in the solidbook chat.
- Sept 8th, 2023 update
- Let’s recap
- Why did I start writing this book again?
- How did it go?
- 9 Lessons I’ve Learned
- The final course & book outline
- Frequently asked questions
- When are you resuming work on the book?
- What’s going to happen to solidbook?
- When is the final book going to be released?
- In summary
- More questions?