A program for integrating low-code development capabilities into an application.

Abstract

This technology provides a way to easily integrate low-code development capabilities into user applications. [Solution] A program for incorporating low-code development functionality into application 20 is provided as a library 14 that can be incorporated into application 20. The program comprises one or more low-code components 300 that can be added to a low-code application 220 developed on application 20, and a low-code execution engine 320 for executing the low-code application 220 composed of one or more low-code components 300. Each of the one or more low-code components 300 includes a component setting 310 having at least one of one or more screen settings 312, one or more input / output settings 314, and one or more scripts 316. The low-code execution engine 320 is configured to execute one or more of the screen drawing process, input / output processing, and script processing of the low-code application 220 based on the component setting 310.

Description

Technical Field

[0001] This disclosure relates to low-code development technology.

Background Art

[0002] In conventional system development, it was necessary to code a program based on a design document. In this regard, in recent years, development methods called no-code development and low-code development have become widespread. No-code development is a method of developing an application by combining pre-prepared components. In contrast, low-code development is a method of developing an application by combining pre-prepared components and with less coding or setting than full-scratch development.

[0003] Regarding low-code development technology, for example, Japanese Unexamined Patent Application Publication No. 2023-15625 (Patent Document 1) discloses a business support device that "automatically formats and outputs a character string of log information (an example of an extraction target) using a screen data structure in a low-code development base" (see paragraph

[0022] ).

Prior Art Documents

Patent Documents

[0004]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0005] According to the technology disclosed in Patent Document 1, a user needs to use a low-code development base. Therefore, the functions and execution environment of the developed low-code application will depend on the low-code development base. In addition, when a user tries to incorporate a low-code development function into their own application, a huge amount of man-hours will be required for the implementation of the low-code development function.

[0006] This disclosure is made in light of the above-mentioned background, and in one aspect, its purpose is to provide a technology that allows users to easily integrate low-code development functionality into their applications. [Means for solving the problem]

[0007] According to one embodiment, a program is provided for integrating low-code development functionality into an application. The program comprises one or more low-code components that can be added to a low-code application developed on application 20, and a low-code execution engine for running the low-code application composed of one or more low-code components. Each of the one or more low-code components includes a component configuration having at least one of one or more screen configurations, one or more input / output configurations, and one or more scripts. The low-code execution engine is configured to execute one or more of the screen rendering, input / output processing, and script processing of the low-code application based on the component configuration.

[0008] One or more scripts are configured to call functions implemented in native code. The low-code execution engine is configured to execute functions implemented in native code via one or more scripts.

[0009] One or more low-code components are configured to contain a User Interface (UI) implemented in native code. The low-code execution engine is configured to display the UI implemented in native code.

[0010] One or more low-code components are configured to contain custom components implemented in native code. The low-code execution engine is configured to execute custom components implemented in native code.

[0011] The screens of a low-code application are created using a designer screen. The low-code execution engine is configured to read the settings for each component of the low-code components included in the low-code application created using the designer screen. [Effects of the Invention]

[0012] According to one embodiment, low-code development capabilities can be easily integrated into a user's application.

[0013] The above and other purposes, features, aspects and advantages of this disclosure will become apparent from the following detailed description of this disclosure, which will be understood in conjunction with the attached drawings. [Brief explanation of the drawing]

[0014] [Figure 1] This figure shows an example of the application of the low-code library 14 according to this embodiment. [Figure 2] This figure shows an example of the development flow for a low-code application using the low-code library 14. [Figure 3] This figure shows an example of the configuration of application 20, which includes a low-code library 14. [Figure 4] This figure shows an example of the designer screen 210 and the screen of the low-code application 220. [Figure 5] This figure shows an example of the functionality of Script 316. [Figure 6] This figure shows an example of the implementation of low-code component 300. [Figure 7] This figure shows an example configuration of an information processing device 700 used for developing and / or running application 20. [Modes for carrying out the invention]

[0015] Hereinafter, embodiments of the technical idea according to the present disclosure will be described with reference to the drawings. In the following description, the same parts are denoted by the same reference numerals. Their names and functions are also the same. Therefore, detailed descriptions thereof will not be repeated. Also, each embodiment, each modification example, each software or program configuration, each hardware configuration, each function, and each process, etc. may be selectively combined as appropriate.

[0016] <Application Example> FIG. 1 is a diagram showing an application example of the low-code library 14 according to the present embodiment. Referring to FIG. 1, the function of the low-code library 14 will be described in comparison with the conventional low-code platform 1.

[0017] (Limitations in the Low-Code Platform) Conventionally, users have developed low-code applications using the functions of the pre-prepared low-code platform 1. In such a case, the developed low-code applications operate on the low-code platform 1. In the example of FIG. 1, the low-code applications 2 and 3 are developed on the low-code platform 1. There are mainly two limitations in application development using the low-code platform 1.

[0018] The first limitation is the limitation of the functions of the low-code application. Basically, users develop low-code applications by combining the components provided by the low-code platform 1. Therefore, the functions of the low-code application are restricted by the components provided by the low-code platform 1 and the specifications of the low-code platform 1, etc. It is not easy for users to implement original functions in the low-code application.

[0019] The second limitation is the restriction on the execution environment of the low-code application. The low-code application operates on the low-code platform 1. Therefore, it is not easy to distribute or sell the developed low-code application. Taking Figure 1 as an example, the user cannot easily distribute and sell the low-code applications 2 and 3 to customers.

[0020] When the user is a software vendor or an individual developer, etc., since the user needs to distribute the developed product, the above limitation may become a problem. Therefore, it is not desirable that the execution environment of the product is restricted to the low-code platform 1. However, the user may desire to introduce low-code development for reasons such as reducing development man-hours. If the user implements the low-code development function in their own product, the above limitation can be solved. However, if the low-code development function is implemented from scratch, it will take a huge amount of man-hours.

[0021] (Functions provided by the low-code library) The low-code library 14 can eliminate the above limitation by providing a function to easily add the low-code development function to the user's application 10. Development using the low-code library 14 is completely different from development using the low-code platform 1 in the following aspects.

[0022] In development using Low-Code Platform 1, users develop low-code applications using low-code development functions. In other words, users are merely using low-code development functions. In contrast, in development using Low-Code Library 14, users can integrate low-code development functions into their own Application 10. In other words, users can turn their Application 10 into a low-code platform. Hereafter, the application that has been turned into a low-code platform will be referred to as Application 20. There are various advantages to turning Application 10 into a low-code platform. The advantages of Low-Code Library 14 will be explained below. Hereafter, for the sake of simplicity, individuals, teams, and corporations that develop Application 20 using Low-Code Library 14 will be collectively referred to as "developers." Also, individuals, teams, and corporations that use Application 20 will be collectively referred to as "customers." When referring to developers and customers collectively, we will use the term "user."

[0023] The first advantage is that it enables low-code development that is independent of the execution environment. Application 20 includes a low-code library 14. Therefore, Application 20 can provide low-code development functionality regardless of the platform. In other words, developers can sell and distribute Application 20 to customers without platform limitations. For example, Application 20 can run on an information processing device owned by the customer. Information processing devices include, for example, servers, personal computers, smartphones, tablets, and wearable devices.

[0024] The second advantage is that Application 20 can offer customization capabilities to customers. Application 20 can function as a low-code platform. Customers can use the low-code development capabilities to freely customize Application 20 for their own business needs.

[0025] The third advantage is the reduction in development time. By using the low-code development features of Application 20, developers can develop applications tailored to each customer's needs in a shorter time compared to full-scratch development. In the example in Figure 1, the developers developed custom applications 30 and 40 based on Application 20.

[0026] The fourth advantage is that there are no limitations on the functionality that can be implemented in application 20. Based on the component configuration 310 (see Figure 3), the low-code library 14 can use any functionality provided by application 20. For example, application 20 includes native code 11, a database 12, and other libraries 13. The low-code library 14 can access these functions and data. Furthermore, as will be discussed later with reference to Figure 6, users can implement components for low-code development in native code and add those components to the low-code library 14.

[0027] As explained with reference to Figure 1, a user can develop an application 20 that functions as a low-code platform simply by incorporating the low-code library 14 into their own application 10. Because application 20 includes low-code development capabilities, it is not dependent on any particular low-code platform. Therefore, the user can distribute application 20 to customers. In addition, the user can effectively utilize code assets such as native code 11 in the development of application 20. Furthermore, the user can add functions implemented in native code to application 20. As a result, application 20 can achieve both the convenience of low-code development and the scalability of full-scratch development.

[0028] <Example of developing a low-code application using a low-code library> Figure 2 shows an example of the development flow of a low-code application using the low-code library 14. Application 20 comprises a designer screen 210 and a low-code application 220. The designer screen 210 has the function of designing the low-code application 220 by combining low-code components 300 (see Figure 3), which will be described later. In other words, the designer screen 210 behaves like the low-code platform 1. The low-code application 220 is a business application, etc., used by the end user. In other words, the low-code application 220 behaves like low-code applications 2 and 3.

[0029] The designer screen 210 and the low-code application 220 may be implemented as a single application. Alternatively, the designer screen 210 and the low-code application 220 may be implemented as separate applications. The developer may use application 20 to provide the following services to the customer:

[0030] (Providing a low-code platform) The developer may provide the customer with application 20 that does not include the low-code application 220. Alternatively, the developer may provide the customer with application 20 that includes an empty application 230, which is a template for the low-code application 220.

[0031] In this case, the customer can use the designer screen 210 to develop low-code applications necessary for their business operations. Furthermore, the customer can use the designer screen 210 to customize the low-code applications as needed.

[0032] In this way, the developer can offer application 20 to the customer as their own low-code platform. In this case, the developer only needs to provide the low-code components 300 and other extensions (such as proprietary functions). The customer can then create business applications tailored to their own needs. Since application 20 is not dependent on the execution environment, it may be installed on an information processing device provided by the developer. Alternatively, application 20 may be installed on an information processing device owned by the customer.

[0033] (Development of applications tailored to each customer) If the customer lacks programming knowledge, the developer may use the low-code development capabilities of application 20 to develop the customer's business application 240 on their behalf. By using the low-code development capabilities, the developer may be able to develop the customer's business application 240 at a lower cost and in a shorter timeframe than if it were developed from scratch.

[0034] Furthermore, developers can combine the above services and offer them to customers. For example, a developer may sell an application 20 to a customer that includes several low-code application samples. In this case, the customer can use the samples to develop their own business application 240.

[0035] As explained with reference to Figure 2, developers can provide flexible services to customers by utilizing the low-code platform application 20. Furthermore, by using the low-code development capabilities of application 20, developers can develop customer-specific applications at a lower cost and in a shorter time than before.

[0036] <How low-code libraries work> Figure 3 shows an example of the configuration of an application 20 that includes a low-code library 14. The mechanism of the low-code library 14 will be explained with reference to Figure 3. As an example, application 20 includes native code 11, a database 12, other libraries 13, and the low-code library 14.

[0037] Native code 11 is the main body of application 20. For example, native code 11 includes code to implement functionality specific to application 20. Native code 11 can also be written in any programming language. Application 20 may contain one or more native code 11.

[0038] Database 12 is a database referenced by Application 20. Database 12 may be referenced from native code 11, other libraries 13, and low-code libraries 14. Application 20 may contain one or more databases 12. Application 20 may also not contain databases 12 if they are not needed. Furthermore, Application 20 may be configured to reference external databases. Databases include hierarchical databases, network databases, relational databases, NoSQL databases, and databases of any other format.

[0039] Other libraries 13 are any libraries other than the low-code library 14. Application 20 may include one or more other libraries 13 as needed. Application 20 does not have to include other libraries 13 if they are not needed. For example, other libraries 13 may include UI components, cloud APIs (Application Programming Interfaces), AI (Artificial Intelligence) APIs, O / R mappers, and other optional libraries.

[0040] The low-code library 14 provides low-code development functionality to the application 20. The low-code library 14 includes one or more low-code components 300 and a low-code execution engine 320. Furthermore, the low-code library 14 may also include a designer screen 210. The low-code library 14 may be a single library or a combination of multiple libraries.

[0041] Low-code components 300 are individual components in low-code development. For example, low-code components 300 are components such as screens and fields. Users can develop low-code applications 220 by combining low-code components 300 on the designer screen 210. Low-code components 300 are mainly provided in units of fields such as labels, buttons, and boxes. Low-code components 300 may also be provided as a combination of two or more fields. Furthermore, low-code components 300 may be provided in units of screens containing one or more fields.

[0042] A low-code component 300 includes a component setting 310 for defining the appearance and behavior of the low-code component 300. The component setting 310 includes at least one of a screen setting 312, an input / output setting 314, and a script 316. If there are multiple low-code components 300, each of the multiple low-code components 300 includes its own component setting 310.

[0043] Screen settings 312 include settings related to the appearance of the low-code component 300. For example, screen settings 312 include settings such as the layout of fields or screens. If the low-code component 300 does not include a UI, the component settings 310 of that low-code component 300 do not need to include screen settings 312. Examples of low-code components 300 that do not include screen settings 312 include components that only perform input / output processing, and scripts 316 created without being linked to a UI.

[0044] The input / output settings 314 include settings related to data input and output via the low-code component 300. For example, the input / output settings 314 include settings such as the types of characters that can be entered into the text box and the database table referenced by the list box. In addition, the input / output settings 314 include settings for arbitrary input / output processing that is independent of the UI. For example, arbitrary input / output processing that is independent of the UI includes processes that execute SQL and processes that execute web APIs.

[0045] Script 316 can contain any processing that the low-code component 300 is to execute. The user can use script 316 to have the low-code component 300 execute any processing. Script 316 may also be created as a standalone low-code component 300. In this case, script 316 is used in conjunction with the low-code component 300.

[0046] Script 316 may contain a class, a method, or both. The user can associate a class or method defined in script 316 with an event of a low-code component 300. This allows script 316 to be executed in response to an event of any low-code component 300. For example, script 316 may include processes such as displaying a popup when the UI is manipulated, or enabling / disabling buttons.

[0047] Furthermore, script 316 is configured to allow the calling of user-defined functions. For example, the user may write classes, methods, etc., included in the native code 11 in script 316. In this case, the low-code execution engine 320 can call the native code 11 via script 316.

[0048] The low-code execution engine 320 operates a low-code application by referencing one or more low-code components 300. As illustrated in Figure 2, a user can create a screen by combining one or more low-code components 300 on the designer screen 210. The user then inputs component settings 310 for each low-code component 300 that makes up the screen on the designer screen 210. Based on the operation input received from the user, the designer screen 210 sends the component settings 310 to the low-code execution engine 320. Based on the component settings 310, the low-code execution engine 320 generates a screen for the low-code application 220 and implements various functions of that screen.

[0049] The low-code designer application 330 displays the designer screen 210 by referring to the low-code library 14. For example, the low-code designer application 330 may be an application independent of the low-code library 14. The low-code designer application 330 may be distributed to the customer together with application 20. When a low-code application 220 is developed on the designer screen 210, the low-code designer application 330 generates its settings. The low-code designer application 330 may save the settings of the low-code application 220 to the storage of the information processing device, etc. The low-code designer application 330 may also send the settings of the low-code application 220 to the low-code execution engine 320. The low-code designer application 330 may also read the settings of the low-code application 220 from the storage of the information processing device, etc. This allows the user to easily develop custom applications, etc., by reusing the settings of a previously created low-code application 220. The settings of the low-code application 220 include the component settings 310 of one or more low-code components 300 included in the low-code application 220.

[0050] The low-code designer application 330 may be separate from the low-code library 14. Alternatively, the low-code designer application 330 may be included in the low-code library 14. Furthermore, the low-code execution engine 320 and the low-code designer application 330 may be implemented as a single program or as separate programs.

[0051] By having the above configuration, the low-code library 14 can incorporate the designer screen 210 and the functionality for developing low-code applications 220 into application 20.

[0052] As described above with reference to Figures 1 to 3, the technology of this disclosure provides a program for incorporating low-code development functionality into an application 20. The program is provided as a low-code library 14 that can be incorporated into the application 20. The program comprises one or more low-code components 300 that can be added to a low-code application 220 developed on the application 20, and a low-code execution engine 320 for executing the low-code application 220 composed of one or more low-code components 300. Each of the one or more low-code components 300 includes a component setting 310 having at least one of one or more screen settings 312, one or more input / output settings 314, and one or more scripts 316. The low-code execution engine 320 is configured to execute one or more of the screen drawing process, input / output process, and script processing of the low-code application 220 based on the component setting 310. Script processing refers to the processing of methods etc. described in the script 316.

[0053] Figure 4 shows an example of the designer screen 210 and the low-code application 220 screens. In the example in Figure 4, the designer screen 210 and the low-code application 220 are implemented as separate applications. That is, application 20 includes two applications. However, this is just one example. The designer screen 210 and the low-code application 220 may also be implemented as a single application.

[0054] The designer screen 210 includes a solution explorer 410, a toolbox 420, an editor 430, and properties 440. The solution explorer 410 displays a list of settings for the low-code application 220. The designer screen 210 can load settings for one or more low-code applications 220 from the storage of the information processing device, etc.

