WSO2 sponsored this post.
Coding applications requires a specific skill set, entails a significant learning curve that creates a significant barrier to entry and can be daunting to non-technical users who wish to create simple applications. Low-code tools try to eliminate the need for code with visual drag-and-drop interfaces. Because they come with predefined and pretested templates, creating applications with requirements that fit into the scope of these templates is rather straightforward. You have a working application, or at least a prototype, in a matter of minutes.
The compelling business benefits such as reduced complexity and increased developer productivity have helped low-code tools to rapidly move toward mainstream adoption. However, for more sophisticated enterprise use cases, this can become prohibitively complex. Although they focus on simplicity, do low-code tools fall short in seamlessly building enterprise applications that are complex in nature and are constantly evolving?
The Proven Traditional Approach
Traditionally, programmers code enterprise applications using languages such as Java, Go, Node.js and Python, which come with powerful frameworks to support microservices, reactive programming and cloud native strategies. They also have well-established tools and processes to tackle the complexities that are deep-rooted in enterprise application development and integration. Low-code tools? Not so much.
For instance, your coders have brilliant integrated development environments (IDEs) featuring elegant support for code refactoring, reuse, debugging, error handling and more that boost developer productivity. With a wide spectrum of libraries and frameworks available for programmers in their chosen programming language, the sky’s the limit in terms of what they can implement. What’s more, if they adopt the concept of polyglot programming, which promotes the use of different programming languages that support different ecosystems or language features to solve different problems, developers have even more options to address their problems.
Developers can also get their code reviewed and work on it collaboratively through version control systems. Continuous integration and continuous delivery (CI/CD) pipelines will be triggered from a push to a branch or some other condition around commits, which starts the build phase. In the continuous integration phase, the code gets compiled, reviewed and tested. The unit tests will run and indicate code bugs. If any tests fail here, it will send a notification to the developers who worked on those changes. The bugs and security issues get detected and fixed as early as possible without waiting until the very end to get feedback to the developers. After that, the build artifacts get pushed to QA or staging environments. With continuous deployment, the code changes finally get released to production and get to customers. Even a basic CI/CD pipeline tied with version control saves hours of manual debugging time and makes the deployment process smooth.
Can we really claim that low-code environments are conducive to such processes, given the added value of traditional coding?
Problems with Low-Code Platforms
The premise that low-code means less work and more productivity is not exactly true, especially when it comes to enterprise applications. Most developers have faced at least one or more of the five following problems with existing low-code platforms.
Version Control and Collaboration
With visual-only development, it’s very difficult to have entire teams of software developers work on the same project simultaneously. When it comes to version control, most low-code platforms offer versioning in the form of a simple list of revisions. However, when more than one developer works on the configuration, the control mechanism for collaboration, such as performing a diff for a graphical flow against a version and merging changes, doesn’t kick in. Such features for enabling collaboration are rarely built-in or are inconsistent in behavior.
Testing and Debugging
While there is a plethora of elaborate testing and debugging tools for coding languages, the options to test and debug apps built on low-code platforms are limited. Unit-testing capabilities are scarce and logging is the most common option for debugging. A handful of renowned low-code platforms provide testing and visual debugging capabilities, but they hide the inner workings.
So, a developer has to manually test the app without any automation to streamline the effort. All is well if everything works as expected. However, if something goes slightly awry, even an experienced programmer would be hard-pressed to troubleshoot.
Customizing the Application
Yes, low-code platforms promise customizability. Yet, the reality is that apps created by these platforms can be customized only to a limited extent. When the application was originally scoped, the low-code tool met the project requirements. It was perfect. But needs change, and eventually customers or end users will have reasonable requests that low-code solutions won’t be able to solve. Sometimes, it’s just not possible to integrate with certain systems due to inherent limitations in the low-code platform.
To ensure security of the applications that the low-code platform is building, they must go through the same security checks just as any other application. Even though some level of security, such as input validation, is baked into most low-code development platforms, developers still need to pay a great deal of attention to security issues and test for vulnerabilities.
However, because there is no visibility to what’s going on underneath, scanning the application for security checks becomes tedious. The same features that make low-code development so attractive to some organizations can bring challenges when it comes to security.
Managing Enterprise Application Integration
Creating enterprise applications also entails a large chunk of integration. A low-code solution might be capable of handling things if a developer follows a carefully constructed “happy” path. We are not talking about relying on low-code solutions to simply integrate applications with software-as-a-service (SaaS) applications and simple web APIs, however. Enterprise apps often need to also connect with distributed systems, archaic legacy applications, overly complex third-party APIs, commercial off-the-shelf systems and much more. These integrations were never meant to be simple, and they involve complex data mappings, transformations, filtering, protocol conversions, etc. In such cases, coding is easier than graphical configuration because you can only visually model so much before it’s just more efficient to drop into text.
Vendor Lock-in Due to Black Box or Proprietary Formats
Vendor lock-in is probably still the biggest fear surrounding low-code platforms. Many are proprietary systems that either prohibit the underlying code from being moved out or generate convoluted code that is neither readable nor reusable. This makes it difficult to move the resulting app to a different platform, thereby creating a dangerous risk of vendor lock-in.
Making Low-Code Work
The limitations with low-code platforms could make a strong case for steering clear of low-code platforms and letting software engineers use a trusted programming language to build enterprise applications. To be sure, many existing low-code tools are best suited for individual developers with quick standalone projects, but not for real enterprise applications. There is, though, an approach to low-code that harnesses its potential to streamline enterprise application development.
The key to this low-code approach is straightforward: supply “clean” code. In other words, the low-code platform lets developers switch between options. They can create apps using the visual flow representation, which generates app code, or they can drop down into the code to write the application, which simultaneously creates the visual flow. By providing a simple code representation for each app built via the low-code platform, the users can have the best of both worlds.
This approach is not exactly new, but there are some caveats. To be effective, the code representation should:
- Be based on open standards
- Represent the low-code flow without any gaps
- Be able to run on any hardware/OS platform.
There are six primary benefits of such a code representation:
- There are no limitations to customizing and extending the application to fit the business 100%.
- Developers can harness the power of sophisticated IDEs, libraries, and frameworks if they want to make enhancements that can’t be made via the UI.
- Teams can apply the tried-and-tested software development lifecycle (e.g., use a code repository, apply CI/CD), because one simply can’t or shouldn’t give up the discipline of software engineering for the sake of productivity or speed.
- Teams have the support they need for collaboration (e.g., code reviews via diffs).
- There are no proprietary lock-ins and no black box.
- The textual representation helps developers understand the underlying mapping between UI components and the code, which helps to streamline development for custom needs.
Conclusion: Using Low-Code Correctly
Low code is an attractive and powerful concept that can tremendously improve your organization’s ability for sustainable and disruptive innovation. Today, low-code tools enable citizen developers and trained software engineers to build templated enterprise applications rapidly. But current low-code tools remain inadequate because enhancements to applications are inevitable, and such customizations can get drastically complicated due to limitations in low-code platforms. So, platform vendors must continue to evolve low-code tools if they are to become truly viable for enterprise applications.
One solution is to make a textual representation of the graphical flow available to users as clean, readable code. The long-term benefits of being able to export that code and use it to follow the standard but proven software engineering process far outweigh anything that low-code platforms have to offer. And from there, considering what low-code tools are meant to achieve, they can live up to the promise to make complicated enterprise application development into something truly accessible and powerful.
Featured image via Pixabay.