What is Low-Code? All Developers must know it

What is Low code?

 

What is "Low-Code"? If you have heard of it for the first time, chances are it will be the same as my inner story after hearing this word from my boss: what? "Low-Code"? "Code" refers to the code I know, but what does the word "Low" mean? It's not that the boss found that the code I wrote recently was ugly and "Low"... Thinking too much, how could the boss review the code himself? Does that mean "Low" in "Low-level programming"? The boss finally found that it was too wasteful for me to wait for programming wizards to pile up Java business code all day long. He wanted to send me to retreat to write a high-performance C language network library... Obviously not, how can the boss have such technical feelings. What does that mean? As a programmer whose search business is higher than EQ, anyone who can ask Google will never ask his boss. So after a meal, I opened the first search result without thinking about the location. Sure enough, this is a Wikipedia entry full of the fragrance of freedom that can only be smelled over the wall: Low-code development platform.

1. Wikipedia definition:

From this definition of Wiki, we can extract several key information:

The Low Code Development Platform (LCDP) itself is also a kind of software, which provides developers with a development environment for creating application software. Is it kind to see the words "development environment"? For programmers, the nature of low-code development platforms is almost the same as IDEA, VS, and other code IDEs (integrated development environments), and they are both productivity tools for developers. Different from traditional code IDEs, low-code development platforms provide higher-dimensional and easy-to-use visual IDEs. In most cases, developers do not need to use the traditional handwritten code method for programming but can complete the development work in more efficient ways such as graphical drag and drop and parameter configuration.

 

2. Forrester definition:

 

Following the description of the Wiki, it can be found that the original term "Low-Code" was proposed by Forrester as early as 2014. Its ancestor-level definition of low-code development platforms is as follows:

Compared with the Wiki version, this definition is more inclined to clarify the core value brought by low code:

The low-code development platform can achieve rapid delivery of business applications. In other words, not only is it “capable” to develop applications like traditional development platforms, the focus of low-code development platforms is to develop applications faster. More importantly, this degree of fastness is disruptive: According to a survey conducted by Forrester in 2016, most companies reported that low-code platforms helped them increase development efficiency by 5-10 times. And we have reason to believe that with the continuous maturity of low-code technologies, products, and industries, this improvement factor can continue to rise. The low-code development platform can reduce the development cost of business applications. On the one hand, low-code development requires lower investment in the entire software lifecycle process (less code writing, simpler environment setup and deployment costs); on the other hand, low-code development also significantly reduces the use of developers Threshold, non-professional developers can quickly start their jobs after simple IT basic training, which can fully mobilize and utilize the existing human resources of the enterprise and can also greatly reduce the dependence on expensive professional developer resources.

 

3. Low code core capabilities:

 

Based on the above definition and analysis, it is not difficult to summarize the following 3 core capabilities of the code development platform:

Full-stack visual programming: Visualization has two meanings, one is the click, drag, nd configuration operations supported during editing; the other is the preview effect of what you get is what you get (WYSIWYG) after editing. Traditional code IDEs also support some visualization capabilities (such as Visual Studio's MFC/WPF in the early years), but low-code emphasizes full-stack, end-to-end visual programming, covering all technical levels (interface/data) involved in a complete application development /logic). Full life cycle management: As a one-stop application development platform, low code supports the complete life cycle management of applications, that is, from the design stage (some platforms also support the advanced project and demand management), through development, construction, and testing And deployment, all the way to the various operations and maintenance (eg monitoring and alarming, application offline) and operations (eg data reports, user feedback) after going online. Low-code scalability: When using low-code development, most of the cases are still inseparable from the code, so the platform must be able to support flexible extensions at all levels of the application with a small amount of code when necessary, such as adding custom components and modifying the theme CSS Styles, custom logic flow actions, etc. Some possible demand scenarios include UI style customization, legacy code reuse, dedicated encryption algorithms, and non-standard system integration.

4. Not just write less code:

 

Back to the original noob question that hit the mind directly: what does "Low" in Low-Code mean? The answer is obvious: it does not mean that the level of abstraction is very low (on the contrary, the abstraction level of low-code development methods is one level higher than that of traditional programming languages), nor does it mean that the code is very low (and on the contrary, the code generated by low-code generally passes through Careful maintenance and repeated testing, the overall quality is better than most of the handwritten code), but simply "write less code"-write code only in a few cases where it is needed, and most of the time, you can use non-code methods such as visualization solve. Looking deeper, low code is not just writing less code: less code is written, the fewer bugs (as the so-called "do fewer mistakes"), so the two pillars of development work "catch up with demand" And "bug fixes "are less; less code to be tested, then test cases can also be written a lot; in addition to the development phase, the platform also covers the subsequent application construction, deployment and management, so the operation and maintenance operations are also Less (Low-Code → Low-Ops).

However, less is not the ultimate goal: if you simply want to achieve fewer results, cutting demand, reducing manpower, and reducing quality requirements is the same. The philosophy behind low code is Less is More, or more precisely, Do More with Less-more capabilities, faster launches, better quality, and lower cost, Deeply practiced the essence of Ali's values ​​​​of "necessity, need, and need".

5. Responsibilities and challenges of the platform:

 

The above is about the capabilities and attractiveness that low-code provides to developers. As a service provider and application carrier, what responsibilities should the low-code development platform assume, and what challenges will it encounter? Is it necessary to "leave the complexity to yourself and the simplicity to others" as Alibaba Cloud advocates? Although this sentence sounds very clear and righteous, I don't know if you have ever thought about why we must hold on to the complexity and find things for ourselves for no reason. Can't we just get rid of the complexity, and leave something simple for our own employees in Alibaba Cloud? Is it because the work is too easy to reflect the value of KPI, or is the food at home not as good as the company's supper? After contemplating for a long time, I found the answer from the first law of thermodynamics: the total complexity of developing an application is constant, and it can only be transferred and cannot disappear out of thin air. If you want developers to do less and enjoy simple pleasures at ease, then the platform must do more and silently assume as much complexity as possible. Just like an acrobatic male actor covered in tendons, holding a female partner who is spinning and jumping at a high place steadily; the lighter and less effortless the people above, the more stable the people below, the more they have to use their full strength. Of course, it's not that the actresses above are relaxed and stress-free, but their respective divisions of labor are different, and the complexity they bear is also different.

According to the division by Fred Brooks, the author of "The Myth of Man-Moon", the complexity of software development can be divided into Essential complexity and Accidental complexity. The former is the minimum complexity inherent in solving the problem and has nothing to do with what tools you use, whether you have rich experience, whether the architecture is good, etc., and the latter is the complexity introduced in the actual development process. Generally speaking, the essential complexity is strongly related to the specific problem domain to be solved by the business, so here I call it the better understood "business complexity"; this part of the complexity cannot be solved by any development method or tool, including Low code. The accidental complexity is generally strongly related to the technical details of the development stage, so I call it "technical complexity" accordingly, and this part of the complexity happens to be good at low code and suitable for solving. For developers to shield the underlying technical details as much as possible, reduce unnecessary technical complexity, and support them to better deal with business complexity (to meet the needs of flexible and common business scenarios), this is what a low-code development platform should do To the core responsibilities.