The mission of Develpreneur is to build better developers. This statement begs the question “why do we need them?” When you look at technology, the tools to create applications get more powerful every year. Each step along the way abstracts developers more from bare metal code. All of the details of coding are being swept away by powerful frameworks. In the light of these advances, there should be less need for better developers. In fact, lesser developers should be our focus.
Systems Are Getting More Complex
The first thing we need to accept is that applications are getting geometrically more complicated. There are full-featured frameworks and platforms for building applications, but those hide complexity. They do not eliminate it.
Think of a lego village made out of several buildings. The town can be the focus and structures shifted around to customize it. However, each building is a framework of legos as well. Thus, each building could be re-built to customize the village. In the past, we built one-room buildings. Now we are given multi-room complexes to solve our problems. The solution is larger and more complex, we just forget the scale of it because we are viewing at a building-level instead of block-level.
What We Don’t Know
That great teacher of life skills, “The Horror Movie,” has shown us that the unseen can be even more dangerous than the visible or apparent. The systems we are building today are not an exception to this rule. All those little chunks of code that are under the surface of your framework or platform are still potential points of failure. They are not less of a risk just because you are shielded from what they do.
As an example, we graduate from lego to actual buildings. Those skyscrapers are just a collection of floors, right? Unfortunately, that is not the case. As the building grows out and up, there are new issues to address. A ten-story building is not just a one-story building repeated ten times. Software Applications are like this. We not only have to integrate frameworks and platforms, but we also must be concerned about how the underlying code functions. Ignorance is not bliss.
Solutions Are The Focus
None of these great tools for building applications are useful until they are utilized to solve a problem. The problem may be singular, or it may be one with thousands of “sub-problems.” Nevertheless, developers are only valuable when they are solving problems. The challenge with frameworks and platforms is that they address developer problems. So they are great tools for a developer but provide no value to anyone else.
Think of a mechanic. They have a toolbox to help them do their job. The box is a way to help them carry and organize their tools. It does not help with any repairs. The mechanic needs to understand how the tools can be found and used to repair an item. Sourcecode is similar. The goal is not to have a framework for building better software, is it to make it easier to create software solutions.
Better Developers Have a Strong Foundation
Thus, modern developers need to know more than the ones of the past. They need to, of course, know all the specifics of the frameworks. However, that is just the beginning. All of the foundational knowledge that goes into the framework is important as well.
For example, a library of graphical controls can speed the development of an application. The application is not going to be useful if it is designed with the components placed randomly or if the developer does not understand how GUI events work. That may seem like a simplistic example, but what about a case where the developer only knows a few of the available controls? How about the situation where the developer does not know how a drop-down control typically works?
When one considers advances like mobile apps, micro-services, IOT, and new interfaces (voice, facial recognition, etc.) the complexity becomes apparent. Modern systems have to interact well beyond their boundaries and often do so in environments that are sometimes connected, but other times not. A move to the big building blocks we have available does not remove the complexity they hide. Thus, developers need to know far more than they did in the past. Even worse, this situation will only continue as systems grow in size and complexity.
