Source | alibaba cloud native public number

The author | ChuHeng

What is low code? Why do we need low code? Does low code put programmers out of business? This article summarizes the basic concepts, core values and current state of the industry in the field of low code, and gives you a comprehensive understanding of low code.

preface

If you choose a keyword to represent the year 2020, I believe everyone will agree that it is “COVID-19”. It came like a tornado, cutting off physical connections between millions of people around the world in just a few months. But the good news is that we have fully entered the Internet age:

• No matter how thick the N95 mask is, it cannot block the smooth flow of information bit stream (otakus: STATION B still smells sweet).

• No amount of time spent in quarantine at home can prevent the message from arriving on time.

“The new productivity represented by new technologies must be the driving force for us to overcome the epidemic at full speed and create the best future,” Xiao Xiaozi said at the Cloud Computing conference in September. So in The post-pandemic era, what new technologies are needed to truly unleash IT productivity, accelerate The digital transformation of society, and Make The World Great Again? I think it’s low-code.

Based on classic visualization and model-driven concepts, combined with the latest cloud native and multi-side experience technology, low code can achieve significant efficiency and cost reduction in the right business scenario, providing a new high productivity development Paradigm Shift for professional developers. On the other hand, low code also enables business people who do not understand code to become so-called Citizen developers, filling the growing professional talent gap and enabling the ultimate agile form of BizDevOps, a deep collaboration between business and technology. This article will focus on introducing the background knowledge of low code, including the definition and significance of low code, related concepts, industry development, etc., hoping to help you better understand the emerging field of low code.

What is low code?

What is “low-code”? If you’re hearing it for the first time, you probably have the same thought I had when I heard it from my boss: What? “Low – Code”? “Code” means Code I know, but what does the word “Low” mean? Maybe the boss found out that the code I was working on was ugly and “Low”… How can the boss review the code himself? In “low-level programming”, it means “Low”. My boss finally realized that it was too wasteful for me to stack Java business code all day long, so he sent me to write a high-performance C language network library. Apparently not, because the boss is not that tech-savvy. What the hell does that even mean? As a programmer who is more emotionally intelligent than a search engine, anyone who can ask Google would never ask the boss. So AFTER a meal of operation, I opened the first search results without thinking. Sure enough, this is a Wikipedia entry with the scent of freedom you have to climb over the wall to smell: low-code Development Platform.

1. The Wikipedia definition

From this definition of Wiki, we can extract a few key points:

• The Low Code Development Platform (LCDP) is itself a type of software that provides a development environment for developers to create applications. Isn’t it nice to see the words “development environment”? For programmers, low code development platforms are much like integrated development environments (IDES) such as IDEA and VS, which serve as productivity tools for developers.

• Unlike traditional code ides, low-code development platforms provide visual ides that are higher and easier to use. Most of the time, developers don’t need to use traditional hand-written code to program, but can use graphical drag-and-drop, parameter configuration, and more efficient ways to do development.

2. Forrester definition

The term “low-code” was first proposed by Forrester in 2014. The original definition of low-code development platform is as follows:

This definition illustrates the core value of low code more than the Wiki version:

• Low code development platforms enable fast delivery of business applications. In other words, it’s not just about “being able” to build apps like traditional development platforms. The point of low-code development platforms is to build apps “fast.” What’s more, the speed is subversive: according to a 2016 Forrester survey, most companies report that low code platforms have helped them improve development productivity five to 10 times. And there is reason to believe that this multiple will continue to increase as low-code technologies, products, and industries mature.

• A low code development platform can reduce the development cost of business applications. On the one hand, low code development requires less investment in software lifecycle processes (less code to write, simpler environment to set up, and simpler deployment costs); On the other hand, low code development also significantly reduces the threshold of the use of developers. Non-professional developers can be quickly hired after simple IT basic training, which can not only fully mobilize and utilize the existing human resources of the enterprise, but also greatly reduce the dependence on expensive professional developers.

3. Low code core ability

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

• Full-stack visual programming: Visualization has two meanings. One is click, drag and drop and configuration operations supported during editing. The other is a WYSIWYG preview. Traditional coding ides also support some visualization capabilities (such as MFC/WPF in Visual Studio in the early years), but low coding is more about full-stack, end-to-end Visual programming that covers all the technical layers (interface/data/logic) involved in a complete application development.

• Full life Cycle Management: As a one-stop application development platform, low code supports the full life cycle management of applications, that is, from the design stage (some platforms also support more advanced project and requirements management), through development, construction, testing and deployment, through various operations after launch (e.g Monitor alarms, app offline) and operations (e.g., data reports, user feedback).

• Low code extensibility: With low code development, most of the time code is still required, so the platform must be able to flexibly extend the application levels with a small amount of code when necessary, such as adding custom components, modifying theme CSS styles, and customizing logic flow actions. Some possible requirements scenarios include: UI style customization, legacy code reuse, dedicated encryption algorithms, and non-standard system integration.

4. It’s not just writing less code

Back to the original heart-wrenching little white question: What does “Low” in low-code really mean? The answer is obvious: Neither is it low abstraction (conversely, low code development is a level higher abstraction than traditional programming languages), nor is it that the code is low (conversely, the code generated by low code is generally well maintained and repeatedly tested, and the overall quality is better than most written code). Instead, it’s simply “code less” — writing code by hand only when it’s needed, and most of the rest can be done in non-code ways like visualizations.

Further down the line, low code isn’t just about writing less code: You write less code, and you have fewer bugs (” doing fewer things wrong “), so there are fewer “catching up” and “fixing bugs,” two pillars of development. With less code to test, you can write fewer test cases; In addition to the development phase, the platform also covers subsequent application construction, deployment, and management, so there is less o&M (low-code → low-OPS).

However, less is not the end in itself: if you simply want to achieve less, so is reducing the need for manpower and quality. The philosophy behind low code is Less is More, or More accurately, Do More with Less — More capability, faster launch, better quality, cheaper — in the spirit of Alibaba’s “want something, want something, want something” philosophy.

5. Platform responsibilities and challenges

The above mentioned is the ability and attractiveness of low code for developers. Then, as service providers and application carriers, what responsibilities should low code development platforms themselves undertake, and what challenges will they encounter? Is it necessary to “leave the complexity to yourself and the simplicity to others” as Ali Cloud advocates? Although this sentence sounds very profound, but I do not know if you have thought about it, why we must hold on to complexity, just for no reason to find trouble for themselves? Can’t we just cut out the complexity and leave some simplicity for aliyun’s own employees? Is it that the work is too easy to reflect the KPI value, or the food at home is not as good as the company’s midnight snack?

After thinking long and hard about it, I found the answer in the first law of thermodynamics: the total complexity of developing an application is constant and can only be transferred, not disappeared. For developers to do less and enjoy the joy of simplicity, the platform side has to do more, quietly shouldering as much complexity as possible. Like a male acrobat covered in tendons, poised to lift a female partner spinning and leaping high; The more light and effortless the man above appears, the more steady and strenuous the man below. Of course, this is not to say that the actresses above are free of pressure, but they have different responsibilities and different levels of complexity.

According to Fred Brooks, author of The Myth of the Man-Month, software development complexity can be divided into Essential complexity and Accidental complexity. The former is the minimum complexity inherent in problem solving, regardless of what tools you use, experience, architecture, etc., while the latter is the complexity that is introduced in the actual development process beyond that. In general, intrinsic complexity is strongly related to the specific problem domain that the business is trying to solve, so I refer to it here as better understood “business complexity”; This part of complexity is beyond any development method or tool, including low code. Accidental complexity is so closely related to the technical details of development that I refer to it as “technical complexity”; This is the part of complexity that low code is good at and is good at.

Shielding developers from low-level technical details, reducing unnecessary technical complexity, and enabling them to better cope with business complexity (meeting the needs of flexible and common business scenarios) is a core responsibility of a low-code development platform.

While fulfilling the above responsibilities, the low code development platform, as a developer-oriented product, should also strive to provide developers with a simple and intuitive ultimate development experience. In addition to the enormous amount of work behind it, it is also necessary to find the right balance between “power” and “ease of use”, which are difficult to achieve in both ways. This is probably the biggest challenge in designing a general-purpose low-code development platform.

Low code related concepts comparison

1. Pure Code (pro-code/custom-code)

“Pure Code” is probably a term I’m making up. It’s more commonly referred to as pro-code or custom-code; But it all means the same, and it means traditional code-centric development. I chose “pure code” because “professional code” makes low code seem unprofessional, and “custom code” makes it look like low code doesn’t support custom custom code.

Of course, I think a more accurate term would be “high code” (which is exactly the same as low code, but I hate the name…). For example, SwiftUI interface designer for iOS development and PowerDesigner modeling tool for server database application development can be done in a non-code way, even with traditional code ides. However, this part of the visualization is only ancillary in traditional development mode, and usually results in code that the developer can modify directly; Developers still do most of their work around code.

The relationship between low code and pure code is similar to that between videos and articles:

• Low code is like a modern “video”, with most content made up of visuals that are easy to understand and expressive, and therefore more accessible to the masses. But at the same time, the video is not so rigid as to only have pictures. It is perfectly possible to add a small amount of text (such as subtitles and annotations) to make up for the lack of accurate picture expression. BTW, a further description of the dialectical relationship between “graphics” and “text” can be found in the article “Architectural Mapping: Tools and Methodologies.”

• Pure code is more like traditional “articles,” which have long been the only medium for information, but have been eclipsed by the advent of video technology and the proliferation of hardware and software infrastructure. Nowadays, video has become the main channel for most people to obtain information (from TV and movies to Douyin), while fewer and fewer people regularly read books and articles. But there is no denying that articles still have a purpose and an audience (otherwise I wouldn’t bother typing so many words), and even if “market share” has been squeezed, there will always be room for it.

