“Bullshit, what programmer doesn’t use low-code tools these days? Do you really think the concept of low code is new? You know what? Low code has always been a productive tool.”

​

That was my first reaction to the article titled “Industry cancer” low code.

Well, to calm the excitement, for those of you who aren’t familiar with low-code development, let’s explain what the concept of “low-code development” really is.

The concept of low code

Low-code Development (LCD), a concept that was formally introduced in 2011, allows developers to create applications through graphical user interfaces and configurations, rather than relying heavily on handwritten Code as in the traditional model. Correspondingly, software that provides such low-code Development functionality to developers is called low-code Development Platform (LCDP).

Low-code developers often do not need to have very specialized coding skills, or coding skills in a specific area, but can use the platform’s capabilities and constraints to achieve professional code output.

As we can see from the definition, the way low-code development works relies heavily on manipulating the graphical user interface, including dragging and dropping controls, and modifying the configuration of areas within them that can be edited. This visual approach to development goes back even further to the Dreamweaver era. With the increasing complexity of front-end projects, this way can no longer adapt to the needs of modern projects, so it is gradually replaced by more professional engineering development mode.

But the need to generate project code quickly has never gone away. People are slowly finding two ways to do this:

In a highly customized scenario, based on experience, find relatively fixed product forms, such as company profiles, product listings, event pages, etc., and open a small number of editing portals for non-professional developers to use. This is essentially the codeless approach.

The other group, on the contrary, follows the idea of early visual development, and tries to achieve a higher degree of freedom and upper limit of interactive complexity of page building process based on componentization and data binding through abstract syntax or IDE. This kind of project development method usually requires certain development experience and coding ability, but compared with ordinary coding development method, it is more through the operation of visual tools to achieve the overall efficiency improvement, so it is called low-code development.

Real-world scenarios, especially commercial low-code platform products, often offer a combination of these two approaches.

Typical application scenarios for low code development

A typical application scenario of low-code development is in the development process of background systems on the PC side, for the following reasons:

1: Although the specific page layout of the middle and background system is not fixed, the overall UI style is unified, which can be built based on the unified UI component library. Through the component drag-and-drop combination, the page can be flexibly organized into different forms and functions, so it is suitable for the development mode of low code type.

2. The middle and background system involves adding, deleting, modifying and checking data, which requires certain coding and debugging capabilities, and cannot be completed directly through UI interaction, so the code-less development mode is not applicable.

With the development of middle and background systems as the goal, low-code development can also be subdivided into the following two ways: the development method based on writing JSON, and the development method based on visual operation platform.

  • Low-code development based on writing JSON

When we look at the final presentation of the front end of a project, we can see:

1: The front end of a project essentially renders different pages connected by routing. The goal of front-end development is the presentation and interaction of the final output page.

2: If you have learned the basic principles of the browser, you will know: every page content in the browser, ultimately boils down to the DOM Tree + Style + Dynamic Logic.

3: In today’s componentized development, a canonical component contains DOM subtrees and styles for specific functions. Therefore, the content of the page can be defined as: Component Tree + Dynamic Logic.

The logic of low code development based on JSON-Schema is that in certain scenarios, such as adding, deleting, modifying and checking pages in the background of development, most of the front-end manually written code is modeled. The code organization of the page component structure template and corresponding data model can be replaced with a more efficient JSON syntax tree description.

You can improve development efficiency and reduce technical requirements by developing a JSON Schema for writing and encapsulating a set of runtime tools that render the corresponding JSON syntax tree.

The code below is an example of a component syntax tree. We show the low-code development pattern by writing a simple JSON syntax tree and the corresponding compiler.

On the other hand, there are some disadvantages to this approach:

Input efficiency: The amount of code used to describe the component structure alone is more than the JSX syntax for the same structure, which is often not an immediate improvement for an experienced front-end developer.

Learning and memory costs: With the introduction of new JSON syntax schemas, there are inevitable learning costs for front-end developers, back-end developers, and non-professionals alike. In addition, different components have different properties, to be flexible in the actual writing process, the memory is also a test. Reviewing documents over and over again is inefficient (an optimization for this is to use the options feature for IDE Snippets to generate corresponding syntax hints).

Reusability and maintainability: In the case of reusable business components in multiple pages, it is often necessary to manually copy them to the JSON of each page in the JSON writing mode, sacrificing the maintainability of reusable components. Also, for complex pages, the length of the JSON can make the maintenance experience less pleasant.

Difficulty of troubleshooting: This problem involves people, and if non-professionals are working on THE JSON development process, when problems are encountered, there may be obstacles in how to troubleshoot them, so additional professionals are usually required to provide technical support.

A number of low-code tools further provide a visual operating platform to address the issues of input efficiency, memory cost, and maintainability in writing JSON. Let’s see how this approach solves the above problem.

  • Low-code development of visual operating platforms

The visual low-code operating platform turns the process of writing JSON into a drag-and-drop component and debugging property configuration, as shown in the figure below. This interaction is more user-friendly and more efficient for users.

Most visual platforms divide the layout into three areas: a component selection area on the left, a preview interaction area in the middle, and a property editing area on the right. The layout of these three areas corresponds to the operation flow of a user-generated page:

  • First, select the component in the left panel.

  • Then, drag into the middle preview area and place into the appropriate container block.

  • Finally, debug the newly moved component properties in the right panel.

After debugging is complete, the next component is looped until the entire page is set up.

There are many low-code products, including commercial products such as Kony, OutSystems, Mendix, Appian, iVX (domestic), as well as open source products, For example, Ali Feibing, Baidu Amis, Shell River Chart, Vvvebjs, React-Visual-Editor and so on. Here is not an introduction, interested, you can further search to understand.

In the end, low code really isn’t a cancer in the industry and has evolved over the years. A lot of people criticize low code for worrying that it will cost programmers their jobs, and I seriously doubt that such people would be able to outsource it to the company’s website, because low code does make it impossible for you to cheat and lose your job.

Furthermore, there is Serverless back-end operation and maintenance, why can’t there be low code in the front end, not to improve the technical capability, but unfounded nonsense. To put it bluntly, the programmer industry itself is a technical work, like the carpenters and blacksmiths in the early days, will inevitably be replaced by mature industrialization. If the programming industry needs a lot of labor for decades on end, it’s truly stagnating. Just like today, ten years ago you could have written HTML+CSS to get a job as a front-end developer, but now you’d be starving if you could only do that. Aren’t those scaffolding tools and frame code a sign of low code?

For now, embracing change and growth and advancing technological capabilities is the way to go. Be the programmer who kills the programmer, until one day the world has no programmer, is the programmer’s biggest victory.

Good night, 42…