0. Overview
There are several basic principles that we should follow when writing code.
Of course, it's not mandatory to follow them all the time, but adhering to these principles can bring various benefits when writing code.
These principles make the code easier to read and maintain. Below are some important principles of code writing.
1. Development Principles Remembered by Acronyms
1.1. DRY (Don't Repeat Yourself)
The DRY (Don't Repeat Yourself) principle means avoiding duplication in the code.
Instead of repeating the same functionality or information in multiple places, manage that functionality or information in a single place.
Duplicate code is prone to bugs and can be difficult to maintain. For example, if you have written code for the same functionality in multiple ways, you will need to make the same changes to the code in several places when modifications are needed.
1.2. KISS (Keep It Simple, Stupid)
The KISS (Keep It Simple, Stupid) principle means keeping the code as simple as possible.
Simple and clear code is easier to understand and find bugs in compared to complex code. Complexity can make problem-solving processes difficult.
Code readability and maintainability are closely related. Code with poor length and readability makes it difficult to find areas with errors or areas that need to be modified.
Especially as a common mistake made by junior developers, writing code that is easy for oneself to understand can also lead to overtime work for other team members.
2. Essential Principles for Variables, Functions, and Modules
2.1. Use Meaningful Variable and Function Names
Specify variables and function names clearly and meaningfully. When you or other developers read the code, it becomes easier to understand what the variables or functions do.
For intuitive and concise coding, every variable and function should contain meaning. Meaningless function and variable names are the biggest factor that reduces productivity by making it difficult to understand the functionality.
2.2. Use Small Functions and Modules
Try to keep functions and modules as small as possible. Functions should only do one thing, and modules should group related functionalities.
The problem with large functions and modules is that they tend to have lower reusability. On the other hand, small functions and modules make it easy to reuse code, which greatly helps shorten coding time as the development scale increases.
3. Ending Principles More Important Than Starting
3.1. Unit Testing and Test-Driven Development (TDD)
When writing code, write unit tests and follow the Test-Driven Development (TDD) principle. Tests verify the operation of the code and help discover bugs.
However, when using TDD, the development speed may slow down as you go through the process of creating tests along with development. It is necessary to have a flexible attitude to determine what is more suitable for your project and apply it.
3.2. Exception Handling
Pay attention to writing exception handling. When developing, we should always consider and prepare code to handle exceptional situations.
In robustly functioning programs, there are often well-prepared exception handling to respond to various scenarios. Ultimately, unexpected conditions may occur contrary to our development intentions, so it is very helpful to be able to identify the necessary exception handling comprehensively at the development planning stage.
3.3. Code Review
Code review is an important learning tool. Read other developers' code and give and receive feedback. When looking at code from another person's perspective, you can find bugs or areas for improvement.
If there is no one to do code reviews with, there is also a self-code review using TDD as an alternative, so it is good to refer to it.
4. Principles for Team Development
4.1. Use Appropriate Comments
Use comments that explain the code. Comments that explain what the code does and why it is written that way are very helpful in practical team-based development.
However, frequent use of comments is equivalent to saying that it is difficult to convince with the code itself. It is best to reduce comments as much as possible and strive for the code to explain itself.
4.2. Adhere to Code Style Guides
Follow the code style guide for your project team or language. Maintaining a consistent code style makes collaboration easier and increases code readability.
Aligning the same code style can sometimes feel unnecessary and inefficient. However, when working on a project as a team, it is important for anyone to understand and modify/use the code, so it is important to maintain a consistent code style.
Especially when joining an existing project, it is essential to understand the existing code style and familiarize yourself with the guide before starting development.
5. Principles for Skill Improvement
5.1. Invest in Self-Development
The pace of advancement in programming skills is accelerating. To keep up with this, continuous learning and effort are necessary. No matter how many years of experience you have, investing in learning new technologies and tools to enhance your skills is essential.
5.2. Trend Monitoring and Exchange Among Technologists
Continuous monitoring and interest in trends such as GitHub, Reddit, and tech news are required to stay up to date with trends.
Rather than raising the quality of the work you have created and putting it on the market quickly, receiving feedback from experts in various fields can also greatly help improve your skills.
6. Conclusion
Writing code is a combination of art and science. It may be difficult at first, but by gaining experience and following the principles above, you can grow into a better programmer. Failures and bugs are part of learning, and you will continue to improve and write better code over time.
Also, read this article together:
Automate Data Collection Now
Start crawling 5,000+ websites in 5 minutes without coding experience