If we follow the analogy above, low code will follow a similar trajectory to video in the future, moving beyond pure code into the mainstream. Gartner’s prediction is similar: by 2024, 65% of all application development activities will be low-code, and 75% of large enterprises will use at least four low-code development tools for application development.

But again, just as video will never replace articles, low code will never completely replace pure code development. In the future, the low code and pure code approaches will coexist in complementary forms for a long time, each shining in its appropriate business scenario. The “Low-code Business Scenarios” section will detail which scenarios are more suitable for low-code mode development at this stage.

2. Zero-code/no-code

From the point of view of classification completeness, if there is “pure code”, there should naturally be the opposite “zero code” (also known as “no code”). Zero code is an application development platform that doesn’t need to write any code at all, but that doesn’t mean zero code is more advanced than low code, it just makes a more extreme choice: embracing simple graphical visualizations completely and eliminating complex text code entirely. The reason behind the choice is that zero-code development platforms are expected to lower the barriers to application development as much as possible, allowing everyone to be a developer (note: development ≠ writing code), including business analysts, user operations, and even product managers who don’t know anything about code.

Even for professional developers, under the trend of increasingly detailed division of technology (front-end/back-end/algorithm /SRE/ data analytics..) It is also difficult to recruit a full-stack engineer who can independently develop and maintain a complete set of complex applications. But zero code can change all that: whether you’re a tech geek with Java and JavaScript, or an algorithm with deep learning expertise but no time to learn about Web development, you can achieve your technical or full-stack dreams with zero code. The joke that “the idea to change the world already exists, but only one programmer is needed” may come true. Oh no, you don’t even need a programmer, people with ideas can do it themselves.

Of course, all choices have a cost, and zero code is no exception. The price of abandoning code entirely is limited platform capabilities and flexibility:

• On the one hand, visual editors are nowhere near as expressive as turing-complete general-purpose programming languages, and can’t be easily customized and extended without introducing code (of course, it could theoretically be a graphical programming language like Scrach/Blockly, but that would just be writing code by hand in a different form).

• On the other hand, because the target audience is non-professional developers, the operations that the platform can support tend to be more “dumb” (e.g Pages only support simple stacks of large business components, not fine-grained atomic components and flexible CSS layout definitions, and only reveal relatively “user-friendly” models and concepts (e.g Using “tables” to represent data instead of “databases”) does not support strong professional underlying development primitives and programming concepts.

Although zero code has the above obvious differences from low code in a narrow sense, in a broad sense, zero code can be considered a subset of low code. In its relevant research report, Gartner defines “No Code” in a broader scope of “Low-code Application Platform” (LCAP). At present, many common low code development platforms in the market also have a certain degree of zero code capability; For example, Mendix, a leader in the low-code space, offers both an easy-to-use zero-code Web IDE, Mendix Studio, and a more powerful low-code desktop IDE, Mendix Studio Pro.

3. HpaPaaS (High Productivity Application PaaS)

As mentioned above, the term “low-code” is a credit to Forrester. Gartner, also an internationally renowned research firm (A.K.A. ‘s word maker), is clearly not going to give up easily in this new concept writing contest that could determine the status of the low-code world. That’s why, in 2017, he invented the higher-sounding acronym “HpaPaaS” (High-Productivity Application Platform as a Service).

As defined by Gartner, HpaPaaS is a platform that supports declarative, model-driven design and one-click deployment, providing rapid application development (RAD), deployment and run features on the cloud; This is clearly the same definition as low code. But as it turns out, being too technical is not always a good thing, as HpaPaas eventually lost out to an earlier, more down-to-earth, and more convenient “low-code” : Since 2019, Gartner has adopted the term “low-code” (such as LCAP) in its relevant research reports, personally marking “HpaPaaS” with @deprecated mark.

Photo source: blog.kintone.com/business-wi…

It should be added that the term “HpaPaaS” did not come out of the woodwork. Rather, it is derived from the earlier term “aPaaS” proposed by Gartner. The relationship between the two is that HpaPaaS is a subclass of aPaaS; In addition to HpaPaaS, which is a highly productive application development platform implemented through low code, aPaaS also includes traditional high-control aPaaS, or pure code development with greater control.

APaaS is not a word that has been invented, but rather has roots in the rise of cloud computing. As you may have guessed, aPaaS and IaaS/PaaS/SaaS are ancient concepts of cloud computing: APaaS is between PaaS and SaaS and is more application-oriented than PaaS but does not provide off-the-shelf software services as SaaS does (see the illustrated source article for more details).

Why low code?

It probably doesn’t matter what the low code is, after all, in this information-exploding world, there is no shortage of novelty and ephemeral things. Most so-called new technologies are flash in the pan: they appear, they are seen; Most people said “oh”, read it but showed no interest; A few people marveled at its ingenuity, gave an emotional “like” and looked back over what to use. What really determines whether a new technology can translate into new productivity is never how good or gorgeous the technology itself is, but whether it is needed at all: why low code? If you fill in the question above with different subjects (cool fact: this is called “delayed subject initialization”), you can put the problem into perspective:

1. Why does the “marketplace” need low code?

In this era of “Internet plus” and “digital transformation”, enterprises are increasingly in need of apps to improve internal information flow and strengthen the contact between customers. However, the IT information age, which has not been born for a long time, is also facing a similar contradiction between supply and demand with the primary stage of socialism in China: backward software development productivity can not keep up with the growing business needs of the people.

Gartner predicts that market growth in application development demand will exceed enterprise IT delivery capacity by at least five times by 2021. Faced with such a huge IT gap, without a revolutionary “new productivity” system, IT is hard to imagine that the development and continuation of the existing traditional technology system can completely solve the problem. Low code technology comes with this mission, hoping to revolutionize application development productivity and save the IT world from the brink of disaster by:

1) Efficiency improvement and cost reduction & quality assurance

Although the software industry has been developing rapidly with new languages, frameworks and tools, we practitioners have to admit that software development is still in the artisan workshop stage, with low efficiency, high labor costs and uncontrollable quality. Late project delivery has become the industry norm, and bottlenecks are almost always developers (problems that machines can solve are not problems); Excellent developers are always scarce resources, but also expensive thief; The software quality defect cannot converge all the time, and the on-line failure is frequent.

In contrast, after hundreds of years of industrial revolution, most of the traditional manufacturing industry has already got rid of the strong dependence on “people” : from raw material input to product output, the stable support of various precision instruments and automatic assembly lines in the middle has truly realized the standardization and scale of production. Although informatization is known as the third industrial revolution of mankind, the software industry is far from reaching the mature “industrialization” stage.

So, dear programmer friends, when you have been tuning the interface with the front-end network all morning, quarreling with the demand of the product all afternoon, fighting with your own bug all night, finally falling asleep and being woken up by a series of alarm messages, have you ever looked up at the stars and dreamed: “I have a dream… That one day, software development can also be like industrial products, batch production, stable and efficient without trouble.” By now, whether you realize it or not, that vision is slowly becoming a reality.

Yes, low code is industrializing the application development process: every low code development platform is a technology-intensive application factory, with all project stakeholders working closely together in the same production line. Instead of tech geeks who knew a hundred ways to write for loops, it was a group of app makers with ideas and business sense. With mature infrastructure, off-the-shelf standard parts, and automated assembly lines in application factories, developers need to focus only on the core business value. Even if you encounter non-standard requirements, you can always do it yourself, with the most flexible manual customization (code) way to solve various corners of the problem.

2) Expand the application development workforce

By allowing most of the development work to be done with simple drag-and-drop and configuration, low code (including zero code) significantly lowers the barriers to adoption, allowing organizations to take advantage of the aforementioned civilian developer resources. In some scenarios of pure zero code requirements, low code also enables business personnel to realize self-service application delivery, which not only solves the backlog problem under traditional IT delivery mode, but also avoids the scarce professional development resources being occupied by a large number of simple and repetitive application development requirements. It also allows business people to truly implement applications on their own terms, freeing them from the constraints that are inevitable when someone else develops them.

At this point, application development capability will no longer be the prerogative of a small group of professional developers, and the threshold for skill and cost of ownership required will continue to fall, achieving a true “authoritarianism of technology.”

3) Strengthen communication and cooperation in the development process

According to multiple surveys, one of the biggest causes of software project failure is poor communication. In the traditional development model, business, product, design, development, test and operation personnel have different roles, and each has its own set of tools and languages. For a long time, it is easy to form a silos, which makes cross-functional communication difficult and inefficient. This is why the current hot trends in Agile development and DevOps both emphasize communication (Biz and Dev in the former, Dev and Ops in the latter), while classic DDD domain-driven design advocates a “unified language” to reduce communication incompatibility between business and technical people.

With low code, this situation is radically improved: The above roles can be in the same low code development platform (can even be the same person) closely, this new collaboration model not only broke the functional silos, also can through the unified visual language and the application of single said (page/data/logic), easy alignment project parties understanding of the application form and the project schedule, To achieve the ultimate agile development model, and BizDevOps to go one step further than traditional DevOps.

4) Aggregation effect under unified development platform

Low code attempts to converge all application development-related activities on one platform, resulting in more convergent effects and scale gains:

• Convergence of people: In addition to the close collaboration of functions mentioned in the previous point, convergence of people working on a unified low-code development platform also promotes standardization, standardization, and unification of the entire project process.

• Application aggregation: On the one hand, it is easier for new applications to design architecture, reuse assets, and call each other; On the other hand, the data of various applications can communicate with each other naturally, and the data outside the platform can also be connected through integration capability, completely eliminating the problem of data island of the enterprise.

• Ecological convergence: When a low-code development platform brings together enough developers and apps, it creates a vast, interconnected, and imaginative ecosystem that fully leverages the value of low-code.

