1 the introduction

Before we talk about low-code scaffolding, we need to understand what scaffolding is (in this article scaffolding means building a custom new page through Web interaction).

In my opinion, the essence of construction is efficiency improvement, which is divided into efficiency improvement for r&d personnel and efficiency improvement for customers:

  • Improvements for developers: Compared to Pro Code, the build is more abstract, sacrificing some customization for a more efficient way of developing.
  • Customer improvement: If users have any demands for building Web applications, self-built essentially buy from ali cloud server is one of the most pervasive solution, but because of the high professional requirements, users will be very narrow, so the need for different user demands develop custom solutions, essentially by reducing generality in exchange for a lower cost of overhand, or in certain areas to reduce those costs, For example, BI building.

Improving performance is a bad idea, but almost all of the work in software engineering comes down to improving performance. For example, Vscode and Typescript improve coding efficiency; React and Vue frameworks improve application development efficiency; Even Microsoft says its mission is to empower every person and every organization in the world to achieve greatness, which in large part means to improve the productivity of society as a whole.

The low-code Development Platform goes a step further, allowing applications to be created quickly with zero or very little Code.

In practice, zero code is impossible to cover all areas, while 100% full code can cover all areas, but the development cost is too high, so the low-code mode in between is worth trying, because many custom scenarios don’t require too much advanced code. A lot of complex logic can be done with a few simple assignments or conditional statements, but if you don’t allow code to be written, it can be even more expensive to use than if you write a little code.

Therefore, the essence of building is to solve the problem of efficiency improvement. Considering efficiency improvement, it depends on the cost performance. Is it more efficient for users to use low code platform after learning a few lines of simple code, or is it more expensive for users to use complicated building and not write code? Some people say that you can’t learn code, but simple code is essentially the same as building, is the input of computer instructions.

Some scene complexity behind will be transferred to other links, such as data structures, scenes, the building is not low code, but it can implement complex business logic, reason is that the complexity has been eaten by the SQL layer, since complexity can’t eliminate, so which layer to achieve more efficient, do it by which layer is reasonable.

2. Intensive reading

Low code not only includes “ability to write code”, it mainly has the following four characteristics: material access, arrangement ability, rendering ability and code output ability.

Access to materials

A generic build engine should be able to access generic materials, i.e. components themselves can be used by the build platform regardless of the build environment.

This requires that the platform itself does not invade the component code implementation and can fully control the exposed props of the component. It is necessary to automatically identify the props variables of the component and automatically recommend and edit the form type according to the type.

In addition to simple setters for text, numbers, drop-down boxes, and so on, there are several complex editors:

  • Callback function editor.
  • Node Node editor.
  • Text internationalization editor.
  • Expression editor.

Callback function editors and expression editors are both examples of poor coding capability, essentially describing a variable value or callback in code.

The Node editor deals specifically with Node type props parameters, such as props. Header and propder.footer, which are described as components in code mode and converted to canvas drilldown mode for editing in visual mode.

Choreography ability

Orchestration ability includes page orchestration and logical orchestration, which is the core ability of low code construction.

The page layout

Page layout contain a lot of interaction, such as drag and drop components, layout, the layout is promising, such as cloud swallowtail edit mode, through free drag-and-drop layout, reduce the user’s understanding of DOM fluid layout costs, but through adaptive four surrounding from the simulate fluid layout automatically open container, the container collision between extrusion effect.

The combination of components and components can form a new material, generally called a template. For example, a page as a whole can also be called a template. The ID of the template component is the container component of the root node of the page. But the template has not meet scenarios, such as the expectations component of composite has a new configuration, this is the extended the concept of business components, low code can be thought of as the template editor as a whole, any edit form, can be set as the template of the edit form value can be read through to the inside of each component.

The logical layout

Logic choreography is at the heart of low code capability. In a low code engine, all component parameters can be described in low code, such as a props. Color can be used to select a fixed value through a color selector, or it can be converted to an expression pattern to write a piece of code.

This section of code in addition to ordinary JS ability, also has the basic state management ability, that is, can access the current scope of the state this.state, and state scope is divided by the container, the container is divided into holding the state of the container and do not hold the state, a holding state of the container in the sub-component state is interworking.

In addition to the basic state management capabilities, it also has the ability to access the context by calling some of the engine’s apis to operate on the canvas. This is typically used for component callbacks, where this. SetState is called to set the state. In addition to context, stylistic, international, fetch capabilities are accessible from this. Fetching capabilities are drawn exclusively to the engine layer to decouple all components from fetching logic. Any component that fetch data does not need to send fetch requests when fetching data.

Another dimension of logic orchestration is visualization. The visualization of the above low code capabilities as logical nodes and lines has certain advantages in describing and maintaining complex logic.

Ability to apply colours to a drawing

The special feature of construction is that the construction process can almost only be completed on the PC side, but the application after release often has the appeal of multi-rendering. For example, more and more companies use mobile phones to view BI reports, and reports even need to be embedded into wechat and Alipay mini programs. Forms built by PC often have a large number of appeals filled in by mobile phones.

Therefore, the editing and rendering side should be separated, but in order to ensure logical consistency, the core code needs to be reused, so the best way to build the engine is to use the UI-independent kernel + business layer to expand the UI implementation. The UI-independent kernel is only responsible for storing and manipulating the canvas data, excluding a bunch of panels added by the designer. It is often enough to reuse the logical kernel when rendering.

Cross-side reuse of components is also necessary, and there are many technical solutions for cross-side rendering.

The code ability

The mutual transfer between LowCode and ProCode is also a big problem. First of all, the benefits of mutual transfer are needless to say. You can freely switch between efficiency improvement and customization, which must be the most ideal development mode, but there are many obstacles in the implementation.

The first is to convert LowCode to ProCode. This is easier because LowCode itself is defined in JSON, and code is a JSON superset. There are no technical barriers to converting from a subset to a superset.

Converting from ProCode to LowCode is tricky. One way is to limit ProCode’s capabilities, or even replace native JS with a new syntax, essentially by limiting ProCode’s capabilities so LowCode can catch up. Another way is asymmetric conversion, that is, after converting from ProCode to LowCode, there will be missing functions, or even if the function is not missing, the corresponding functions of LowCode cannot be edited on the building platform.

Runtime capability

Only have the ability of low code up platform is too general, although the function is very powerful, but in specific business scenarios may not have much effect, specific business scenarios should have specific solutions, structures, nature is the effect, if the content of the atomization, low code too much, just put the cart before the horse, just write code in another way, It has not really achieved the use of scaffolding to improve development efficiency.

There are three common service customization methods:

  • Customized business components: For example, the components used in 80% of scenarios of a complex business system are consolidated into a customized business component, saving most of the configuration time and enabling users to feel the benefits.
  • Customize business templates and low-code business components: Further, solidify business templates that are essentially code templates, or take low-code business components and make a hybrid component for a business scenario without developing new components.
  • Customizing service configuration items: Some service scenarios are highly specialized. On the one hand, the user groups are different, and on the other hand, the configuration items based on the service should be provided to meet the service logic and save configuration steps.

The above general methods can be achieved through the existing open capabilities of the engine, but for data scenarios, there are some scenarios that rely on the run-time capabilities of the engine, which need to be abstracted and implemented with low code.

Such that the current page all configuration components of the same data set automatic screening of associative links, although screening linkage associated low code may be able to configure, but when the canvas component quantity change, or a component dynamic invocation API new component, dynamic relation between static configuration is very difficult to meet the scene, we can explore some global runtime ability, Having components implement these runtime capabilities allows them to take the canvas information and run it dynamically when the engine actually calls them, rather than editing to produce a static JSON that is completely separate from rendering.

Run-time capabilities vary from platform to platform for different vertical scenarios. If you want to get through the underlying engine, you can provide expansion slots to dynamically register the engine run-time capabilities.

3 summary

It is impossible for a low-code platform to eat all the scenarios. As long as someone is willing to “customize” the vertical business scenarios, users will immediately feel that the efficiency of the construction is improved. We should stand in the perspective of users and make the platform in a way that maximizes their interests.

Builds the platform but the maintenance cost is very high, every business scenario alone maintain a is certainly not a long-term solution, we need to design a set of elastic core engine low code, various business can be based on his own user of the group of “tailored” exclusive designer, a set of Shared structures, and the power of the engine general agreement, and free extend customization capabilities.

Therefore, not only the rendering state should be polymorphic, but also the designer should be polymorphic, where the parts that can be solidified into standards need to be laid down, such as material access specifications, programming capabilities, coding capabilities, runtime capabilities, so that each building platform can be combined and different.

Both at home and abroad, there are a lot of fairly good building systems, but either they are too general, specific scene improvement is not obvious, or they are too vertical, can not be done in another business scene. Now ali low background code set up in the organization in formulating the standards, the engines, general ability cure for standard protocol, let different platforms can be aligned specification and function, the future will also constantly convergence core engine implementation, based on it can create thousands of vertical structures, platforms, with the business doing building work, and at the same time maintain engine kernel with specification to each other.

Ali Data Experience technology team of the author is a member of the low code building organization in the background, and achieves the perfection in the field of data building. In terms of technology, we are getting through the technical solutions of middle and background building and data building. In terms of products, we are gradually unifying the data building platform of Ali Group, and QuickBI has also become the only BI product entering the Gartner quadrant in China with a promising future.

Ali Data in Taiwan experience technology team is recruiting people, if interested, you can contact [email protected].

The discussion address is: intensive reading of “Understanding low Code Build” · Issue #260 · dt-fe/weekly

If you’d like to participate in the discussion, pleaseClick here to, with a new theme every week, released on weekends or Mondays. Front end Intensive Reading – Helps you filter the right content.

Pay attention to the front end of intensive reading wechat public account

Copyright Notice: Freely reproduced – Non-commercial – Non-derivative – Remain signed (Creative Commons 3.0 License)