Shaft's Code Manifesto: Lessons in Software Brilliance
Tags: softwaredevelopment
Published: 2023-10-02 04:23:21

## Intro:
The need of a no-nonsense software developer is not just to solve problems; but to prevents them from happening in the first place. The path to excellence in coding is paved with principles that ensure the lines of code created not only work flawlessly but also stand the test of time. Let's delve into the world of software development through the perspective of the iconic character John Shaft, who navigates the intricate streets of coding, imparting and embodying the principles of effective design, sustainability, and code excellence. 

## Detective's Guide to Code Craftsmanship:
So, fasten your seatbelts, because we're about to embark on a journey to uncover the secrets of software design, Shaft-style.

1. **KISS** (Keep It Simple, Stupid): Just like I always say, KISS is all about keeping things plain and simple in software design. It's about steerin' clear of needless complications and optin' for straightforward, clear-cut solutions

2. **YAGNI**(You Ain't Gonna Need It): Now, here's the deal with YAGNI, my friend. It tells us not to pile up fancy features in our software that ain't needed right now. Instead, it pushes us to tackle the problems at hand and skip all the guesswork and extra fluff. This keeps our code sharp and ready for action."

3. "Prefer **Readability** Over Conciseness: Here's the scoop, my friend—when you're coding, make it crystal clear for anyone who reads it, even if it means goin' a bit longer or spellin' things out. Why? 'Cause readable code is the key to teamwork and keepin' things in check."

4. **SRP** - Single Responsibility Principle: Alright, listen up. When it comes to classes, keep it simple—each one should only change for one darn good reason. This rule pushes for compact, specialized classes with crystal-clear duties.

5. Open-Closed Principle: Your software pieces, be it classes or modules, should be like a good jacket—open to get a cool new patch but closed so you don't tear up the whole thing. This way, you can add new stuff without messin' up the old

6. Composition Over Inheritance: Alright, here's the deal. Instead of inheritin' all the baggage from your old man, try mixin' things up. Build your complex stuff by puttin' together simpler, reusable parts. This way, you stay flexible and avoid gettin' tied down by the family tree."

7. Design by Contract (**LSP** - Liskov Substitution Principle): When you create those fancy new classes, make sure they can step in for the old-timers without causin' a ruckus. It's all about keepin' things smooth and predictable, so your code stays on the straight and narrow

8. **Code Reviews**: Now, this one's a no-brainer, my friend. You and your crew need to sit down and go over each other's work. It's like checkin' your gear before you hit the streets. It helps spot any trouble, keeps the quality up, and makes sure everybody's on the same page."

## The Shaft Way
When you find yourself in a tricky situation, ask yourself, "What would Shaft do?" Because in the world of software, following Shaft's principles can make all the difference between code that's forgettable and code that's legendary.


## Further reads:
1) inspired by [KISS](https://dev.to/wyattdave/power-automate-keep-it-simple-stupid-ocl) by @wyattdave 
2) SOLID Principle - [JAVA example](https://www.baeldung.com/solid-principles)