The low code continues to receive a lot of press and debate. Many software developers still wonder if using low code makes the application development process better or hinders the development process and leads to worse applications. Others are worried about the security implications of low code.
Of course, if the inevitable result of using low code is greater application complexity, then low code can lead to increased security issues. But is that so? I’ve been writing a lot lately about the complexity of applications and a lot about low code. But the connection between the complexity of the application and the use of low code is an interesting prospect. Let’s dive.
Complexity does not depend on the approach
To be clear, the inevitable result of low code is not necessarily complexity. Just like traditional application development, complexity can and often does penetrate the product code base lifecycle. Although not inevitable, it is common. There are many steps you can take to reduce the complexity of applications, no matter how they are built, which improves productivity, 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 problems are not related to the use of low code. They are just as important in regular product development processes.
The unknown is not complicated
What low code increases is the amount of code in your application that is not written directly by your development team. There is also code that is automatically generated by the low code platform or is included in libraries necessary for the operation of your application, but is not a product of your developers. This way, there is often more “unknown” code in your application when you use low-code techniques.
But the unknown is not the same thing as complexity. Unknown code – code provided by someone else and added to your application – does not in itself increase the complexity of the application.
In fact, the opposite may be true.
Low code reduces complexity
Using low code development techniques can reduce the likelihood of excessive intrusion into your application. By simplifying cognitive workload and time pressure on application developers, low-code platforms allow developers to focus on the bigger picture, the business logic of applications, and focus less on detail.
What happens to the small details? They are processed from the low code environment. In addition, the low code environment will use standardized, proven techniques to perform these low-level tasks. The automatically 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 more of this pre-tested, standardized code is used in your application. Using a low-code tool to build your application leads to an overall wider use of standardized coding techniques, industry best practices, and ultimately more software reuse.
But what about complexity? Increasing the use of standardized coding and reusing software are common strategies used to reduce application complexity. Standardized coding reduces the cognitive load associated with understanding how an application works, and reusing the code tends to reduce the number of moving parts that can fail in a complex application. As a result, the application created with low code tools will be less complex than the functionally equivalent application developed using traditional programming techniques.
How do standardization and reuse affect complexity?
When we think about the complexity of an application, we usually think of two different aspects of the application: the size and number of components that make up the application, and the rate of change in the application software.
Increasing the use of reusable code reduces the size and number of components in the application, while increasing the use of standardized coding techniques leads to a reduction in the rate of change – at least for modules or components where standardized coding is applied.
The reality for each application will be more complex (play on words), but the basic philosophy is still valid. Increasing the use of standardized coding techniques and increasing the use of reusable software components reduce the complexity of the resulting application.
This is not new
This analysis is not new or unique to low code space. We’ve used software abstraction to “hide” the complexity of code from developers for decades. Every time we use a higher-level language – such as C, Java, Ruby or Go – we abstract the actual code that is created and executed to perform the desired actions. We focus our development on “higher-level constructions”, allowing the compiler or interpreter to handle the details of creating and executing machine code.
And that doesn’t stop with compilers. When we use higher-level software packages, environments, and frameworks, we also abstract the complexity so that we can focus on higher-level capabilities. So, using Ruby on Rails, Spring, Hibernate, Gin, jQuery, Bootstrap or even HTML / CSS, we abstract the complexity to work at a higher level. The result is more powerful applications and higher reliability, with less development effort and lower maintenance costs. This is no different from the arguments discussed in the low code community today.
The world of software development is complex, with new challenges emerging every day. Software developers regularly use tools, resources, environments, and techniques to make the software development process easier and simpler. Recently, low code techniques have improved and low code platforms have become a useful tool to improve the software development process without adding unnecessary complexity to the application.
Copyright © 2022 IDG Communications, Inc.