Low Code for Coders – Part II
In our last post, we talked about the myriad of issues coders have with low-code platforms and what it would take to make these tools useful to developers. Here is a quick recap of the requirements we identified to make a low-code platform useful for coders:
- The generated code is of sufficient quality
- Two-way synchronization is possible between the visual designer and the IDE
- The visual designer is intuitive enough for business users but flexible enough for developers
Now let’s walk through how each of these needs is addressed in VisionX. We are going to use a simple order processing application as an example where we show how (1), a citizen developer can create an initial prototype very quickly and (2), a developer can then step in and add the functionality that is too complex to be built with a visual designer.
Full disclosure: It would be preposterous to claim that we have solved every single problem developers see with low code. But we do believe that VisionX offers a unique solution for businesses looking to realize the benefits of faster application development using visual design while keeping the flexibility of manual coding.
1. Setting Up the Application
As the focus here is on the developer, let us run through this point pretty quickly. We need the user to be able to generate a prototype with as little effort as possible. Let’s assume that the business unit currently uses a spreadsheet to track orders and we want to generate an application from that sheet. We can simply import the Excel file to create the basis for our application:
A. Add a new application screen and select “Take data from a spreadsheet”:
B. Import the spreadsheet:
C. Clicking “Finish” will create the application with the initial workscreen based on the table in the spreadsheet. Then we can add a detail table to show the details of each order:
That only took a few minutes. We can now preview the application in a browser:
A user with a basic understanding of VisionX can now add buttons, reports and a good amount of simple to moderately complex business logic but, of course, there will be a limit to how much can be achieved without creating custom code. At this point, the user would ask a developer to step in to add the missing functionality.
2. Customizing the Application
To add custom code, we first select the element we want to adjust. Clicking on the “Show Source Code” button on the context menu for the element will take us straight to the code in the Eclipse IDE:
When developing VisionX, we took a lot of care in making sure that the generated code is clean and easy to read.
We can now make any changes in Eclipse just like we would if we were manually writing the entire application. After saving, those changes immediately appear in the visual designer in VisionX.
Adding Manual Code to the Application
In our example, we just want to add a simple map integration:
This change shows up in our live preview immediately:
Again, the synchronization goes both ways, meaning that any change in the designer shows up in Eclipse right away and vice-versa. Developers often don’t believe that this two-way sync is possible, so it’s always fun to show them that it actually works.
3. Handing the Application Back to the User
Now that we have manually adjusted the code, we can tell the user to keep working on his or her application. No installation or update is required on their end, they just continue to build using the visual designer.
This seamless back and forth between the user and the software engineer is probably the most important point here. A developer can step in at any time and make a few adjustments without much interruption to the flow of the user’s creative process, but does not have to deal with some of the more mundane tasks, such as setting up and adjusting GUI elements based on the user’s preferences. As business units get more familiar with the development process, the gains from this interaction will continue to increase.
Better Interaction Between Business and IT
As discussed in our last post, we believe that one of the main benefits of software development using a low-code platform is improved communication between developers and users. There will always be some naturally occurring friction between business units, who want their application requirements met yesterday, and IT departments, who have to deal with development capacity constraints. The fact that most users do not exactly speak our language only exacerbates this problem.
Getting users involved in the building their applications not only gives them what they want but also allows them to experience some of the issues developers face. Allowing for live changes in both directions gives both sides the opportunity to work together in ways that were not possible before, which will eventually lead to better applications in less time.
In our next post, we will look at a more specific example for an application that was generated using VisionX.