[0055] The toolbox 420 displays a list of fields that can be placed on the screen. The user can design the screen of the low-code application 220 by dragging and dropping fields from the toolbox 420 to the editor 430. Each field displayed in the toolbox 420 corresponds to one of the low-code components 300. Low-code components 300 with only input / output functions are not displayed as fields in the toolbox 420. The toolbox 420 may also display components that combine multiple fields. Furthermore, the toolbox 420 may display the screen as a component.

[0056] The editor 430 is an area for writing screens and scripts 316, etc., for the low-code application 220. The user may design a screen from scratch by adding fields to the editor 430 from the toolbox 420. Alternatively, the user may select the settings of an existing low-code application 220 from the Solution Explorer 410. In this case, the editor 430 displays the screen of the selected low-code application 220. The user can design screens for other applications by customizing the screen of the selected low-code application 220. The designer screen 210 includes screen settings 312 with information such as the type and location of fields placed in the editor 430. In the example in Figure 4, the user is designing the "Author screen" on the editor 430.

[0057] Property 440 can display and accept various setting items for each low-code component 300. These setting items may include settings related to screen settings 312, input / output settings 314, and scripts 316. For example, property 440 can accept settings related to the layout of the low-code component 300 and reflect them in screen settings 312. As another example, property 440 can accept settings related to the database referenced by the low-code component 300 and reflect them in input / output settings 314. Furthermore, as yet another example, property 440 can accept settings for associating a script 316 with the low-code component 300. For example, a user can select a method to be executed when an event occurs in the low-code component 300 (e.g., a button is pressed) via property 440. This method is a method written in script 316. The association information between the low-code component 300 and script 316 may be included in input / output settings 314. Alternatively, component configuration 310 may separately include information on how to link the low-code component 300 and the script 316.

[0058] The user develops a low-code application 220 via the designer screen 210. This creates component settings 310 for one or more low-code components 300 included in the low-code application 220. In reality, the low-code application 220 is part of application 20. Therefore, it can also be said that the user designs the screens and functions of application 20 via the designer screen 210.

[0059] The low-code application 220 is displayed by the low-code execution engine 320. More specifically, the low-code execution engine 320 displays the screen of the low-code application 220 based on one or more part settings 310 received from the designer screen 210. In the example in Figure 4, it can be seen that the screen of the low-code application 220 is a screen designed on the designer screen 210.

[0060] As explained with reference to Figure 4, the screen of the low-code application 220 is created by the designer screen 210. The low-code execution engine 320 is configured to read the component settings 310 of each low-code component 300 included in the low-code application 220 created by the designer screen 210. For example, the low-code execution engine 320 receives the component settings 310 of each low-code component 300 included in the screen of the application 20 from the designer screen 210 and reads the received component settings 310. As another example, the low-code execution engine 320 may read component settings 310 that have been placed in a predetermined location. In this case, the user only needs to place the component settings 310 generated by the designer screen 210 in the predetermined location within the project of the application 20.

[0061] Figure 5 shows an example of the functionality of script 316. Script 316 is used by being linked to any low-code component 300. Script processing, such as methods described in script 316, may be executed when a UI element such as a button is operated. Furthermore, script processing may be executed when the low-code application 220 is launched. Additionally, script processing may be executed when an input / output processing low-code component 300 is executed. The low-code execution engine 320 can implement behaviors linked to each low-code component 300 via script 316.

[0062] The user can change the behavior of each low-code component 300 by editing script 316. Script 316 is also configured to call functions implemented in native code 11. For example, the user can write a class or method defined in native code 11 in script 316. In this case, the low-code execution engine 320 can use the functions of native code 11 via script 316. This allows the user to easily associate previously developed program assets (i.e., native code 11) with the low-code components 300. As a result, application 20 becomes a low-code platform that effectively utilizes the user's program assets.

[0063] As explained with reference to Figure 5, one or more scripts 316 are configured to call functions implemented in native code. The low-code execution engine 320 is configured to execute functions implemented in native code via one or more scripts 316. This allows the application 20 to have higher extensibility compared to the existing low-code platform 1. In addition, users can effectively utilize program assets they have created in the past.

