If you could make a MASSIVE improvement in one area of your software development, what would that be?
Explore new ways to write code...
Learn how to develop more extensible software...
Improve how your team works together...
Prevent bugs before they happen...
Build more testable, modular components...
Those all sound pretty good, right?
I'm putting together some training material around SOLID development principles (the 5 core principles that expert software developers live by to write clean, manageable code). If the list above sounds like something you'd be interested in exploring, keep reading.
The Recurring Theme in Software Quality
Over the past 18 years I've had the opportunity to work with software teams ranging from a few developers to larger, enterprise projects with hundreds of people. One of the things I've noticed is that the quality of the product is largely dependent on the quality of the code.
Your contribution as a developer is vital to the success of a project and your client's satisfaction. As developers, we often don't have much say in the direction of the product or the business side of things, so the best thing we can do is deliver the greatest quality in what we can control: our code.
There's no denying it; better coding skills result in better finished products with less bugs.
SOLID Helps You Write High-Quality Code
There are 5 principles that make up the acronym SOLID, each of which exists to help you write cleaner, more manageable code:
- Single Responsibility principle - A software entity should do one thing, and do it really well. This principle helps ensure that changes to your code don't have unintended consequences.
- Open-Closed principle - A software entity should be open to extension, but closed for modification. This principle helps ensure that your code can be updated to handle new requirements via extension, not modification (which can cause unintended side effects.)
- Liskov Substitution principle - An object that inherits from another object (i.e. a subclass) should be usable anywhere its parent is usable, without unexpected results. This principle helps ensure you'll focus on what your code should do (not on how it's structured), and promotes better use of abstractions and interfaces.
- Interface Segregation principle - Classes should not be forced to implement or depend on interfaces that they do not use. This principle helps you to write clean code with discrete functionality, and prevents ambiguity in your interfaces. Following this principle also helps prevent unintended consequences when updating code.
- Dependency Inversion principle - Software layers (low-level and higher-level) should be decoupled and not have dependencies on one another. This principle ensures that software is built with a focus on abstractions, not any single implementation, which promotes code reuse and extensibility.
These are a set of 5 core principles that, when followed, help you craft high-quality software. The rules are simple to explain, but difficult to fully understand, since their proper use requires experience or immersion. Fortunately, this training is designed to give you clear, concise information about what these principles are and how to apply them, as well as provide an open forum for getting your questions answered so you'll walk away with a clear understanding of SOLID and no gaps in your learning.
You'll also learn how these rules work in harmony with one another, how they're sometimes misinterpreted or used incorrectly, and how they complement or differ from other concepts you've probably heard of (like design patterns, the DRY principle, N-layer design, and others.)
The Guarantee—You'll Write Better Software, Forever
That's a crazy guarantee. But it's my promise to you.
By learning these few simple (but nuanced) principles you'll have an improved understanding of how the best software projects are built, and how expert-level code is written.
SOLID principles aren't tactics or shortcuts, and they're not language-specific. These are fundamentally better ways to write code developed and honed over decades, and you will apply them every day for the remainder of your development career.
Your Instructor
Hi, I'm Travis.
I have over 18 years experience developing software and I've worked in teams ranging in size from small startups to several enterprise projects. My favorite thing to do is write great code, but one of my greatest passions is helping others do the same.
I have professional experience as a software development instructor, and teaching has been the highlight of my career. I'm thrilled you're interested in learning more about SOLID principles and seeing how much of a game changer they are for your development, and just as much, I'm thrilled to be a part of that journey.
You're in good hands, and this SOLID training will change how you write (and think about) code. That's my promise to you.
“Travis is an excellent instructor who truly cares about his students. Learning from him allowed me to apply new skills to my job, but ultimately led me to following a career path in tech.”
“... he has deep technical knowledge across a wide array of subjects. Also, unlike most technical people, his skills were as much art as they were science. He has a mastery of back-end services coding, but also has an artful eye for user experience development.”
“He has an insane sense of technical, design, and business knowledge as well. This is the kind of guy everybody goes to when they need advice or just someone to collaborate code with.”
What's Next?
The material for this SOLID training is still being put together, so hang tight! I'll reach out to you soon with more information.