Does low code make applications overly complex?

Low code continues to receive a lot of press—and debate. Many software developers still wonder whether the use of low code makes the application development process better, or if it interferes with the development process and results in inferior applications. Others worry about the security implications of low code.

Certainly, if the inevitable outcome of using low code is greater application complexity, then low code could lead to increased difficulty with security issues. But does it? I’ve been writing a lot about application complexity recently, and a lot about low code. But the correlation between application complexity with the use of low code is an interesting perspective. Let’s dive in.

Complexity is independent of the approach

To be clear, the inevitable outcome of low code is not necessarily complexity. Just like traditional application development, complexity can and often does make its way into the lifecycle of the product code base. While not inevitable, it is common. There are many steps you can take to reduce complexity in apps regardless of how they are built, which improves performance, scalability, availability, and speed of innovation.

Yes, a low code application, like all applications, can become complex, and requires the use of simplification techniques to reduce complexity. But these issues are not tied to the use of low code. They are just as significant in regular product development processes.

Unknown is not complex

What low code does increase is the amount of code in your application that was not written directly by your development team. There is more code that was auto-generated by the low code platform, or included in libraries required for your application to function, but was not the product of your developers. Thus there is often more “unknown” code in your application when you use low code techniques.

But unknown is not the same thing as complexity. Unknown code—code provided by someone else and added to your application—does not, in and of itself, increase the complexity of the application.

In fact, the opposite can be true.

Low code reduces complexity

Using low code development techniques can reduce the likelihood of excess complexity seeping into your application. By simplifying the cognitive load and timing pressures on the application developers, low code platforms allow developers to focus on the bigger picture, application business logic, and focus less on details.

What happens to the nitty gritty details? They are handled by the low code environment. Further, the low code environment will use standardized, proven techniques to complete these low level tasks. The auto-generated code and library code is developed, tested, and improved long before your application team uses it. The more you use low code to build your application, the greater the amount of this pre-tested, standardized code that is in use within your application. Using a low code tool to build your application results in an overall greater use of standardized coding techniques, industry best practices, and, ultimately, more software reuse.

But what about complexity? Increasing the use of standardized coding and leveraging software reuse are common strategies used to reduce the complexity of an application. Standardized coding reduces the cognitive load involved in understanding how an application works, and code reuse tends to reduce the number of moving parts that can fail in a complex application. As a result, the application created with low code tooling will be less complex than the functionally equivalent application developed using traditional programming techniques.

How do standardization and reuse impact complexity?

When we think about the complexity of an application, we typically think about two different aspects of the application: the size and number of components that make up the application, and the rate of change to the software of the application.

Increasing your use of reusable code decreases the size and number of components in an application, while increasing the use of standardized coding tends to decrease the rate of change—at least for the modules or components where standardized coding techniques were applied.

The reality for any given application will be more complicated (pun intended), but the basic philosophy still applies. Increasing the use of standardized coding techniques and increasing the use of reusable software components tend to decrease the complexity of the resulting application.

This isn’t new

This analysis isn’t new or unique to the low code space. We have used software abstraction to “hide” code complexity from developers for decades. Whenever we use a higher-level language—such as C, Java, Ruby, or Go—we abstract away the actual code that is created and executed to perform the desired actions. We focus our development on “higher-level constructs,” allowing the compiler or interpreter to handle the details of creating and running the machine code.

And it doesn’t stop with compilers. When we engage the use of higher-level software packages, environments, and frameworks, we also abstract away complexity so we can focus on higher-level capabilities. So, using Ruby on Rails, Spring, Hibernate, Gin, jQuery, Bootstrap, or even HTML/CSS, we are abstracting away complexity in order to work at a higher level. The result is more powerful applications, and higher reliability, with less development effort and lower support costs. This is no different than the arguments discussed in the low code community today.

The world of software development is a complex one, with new challenges arising every day. Software developers regularly use tools, resources, environments, and techniques to make the process of software development easier and simpler. Recently, low code techniques have improved and low code platforms have become a useful tool for improving the process of developing software, without adding undue complexity to the application.

Copyright © 2022 IDG Communications, Inc.

Leave a Comment