# Essential Programming Principles Every Developer Should Know
Written on
Chapter 1: Introduction to Programming Principles
Programming principles serve as fundamental guidelines for crafting computer programs. While they are often referred to as rules of thumb, each principle is backed by both theoretical foundations and practical applications within the realm of software engineering.
These principles are invaluable for developers, yet they can sometimes be challenging to grasp. They provide a framework for writing effective code, emphasizing that they are not strict rules but rather recommendations that facilitate the creation of code that is adaptable and manageable over time.
This may prove difficult to adhere to since the principles are not always straightforward, which can create confusion about when they should be applied.
Section 1.1: Single Responsibility Principle (SRP)
The Single Responsibility Principle asserts that a program should focus on one specific responsibility. In the context of object-oriented design, this means that each module or class should manage a single aspect of the software's functionality, encapsulated entirely within that class or module.
Commonly referred to as 'the rule of classes' or 'the law of Demeter,' this principle suggests that all classes should maintain a singular focus. For instance, an Order class should not handle both validation and processing; instead, it should assign validation tasks to another object, like a CreditChecker, while retaining sole responsibility for order processing.
Section 1.2: Open/Closed Principle (OCP)
The Open/Closed Principle posits that software entities should be designed to be open for extension but closed for modification. This means that a class's behavior can be extended without altering its original source code.
A module or system is deemed closed to modification when its behaviors are fixed and cannot be altered by external entities, including its own developers. If modifications are necessary, it indicates a violation of the OCP.
Chapter 2: Core Principles in Software Design
This video discusses the top five programming principles that every software engineer should adhere to, providing insights into their significance and application.
Section 2.1: Liskov's Substitution Principle (LSP)
The Liskov Substitution Principle states that for a derived class to qualify as a subtype of its base class, it must be possible to substitute instances of the derived class for instances of the base class without altering the desired behavior of the program.
This principle was introduced by Barbara Liskov and Jeannette Wing and is primarily relevant to static polymorphism. It may not directly apply to other forms of polymorphism, such as dynamic or reflectional; however, many experts consider the principles governing these variations to be fundamentally similar.
Section 2.2: Interface Segregation Principle (ISP)
The Interface Segregation Principle advocates for the division of interfaces that serve significantly different purposes.
If your application comprises multiple client classes, it is advisable to create separate interfaces for each. For example, if your program includes both a graphical user interface (GUI) and a command-line interface, distinct interfaces should be created for each client type.
Each interface should be concerned with a single responsibility, avoiding the inclusion of unrelated functionalities.
Section 2.3: Dependency Inversion Principle (DIP)
The Dependency Inversion Principle emphasizes that high-level modules should not rely on low-level modules; instead, both should depend on abstractions.
For example, in an application that allows users to upload images, the high-level code should remain unaware of how those images are stored or processed. It only needs to know the mechanism for uploading images and receiving a link in return.
This design allows for changes to the backend storage methods without disrupting the client code.
In this second video, you will learn about 50 essential definitions that every programmer should be familiar with, enhancing your coding vocabulary and understanding.