the raise of dependency management.

December 25, 2023

2023   ·   software  

Robert C Martin was the first software engineer that started advocating about better Dependency Management. Some of his teachings evolved into now called SOLID principles and many others.

Let’s look the organic reaction that raised the need for SOLID principles and many other Software Principles which double clicked on Clean Code.

In any Engineering profession, there are two fundamental parts:

  1. Designing the Product
  2. Building the Product

In Civil Engineering:

  1. Blue Prints of Buildings are the design of the product.
  2. Building the building itself. Building the house or apartment itself, takes exponential time when compared to designing the blue print.

This applies in other engineering departments too like: Mechanical Engineering, Electrical Engineering, etc.

So, this can be notated as `` Design << Build

But,

In Software Engineering:

  1. Writing the Code is the design of the product.
  2. Compiling and Building the application is the build part of the product.

Counter intuitively, here, the Compiling and Building of product is so cheap. This enables the Business the flexibility to change its requirements based on customers and implement and build the product continuously that meets customer needs.

This brings us with two main goals of a software product:

  1. Meet the customer/business requirements.
  2. Be soft and flexible to enable incremental updates/modifications.

Most programmers are very good at first goal, but not in the second goal. And some do not even give weight to second goal.

This ignorance leads to some of the unwanted Design Smells

  1. Rigid: Even a small change in source code takes lot of effort.
  2. Fragile: Changes in one module, affects long distance modules.
  3. Immobile: Internal components can not be reusable.
  4. Viscous: Minor modifications take build or compile of unnecessary modules, leading to long ops times.
  5. Needless Complexity: Hard coupling with future requirements.

If these design smells are left unchecked, the code is destined to rot and degrade gradually.

All these smells are nothing but Dependency Management. Infact OO is all about dependecy management.

There are 11 Dependency Management principles, divided into three parts.

  1. SOLID (5): These principles control the relationships and operations between classes.
  2. Component Cohesion (3)
  3. Component Coupling (3)

Using these 11 principles, we can make sure our code does not get degraded overtime.

Supporting Reads: