How did we forget about LEGO…

By Vadim Pinskiy, VP of R&D at Nanotronics

The purpose of LEGO is to allow children all over the world to build. This can mean anything from cars to boats to structures from their imagination. Although it is not the first of its kind, a lot of what we first create is systemic through a block system like LEGO.

It is safe to say, however, that no youth starts their creation with the extrusion process. A child milling away at a block of plastic at a machine shop to create their necessary LEGO pieces is unimaginable.

With limited time allocated to “playing”, why would they waste it on non-essential tasks? Not only is it impractical, but it would also be unproductive.

Playing with LEGO means thinking in LEGO. Ask a child to build a large structure, and they will start to strategize using an assembly of individual blocks. It is unlikely that they will stop to consider the remaking of those blocks from other materials or processes.

If this is logical, then why do we forget to apply that same practicality when teaching software engineering?

The first lesson in every software engineering class is “Hello world,” which is often followed by the basics such as learning how to declare libraries, initialize vectors, and set up print commands.

That goes on for ~30 years! Or for some, even longer. Code development is and should no longer be possible or practical from the bottom up.

Though known at the mid-level and senior-levels — young engineers are taught the opposite. They are taught and naively embrace the control — and the illusion of elegance — that comes from bottom-up development. But in 2020, the computation and deployment cycles required are simply too long. It is not practical to consider bottom-up development for most modern developments.

Although one can argue that a “software” library is essentially the building block — while the code is just the implementation — I would argue that it is time to enhance them. It is not enough to simply string discrete libraries together. We must educate young developers on the need to work with already established code stacks and initiate a change, rather than pure redevelopment.

Advanced programming languages are guiding modern development in this direction, but the pragmatic startup of a development task is still a blank screen. The better approach is to enforce teaching software development through modification and evolutionary learning. Incoming students and junior developers alike should be tasked with making “small,” gradual changes to existing code collections.

The first programming task should not be “Hello world” but rather changing an existing print screen to be more dynamic and integrated with another call-back function. Forcing students to read complex code — and preferably in very complex structures — is the best way to introduce real world conditions and situational awareness for active learning. This heightens the baseline that future work will be derivatives of in regards to building blocks development and adding continuous changes to those blocks and their modules.

Looking at one of the classic complaints of junior developers is “spaghetti code” — this complaint implies that if a full refactor was to be done, a “perfect” or elegant solution is possible but was not accomplished due to introduced error. One could argue that the use of static LEGO-like blocks and support of that mechanical development would lead to inefficient structures. However, it must be noted that that statement, in turn, overlooks the deployment advantages of using such blocks.

Shifting developers into the mindset of “building blocks” should be done from the onset of programming education. Such an approach will create more functional teams and minimize the restraints that happen between a junior and a senior programmer.

The main point is that bottom-up development no longer guarantees stability, understanding, or even adaptiveness in advanced modern markets. Performance is also not guaranteed, and in the case of Artificial Intelligence frameworks it is likely to lag.

Keeping with the LEGO analogy, if everyone uses the same blocks throughout their lives, what separates a child from a full-time engineer?

In software development, as in civil engineering, the answer is simple — though the blocks are known, the deployment and usage of them is far from trivial. Developers need to understand the blocks that they are using and how to structure them appropriately. It is no longer safe to include every library and then recursively develop a new one until one sticks. Instead, adaptable solutions need to be available quickly and flexibly to solve ever-changing problems.

In the context of Artificial Intelligence, on the other hand, implementation and assembly details are often more critical than the general framework and model selections. Data flow, algorithms redundancies, data lags and performance loss, is what separates an off-the-shelf solution from one that has been turned towards a specific application and industry.

It would be unfair to label this an easier challenge than bottom-up software development, but it surely is a distinctly different challenge. It is one that educators need to implement and new software developers need to embrace from the start of their education. We should not forget LEGO-like building blocks from our youth, as they will be at the heart of most of our mid-career playing.