2. Why is low code needed “in this era”?

If you look at the various low-code products on the market, it’s not hard to see that many players in the low-code space existed before the concept of low-code was born. For example, OutSystems, another giant in the low-code space, started in 2001. FileMaker, also named one of the leaders in the low code industry by Forrester last year, was born way back in 1985 (at the age of 35, as if implying something crazy). So, if low code is as good as it sounds, why hasn’t it caught on before? From the perspective of technology and business, the reasons can be summarized as follows:

1) Insufficient technology maturity

Core technologies of low code (visualization, model-driven, RAD, BPMS…) Both have a long history of development and seem to be old wine in new bottles. Yet rational people know that any technology follows what is known as The Hype Cycle and cannot be born and then leapfrog to mass adoption and production. Taking model-driven technology as an example, although more than a decade ago, there had been systematic theoretical research (e.g. MDA) and supporting tools (e.g. EMF), but under the technical background at that time, due to incomplete capabilities, excessive idealization and high technical threshold, it had not been able to go mainstream in the industry.

In this era, the “old” technologies that support low code have been developed and tested for a long time, while other “new” technologies that complement each other perfectly (e.g Cloud-native, responsive Web) is also growing rapidly and maturing, and IT’s time to repackage the new bottle of “low code” and bring a sweet ride to the traditional IT market that is in need of new productivity.

2) Business income is not obvious

Even if the low-code technology of a decade ago had been mature enough, it certainly would not have had the same impact on the application development market as it does now. Why is that? Because technology was all about business, and the business requirements for application development were much simpler: Without today’s multi-channel, multi-experience, integration and customization requirements, nor the flexibility, distribution, and high availability that have become standard for enterprise applications, nor the rapidly changing IT business scenarios to drive continuous integration and fast delivery.

Although low code can perfectly solve all the above problems (such as multi-application generation, cloud native architecture and API integration capabilities), given the current market and business background and the immaturity of technologies mentioned above, the overall input-output ratio will be very low, which is not enough for enterprises to adopt low-code solutions on a large scale.

In an era when companies are so spoiled by the power and benefits of new technology that it’s easy to say: I want to make a food delivery app. Client? Android, iOS, H5, small procedures to a set. Operating side? It’s usually on the computer, but remember to fit it on your phone. The service side? Go to the clouds, of course. Oh, I heard from my tech partner that it’s fashionable to have a multi-cloud architecture. More money for operations? What is operations? Why don’t we have an app that works, and it costs me money to operate? The money you gave me as an investor came from the wind!

If the traditional development model, such a full set of hours and quotations down, may have scared away this group of naive and lovely people like product managers; But the modern low code technology can realize the dream of selling vegetables for the entrepreneur above, and realize the value of white powder with the price of cabbage. If Cheng Wei had been able to use the current low code, the first version of Didi App would not have been outsourced and directly scrapped (at least for a while longer…). .

3. Why do “professional developers” need low code?

While it is true that zero code is designed for non-professional developers, the business scenarios it can support are too limited to truly revolutionize traditional development models and replace complex business scenarios that still require professional developers. Low code in a narrow sense has the potential to do this because it is inherently tailored for professional developers. According to a recent Gartner research report, “66% of users of low-code development platforms are professional developers in enterprise IT departments.” This illustrates that professional developers need low code more than civilian developers.

A group of plaid shirt students in front of the screen will ask: “Low code is not how to write code, how can we serve programmers?” . While programmers hate to repeat themselves, it’s important to say it again: Development ≠ writing code. The primitive man squatting in the cave ten thousand years ago, painting the ancient totem with small stones; Xu Zhimo, sitting at his desk 100 years ago, was writing love letters to Lin Huiyin with a pen. Many of us who are hunched over screens today have already started scribbling on a tablet or iPad. The tools we use have evolved over thousands of years, but the nature of what we do hasn’t changed much. Whether it’s using a small stone or a small mouse, the essence of writing and painting is creation and expression. The final product is not good or bad depending on what you have in your hand at the time; Likewise, application development is all about ideas and logic, and the ultimate value doesn’t depend on whether you implement it in plain code or low code.

And low code is likely to be a better next generation productivity tool than pure code:

1) Reduce unnecessary workload

The minimalist development mode of visual drag and drop and parameter configuration combined with the model-driven automatic code generation mechanism can eliminate most of the tedious and repetitive Boilerplate code. One-stop deployment and operation and maintenance management platform, no need to build CI/CD pipeline, apply for environmental resources, configure monitoring alarm; Simultaneous generation, construction and release of multi-terminal applications at one time, so as to avoid manual synchronous maintenance of multiple repetitive terminal applications; Out of the box component libraries, template libraries, theme libraries, connectors, and more make it possible to maximize software reuse. In short, low code allows professional developers to focus on creative, valuable, and differentiated work, rather than wasting valuable development time on unnecessary, non-business core work.

