Software may be eating the world, but low code could eat software

Marc Andreesen famously claimed in 2011 that “software is eating the world” in an op-ed article in the Wall Street Journal.

His point was that software was the new engine of value creation.

“My own theory is that we are in the middle of a dramatic and broad technological and economic shift, in which software companies are poised to take over large swathes of the economy,” Andreesen wrote.

The article details a variety of examples in which digital companies, such as Netflix, Amazon, Apple and Spotify, have achieved a dominant position powered by software and digital products. The article defines software rather loosely, asserting that companies use software to trade in digital assets and dramatically expand the use of data and automation are the new winners.

Andreesen was right. Software-powered companies have and are eating the world. Though, his analysis focuses on large companies winning considerable victories with industrial-scale software. The software he points to that ate the world was a product of elite engineering teams and layers upon layers of complex platforms.

In my view, we are entering a new era in which software will continue to eat the world, but in a far broader and more distributed way. It won’t just be the most famous or largest companies that achieve digital victories. We will find that in almost every business, the use of software will boom to increase efficiency, bring new awareness and expand automation.

This will never happen if this software can only be created by elite engineering teams.

The way that software will eat the rest of the world will be through low-code and no-code methods, but that’s not all. Much of the software that Andreesen points to as having eaten the world will itself be eaten by low-code methods.

In short, if software is eating the world, then low code is eating software.

Let’s review what exactly I mean and explain why this is happening.

Low-code basics

Low code makes the process of creating applications much easier. It is important to remember that modern low-code systems are just this era’s model for the intelligent application of core concepts of computer science.

If you’ve been around the enterprise software and computer science world for a while, you know that the idea of simplified coding that takes over the world of software development is not new. Domain-specific languages are one form of this idea. SAP created ABAP and Salesforce invented Apex as domain-specific languages to make it easier to code their applications and separate them from underlying implementation details. Going way back, so are fourth generation languages. Going even farther, we can point to IBM’s RPG as a form of low code.

Low code, in simple terms, is the capability to build and automate applications of a certain type rapidly. No code is the ability to customize an application purely through configuration settings.

Low code, in simple terms, is the capability to build and automate applications of a certain type rapidly. No code is the ability to customize an application purely through configuration settings.

The “code” in the term low code is the key to understanding its power. Unlike a traditional high-code language like Java or Python or C, in which you can almost code anything you want, in a low-code world, the code exists to provide just enough ability to adapt an application of a certain type.

The “low” in the term suggests that the amount of coding to adapt an application should be small compared to the amount of code needed to implement the application in a high-code manner. The “low” also means simplicity, it is easier to use low-code methods.

The “of a certain type” part of the definition is also important. Low-code development systems aren’t built to do anything. Low-code development environments focus on particular types of applications and provide building blocks that do much of the work to implement that type of application.

Once low-code applications are created, they can be changed and adapted to ever-evolving requirements faster than high-code methods. Low-code applications also require less maintenance, meaning lower technical debt. Modern low-code applications created using platforms from companies like Appian are proven to be enterprise-grade in terms of scalability, reliability and performance.

There is a tradeoff. Low-code applications are focused on creating specific types of applications. When a low-code platform matches your needs, then a much larger number of people can participate in creating, maintaining, and evolving applications. This is where the big win comes from, a topic I will return to in a minute.

Expansion of services creates leverage

Low-code development platforms are more relevant and powerful than ever because we live in a world that is full of abstractions and services. Low code allows us to access services and create new applications with much less effort.

The most advanced low-code development platforms have a full stack of capabilities required for creating enterprise applications. For example, most low-code development platforms have a simplified way to define a user experience. This abstract definition is then rendered into user interfaces that are delivered on numerous devices.

On a modern low-code platform, a developer can define one user experience (UX) using the abstraction and then find that the application will work on the web, on desktops, on tablets, and on mobile devices without any additional effort. The low-code applications have to live with the power of the abstractions the platforms provide. That’s the cost, but as the platforms have matured, that cost has become lower and lower.

