Two Research Questions to Revolutionize App Development
By: João Abril De Abreu
Tags: Innovation, Research And Development, Low Code, Research, Software Development

A few years from now, writing code will be considered a primitive and very inefficient method to create software applications. Automation is already more than just a trend, and its influence will continue to grow in every field. Consequently, we can expect that soon, creating an app may look much more like this:

Zoe, the CEO of an interior design startup, realizes that using a board to track vacations doesn’t work anymore since many of her employees are remote. She talks to her digital app creation assistant through a smartphone: “Hey Suri, I need a way to track employee vacations.” Suri is experienced in creating similar apps and asks a few questions to clarify her requirements. Then, it provides a few existing branded apps that may solve the problem.

After Zoe picks the design that suits her best, she makes a quick sketch to explain how she’d like to have the main screen laid out. Suri applauds her work and suggests changing the position of one of the buttons to make it easier to use. Zoe accepts the suggestion, publishes her app, and immediately gets it in the hands of her employees.

I believe that this future looks better than the present. Now, to create an app, you need to know about programming, data modeling, and querying. Even with low-code, people who don’t understand these concepts — which is most of us — are just not able to do it.

But how can we change this?

We need to do a lot of research and address two fundamental questions: what’s the most natural method to create an app, and how can we overcome the technical challenge of turning it into reality?

What Would Natural App Development Look Like?

When building software, usability experts are more focused on finding ways to improve the experience for the end-users than finding better alternatives for developers to create software. Behind this are two wrong assumptions:

The first assumption is that building software is ultimately about programming computers, and therefore it’ll always be a highly technical task no matter what. This is not true, as we’ll see further ahead. The other assumption is that software creators are a special kind of people that can “think like computers” and quickly learn all sorts of complex computer languages. That’s also not right.

Even if some have a natural appetency and willingness to “think like computers,” nowadays, the need to create software applications isn’t exclusive to them. All kinds of companies are rushing to become digital to survive. And since there aren’t enough software developers in the world to help them, professionals from other fields are being pressed to step in and create apps themselves.

If we are to create a development experience for everyone, we need to understand what would be the most natural way for people to develop an application. As you can imagine, writing code is probably not it. We must answer this question at two levels: the interaction and the conceptual levels.

The Interaction Level

What would be the most intuitive way to interact with an app creation system?

Is it by describing an app through speech? Would you instead write it down? Would drawing the interface be easier? Would you want to give examples of the expected behavior?

I expect the ideal experience to be a mix of all these interaction styles, each suitable for particular development tasks. For instance, it’s probably easier to customize an interface layout by manipulating it directly (e.g., dragging a button) than by explaining the concept in any other way. With this in mind, the developer should be able to preview the behavior in real-time during the app creation and be encouraged to refine it based on suggestions.

Defining the ideal interaction is a challenging task that can keep any product design team busy for a long time. Still, to revolutionize app development and enable everyone to do it, we must go deeper than the interaction level. We must first understand and solve the conceptual level.

The Conceptual Level — how do you think?

Let’s get back to Zoe’s story. As the CEO of her own business, the last thing on Zoe’s mind is control flow, client-server architectures, and local storage. She doesn’t understand those concepts, nor does she want to. And she shouldn’t have to either.

Now imagine that Zoe’s digital app creation assistant would ask her how often the vacation data should be cached on the client-side. She would be confused and forcefully exposed to concepts that are not natural to her, even if using a natural style of interaction — the English language.

The assistant should instead be asking if the app needs to work when there’s no internet connection or how fast it should run. Those are the practical benefits that come from caching data on mobile devices. As a regular user, Zoe would understand and relate to these questions, being able to answer them accurately.

If we want to create a development experience fit for most people, we need to understand their background knowledge and way of thinking. In particular, we need to know how they think about software apps instead of forcing them to adapt.

Until we understand how non-technical people think about software applications and are willing to respect that, we’ll keep excluding them from app development. Unfortunately, empathy is not enough — we need to be able to do so from a technical standpoint, which leads us to the second big question we must answer.

How to Create Computer Programs Automatically?

There’s no use in defining a visionary app creation experience if we can’t implement it. So, how do we implement an experience that enables everyone to build and define an app’s behavior? Let’s start by defining the essence of software development.

Computers are nothing more than machines that store data and execute sequences of instructions to transform that data. Defining these sequences of instructions is what we call programming.

Languages such as C#, Java, JavaScript, and most visual programming languages enable developers to program apps without having to worry about deeper technical details. In other words, they allow developers to define sequences of instructions that the computer will run.