2) Strong platform capability support

Although the technical support work listed above does not directly generate business value, it will directly affect business performance, cost, stability, security, sustainable development ability, etc. Forward-looking companies will not allow these vital metrics to be sacrificed in exchange for temporary business acceleration. Low code development platforms understand this, so while simplifying and masking the underlying technical details, they also try to do the best they can (at least as well as pure code development) on what they cover, including but not limited to:

• Modern technical architecture and implementation: A modern low-code development platform will support user applications with a technical architecture and implementation solution that is modern and in line with industry best practices. For example, the front-end is based on the mainstream HTML5/CSS3 standard and React framework. The backend is based on the mature Java language, SpringBoot framework and MySQL database, The deployment environment is based on the cloud native Docker image, CI/CD pipeline, K8s cluster and Service Mesh technology (see “Getting Started with Service Mesh: Origins, Development and Current Status” for more information).

• Zero-cost technology upgrade and maintenance: the low-code high-dimensional abstract development approach completely decouples the core business logic of the application from the underlying technical details. In most cases, developers do not need to care about the underlying technology selection, nor do they need to personally follow up on the version upgrades and bug fixes of these technologies, and enjoy the technology bonus and application security improvement for free. Even if some underlying technology or tool needs to be completely replaced (such as an open source project that is no longer maintained), the developer is not aware of it at all; Technology migration can be hard and difficult, but the platform can work on its own. As long as the service stays online, time is still good for developers. You may also be pleasantly surprised to find that app access is suddenly faster, as if there were some kind of divine intervention, gratitude, and low code.

3) Reuse of integrated ecological capabilities

Reuse is the most effective way to improve software development efficiency and engineering quality. In the traditional code development mode, developers can achieve reuse by extracting common classes/functions, referencing shared libraries, calling external API services, and precipitating code fragments and templates. In a low-code world, platforms can also provide corresponding multi-level and multi-granularity reuse methods, such as page component libraries, logical function libraries, application template libraries, and so on.

But more importantly, low-code platforms can also take full advantage of their integrated ecosystem and provide powerful and easy-to-use reusable capabilities (assets) discovery, integration and sharing systems: In the case of page components, you can either use system components directly, search for and reference more appropriate components in the platform’s own component marketplace, or develop a custom component yourself in code and publish it to the marketplace. The larger the platform ecosystem, the more reusable capabilities accumulated and the lower the cost of application development.

The world as a whole, by contrast, although the traditional code ecological more vast and profound, but because of lack of unified platform and technical exchange, market, code integration costs higher, has long been no form ecological capacity with similar scale potential reuse system, lead to repeated rolling and the phenomenon of low level repeated construction norm, reputation as the “new construction”.

At this point, another batch of students wrapped in emergency clothes shiny head also could not help: “ten thousand low code really developed, is not the need for so many programmers ah? There are both the old and the young, and we are both in a yard, so why should we be in such a hurry?” . Low code is a productivity revolution in application development, but it won’t put programmers out of business. It removes difficult programming syntax, tedious technical details, and all the repetitive tasks that can be automated. It does not and cannot remove the core things of application development: rigorous business logic, clever algorithm design, good engineering style, etc. For the real programmer, even if you strip away layer upon layer of programming language and tool proficiency skills, you’re still left with a valuable core developer.

Of course, if you insist on changing the world purely by writing code, you won’t lose your job. Or you can choose areas where low code is not suitable for the time being, such as low-level system drivers, 3D game engines, rocket launch programs; Alternatively, you can choose to write custom code extensions that are essential to the low code, providing quality building blocks for civilian developers. Finally, you can also choose to contribute to the underlying code of the low code platform itself. For example, join the EMAS team of Aliyun cloud native application R&D platform (” ▽ “) and build the next generation cloud native low code development platform “Mobi” with the author. Pengqun. Pq # alibaba-inc.com.

4. Why does “I don’t” need low code

Even though everyone agrees on the “why low code” argument above, every now and then someone will jump in and tell everyone why I don’t need low code. It is true that practice is the source of knowledge, and there is some truth behind most doubts; But in my opinion, it’s more likely subjective or unconscious bias. Here I’ve listed some of the common concerns about low code and my own thoughts, hoping to help you see a more comprehensive and objective view of low code.

Challenge 1: Low code platforms don’t work well

“I’ve tried some of the so-called low-code development platforms, and they’re either very weak, or the experience is so bad that I can only make toy apps.”

As an experienced user who has investigated many low-code products at home and abroad, my opinion is that one should not generalize. Low code market is in the early stage of the outbreak in China, so many products with low code only touch a little edge are also rubbing hot spots; But they are not representative of the current state of the industry and the direction of low code. Real mature enterprise low code development platform on the market, is fully capable of in an efficient way of development meet the demand of the function of the most complex scenarios, as well as security, performance, enterprise applications need scalable nonfunctional requirements, such as that in foreign markets has been fully validated (otherwise wouldn’t be hope so).

