Before you go, check out these stories!

Hackernoon logoIs Visual Programming The Next Paradigm Shift For Software Development? by@youngkasi

Is Visual Programming The Next Paradigm Shift For Software Development?

Author profile picture

@youngkasiMarko Lehtimaki

Co-founder and CEO of AppGyver

Over the course of history, humans have endeavored to make things faster, easier, and more efficient. Software is no exception to this – it was created to solve real-life problems.

In 1981, Steve Jobs famously compared computers to “bicycles for the mind,” meaning that the computer had the ability to amplify the power of the human brain and manage higher levels of complexity – and nothing is more complex than real-life problems.

When we first worked with computer software, programming was hard. The concepts available were very close to how the underlying hardware functioned – memory pointers, logic gates, and so on. A special kind of thinking was required. We soon moved on from writing the lowest-level machine code by hand to the first programming languages like BASIC and Fortran, and the march has continued on. However, even with decades of advancement, programmers are still working with concepts that are not always the most intuitive for humans to understand, and written code is not often the best way to represent them.

With the advent of true visual programming, there is now the chance to change that and produce an order-of-magnitude leap in productivity while lowering the entry barriers into software development.


The first programs were simple. People were amazed when huge room-sized computers did simple mathematical calculations. But eventually, as we all know, computers became pocket-sized, and programs that ran on them were designed to be increasingly complex with connections to vast databases, increasingly immersive user interfaces, and the ability to compute far beyond the human capacity. 

Abstraction is just another way of saying managing complexity. It’s taking something that is complex and making it simple to use and work with. In programming, we enable abstraction by using tools that help us to utilize our limited time and focus. As time goes on, we have seen the development of software development kits, interfaces, APIs, and code libraries provide us with more capacity and enable us to tackle more complex problems with the massive computer power we now have at our disposal.

No one solving a business problem with an app today would ever consider programming a kernel for the chips we use in a computer or writing code to make their own proprietary database language from scratch. If we look at the evolution of website implementation, many have moved to WordPress instead of programming HTML and JavaScript for much of a website's core functionality. To do these things from scratch would demand a strong and increasingly hard to prove business case with so much prefabricated code, themes, and plugins already in existence for the WordPress platform.

Code-based logic is not intuitive

We like to think of a brain as similar to a computer. After all, we built computers to do things faster and better than we could. In fact, when we were first using computers, we had to initially think and speak like machines to get them to operate. As time moved on, new programming languages came around to make it easier to tell computers what to do and make the complexity easier. This cool video shows the most popular programming languages between 1965 - 2019

Each new language tried to leave behind complexities from its predecessors, and they became more naturally expressive. It can be argued that the huge popularity of “lighter” languages like JavaScript or Python is at least in part because they provide sensible defaults to many things that can be hard – such as memory allocation.

There are numerous different languages and programming paradigms (e.g., functional vs. object-oriented) to choose from when writing the code to describe how a certain piece of logic should be executed, and these can be very different from one another. If you ask five coders to write the code for a simple application using C++, they will nearly always write it differently. However, if you asked them to draw a diagram of the app logic, chances are they’ll each produce something pretty similar. This is because a visual approach is more natural – it feels like the right abstraction level for humans, compared to following arbitrary syntax and thinking like a computer.

A visual approach also enables much more context to be present on the screen at the same time, so inputs for functions can be validated at a higher fidelity level, for example.

Visual programming has come a long way

Most people are familiar with Scratch. It was one of the first, and most commonly referenced visual programming tools. Of course, this tool was not designed to create complex enterprise-level software and interfaces, but it was one of the first ways young people started their journey into software development and which could actually make something happen.

Over the years, the terms “no-code” and “low-code” were introduced to describe the tools using a graphical or augmented visual development interface to replace parts or all of the typed lines of code language. In the past, these tools were relegated to producing a limited set of simple functions for the non-programmer. Professional-level software was not possible with Scratch. Now, visual tools are starting to go far beyond Scratch to a place where professionals can produce software for real business and consumer cases that is equivalent in sophistication to what an experienced programmer could produce with code. In the next few years, it is likely that visual programming will become the new preferred way to program. If you are not convinced, history shows this progression is a familiar technology journey. 

