Skip to main content

SOLID

 This week, we read a very straight-forward chapter by Edward Guiness of the book Ace the Programming Interview: 160 Questions and Answers for Success. It very quickly explains the SOLID principles, which are widely-known principles applied to object-oriented programming that have to do with minimizing dependencies between classes. I won't explain what each principle consists of (since it's very easy to find), but I will share my general thoughts about them. 

I still remember when I first started university, my code consisted of one very long python file that you could very easily read from top to bottom; the concept of functions was still foreign to me, and when we started using them, we would split up all of our code into two or three functions and that was that. Since then, we've been introduced to many different ways to make code cleaner and easier to read, and one that's been repeated often is the Single Responsibility Principle, which I agree is very useful in order to make code more maintainable. 

While working, more often than not (especially in my current role) I come across code for a project that I don't own and just have to make some changes to. I've had to learn to follow the Open/Closed principle (and to a lesser extent the Liskov Substitution) so that I don't break anything and receive angry pings from the team that actually owns the project. 

I don't have much experience with the other two principles (Interface Segregation and Dependency Inversion), as outside of school, I haven't come across the need of using interfaces (or perhaps I just haven't noticed when they could've been useful), but I can definitely see how they could be useful whenever I actually work with them. 

As the author mentions, it's also important to note that these rules aren't always set in stone, and they can also be open to a little interpretation, so it's good to use common sense (and know, from experience, when it's right to ignore them), but I think we can all agree that they serve as good guidelines for software engineers as a whole, and it's in our best interest that more people learn about them, as that translates into easier work for us down the line, when you have to stare down a project you've never seen before and have to tread carefully if you don't want to break anything.

Comments

Post a Comment

Popular posts from this blog

Microservices

 This week, we read an article called Microservices  by James Lewis and Martin Fowler, which did a great job explaining the differences between monolithic applications and those that run on microservices (and the ones that use a little bit of both). They explained the advantages and pitfalls of implementing any of these methods, and they conclude that while microservice-based applications seem promising, it's still too early to tell whether they'll be better than monolithic ones. Luckily for us, this article was published in 2014, and we're far enough in the future to know that they are, in fact, more widely used today. Before reading this article, I was already aware of these different types of applications, and I knew that the market had a preference towards microservice applications, but I hadn't realized how much this change had affected how businesses are run today. From personal experience, I belong to a cross-functional (XFN) team that dabbles in many different p...
Post a Comment
Read more

4+1 View Model

 This week, we looked at many different resources: two very short videos ("The 4+1 Model" by the Virtual Training Company and "Six Blind Men" by Phat Phish) and an article by Grady Booch titled The Elephant and the Blind Programmers . What they all had in common is that they all touched on either the 4+1 view model, or a concept known as wisdom gap, which is very closely related to the model.  In order to explain the need for the 4+1 model, Booch relates it to the old Indian story, which talks about how different blind men examine an elephant and come to different conclusions as to what it is, since they are all looking at different parts of it. The moral of the story is that they are all right in their own way, yet none of them have the full picture. The same applies to the model. Depending on who you are and what part of a system you're working on, you'll be interested in looking at it from a certain way, which will definitely differ from the other team me...
Post a Comment
Read more

Why is an architect?

  This week's (very short) article, Who Needs an Architect?, Martin Fowler explains to us the different definitions of architects that exist in the software world. The first and most common definition, which Fowler disagrees with, says that an architect is (s)he who helps identify what the most important parts of a project are, in order to give it structure. However, it is also mentioned that these parts are usually the most important because they are the hardest to change, so an architect's job should also include reducing the amount of these parts. Following the logic, by this definition, an architect's job is to reduce the amount of architecture.  The second proposed definition, which I also think I agree with, is that an architect's role is more like a guide's. His purpose is to help the team become better by using his expertise, and communicating with as much of the team as possible in order to remove their blocks. I think the word architect  still fulfills thi...
Post a Comment
Read more