Of course, the domestic market is still in the chaotic stage of mixed fish and dragons, the probability of encountering real dragons is very low, but hit goldfish carp and even wood fake fish are unavoidable. I believe that with the passage of time, the real strength and reputation of the product can stand out, for everyone to show the low code should be like.

Doubt 2: low generation low development is uncontrollable

“The various visual components, logical actions and deployment environments on the platform are all black boxes. If there is an internal problem, it cannot be checked and resolved.”

As an equally uncomfortable programmer who doesn’t understand the underlying principles, I prefer to believe that the problem is temporary. While this is certainly a pain point in today’s use of low-code platforms, it is not an inherent flaw in low-code technology itself. There is an adage in computing that any problem can be solved by adding an indirect middle layer. The same is true of low-code thinking: the same is true of operating systems back then and cloud platforms today, the idea is to reduce developer workload and mental burden by creating a black-box middle-tier abstraction.

Of course, all the additional middle layers are not completely free, and low code is no exception. As a new middle tier that is not yet mature and stable, low code is bound to have all kinds of problems that can put users in a bind, just like operating system kernel bugs and cloud HOST I/O hang. But history also tells us that all great technologies eventually mature; As long as the low-code space continues to grow healthily, there will be fewer and fewer problems, and eventually it will come down to a level that most people don’t know about. The “blue screen” problem that haunted Windows users in the past is now irrelevant to new users. The “thin and blue” problems of today’s low code developers will be forgotten in the future (who has a dark history?).

Challenge 3: Low code applications are difficult to maintain

“Once the app gets complicated, it’s better to use all the code, with all the complicated logic streams interspersed with custom code that you can’t read or change.”

As a mindless evangelist who knows a thing or two about software maintainability (see “Fire Fighting Essentials! Troubleshooting and System Optimization Manual”), I have to say this: With low code development, you have to teach basic law. In general, the root cause of poor application maintainability, whether low code development or pure code development, is not the development tools, but rather the developer’s failure to follow common principles of software development, such as engineering discipline, naming readability, DRY/KISS/SOLID principles, etc.

A good low-code platform never prevents developers from improving the maintainability of their applications; On the contrary, they offer guidance and help wherever possible. Mendix, for example, in addition to supporting basic model analysis and refactoring (e.g In addition to useless models, object renaming, sub-logical flow extraction), it even provides application quality control (AQM) capabilities based on ISO/IEC 25010 standards. On the other hand, one of the things that makes an application difficult to maintain is the complexity of the application itself, and low code, as a highly abstract and automated development pattern, is specialized in reducing the complexity of the application.

Taken together, low code is not a silver bullet that will solve all problems, but it is not a bomb that will cause more problems: the upper limit of application maintainability is definitely higher than traditional development model; But it’s still the developers themselves who determine the limits of maintainability.

Low code industry development

The best way to respond to criticism is to be yourself and let your performance speak for itself. For an industry, whether its current performance is good enough or whether it has the potential to do better in the future can be measured in three aspects: market size (whether the pie is big enough), applicable scenarios (whether it can be implemented), and the status of competing products (whether it has been proven).

1. Market size

> “Talk is cheap, show me the code money.

Articles can be fooled, but markets don’t lie:

• In 2015, Forrester predicted that the low code market would grow from $1.7 billion in 2015 to $15 billion in 2020.

• Marketsandmarkets, in an April analysis, predicted that the low-code market would grow from $13 billion in 2020 (an estimate that appears to be close to Forrester’s estimate) to $45 billion in 2025 (cagR: 28.1%).

• In its 2018 analysis report, PS Inteligence predicted that the Asia Pacific region will maintain the highest growth rate in the global market for low code development platforms over the next five years (2019-2024).

To sum up, there are two points:

• The market for low code is large enough and growing at a high rate.

• As an economic powerhouse and IT powerhouse in the Asia-Pacific region, China’s low-code market will usher in a breakout period, with a growth rate exceeding the global average in the next few years.

2. Application scenarios

In theory, low code is a generic development pattern that fully aligns with traditional pure code and should be able to support all possible business scenarios. But the theory is just the theory, the dream of low code is not yet in reality, nor can it completely replace reality. As mentioned above, low code and pure code are complementary and will coexist for a long time in the future, each shining in its appropriate business scenarios. It should also be pointed out that low-code technologies, products and markets are not fully mature at this stage, so some scenarios that might be suitable for low-code development can only be replaced by pure code first.

In Gartner’s 2019 Low Code Research report, an “application pyramid” was drawn to illustrate scenarios for low code:

• Application level classification: From the bottom up, these are the Workgroup Class, the Departmental Class, the Enterprise Class, and the extreme-scale Enterprise Class with the most powerful requirements. It is easy to see that the main dimension of segmentation is the user base for which the application is targeted (the larger the base, the higher the need for scalability).

