This article is written by Xiao Fan, a member of the team. We have authorized the exclusive use of Doodle Big Front, including but not limited to editing and original annotation rights.

preface

There must be more than a thousand Hamlets in a thousand eyes. This article is not only about visual architecture, but also about low code systems that improve development efficiency.

I’ll share my understanding of the low code system below. If you have different opinions, welcome to discuss!

What is low code

define

Anything that can be done by writing less code can be incorporated into a low-code system.

Low code is a system between no code and full code, with tools, constraints, and configurations to generate common business code, based on which small changes can be made to quickly develop different customized businesses.

contrast

Advantages of no code:

  1. The usage and configuration are simple
  2. Members without development experience (such as operations, products, design, etc.) can complete functional business development through this system

Disadvantages of no code:

  1. The business model and boundary are single and cannot be customized for special functions
  2. When research and development intervene, due to the compatibility, special customization and other issues to be considered, the update lag and time consuming is serious

Advantages of low code:

  1. Basic business code can be quickly generated by means of construction and configuration
  2. The scope of business models, boundaries is expanded, and secondary custom development can be done on the base code
  3. In the process of secondary customized development, materials can be accumulated and fed back to the low code system to improve the process

Disadvantages of low code:

  1. Construction, configuration process, need to understand a certain knowledge of the development system, starting cost more than no code
  2. Business models and boundaries are expanded but still limited to a certain extent (e.g. e-commerce industry, Internet of Things model, etc.)

In simple terms, low code is the fault tolerance and improvement made on the basis of no code, so that the development can better intervene and improve the efficiency of the whole project cycle.

Technical significance and business value of low code

After this simple comparison, let’s move on to a deeper discussion of the technical and commercial aspects of low code architecture

Technical sense

  1. Rapid iteration of the same type of business is needless to say, improving efficiency and reducing costs.
  2. Visualization technology can extend the low code system from the role of research and development to the role of design, product, operation and so on, and make certain analysis and construction of the project at the early stage of the project development
  3. With low code generation projects, the base library can be upgraded uniformly. A series of regular unified configurations, such as burying points and detection, all use corresponding low code generation.
  4. Reduce manual development, test regression, problem location will be more accurate.

Commercial value

To fully embody the meaning of technology in business can be summarized as the following three points:

  1. Speed: it can quickly read basic projects and customize them
  2. Cost: Reduced investment in mid-level R&D
  3. Safety: Machines are always safer than people, creating fewer problems and being easier to locate

You might wonder why the decline is in intermediate r&d, not elementary. The hardest thing to do after a low code system is to have skilled people, skilled people who develop businesses rather than tools. The system allows entry-level workers to quickly become skilled workers, reducing the value of those previously skilled in business development. Either you go up and become a custom system guy, or you reduce your value to fit the cost of the business.

For example, the emergence of electric bikes has driven many small and medium-sized bike companies out of business, but the experience of the top bike yard is smaller, but not much better. In development, too, even the top bike makers are struggling under the big background, so the rest can only switch to electric cars.

Low code system setup

The construction here is not just limited to low code construction projects, but refers to how to build a set of low code system suitable for their current business.

Business + Material library

A low-code architecture must fit the current business or a common business model.

Therefore, in the process of building a low-code system, we must first accumulate a large number of business models for continuous training.

The first step in the output is the refining of the business, moving from the base component library to the material library.

Here, the composition of the material library is enlarged a bit (for lack of a better word).

Material library is a huge material system composed of basic components, business components, business templates, business frameworks, basic code blocks, business code blocks and so on.

Basically, 70-90% of the current business can be built quickly from the above material fragments.

After completing the above requirements, you can consider the next steps to improve efficiency with tools or specifications.

Interaction + Efficiency

The second step in a low code architecture is interaction and efficiency.

  1. Start with the most basic CLi tools and build CLi tools that meet your own service requirements. You can add corresponding code blocks and select corresponding service templates through simple interaction
  2. United background, through the interface product, directly generate the corresponding form, form template.
  3. Generate corresponding structural codes through Sketch analysis or AI map recognition. (Sketch can be parsed into a tree interface using tools, and you can get the metadata you want by adding the corresponding node tags)

If you contact the front end of the number of years is relatively early, then must have heard or used Dreamweaver this front end tool. The real-time preview + drag configuration is cool, but without the constraints of the business model and the support of the above material library, the generated code is worse than writing by hand, so the product only works well in the demo stage, but loses its advantages in actual development.

This is an example of the opposite. If you design a low-code system that is far less efficient in practice than it would be in direct programming, then the system is failing.

The product is not necessarily bad, but the result of using the product is not necessarily good. All processes and tools need to be closely aligned with the business to give full play to their value.

As you can see from the second point, it’s not just processes with interface interactions that are referred to as low code. The back-end can use tools to extract and combine the corresponding interface parameters and directly generate the corresponding CURD page. As long as it conforms to certain rules and styles, that is, forms and basic components of forms are available, business pages or even a simple CURD project can be directly output. Low code architecture is not limited to visual architecture, but throughout the business development process.

Of course visual build projects are always the most intuitive and simple low-code means, but it is important to emphasize that drag and drop build is only one method and not the only one.

Processes and tools that can be developed with minimal human involvement can be assigned to a low code system.

Process design

Most low-code designs abstract the overall business model through JSON configuration, with certain parsing rules to generate concrete code.

Then as shown in the figure (secondary development brings personalized customization, and rich enough material library can even eliminate this step in the face of simple business), configuration generation represents a certain constraint.

Project configuration can be roughly divided into two levels:

  1. Base type selection: mobile, PC, cross-terminal, RN, applets, etc
  2. Business type selection: e-commerce, advertising, large screen, finance, etc

The choice of project type determines the final component configuration, and the choice of each project type leads not only to the rendering of the base components but also to the selection of business components.

Specific JSON configuration and visual construction related content, there are a lot of blogs are introduced, the follow-up part of the blog recommended, you can see.

conclusion

Maybe some of you have a misunderstanding about low code because the audience for low code platforms must be non-programmers. This preconceived situation feels pit many students who study low code build.

The bottom line is that low-code platforms are designed for non-programmers, and low-code platforms are designed for programmers or people who know something about programming.

If the low code system is suitable for the current business situation, it can transfer part of the business capability to the corresponding operation, product and design through the simple interaction of visual construction.

The ease with which part of the business is packaged can reduce part of the development time, but this part is code free for them. Don’t bring too much low-code programming into the mix and cause extra mental strain. (The result of no code trying to achieve low code is extremely complex configuration.)

That’s why we’ve been talking about business models and boundaries, and when you get away from business models and boundaries, you’ll see that the mental cost of visual architecture has side effects that go beyond just portfolio development.

Write in the last

It’s not necessarily good r&d that can develop tools but it’s not good R&D that can’t develop business.

Technology to assist business, business feedback technology.

Found that after writing the above things, found that the final elimination is my cut figure son, the baby instant is not happy.

Recommend the blog

It’s about low-code

How to design and implement the PC site construction system – Schema

Introduction to low code