The collection of abstractions for UX, data, and process automation are extended by various types of application components for case management, legacy modernization, collaboration, and so on. Low-code also excels at orchestrating services from many systems to add higher levels of automation and process control.

Ray Kurzweil points out in his explanation of the exponential growth of technology how acceleration takes place at faster and faster rates as more and more powerful services are orchestrated. (See this article on Technology Leverage for more detail.)

Ray Kurzweil points out in his explanation of the exponential growth of technology how acceleration takes place at faster and faster rates as more and more powerful services are orchestrated.

Now that software-as-a-service (SaaS) tools have become widespread and API-enabled, a rich landscape of services exists. Even small or medium-sized companies have lots of SaaS applications that act as systems of record and perform essential transactional functions such as accepting or making payments.

Low code unlocks the power of all of these services with much less effort than high-code approaches.

The expanded services landscape also makes a much wider set of data available. Low-code applications can access and distill this data to create much more detailed models of business activity, which can be the foundation of better analytics and increased automation.

For certain functions, low-code methods are also being used to create services that can be used by the platform or by external consumers. High code methods can always be used to create new services that can be plugged into the low-code environment.

Low-code development platforms are constantly evolving. Process mining, conversational artificial intelligence (AI), AI and machine learning (ML) modeling, and new forms of data storage such as graph and document databases are showing up in low-code platforms.

As time goes on, low-code development platforms will be more and more powerful.

The superpower of low code: Increased productivity

The fact that coding is simpler has several profound effects on productivity. Specifically, low-code development platforms:

•  Expand the number of people who can code. This is a claim that must be made carefully. Low code doesn’t mean that everyone can now create advanced software. However, it does mean that people who could never create high-code apps can create simple low-code apps, and these can be hugely helpful.

•  Improve productivity of advanced developers. Developers using low-code methods can get more done than using high-code methods for numerous types of applications.

•  Reduce maintenance burden. Low-code software generally is easier to maintain over time than high-code methods because much of the complexity is managed by the platform. The simplified applications dramatically reduce technical debt.

•  Improved user experience and satisfaction. Standards and design principles enforced by low-code platforms avoid many errors and provide a pleasing experience as well as make applications automatically work on a phone, a tablet, a laptop, or a desktop without modification.

•  Better TCO and ROI. All of these improvements to productivity lead to better TCO and ROI for low-code applications.

Now that low-code methods have become more powerful, increasingly low-code apps are being managed not like one-off spreadsheets but like the key software assets they are. Like other software assets, they are being created with test suites and source code management techniques, and advanced operational logging and monitoring. In other words, low-code apps have become real-software, not just departmental toys. As this maturity is recognized, more and more developers and enterprises will consider low-code platforms for their applications.
Low code will eat high code

The economics of the low-code development platforms will be one of the main engines driving their adoption. Low-code development will eat software because it will be the cost-effective and efficient way to create the applications the world needs.

People with a need for an application will face the following choices:

•  Build with high code methods

•  Buy a product if one exists

•  Build on a low-code development platform

•  Buy a product built on a low-code development platform

The difficulty of high code and the lack of fit for many products will drive people to low-code methods. Many of the low-code platforms now come with a huge number of components and templates to accelerate development.

As low-code development platforms have matured and the number of services has grown, low code fits many more problems. Low code expands the pool of people that can solve them.

The number of new components and techniques available through low-code development platforms such as process mining, conversational AI, and others mentioned above, continues to grow. Low-code platforms will become a safe and low-cost way to experiment with new technologies.

Using low code is a tradeoff. Developers accept the limits of the environment, hoping that the simplified coding methods still allow them to create the application they require. Low-code systems can do much more than they could in the past. Low code will eat software because the trade-off becomes less and less painful as low-code systems become more and more powerful.

Tarun Khatri is the cofounder, executive director and head of the Appian practice at Xebia.

Source