• Mission Criticality: From bottom to top, Mission Criticality of each level of application increases step by step. For example, a back-office administration application that is only used within a workgroup is typically not involved in critical tasks that affect the entire enterprise. From an enterprise perspective, there are many common mission-critical applications in the software industry, such as real-time operating systems, air scheduling systems, and bank reconciliation systems.

• Implementation Complexity: From the bottom up, each level of application Complexity increases. For example, the top-level enterprise-level applications need to meet more stringent non-functional requirements, including but not limited to user experience, performance, reliability, security, scalability, maintainability, and compatibility, in addition to the large coverage of functions and complex services. Other examples of complex software include: A 3D game interface (complex interaction) and an extremely low-level game engine (complex logic), and a very large CRM system (complex implementation on the one hand, and mature software with a high degree of standardization that can be used directly with off-the-shelf SaaS software in most cases).

• Application demand: From top to bottom, the Volume of demand for each level of application increases step by step, presenting a pyramid shape. This feature can be understood by the universal 2/8 principle: 20% “universal” applications can cover at least 80% of user groups due to the universality and universality of the demand (such as the attendance system used by most people in the enterprise); The remaining 80% are “niche” applications, due to the customization and specificity of their needs (e.g., ant’s option system…). “To cover only the 20% of users in their respective cliques.

• Fit with low code: From top to bottom, each level of application is becoming more Relevant to low code. In other words: the simpler the application, the lower the code; The less critical the task, the lower the code. At the same time, since low-code applications tend to be at the bottom of the pyramid, and these applications are in greater demand, it can be concluded that low-code applications can be applied to most business scenarios (and the proportion will continue to rise, gradually approaching applications higher up the pyramid), for example: B2E applications (forms, approval flow, ERP system), B2B applications (enterprise mall, industrial console), B2C applications (enterprise display, marketing page, shop decoration).

3. Overview of competing products

While low code is a new concept, the industry itself is not that new (as mentioned above) and has accumulated a number of veteran glory Kings over the years. At the same time, low code as a sunrise industry and capital hot spot, in recent years, there are more and more new players in this exciting battlefield.

The chart above shows Gartner’s magic quadrant for low code platforms and Forrester’s technology spectrum for low code platforms. As can be seen from the figure:

• OutSystems and Mendix lead the way as recognized leaders in the low-code space. Both are pure general-purpose low-code development platforms that have been around for a long time: OutSystems, founded in 2001, has over 1,000 employees and over $100 million in annual revenue; Raised $360 million from KKR and Goldman Sachs in June 2018 and is now valued at more than $1 billion; Founded in 2005, Mendix has more than 500 employees and over $23 million in annual revenues (18 years of data). It was acquired by Siemens in August 2018 for $730 million.

• Salesforce and Microsoft are not far behind, both leading the industry. But the nature of the two companies and their paths are very different: Salesforce started as a SaaS company and, needless to say, is the giant of the SaaS world. The motivation for such SaaS vendors to do low code is to address customer customization requirements for finished SaaS software. M$does not need to introduce more, just to mention their natural advantages of low code: on the one hand, as an aircraft carrier of office software, low code can help their customers achieve the ability and experience upgrade from Excel forms to customized APPS; On the other hand, as one of the big three in cloud computing, low code can help them connect to the internal cloud computing ecosystem and provide developers with a unified and easy-to-use interface to the cloud.

• The foreign market is well proven, but the domestic market is still nascent, and no one has been able to win the hearts and minds of the above research institutes to squeeze into the above two squares. Some of the current domestic competitive products and financing situation include: In May 2018, Tiaqiyun completed A round of ten million yuan financing; In September 2018, Yichuang technology received strategic financing from Qingyuan Venture Capital; In December 2018, Light Stream completed tens of millions of pre-A financing; In August 2019, Cyberworks received tens of millions of RMB angel round financing from Pacific Century Capital. ClickPaas received A multi-million dollar Series A funding round from Morningside Capital in August 2019; In 2019, Aozhe obtained A+ round financing of 50 million yuan from Ali and B round financing of over 100 million yuan from Gao Rong. (Note: The data of competitive products come from our PD group’s diligent sorting; So I’ve decided not to hack PD for the rest of this article; Next time.)

conclusion

This article summarizes the basic concepts, core values and industry status of the low code field. Although these contents are foundation and the theory of partial, but I always think, understand the premise of a system, it is the case – the technical architecture will only tell you is How to realize the system (How), unable to accurately describe What it could be used to do (What), and Why want to do such a thing (according to); The answer to these two questions is the root cause and driving force of all subsequent system design and evolution.

While programmers really don’t like to repeat themselves, redundancy is a necessary fault-tolerance tool, and the good stuff really isn’t to be missed: Welcome to join the EMAS team of Aliyun Cloud Native application DEVELOPMENT platform. We focus on a wide range of cloud native technologies (Backend as a Service, Serverless, DevOps, low code platforms, etc.) and are committed to providing one-stop application development and management services for enterprises and developers. Pq # alibaba-inc.com