The Most Important Facts About Programming
The facts that you need to realize to become an exceptional developer.
Programming and software are trending words in the world due to the digitization of things. Every field has a set of fundamental facts that helps everyone to understand reality. People find out these facts when they work in a particular field for a long time. For example, in civil engineering, engineers know that a newly built concrete structure will change its size with time. In their field, that’s an important fact, and they may use some techniques to overcome the side-effects of it.
Likewise, programming also has a lot of facts that every developer should understand. I stepped into the programming field about a decade ago. I experienced a lot of facts and myths in programming. I tried to rank the most important facts about programming considering all situations I faced.
The perfect code doesn’t exist.
Nothing is perfect in the world. The same logic applies to your source codes as well. At a code review, someone can say that the code is really good. On the other hand, someone can disagree with that. At the designing phase of a software system, engineers can propose thousands of design patterns. Whereas, we go ahead with the most practical and suitable one. Your current operating system code still can have some bugs, hidden security vulnerabilities, and a bit messed-up codebase.
Google’s code review guidelines once said that,
“A key point here is that there is no such thing as “perfect” code — there is only better code.”
Therefore, the key point is that it is always good to reach milestones with a better code rather than nitpicking for a perfect code.
Design patterns are good and bad.
Design patterns are helpful when we need to decompose a quite larger project into smaller components. The topmost layer is about architectural patterns where the software system gets split into isolated modules. Thereafter, design patterns help in the source code level to split large source files into different sections to reach better maintainability.
The most important fact is that there are two ends of design patterns. If you don’t apply any sorts of design patterns, your code may become a mess that no one likes to look at. On the other hand, if you apply tons of design patterns that are not needed, your code may become a complex piece that everyone afraid to touch.
Therefore, it is so important to maintain the level of complexity when design patterns are being applied. The same thing applies to architecture design too. For example, at this moment, a DevOps engineer at an unknown silicon valley startup maybe deploying hundreds of microservices for a very simple web app.
Popular technologies that you know don’t last forever.
Modern technology is changing frequently. Every day, a new programming library or tool getting released. Modern programming languages and API are adding more features by deprecating existing features. The truth is that your code is getting outdated day by day. What you made in your project yesterday is not modern today. Likewise, your expertise in modern technologies is getting outdated gradually.
For example, if you wrote a lot of code on the Angularjs framework, no one will care nowadays due to trending projects such as React, Vue, and Angular. Further, a source code that is purely written with a programming language without any dependencies also can be outdated because a programming language may deprecate its core methods.
Therefore, the goal should be set to understand the fundamentals and how it works, rather than becoming a die-hard fan of every trending technology. In other words, knowing every latest library or framework doesn’t make an outstanding programmer. But knowing every computer science fundamental does.
Collaboration is the key to success.
Linus Torvalds, the open-source giant once told that,
“In open-source, we feel strongly that to really do something well, you have to get a lot of people involved.”
Building software could be done alone. But it is hard to improve it alone. People have different views and different practices. The working version of every software project just exposes the main idea behind it. Also, the most recent versions of a particular software project have a lot of improvements compared to the earlier versions of the same product.
When there are more people around the project, it becomes more successful and powerful. That’s why the open-source model is very popular nowadays. When there are more views on the project, it’s easy to identify what should be improved, fixed, and delivered.