It’s the traditional app developer’s challenge to find the right sequence that implements the intended app behavior. But if we want to enable app creation for everyone without forcing them to become programmers, we need to have automation based on how they describe their apps.

For example, when Zoe was describing that she needs to use her app offline, Suri should automatically create a program that regularly copies the necessary data from the server to her phone. There’s no need to make it complicated for anyone.

This kind of automation is no easy task, but a few things allow us to believe it does not have to be that hard either.

Let’s Simplify: Enterprise Applications!

The ambition to build a universal program generator that can create any software system based on our requirements, from a search engine to a self-driving car, allowed us to learn a lot about the theoretical basis of automated programming. However, it also kept us from building practical tools that generate programs.

The truth is that not even the most skilled software engineers can develop all kinds of software. They specialize in a business domain and a specific set of technologies, and so should we if we want to create programs automatically. The good news is that enterprise applications, which represent a market with an estimated value of 180 billion dollars, are a particular kind of software.

In a very simple way, an enterprise app is a web or mobile user interface that allows viewing and editing data that is stored centrally in a database (e.g., banking and shopping apps.) The screens, architecture, and the code that support operations such as logging in or inputting and validating data are similar. Even data has similarities across different businesses. For instance, behind most apps, there’s a database that stores names, emails, and passwords.

All these predictable similarities are an opportunity for automation, and low-code platforms have been seizing this opportunity. They’re enabling developers to create apps by dragging and dropping pieces of user interface, gluing everything together with simple visual programming and data querying languages.

Low-code platforms automatically translate higher-level concepts into languages such as HTML, CSS, C#, JavaScript, and SQL to implement the app. This translation can be based on human-defined rules since all templates and visual languages provided by a low-code platform have a deterministic and predictable implementation.

To get rid of programming altogether, the concepts exposed by low-code platforms must be even simpler than they are today, which means translating them automatically into computer languages becomes harder. But as we focus our efforts on the specific domain of enterprise apps instead of software in general, it’s more reasonable to believe that we’re more prepared to answer the question of how to do that translation.

We Can Learn From Thousands of Real Apps!

The recent surge in AI is based on two conditions: we now have access to petabytes of data, and also the computing power to learn from it automatically. This allows us to find statistically relevant patterns and, based on them, automatically create complex algorithms that a human wouldn’t be able to compute mentally.

Among many other amazing things, this intelligence is used to support autonomous cars, to translate automatically between Portuguese and Mandarin, and, you guessed, to automate app creation.

As enterprise applications are developed to run in the cloud, using Application Platform-as-a-Service (aPaaS), the anonymized data that’s available to learn about app creation is increasing fast. We have the potential to learn from the structure of thousands of apps being created all over the world.

This knowledge can be used, for instance, to help map user requirements expressed in any human language to applications or to generate a user interface from an image (a bunch of pixels). This is something that could never be done through the traditional, rule-based approaches.

Moving forward with all of this in mind, we need to understand how to apply machine learning techniques to software development, and in particular, to app development. Learning from app development data is pretty much an ongoing problem, as we never had the means to try it until now. Hopes are high, as this will undoubtedly be a game-changer to answer the big question of how we’ll automate programming.

Program Synthesis For App Customization

Every business is different and the apps that support them need to be fully customized to their individual challenges. The app development platform of the future can’t rely simply on predefined app templates, which don’t cover the whole range of requirements. Current no-code platforms do that and that is why they are not yet powerful enough. The platform of the future must enable developers to specify complex app behaviour using a non-technical language, and automatically translate those specifications to fully working apps, which cannot be done using simple rule-based translation systems.

Fortunately, the field of program synthesis, which focuses on transforming specifications into programs, has made good progress in recent years. Two of the reasons that support this progress are the facts that researchers in the field are focusing on simpler specification languages, tailor-made for specific domains, instead of multi-purpose languages, and they’re also bringing in the power of machine learning to make the synthesis of programs more efficient.

Project GOLEM

A golem is a mythical creature that’s been brought to life out of inanimate matter, and also the image we’ve used as inspiration to revolutionize app development at OutSystems.

The goal of project GOLEM is to help us take a (giant) step towards making enterprise application development accessible to many more people by automating the actual programming. We are joining forces with Carnegie Mellon University, NOVA-LINCS and INESC-ID to research and seek practical answers to the questions we have asked above.

We are already several steps ahead of traditional programming approaches since the OutSystems low-code platform has a domain-specific model behind it that already abstracts many technical details and we have real-world data about app development in all industries. These ingredients coupled with the expertise of our research partners make OutSystems the right place to start this revolution.