We have to remember the dawn of the computer era, where even written languages themselves are a far step above the previously common ways to program a computer, such as paper tapes and punch cards on VAX systems. The simple keyboard and mouse were also an innovation that we currently take for granted. Many people can’t remember when Steve Jobs popularized the mouse and how skeptical and critical people were of the innovation. So shouldn't history make us ask, why we are resistant to visual programming, even for the expert programmer? It would be short-sighted to think that in the future we still need to know syntax and code in order to provide instructions to a computer, while at the same time artificial intelligence (AI) is quickly learning how to drive cars better than humans do, and most of the complex internet infrastructure has been abstracted to visual user interfaces.

There must be a new programming paradigm

For those that are familiar with Star Trek and particularly the Next Generation, you will remember how the character Geordi, Chief Engineering Officer, does programming. He talks to the computer and tells it what he wants to do. Much like how Tony Stark interacts with Friday in the Avengers. It’s important to note that they still need to know what they want, and need to have a huge amount of understanding of the problems they are facing in order to create the right program. In one Star Trek movie, the crew goes back in time and Scotty tries to talk to a computer and is amused by the fact that he has to use a keyboard to tell it what to do. “How quaint,” he says as he proceeds to show the factory owner the formula for transparent aluminum

The world continues to take leaps in problem-solving and managing the level of complexity that can be handled. Visual programming is the next paradigm that caters to this. It simply moves the focus from the code itself to allow more space for an in-depth focus on business challenges and opportunities.

Developers can’t write the world’s best solution from scratch every time. The issue with a lower abstraction level language is that you end up re-inventing the wheel every time you need to implement a feature. Even if you componentize your code and import it via a managed library, the specific way the functionality is connected to the rest of your app is still not “native” and thus prone to breaking when the components evolve.

Experts still needed

If we think of Photoshop as an example, many people can do minor edits to images, but there are also professionals out there who harness the full capabilities of the tool.

One of the challenges around visual programming is the perception that no-code and low-code tools from the recent past have only been capable of executing simple tasks. The simplest functionality was created to make fast and dirty apps with limited effort. The heavy lifting has still been done by writing lines of code for enterprise-level software development. 

But the world has changed over the last few years as the cloud-based platform model for building and managing all kinds of services has become more sophisticated. This is driven by the evolution of devices and the exponential increase in accessibility. The desire for apps to solve all kinds of problems has increased, which in turn has increased the difficulty for IT departments to manage multiple apps on many platforms for both large and small business and consumer tasks. 

The world of programming is moving more to the hands of experts in the business or service they are directly providing, and the quality demanded is becoming more strict. This requires someone not only with the knowledge and expertise of the business or service but also how to make a well functioning piece of software.

To be a developer who can provide the level of quality required, you need to know how an application works, develop user stories, understand databases, UI and UX, and as before, at least on a high level, how the device is processing information and calculating results. In short, you still need to be a professional to make professional things. The only difference is that as the future progresses, the way you are interfacing with the computer is changing – you will still need to know what to tell the computer to do.

Complexity unleashed

The case for visual programming is one that is not focused on the fact that we might not write lines of code anymore. Visual programming can not be confused with being forced to do simple thinking. The case for visual programming is following the path we have always followed with technology. The first years were full of missteps and unsatisfying results. But these trials and failures lead to the paradigm shift we are seeing now that will upend the way we program. 

We have seen it before. With the right tools, we are able to create more amazing and complex solutions to the problems that will make the things we do today seem like child’s play. In the next few years, more and more talented engineers will work with visual programming tools that are designed for professional needs and make it possible for them to produce enterprise-level software at blinding speeds allowing us to solve more and more complex problems. More business experts will also be able to take their expertise to the next level as they let their ideas take shape in software without having to learn a coding language. And as we will be using less of our brain capacity in trying to translate our human way of thinking into particular syntax and code, we can build and manage an order of magnitude more complex software.

But to be clear, both business experts and professional developers will still need to understand what makes software great to make professional software, as well as deeply understanding the business goals of the project. Craftsmanship requires attention to detail. So although visual programming is an answer to make development faster, easier to manage, and open to people who do not know how to write lines of code in a specific language, it is not a replacement for expertise and understanding needed to design the most innovative ways to solve problems.


Join Hacker Noon

Create your free account to unlock your custom reading experience.