[0064] Figure 6 shows an example of the implementation of a low-code component 300. The low-code library 14 includes multiple low-code components 300 by default. Typically, a user can develop an application with a desired GUI (Graphical User Interface) by combining these low-code components 300. However, depending on the application being developed, the user may require fields or screens that are not provided by default. In such cases, the user can create an original low-code component (hereinafter referred to as "custom component 600"). For example, the user can use the created custom component 600 in the same way as a regular low-code component 300 by placing it in a designated folder. In other words, the user can add a custom component 600 to the multiple default low-code components 300.

[0065] Users can create custom parts 600 using native code. Native code may include code in any programming language. In addition to native code, custom parts 600 may include some or all of data in formats other than native code, such as JSON (JavaScript® Object Notation), XML (Extensible Markup Language), text data, and other arbitrary formats. Custom parts 600 may also include some or all of images (such as icon images), audio files, and text data as resources.

[0066] A custom component 600, like the default low-code component 300, includes a component configuration 310. For example, a custom component 600 may include the component configuration 310 of the default low-code component 300. As another example, a custom component 600 may include a custom component configuration specific to that custom component 600. Some or all of the component configuration 310 may be defined as a programming language variable, structure, or a combination thereof. Also, some or all of the component configuration may be defined by JSON, XML, text data, data in any other format, or a combination thereof. The low-code execution engine 320 may use the custom component 600 by referencing the component configuration 310. For example, the low-code execution engine 320 may display the custom component 600 and further implement the behavior when the custom component 600 accepts an operation.

[0067] In this way, users can create original custom parts 600 using native code. The low-code execution engine 320 can then implement the functionality of the custom parts 600 by referring to the part configuration 310. This allows application 20 to offer users significantly higher extensibility compared to conventional low-code platforms 1.

[0068] As explained with reference to Figure 6, one or more low-code components 300 are configured to contain a UI implemented in native code. The low-code execution engine 320 is configured to display the UI implemented in native code. Here, the UI includes the screens of the low-code application 220 and the fields placed on those screens. Furthermore, one or more low-code components 300 are configured to contain input / output processing components implemented in native code. The low-code execution engine 320 is configured to execute input / output processing components implemented in native code.

[0069] Furthermore, one or more low-code components 300 are configured to contain custom components 600 implemented in native code. The low-code execution engine 320 is configured to execute custom components 600 implemented in native code. Custom components 600 may contain components for implementing arbitrary functions such as batch processing, input / output processing, and cloud service APIs, as well as UI. For example, custom component 600 may be a low-code component related to input / output processing implemented in native code. In this case, custom component 600 includes input / output settings 314. Alternatively, custom component 600 may be a low-code component related to UI such as a field or screen implemented in native code. In this case, custom component 600 includes screen settings 312. Custom component 600 may also include a script 316. Furthermore, custom component 600 may include one or more low-code components related to UI implemented in native code, low-code components related to input / output processing implemented in native code, and scripts 316.

[0070] <Information processing device that runs applications> Figure 7 shows an example configuration of an information processing device 700 used for developing and / or running application 20. The information processing device 700 may include a server, personal computer, tablet, smartphone, wearable device, cloud environment, virtual machine, and some or all of these. The information processing device 700 used for developing application 20 and the information processing device 700 used to run application 20 may be the same or different. The functionality of the low-code library 14 and application 20 can be realized by running the program on the hardware shown in Figure 7.

[0071] The information processing device 700 includes a processor 701, memory 702, storage 703, external device IF 704, input IF 705, output IF 706, and communication IF 707. The information processing device 700 also includes a bus 708 that connects these components. The information processing device 700 may have two or more of each component, or it may not have some of the components.

[0072] The processor 701 can read the application 20 from the storage 703 into the memory 702 and execute the application 20. The processor 701 is composed of, for example, at least one integrated circuit. According to one embodiment, the integrated circuit may include at least one CPU (Central Processing Unit), at least one GPU (Graphics Processing Unit), at least one FPGA (Field Programmable Gate Array), at least one ASIC (Application Specific Integrated Circuit), at least one AI (Artificial Intelligence) chip, or a combination thereof.

[0073] Memory 702 functions as a workspace for processor 701. Memory 702 stores programs executed by processor 701 and data referenced by processor 701. Memory 702 can be implemented using DRAM (Dynamic Random Access Memory) or SRAM (Static Random Access Memory), etc.

