Software development is changing. The image of a developer chained to a desk, hand-coding and struggling, no longer needs to happen. Developers have been brainwashed into being unproductive because someone—not mentioning any names—had them believe craftsmanship is the way to go. But evolution goes on, and developers can now escape from this oppressive reality. The struggle is no longer real.

For the last few years, low-code development platforms have been on the rise. Promising the delivery of applications at amazing new speeds, these platforms are visual in nature and allow developers to work closer to the outcome.

The machine has enslaved them. The machine has come to set them free.

A New Abstraction Layer

Visual programming is a new approach that makes all the difference. At the core of this movement is the abstraction layer that allows developers to seamlessly handle more of the inherent complexity of application development.

As humans, developers have a limited ability to handle complexity. Think about the first application running on a mainframe, which had a very basic user interface. Why? Because the abstractions to manage graphic user interfaces had not yet been created, so developers were still under the tyranny of huge amounts of code. As technology evolved to make GUI libraries available, this task became easier, and consequently, UIs became richer.

The evolution of programming languages, from assembly, to C, to C++, and more recently to C# has provided abstraction over abstraction, hiding complexity and enabling developers to work at a higher level than before. To create a new abstraction layer, you have to study the major development patterns at the previous layer and provide a simple(r) interface so developers can leverage the new functionality more easily.

Low-code development platforms do just that. And they do it with two perspectives:

  • They study how developers create and evolve their apps.
  • They study what they create in their apps again and again.

For both perspectives, the major patterns are identified and provided to developers with simple interfaces to abstract the complexity below.

It probably won’t surprise you to know that it is deeply inspired by the way nature works, as with so many things we invent. In this case, it looks a lot like how our brain works.


As code evolves, developers can work at a higher level.


Our Brain as Inspiration

The greatest machine known to man to manage complexity is the brain. Its subtle mechanism allows us to handle the massive amounts of information thrown at us all day, every day. Taking a page from the insightful book Thinking Fast and Slow by Daniel Kahneman, the brain has two working modes. System 1 processes information fast, intuitively, and subconsciously, whereas system 2’s processing is effortful, conscious, and considerably slower.

System 1 handles most of the load of processing things around us. It works based on concepts, built since birth, that abstract the complexity of a situation and make it easier to handle. Just think about how children evolve from crawling to walking and running. As these new concepts of muscle coordination and balance become more entrenched, the task becomes easier, feeling almost intuitive. This is the task moving from System 2 to System 1. It’s also how neural pathways are formed.

Note that this frees you to do other things while you walk or drive, for instance. This mechanism allows you to handle more!

System 2 kicks in when a new situation arises for which a clear pattern does not already exist. By focusing on this new situation repeatedly, a new pattern begins to form in our brains, and System 1 begins to handle it, at considerable lower effort—the neural pathway is in place, and the strain dissolves.

The analogy is obvious. Traditional, high-code programming is our IT industry laboriously working in System 2 mode, reasoning through situations and handling ever-greater levels of complexity to solve business problems. Low-code is System 1 kicking in as new patterns are identified and solved.

Sounds perfect. An evolution meant to be. Or can it be too good to be true? Well, the book does warn you about the mistakes that can be made by System 1. Let’s see.

A Step Up from RAD Tools

If I ask you: what do cows drink? You should not be ashamed to confess that your first thought was probably “milk.” Most (all?) people would answer that, by instinct. This is a famous limitation test for System 1.

Now, what does this have to do with low-code? Well, let’s go back to when low-code was called RAD.

Back in the 2000s, RAD tools were becoming all the rage, with the promise of making development easier and freeing developers from the heavy weight of code. They either focused on generating commonly needed code to accelerate development or providing a simple interface to create a very specific type of application. Both approaches proved to be seriously flawed.

The generated code approach, which one assumes only carried development a percentage of the way, proved to be a lot more effort than initially anticipated. Learning about the thousands of lines of generated code to insert the custom one, proved not to be worth the hassle. This was not the way to freedom.

Additionally, the idea of a simpler interface for a simpler app, often completely without code, proved to be too limiting for businesses. As soon as the plan had slight changes, it was not possible to accommodate and deliver those changes.

Low-code Is the Brain Operating at System 1 and System 2

Low-code does replace a lot of code for developers. But to work on a new layer completely, developers leverage new abstractions, which hide the complexity beneath so they can handle more.

Low-code also provides a simpler interface for developers, enabling great speed and ease by operating such that developers can leverage higher levels of abstraction. But it is not a walled garden. Developers can extend the code when required to address specific things along clearly defined interfaces.

With these two modes, businesses can enjoy the speed and ease-of-use benefits from having most of the applications at a higher level of abstraction and also the power to answer very specific sporadic needs. Brain power has found its place in technology. Or is it the other way around?

Machine Learning: Automating Our Abstraction Job


Machine learning will identify new patterns.


The game is changing, and a new player is emerging. Machine learning will help us identify new patterns from the large amounts of application development data and provide them to developers.

New Artificial Intelligent Assistants will provide timely recommendations to developers, allowing them to create better apps even faster. They will provide the common direction to take for a specific kind of app, offering the next most likely screen, or warning developers about a specific error pattern in their code.

Does this mean the end of hand-coders out there? Not quite. You see, such complex mechanisms need to be built by someone. The connections are set up by a real human brain so that machines can detect patterns and articulate them. The marriage between low-code and machine learning is not about rendering humans useless, but about maximizing human abilities.

In other words, we’ll continue to follow the lead of our brain inner-workings, automatically deriving new patterns and seamlessly offering them when appropriate, with the obvious benefit of speed, ease, and power!

Low-code is just getting started. The future is right around the corner.

- - -

At OutSystems, we painstakingly continue to research emerging approaches to programming and application patterns to provide them to our developers. This can be seen by the new mobile capabilities provided in OutSystems 10 on top of React, the new Styles Editor panel in our IDE, or by the components we consistently provide—new app templates, app components, and UI patterns.