Clean Code Mastery: Programming Principles Every Programmer Should Know

credit: istockphoto.com

Table of Contents:

• Introduction
• What is a Clean Code
• Disclaimer
• Principles and Best Practices for Writing Clean Codes
  1. Consistent Naming Conventions
  2. Keep it Simple, Stupid
  3. Design Patterns
  4. Don't Repeat Yourself(DRY)
  5. Open/Closed Principles
  6. White Spacing is a good thing
  7. You Aren’t Going to Need It(YAGNI)
  8. Refactoring
  9. Code Organization
  10. Composition Over Inheritance
  11. Write Comments
  12. Separation of concerns
• Conclusion

Introduction

Writing clean code is crucial regardless of the programming language you use, be it Java, JavaScript, Python, or any other language. While coding itself may seem easy for developers, crafting clean code—code that’s both readable and efficient—poses a significant challenge. You might be pondering over the question: What exactly is clean code?

What is a Clean Code

Clean code refers to code that is not only efficient but also easy to read, understand, reliable, and maintainable this principle holds irrespective of the size of the software project, and it necessitates the successful execution of all tests. Clean code enhances collaboration among developers and ensures that your project remains robust and scalable.

What is Bad Code:

Bad code is what most of us were guilty of before grasping the concept of clean code. We all know that even bad codes still work, but it takes time and resources to code clean.

I empathize with the humbling feeling when you go seeking help from other developers to debug code that has kept you awake for nights, and they mock you while trying to figure out what's happening in your code,  It can be disheartening🤔  If you've encountered this scenario as a beginner, and are probably still grappling with it, take heart—there's always room for improvement. Embracing the journey to becoming a better programmer is a continuous process that can start at any point.

As you delve into the world of coding, it is important to acknowledge that, as a software engineer you won't always commence projects from scratch. At times, you may need to modify existing code written by someone else. Therefore, adopting these Key principles becomes essential that your code not only functions efficiently but, also remains readable and easy to collaborate on. This approach proves beneficial in the long run. especially when working with a team or maintaining legacy projects.

In this blog post, I'll be sharing valuable principles to boost the quality of your code.

Disclaimer 📣:

Before we delve into the principles, it is important to note that no one can be deemed the "best" programmer. I don't hold the highest level of experience in the tech realm, and it's essential to acknowledge that no individual can know everything about the ever-evolving landscape of technology. However, the lessons I've learned can offer valuable insights.

Now let’s explore these key principles 🚀

Principles and Best Practices for Writing Clean Codes:

1.  Consistent Naming Conventions:

Using the correct naming convention for your variables, functions, classes, and other identifiers is an excellent way to begin—it maintains clarity and provides you with a precise understanding of what you're dealing with.

When developers use the same naming conventions throughout their codebase, it becomes easier to locate functions, modules, etc. that serve a specific purpose.

Example in Java:

    
   public class Product {
      private String itemName;
      private int itemQuantity;
        
      public Product(String name, int quantity){
         this.itemName = name;
         this.itemQuantity = quantity;
      }
   }
         
  

In this Java example, we adhere to consistent naming conventions, using camel-case for both parameter names and instance variables. Consistency is key to making your code more readable.

Bonus Tips:

if you find it challenging to name a function or variable, it might indicate that you're trying to do too much. Break down complex functions into smaller, more focused ones. For instance, instead of having a function named `deleteItemAndRefresh( )`, create two separate functions: `deleteItem( )` and `refreshPage( )`.

2. Keep it Simple, Stupid:

This principle in particular may sound a little condescending and harsh, but it is one of the most important principles that you will need in your code. There is no doubt that writing the least amount of code is a sure route to take when trying to solve a problem. It is easier for human brains to read code when there aren't too many unnecessary loops or logic. Even writing multiple lines of complex code would require more commenting on your work, which makes your application even more difficult to maintain. All this principle is saying is that you should write code as simply as possible. One of the rules of basic programming is to never get caught up in trying to be too clever or show off with writing a block of complex advanced code. Just keep it short and simple. If it's possible to accomplish a task with one or a few lines of code, that's when you should use it.

3. Design Patterns:

In some languages like React, various use cases may require different patterns like Observer or Proxy. These design Patterns are reusable solutions to common problems, consider using some of these well-known design patterns regularly to help enhance code maintainability and understanding.

4. Don't Repeat Yourself(DRY)

The DRY principle emphasizes code reusability to prevent duplication. Instead of repeating code, encapsulate logic in functions or classes. Here's an example in JavaScript:

Original

        
     // code repetition example in JavaScript
      function calculateArea(radius) {
         return 3.14 * radius * radius;
      }
          
         function calculateVolume(radius, height) {
            return 3.14 * radius * radius * height;
         }
        
      

Improved

    
   // code that applies the DRY principle
    function calculateCircleArea(radius) {
       return Math.PI * radius * radius;
    }
      
    function calculateCylinderVolume(radius, height) {
       return calculateCircleArea(radius) * height;
    }
    

 5.  Open/Closed Principles:

The Open/Closed Principle, part of the SOLID Principle, recommends making code open to extension but closed to modification. This ensures that code remains stable even as requirements change.

Let's take, for instance, that you are working on your GUI framework and have released an open-source version for developers to modify and integrate directly. What if you want to release a major update after two months?

That means that their code will break, rendering their work useless. Eventually, they wouldn't want to use your library anymore, regardless of how useful it may have been in recent times. Therefore, it's better to release a code that doesn't allow modification.

For a deeper understanding of SOLID principles explore more here.

6. White Spacing is a good thing:

Whitespace in programming refers to spaces, tabs, and line breaks used for code formatting and organization. Though not essential for program execution, proper whitespace is crucial for code readability and maintainability. The term whitespace encompasses, indentation, line breaks, and spacing. It is essential to maintain proper indentation and spacing to maintain clean code.

In some languages like JavaScript, maintaining whitespace is recommended as it can impact file size. Use tools like Linter to help enforce these conventions.

7. You Aren’t Going to Need It(YAGNI):

YAGNI advises against coding for functionality with the belief that you might need it in the future. It's crucial not to try solving non-existent problems. While maintaining the DRY Principle is important, Only apply it when necessary. Avoid thinking too far ahead, preventing over-engineering and ensuring efforts align with current requirements, minimizing the risk of bugs.

8. Refactoring:

Acknowledging that your code won't be perfect at the initial attempt, refactoring involves revisiting and optimizing your code without changing results. As the codebase evolves, embrace continuous improvement. Consider using automated refactoring tools and code reviews for enhancement to ensure that the code remains efficient and clean.

9. Code Organization:

Structuring code logically improves readability and maintainability. Group related functions, classes, or modules and follow a consistent directory structure to make it easier for developers to navigate.

Effective code organization streamlines development and collaboration, fostering a more efficient and sustainable coding environment.

10. Composition Over Inheritance:

Object-oriented programming follows the principle of "Composition over Inheritance", emphasizing that objects with complex behaviors should contain instances of objects with individual behavior, instead of inheriting a class and adding new behaviors.

Composition programming is cleaner to write, easier to maintain and offers flexibility. In this paradigm, each individual behavior resides in its own class, enabling to creation of complex behavior by combining these individual components.

11. Write Comments:

Commenting on your code is crucial, it aids other developers to understand your code. it might be beneficial to you as well. Have you ever revisited code written years ago by you, only to discover that you no longer grasp the logic behind your own implementation?😂.When coding consider that other developers will read your code.Using comments to clarify objects, variables, and functions. Prioritize simplicity and practicality over complexity. Avoid writing code sorely to impress others; instead, leverage on comments and documentation to enhance code readability and ease of maintenance. Follow the style guide and consider the perspective of the next person who will work with your code.

12. Separation of concerns:

The Separation of Concerns Concept aligns with the Single Responsibility Principle of SOLID. It advocates breaking a program into distinct, independent modules or components, each responsible for a specific set of functionalities. This principle enhances maintainability, scalability, and reusability by minimizing interdependence between different sections of your code. A well-known example of this principle is the Model-View-Controller(MVC) design pattern. MVC separates your code into 3 parts. The data(Model), logic(Controller), and what the page displays(View). These are all distinct components, allowing developers to work on different parts independently. This concept is widely applied in modern web development, ensuring that code segments are self-sufficient, and contributing to collaborative and effective development practices.

Conclusion

To become a better programmer, it requires time, effort and dedication. The key principles outlined here serve as a roadmap toward professionalism and writing clean code. Adhering to these time-honored rules positions you for success in your future career as a programmer.

Feel free to contact me via social media or leave your comments, questions, or suggestions in the comment box as I'll be happy to receive them and try my best to answer them.

                                 . . .

    contact me at ngiate24@gmail.com for general inquiries, collaborations, etc..

 

                            Thank you for reading!👋🏽