[0074] Storage 703 is non-volatile memory that stores programs executed by processor 701 and data referenced by processor 701. Processor 701 executes programs read from storage 703 to memory 702 and references data read from storage 703 to memory 702. Storage 703 can be implemented by HDD (Hard Disk Drive), SSD (Solid State Drive), EPROM (Erasable Programmable Read Only Memory), EEPROM (Electrically Erasable Programmable Read Only Memory), or flash memory, etc.

[0075] The external device IF704 can be connected to any external device such as a printer, scanner, and external HDD. The external device IF704 can be implemented using a USB (Universal Serial Bus) terminal or the like.

[0076] The Input IF705 can be connected to any input device such as a keyboard, mouse, touchpad, or gamepad. The Input IF705 can be implemented using a USB terminal, PS / 2 terminal, or Bluetooth® module.

[0077] Output IF706 can be connected to any output device such as a CRT display, LCD display, or OLED display. Output IF706 can be implemented using USB terminals, D-sub terminals, DVI (Digital Visual Interface) terminals, HDMI® (High-Definition Multimedia Interface) terminals, and DisplayPort terminals, etc.

[0078] The communication IF707 is connected to other devices via a wired or wireless network. The communication IF707 can be implemented using a wired LAN (Local Area Network) port and a Wi-Fi® (Wireless Fidelity) module, etc. The communication IF707 can send and receive data using communication protocols such as TCP / IP (Transmission Control Protocol / Internet Protocol) and UDP (User Datagram Protocol).

[0079] <Summary> As described above, the low-code library 14 according to this embodiment can incorporate low-code development functionality into a user's application. An application 20 incorporating the low-code library 14 functions as a low-code platform that is not restricted by the execution environment. Therefore, the user can distribute the application 20. Furthermore, as an example, by using the low-code development functionality of application 20, the user can develop an application in a shorter time and at a lower cost compared to full-scratch development.

[0080] Furthermore, the low-code library 14 can provide users with significantly higher extensibility compared to conventional low-code platforms 1. For example, the low-code execution engine 320 can call native code 11 contained in the application 20 via a script 316. As another example, the user can create a custom component 600 using the native code. The low-code execution engine 320 can use the custom component 600 in the same way as a regular low-code component 300.

[0081] The embodiments disclosed herein should be considered in all respects as illustrative and not restrictive. The scope of this disclosure is indicated by the claims rather than the foregoing description, and all modifications are intended to be included in the sense and scope equivalent to the claims. Furthermore, the disclosures described in the embodiments and each variation are intended to be implemented, as far as possible, individually or in combination. [Explanation of Symbols]

[0082] 1 Low-code platform, 2,3,220 low-code applications, 10,20 applications, 11 native code, 12 database, 13 other libraries, 14 low-code libraries, 30,40 custom applications, 210 designer screens, 230 empty applications, 240 business applications, 300 low-code components, 310 component settings, 312 screen settings, 314 input / output settings, 316 scripts, 320 low-code execution engine, 330 low-code designer applications, 410 solution explorer, 420 toolbox, 430 editor, 440 properties, 600 custom components, 700 information processing units, 701 processor, 702 memory, 703 storage, 704 external device interface, 705 input interface, 706 output interface, 707 communication interface, 708 bus.

Claims

1. This is a program for integrating low-code development capabilities into an application. It is provided as a library that can be embedded in the aforementioned application, One or more low-code components that can be added to a low-code application developed on the aforementioned application, The system includes a low-code execution engine for executing the low-code application, which is composed of one or more low-code components. Each of the one or more low-code components includes a component setting having at least one of one screen settings, one or more input / output settings, and one or more scripts. The low-code execution engine is a program configured to execute one or more of the following based on the component settings: screen drawing, input / output processing, and script processing of the low-code application.

2. The one or more scripts mentioned above are configured to be callable by functions implemented in native code, The program according to claim 1, wherein the low-code execution engine is configured to execute the functions implemented in native code via one or more scripts.

3. The aforementioned one or more low-code components are configured to contain a UI (User Interface) implemented in native code, The program according to claim 1, wherein the low-code execution engine is configured to display the UI implemented in native code.

4. The one or more low-code components are configured to contain custom components implemented in native code. The program according to claim 1, wherein the low-code execution engine is configured to execute the custom component implemented in native code.

5. The screens of the aforementioned low-code application are created using the designer screen. The program according to any one of claims 1 to 4, wherein the low-code execution engine is configured to read the component settings of each of the low-code components included in the low-code application created by the designer screen.

Images