readable_code

cpp::build_system::modular_project_with_cmake - Create fancy C++ projects without OS/platform dependencies.

Learn about CMake, essential for creating C++ projects!

• Is CMake difficult?

• However, in this lecture, we will learn a CMake template that can be used for any project configuration.

• I'll tell you everything I've learned from struggling with CMake for over 10 years!

Learn about these things

Basic syntax of CMake

• We'll teach you the basic syntax that will help you make better use of CMake.

• Let's use CMake like a programming language by learning basic grammar such as variables, messages, functions, and control statements!

Modern CMake syntax

• Just as the programming paradigm changed from C to C++, modern CMake is now the trend!

• When building libraries and executables with CMake, avoid using the old methods.

Managing External Dependencies with CMake

• Are you still managing external dependencies by installing them on your PC?

• Let's manage CMake projects and external dependencies in an integrated manner.

• Now you can eliminate the need to install separate libraries to build your projects!

Building a reusable C++ project using CMake

• It contains the essence of over 10 years of development experience.

• We provide a CMake structure that allows you to get maximum efficiency with minimal modifications.

• You've never seen a project structure like this before, have you?!

What can you get?

• Ability to use CMake like a programming language

• Best practices for building C++ projects using CMake

  • Managing external dependencies with CMake

  • Automating the development process using CMake

  • Building a reusable, structured C++ project using CMake

Keywords

• Build System

• CMake

• Morden CMake

• Project Architecture

• Modular System

• Third-party library

Things to note before taking the course

readable_code

Why readable_code?

I still remember the feeling of self-doubt I felt when I first entered the graduate school lab and looked at the implemented source code. "Oh... why can't I understand it no matter how much I look at it?" At the time, I thought it was my own shortcomings. More than ten years have passed since then. Now, I realize: the problem wasn't me, it was the code.

Many developers write code, cryptic, and cry out, "I have to get back to it!" But those codes soon come back to haunt them like a shackle. Code written without adherence to conventions for quick implementation and overused comments create confusion when reading, and carelessly created interfaces eventually make it difficult to discern what data is being exchanged. Code written this way, over time, produces incorrect results, becoming unreadable to anyone. Even the author of the code , after a week without looking at it, finds himself having to open the codebook called "debugging" and decipher the code .

We call source code a language . Language exists to communicate with something. Many people mistakenly believe that something is a computer. This misconception is what gives rise to the many cryptographic things we call code. (Isn't it interesting that code actually means encryption?)

But as I mentioned earlier, code isn't something computers read, it's something we read. Therefore, writing source code is akin to writing, and more specifically, to writing technical documentation. You need to write code that's concise and clear enough for people to understand. Code written this way is easy for anyone to read and understand, no matter when they see it. Unfortunately, in the field I've worked in, people often say they don't have time to consider and implement such trivial details. However, what I've learned is that it's not about "not being able to do something because there's no time," but "not being able to do it because there's no way to do it."

Code that's easy for people to read ( readable_code ) is also easy for computers to read, in most cases. This is because it avoids unnecessary variables, functions, transformations, and processes. This also dramatically improves collaboration and code maintenance performance. For example, at my company, I abandoned our existing framework and designed and implemented a new one. This shortened code integration work that would have taken two weeks with the existing framework to just three days . Furthermore , module implementation, which would have taken three months with the existing framework, became possible in less than a month . The problem with human-readable code is that it's not something you can implement; if you can, there's no reason not to. It's an incredible thing that can dramatically improve development efficiency.

A mature development culture, collaboration, and readable code are often considered nice-to-haves, or rather, optional. However, I've witnessed the power of readable code and experienced its practical application. While I might apply this knowledge to my company and team, I don't want to be satisfied with that. I want to increase Korea's software productivity. I want engineers to develop in a better environment. I want a strong development culture to take root within Korean companies.

From now on, I will share with you all the experiences I have had, the successes and failures, and all the know-how I have learned along the way . These are invaluable and will serve as a solid foundation for your path. Would you like to join us? (y/n) … -y