Introduction to Simple Design Lecture 3: Less is more

This course is the third in the Simple Design Roadmap and the final course in the Simple Design Introduction series that covers code quality theoretically. After completing this course, you will have built a solid foundation for writing good code. It would be beneficial to watch the first course, which is available for free, and the second course, which covers duplicate code.

Syllabus

The methods to achieve Simple Design can be summarized in the following two ways.

1. Removes duplicate code.

2. While doing so, reduce the number of components.

In the last lecture, we covered removing duplicate code first, and in this lecture, we will focus intensively on reducing components.

The principles for handling code quality aren't something you can simply memorize; you need to understand why these principles are necessary and the process behind them. Therefore, I'll first explain why we need to reduce components. Then, we'll examine one by one which components have higher priority for reduction. We'll also explore what criteria can be used to determine an appropriate function size, which is one of the important factors in code quality, and we'll cover the process of achieving good functions through examples.

Now, I'll briefly introduce the content of the Refactoring book, which is becoming a classic, discuss the concept of necessary waste from an industrial engineering perspective, and finally wrap up by exploring how to evaluate and improve the code quality of myself and our team.

The table of contents is as follows.

1. What are the components that need to be reduced?

2. Why should we reduce it?

3. Which components should you reduce first?

   1. Quarter

   2. State

   3. Exception handling code

   4. Test Cases

4. Call Stack Depth and Appropriate Function Size

5. Reducing Components Through Refactoring Bad Smells

6. Necessary Waste

7. Reflecting on My Code Quality

This course also comes with rich examples. The examples primarily use Python, TypeScript, and Java, and it will be interesting to see how they differ across languages.

The number of components is directly linked to AI utilization efficiency. Since all coding LLMs have pricing policies based on token count, reducing the number of components means fewer tokens need to be used with the LLM, allowing AI to work more efficiently.

What's the best way to easily maintain large-scale projects? The best approach is to keep our project small so it doesn't become a large-scale project in the first place. I've worked at companies of various sizes, from large corporations to startups, and have done many consulting and outsourcing projects. I've frequently seen cases where software providing very similar functionality differs in code size by more than 10 times. This means some companies are spending 10 times the cost to do the same work as others. However, if you try to solve the problem by simply splitting things up without reducing the overall amount of code, you often end up with more inter-team communication and no improvement in productivity. If you become more sensitive to code volume and the number of components and work to reduce them, the day will come when maintaining long-term projects feels easy.

Let's master the introduction to Simple Design and prepare to move up to the next level.