Chapter 1 Introduction to Coding Practices

Many individuals inquire about the existence of guidelines or best practices in programming. The answer isn't straightforward. It's important to avoid rigidly adhering to rules without context; we must evaluate the specific project and its unique needs.

Nevertheless, certain best practices are beneficial, as they stem from the experiences of skilled programmers who have tackled similar challenges. By incorporating their insights, we can enhance our own projects.

The main objective of coding standards and principles is to help programmers refine their skills, enabling them to write code that is not only efficient but also easier to manage. This is particularly important during later project phases when adding features should be quick, rather than spending excessive time troubleshooting numerous bugs.

What constitutes good code?

Good code extends beyond mere functionality; it should also be easily comprehensible. The goal isn't to impress with complexity but to achieve clarity and effectiveness while ensuring it works correctly. 😃

Meaningful comments — Simply adding comments for their own sake is futile. It’s crucial to revise and update comments whenever the code changes to prevent outdated notes. Clear comments are invaluable, especially when dealing with complicated logic. Referencing unit tests can also provide clarity. A brief description of the code’s function is beneficial; if you struggle to articulate what it does, you may not fully grasp it.

Effective naming conventions — Naming variables, classes, and methods can be challenging. Sometimes, a longer method name is more appropriate than an overly brief one if the latter fails to convey its purpose. Before submitting a pull request, we should carefully evaluate whether these names are appropriate. With experience, identifying odd or unclear names becomes easier.

Avoiding lengthy methods — Strive to limit methods to a maximum of 10 lines of code when feasible. If a method grows too long, consider breaking it into two or three smaller methods.

Caution with inheritance — While inheritance can be a powerful tool, it can also result in tightly coupled code that becomes hard to modify. Changes in parent classes can have unintended consequences for child classes. It’s advisable to minimize multiple inheritance and to combine inheritance with composition for a more adaptable and maintainable codebase.

General Methodologies

Code functions like a book. Imagine if every page had a different format and chapters were disorganized; reading would be challenging.

Consistency — Consistency in your code is vital. If you choose to leave a space below the class name, ensure this practice is maintained throughout your codebase. This uniformity aids in quickly understanding your code. Just as we recognize familiar faces without a second thought, consistent coding allows for immediate comprehension of methods and their parameters.

Always adhere to your project's coding standards. Rather than opposing them, if you find aspects disagreeable, propose an improved solution to your colleagues, explaining why it might be better. Avoid criticizing existing standards without suggesting constructive alternatives.

Collaboration — If you're uncertain about something, seek assistance. Don’t be the individual who spends hours wrestling with a problem without informing anyone. Transparency is key; discuss features openly and offer support to others. Remember, programming is a team effort, not a solitary task.

SOLID Principles

While many resources explain SOLID principles, one essential guideline stands out — the Single Responsibility Principle.

Avoid overly complex conditional statements, especially when different branches execute varying actions. For example, a method designed to truncate a string should not unexpectedly connect to a database as a side effect. Although side effects can be unavoidable, the method name should clearly indicate any non-obvious functionalities. If a method is named truncateString, it should focus solely on string truncation without unexpected behaviors.

Other Important Practices

Keep It Simple, Stupid (KISS) — Often, simpler solutions outperform overly complicated ones. You can always refine and improve code later, so starting with simplicity is wise.

You Ain't Gonna Need It (YAGNI) — Avoid writing code based on hypothetical future needs. Implement only what is necessary at the moment to prevent writing code that may never serve a purpose.

Numerous best practices exist, and attempting to apply all of them simultaneously can lead to worse code. Instead, selectively choose the guidelines that suit your needs best.

If you found this content helpful and wish to join our growing community, please hit the follow button and embark on this knowledge journey with us.

Your feedback and comments are always appreciated, so feel free to share!

Chapter 2 Recommended Videos

To further enhance your understanding of coding best practices, check out these informative videos.

The first video discusses essential habits of top programmers that can significantly improve your coding journey:

The second video covers coding best practices, providing insights to enhance your software development skills: