WO2020242365A1

WO2020242365A1 - Method and system for generating computer controlling instructions

Info

Publication number: WO2020242365A1
Application number: PCT/SE2020/050529
Authority: WO
Inventors: Stig Ottosson
Original assignee: Tervix Ab
Priority date: 2019-05-24
Filing date: 2020-05-25
Publication date: 2020-12-03

Abstract

The present invention relates to a system and method, which when executed by a processing unit (120) of a computer (900) generates a set of computer readable instructions. The method comprising: using a first digital diagram (10) that represents flowchart and comprising graphical elements (21-26; 40), analyzing by the processing unit each graphical element to detect each graphical element; accessing a memory (12); enquiring said memory for data corresponding to said graphical element; obtaining a data comprising a computer readable instruction from the memory corresponding to said graphical element; and constructing an instruction set by adding each computer readable instruction into a memory space, wherein said instruction set is a computer executable program or part of a computer executable program.

Description

METHOD AND SYSTEM FOR GENERATING COMPUTER CONTROLLING

INSTRUCTIONS

Technical Field

The present invention relates to generating a computer program in general and generating a computer program from a flowchart as bases in particular as well as generating flowcharts. The invention also relates to verifying and validating the generated computer program.

Background

Presently, software programmers manually generate program code (so-called source code) in a preferred program language normally directly from their mind or a sketch of a flowchart, which means that logical errors, bugs, and semantic errors easily are introduced.

To produce source code, one normally first decide the program language to develop the code in, which limits the number of people who can follow and understand the logics of the source code if it is not converted to a flowchart after that the coding has been done. Unfortunately, that is too late and limiting for the creative process, as the structure of a source code should be clear before the programming starts and especially so if other people shall have a good chance to influence the solutions to be programmed.

As commercial possibilities seem not to exist to translate visual flowcharts to automatically generated source code, and as programmers are not error free, bugs (errors) are unintentionally built-in in all manually developed source code. These bugs can be extremely difficult to notice by reading source code and to detect in tests why“Beta testing” by some external testers is used. In many cases, the bugs will appear first in the execution of the program resulting in functional problems and in the worst cases even disasters.

Summary

The present invention provides for methods and systems to simplify and make

programming assignments more effective, standardized, and less time consuming by allowing automatic generation of source code (or object code, machine code, etc.) based on a digital flowchart or similar high-level graphical inputs.

Visualization of the logics that the code shall reflect is an important way to minimize the coding of logical errors. However, visualization does not prevent the generation of code bugs, which is another object of the invention. To solve the problem with semantic errors, for example Artificial Intelligence (Al) can be added before, during or after the automatic programming has been done.

Thus, a method is provided, which when executed by a processing unit of a computer generates a set of computer readable instructions. The method comprises: using a first digital diagram that represents flowchart and comprising graphical elements; analyzing by the processing unit each graphical element to detect each graphical element; accessing a memory; enquiring said memory for data corresponding to said graphical element;

obtaining a data comprising a computer readable instruction from the memory

corresponding to said graphical element; and constructing an instruction set by adding each computer readable instruction into a memory space, wherein said instruction set is a computer executable program or part of a computer executable program. The method may comprises a step of verifying said constructed instruction set by: converting each instruction to a corresponding graphical element; constructing a second digital diagram using the converted graphical elements; and comparing the resulted constructed second digital diagram with the first digital diagram. In one embodiment, the method may comprise using an image analysis to carry out semantic testing with subsequent automatic program code generation. In one embodiment, if a digital flowchart is used, arranging a tag that defines the elements and extracts the contents of the element, after which semantic testing and coding takes place. An Artificial Intelligence module may be used for automatic semantic control. In one embodiment an oral input may be used, which is trained to recognize spoken words to generate elements and insert instruction. In one embodiment, checking instructions may be carried out using an Artificial Intelligence module. The method may comprise analyzing content of each graphical element by the processing unit and using the content as a parameter for the computer readable instruction. In one embodiment, an error message is generated if an element is not present in the database. The computer executable program is a source code, object code or machine code. In one embodiment, the method comprises using predefined elements, each element comprises a container, at least one flexible connection line with an ending connector that can be moved freely and one or several fixed receivers, arranged to receive and locks the ending connector from a previous element when the connector is received at the bottom of the receiver. The method may also comprise disconnecting elements by selecting a locked connector receiver, to be displaced again, for insertion of a new functionality to be added with new elements.

The invention also relates to a system for generating an instruction set from a first digital flowchart. The system comprises: a controller comprising a processing unit; a

communication interface; an arrangement for receiving the digital flowchart. The processing unit is configured: to analyze the digital flowchart and detect graphical elements, each graphical element corresponding to a computer readable instruction, look up in a memory for each graphical element to find a corresponding computer readable instruction; and compile each computer readable instruction to generate a computer readable instruction set. The system may further comprise a portion for validating the computer readable instruction set, comprising a processing unit for converting each computer readable instruction to a graphical element, building a digital flowchart of the graphical elements and comparing the built flowchart with the first flowchart. In one embodiment, the processing unit or an Artificial Intelligence module is configured to analyzing content of each graphical element and using the content as parameter for the computer readable instruction. The system may also comprise a workspace on a monitor and a database comprising predefined elements, each element comprises a container, at least one flexible connection line with an ending connector that can be moved freely and one or several fixed receivers, arranged to receive and locks the ending connector from a previous element when the connector is received at the bottom of the receiver.

The invention also relates to a computer program product, which when executed by a computer generates a set of computer readable instructions. The computer program product comprises: an instruction set for using a first digital diagram that represents flowchart and comprising graphical elements, an instruction set for analyzing by the processing unit each graphical element to detect each graphical element; an instruction set for accessing a memory; an instruction set for enquiring said memory for data corresponding to said graphical element; an instruction set for obtaining a data comprising a computer readable instruction from the memory corresponding to said graphical element; and an instruction set for constructing an instruction set by adding each computer readable instruction into a memory space, wherein said instruction set is a computer executable program or part of a computer executable program.

BRIEF DESCRIPTION OF THE DRAWINGS

Reference is made to the attached drawings, wherein elements having the same reference number designation may represent like elements throughout.

Fig. 1 is a diagram illustrating an exemplary system according to one embodiment of the present invention,

Figs. 2a and 2b are flow diagrams illustrating exemplary processing steps according to one embodiment of the present invention,

Fig. 3 illustrates graphical elements and corresponding instructions according to one

embodiment of the invention;

Figs. 4a-4d illustrates graphical element according to another embodiment of the

invention;

Fig. 5 illustrates a schematic view of a work area for generating flowcharts;

Figs. 6-8 illustrate exemplary steps of generating and modifying flowcharts according to the inventions;

Fig. 9 is an exemplary embodiment of an application in which method described herein may be implemented;

Fig. 10 is an exemplary flowchart of a program to be transferred to source code for

controlling the application according to Fig. 9;

Figs. 11a and 11 b illustrates differences between processes of developing programs in traditional way and according to the present invention; and

Fig. 12 is a diagram of an exemplary system in which method described herein may be implemented.

DETAILED DESCRIPTION

In the following the term“code” or“instruction” as used herein, may refer to a language or parts of a language that is created and used to instruct a computer to carry out a function. It may include a command, i.e. an instruction for the computer to execute a logical task. It also may include functions, function calls, statements, loops, and parameters and attributes to these. In the following, the term“flowchart” as used herein, may refer to a diagram of structured elements, each of which depicts a value, a command, instruction, process, system or computer algorithm.

In the following, the term“computer program” as used herein, may refer to a set of commands, code, instructions, or algorithms.

Briefly, from a (standardized) digital flowchart, the user decides which program language that the program shall be coded in. The system of the invention then generates the code in the decided program language. The code may manually be evaluated and corrected directly in the code or on the digital flow-chart. It can also be run through a commercial code to flow-chart generator to obtain a flowchart to be compared with the initial digital flowchart as a control.

In one embodiment, if the generated flowchart of the code or other existing code needs to be implemented in the source code, it first may be run through a transforming program to be a flowchart that the automatic code generator accepts. By using the principle of embodying code in blocks and labeling them, the total product or program flowchart can be reduced (scaled down/zoom out) and easier to get an overview of. When there is a need for inspection or changes, a block can be scaled up and the changes applied in the flowchart resulting in automatic code generation and control with a reversed flowchart generator.

Consequently, according to the invention, instead of direct programming of functional source code e.g. for steering the behavior of a mechanical machine, medical equipment, or electrical actions, etc., a digital flowchart is developed. The basic idea is to start with deciding a program code language (e.g. C++) the source code to be generated and then, as much as possible, to work within the digital flowchart instead of manually coding in the chosen program code. Existing digital source code to be changed or extended with new functionality can be digitized as a digital flowchart. The programmer then choses a program language that the program shall be programmed in. Next, an automatic program code generator generates code from the digital flowchart in the chosen language. To check that the code is in accordance with the flowchart, it can be checked by running the new code in a system that creates a digital flowchart from the existing code. Preferably, this can be done automatically showing when differences between the original and the (re)generated flowchart exist so that the code can be changed.

If a change in the source code is needed, wanted or wished, the digital flowchart can be used again to make changes from which new code may automatically be generated. Existing code can be inserted in the digital flowchart or into the program code.

In one embodiment, when functional source code written in a program language that normally is not used or has undergone many revisions, e.g. from the time it was introduced on the market, not many people may be present to make desired changes. In that case, the code may be transformed in a digital flowchart where after the flowchart is used to generate a similar program in an updated version of the original program language or in a newer or more popular programming language. Using this development principle may ensure that the new program will work without a problem or will reduce substantially. First after such risk minimizing and confirming tests, it is possible to make changes and additions in the digital flowchart for the automatic generation of these changes of the final source code, likewise.

By using digital flowcharts from which code is automatically generated, people without programming knowledge can be involved in the development before the program development starts or when changes are to be introduced. The result will be fewer bugs and illogical solutions, which in turn will decrease the development time and costs to final program code. In addition, a more standardized program code can be generated that will be easier to follow and analyze by other programmers. This, as manual programming, is individual and that some programmers tend to see it as a piece of art to make creative solutions that may cause more lines of code than needed increasing the risks of getting more bugs in the code and longer execution time, although the computers of today are quick in execution. Looking at a flowchart instead of lines of code, exposes when rationalizations in the algorithms can be done. Shortly, that means a standardized programming will be easier for other people than programmers to understand, correct and change the code.

The overall technical process and system 100 for the Program Code Generator (PCG), according to the invention to produce a source code, is illustrated schematically in Fig. 1. Fig. 2a illustrates exemplary method steps according to one embodiment of the invention. Firstly, a digital flowchart 10 is produced, e.g. in some existing chart generator software or in a specialized chart generator according to the invention, as a digital or digitalized flowchart is needed as input for the automatic PCG 11. The flowchart may also be digitalized, e.g. from a physical paper-top chart, a hand drawn flowchart or printed flowchart, for example by scanning. An image recognition function may be applied to the scanned flowchart prior to input or incorporated in the system input as an option. The flowchart may also be input orally as the oral inputs (e.g. using Siri, Google, Alexa, etc.) become more devolved and can allow executing more complex commands.

When a digital flowchart 10 is uploaded and the generation of source code is executed, the PCG 11 first analyses 201 the digital flowchart, e.g. in an analyzer portion 110. When it recognizes the elements of the flowchart, it looks up 202 for corresponding code, which may be defined in a database 12 or data library. At least one database/library may exist for each program language and the user may first select a programming language, e.g. JAVA, JavaScript, C++, Python, PHP, Shell, etc. The language or languages may also indicate in the digital flowchart. Next, if (203) the element has been recognized, a code from the database 12, corresponding to the element is entered 204 in a source code listing 13 in the PCG. The database 12 may contain one or several tables 121 comprising an element, its corresponding code (in a specific language), information about code argument formats, etc. When looking up for an element in the database, a shape search or a shape definition search, i.e. a definition of the shape to a searchable parameter and using the parameter to search may be use. Clearly, any other suitable search methods may be applied. If the element is not recognized, e.g. due to lack of element definition in the database, wrong shape, bad copy, etc., an error message may be generated or an error element or a blank line may be entered 205 in the source code listing 13. The code generator may automatically copy 206 the content of the element or a data related to the element into the source code for the new program to be generated. When one element with its text, arguments, variable, instructions, etc. is complete, the generator steps to the next element 207 following the arrows in the flowchart and looks up 202 the next element until all elements are analyzed and converted to source code. The generated program code 13 may be deployed for use or evaluated and debugged. The system may also only generate parts, e.g. subroutines, of a program. The program may be generated in a memory and downloaded as a print out, displayed, stored in digital form, in a program execution memory, on a data storage medium, etc. In accordance with one aspect of the invention, a portion of the system 100 may be employed for evaluation. Fig. 2b illustrates exemplary method steps according to one embodiment of the invention for evaluation, verification, validation and/or error detection. When a new program code 13, at least some portion of it or just one code line is completed and generated, it can be evaluated 210 in an evaluation portion 16. The evaluation portion 16 may analyze every code and its contents to verify its correctness and functionality. According to one embodiment, the verification may be carried out by testing each code (line) to find out if the code, its semantics, values, and calls, and returns are correct.

According to one embodiment, the evaluation may be carried out by reversing the code generation, i.e. analyzing the code 211 , and looking up 212 the code for finding corresponding element. If there is a problem with finding the code, an error may be generated 215. If corresponding element to the code is found, an element is inserted 216 in the flowchart structure and its content (calls, variables, values, etc.) are entered 217 as the element content. The operation is continued until (217) all code lines are converted, The resulting flowchart 15 may then be (manually or automatically 16) controlled 218 and compared with the original flowchart 10 to find out that it is in accordance with the intention. If not, the source code may be corrected or changed. In one embodiment, comparison may be carried out each time an element is inserted into the flowchart.

Normally, there are three sources of error: logical errors, bugs, and semantic errors. To solve the problem with semantic errors, for example Artificial Intelligence (Al) can be added after the automatic programming has been done. An Al based module 160 in the valuation portion 16 can solve problems with semantic errors, which are entered into the graphical symbols in the flowchart. In one embodiment, when a function has been generated, tested and approved, it may manually or automatically be embodied in what can be called a“code block” with a label making the original flowchart condensed and possible to expand when its inner structure needs to be checked and/or changed. If/when, it is recognized that an existing code 17 is required or needed to be added to the source code, it first can be transferred to a digital flowchart and subsequently altered to in accordance with requirements and needs, meaning removing or adding features in the digital flowchart. Then the original digital flowchart may be expanded with the new flowchart block.

In one embodiment, the scanned flowchart may be analyzed manually or an image analysis (e.g., Al based analyzer) is required to carry out semantic testing with subsequent manual/automatic program code generation. If a digital flowchart is used, there may be a tag that defines the elements and extracts the contents of the element, after which semantic testing and coding takes place. If there is no tag with the element, it can be printed and handled in the same way as in a hand drawn flowchart. If oral input is used or the corresponding voice-based system, the system may be trained to recognize words such as "If a <b then ...", which generates the symbol/element and inserts the instruction. The instruction can be checked directly with, e.g. Al or when the flowchart is displayed digitally so that correction can be made before programming.

The database or data library 12 includes definitions of the flowchart components. Some exemplary embodiments are illustrated in Fig. 3 together with corresponding definitions, i.e. corresponding code, for example:

Element 21 is to be interpreted as“start” or“end” of instruction set or program;

Element 22 is a predefined“algorithm”;

Element 23 is a“conditional function”;

Element 24 is a“data container” with data included in it;

Element 25 is a“specific process”; and

Line 26 is a“next step” instruction.

Alternative elements, in accordance with one aspect of the present invention, are schematically illustrated in Figs. 4a-4c. These elements are especially designed to simplify and streamline the operation of constructing flowcharts and hence the program code. Each element 40 comprises a container 41 , at least one flexible connection line 42 with an ending connector 43 that can be moved freely in“xy” directions (e.g. using a computer pointing device and in respect to the plane of the workspace) and one or several fixed docking vessels 44. The fixed docking vessel 44 receive and locks the ending connector 43 from a previous element when the connector is received at the bottom of the vessel 44. In one embodiment e.g. by double clicking on a locked connector, it may be released to be able to be displaced again, e.g. if a new functionality is to be added with new elements.

Fig. 4a is a general-purpose element, Fig. 4b is“algorithm” element, Fig. 4c is a “condition” element, and Fig. 4d is a“start/stop” element. The elements for algorithm and condition can be added, e.g. by double clicking anywhere on the element after which the element with content becomes a readable and editable unit.

Fig. 5 illustrates an exemplary GUI 50 with a simple workspace 51 and an element menu 52 containing the exemplary elements 40 as described in Figs. 4a-4d.

Fig. 6 illustrates an exemplary and very simple flowchart 60 compiled using the exemplary elements 40. Each element is picked from the menu 52 and moved to the workspace 51.

In the this example, first a start element is picked, then an algorithm element is picked and its docking vessel is connected to the connector of the start element, another algorithm element is connected to the previous algorithm element, a condition element is connected to the previous algorithm element, additional algorithm elements are connected to connecters of the condition element and finally a stop element is connected to the last algorithm elements.

Fig. 7 illustrates a modified flowchart 70 based on the flowchart 60 of Fig. 6. In this stage, the contents of the containers are inserted. The container, named as“algorithm” may also contain parameters, variables, definitions and values to be used by defined functions, etc. When the flowchart constructions completed the idle connection lines and elements are removed.

The methodology of the present invention for generating and working with flowcharts as described above allows simple rearrangement and modification of the flowchart. By selecting a connection point double clicking and loosening the connection, making blocks of selected elements and moving them facilitates the program construction work. Fig. 8 illustrates a further modified flowchart 80, in which a new block“Name 2” is inserted as described earlier. When the construction of the flowchart is completed, the system may convert it to a conventional flowchart with standard symbols and size. Fig. 9 illustrates an exemplary application. A stairway-platform lift-system 90 for wheel chair users has a platform 91 with flaps and a joystick for the travel up or down of along a frame system 92 using a driving system 93. Via a joystick on the platform, that the user can push in either directions the joystick regulates the current to the electric motor 93 mechanically pushing or dragging the platform up or down.

A principle flowchart of the regulation of the platform based on the position of the joystick is illustrated in Fig. 10. Using a simple exemplary programming language here to transform the flowchart to code by the system and method of the present invention, the result in this simple pseudo source code may be as in following:

1. Start [platform travel]

2. /f [flaps are closed] go to‘4 else go to '3 [close flaps] then go to‘2

4. If [direction = up] go to‘6 [positive current to motor] then‘8 else go to 7 [negative current to motor] then ^'8

8. If [end position has been reached] go to‘9 [zero current to motor] else go to‘4.

10. End [platform travel]

Instructions are indicated in Italic and data (contained in the graphical elements) in brackets.

Figs. 11a and 11 b illustrate difference in working methods between traditional way and what is applicable according to the present invention. Fig. 11a illustrates the traditional process comprising after ordering, the software developer codes, builds the program, tests and releases it. Then the customer/user deploys, operates, monitors and plans, where after the developer makes changes and enhancements and the development loop is continued.

A survey (Kraft, J.:”Felfri kod finns inte”, Elektroniktidningen No. 3 March 2020, pp 28-29) alleges that 12% of manually coded rows have built-in bugs and that about 5% of them are detected first during the execution of the code. Each fix of them costs an average of $ 5200. There is no estimation for what the bad-will costs are.

In Fig. 11b, visualisation has preceded programming. Al is used for semantic control. Thus, the process is extensive before the customer tests beta or uses a program directly so that the three sources of error have been significantly eliminated before both beta testing and use. (Abbreviations and description of content of fig. 11b: BAD = Brain Added Design, MAD = Model Aided Design, PAD = Pencil Aided Design, Monitor = observing, checking, or keeping a continuous record of a software (SW), Plan = to make a detailed proposal for doing or achieving something)

Fig. 12 is a diagram of an exemplary computer 900, in which at least parts of the methods described herein may be implemented. The computer 900 may include a bus 110, a processor 120, a memory 130, a read only memory (ROM) 140, a storage device 150, an input device 160, an output device 170, and a communication interface 180. Bus 110 permits communication among the components of computer 900. The computer 900 may also include one or more power supplies (not shown). One skilled in the art would recognize that computer 900 may be configured in a number of other ways and may include other or different elements.

Processor 120 may include any type of processor or microprocessor that interprets and executes instructions. Processor 120 may also include logic that is able to decode media files, such as audio files, video files, multimedia files, image files, video games, etc., and generate output to, for example, a speaker, a display, etc. Memory 130 may include a random-access memory (RAM) or another dynamic storage device that stores information and instructions for execution by processor 120. Memory 130 may also be used to store temporary variables or other intermediate information during execution of instructions by processor 120.

ROM 140 may include a conventional ROM device and/or another static storage device that stores static information and instructions for processor 120. Storage device 150 may include a magnetic disk or optical disk and its corresponding drive and/or some other type of magnetic or optical recording medium and its corresponding drive for storing information and instructions. Storage device 150 may also include a flash memory (e.g., an electrically erasable programmable read only memory (EEPROM)) device for storing information and instructions.

Input device 160 may include one or more conventional mechanisms that permit a user to input information to the computer 900, such as a keyboard, a keypad, a directional pad, a mouse, a pen, voice recognition, a touch-screen and/or biometric mechanisms, etc. Output device 170 may include one or more conventional mechanisms that output information to the user, including a display, a printer, one or more speakers, etc.

Communication interface 180 may include any transceiver-like mechanism that enables the computer 900 to communicate with other devices and/or systems. For example, communication interface 180 may include a modem or an Ethernet interface to a LAN. Alternatively, or additionally, communication interface 180 may include other mechanisms for communicating via a network, such as a wireless network. For example,

communication interface may include a radio frequency (RF) transmitter and receiver and one or more antennas for transmitting and receiving RF data.

It should be noted that the word“comprising” does not exclude the presence of other elements or steps than those listed and the words“a” or“an” preceding an element do not exclude the presence of a plurality of such elements. It should further be noted that any reference signs do not limit the scope of the claims, that the invention may be

implemented at least in part by means of both hardware and software, and that several “means”,“units” or“devices” may be represented by the same item of hardware.

The above mentioned and described embodiments are only given as examples and should not be limiting to the present invention. Other solutions, uses, objectives, and functions within the scope of the invention as claimed in the below described patent claims should be apparent for the person skilled in the art.

The various embodiments of the present invention described herein is described in the general context of method steps or processes, which may be implemented in one embodiment by a computer program product, embodied in a computer-readable medium, including computer-executable instructions, such as program code, executed by computers in networked environments. A computer-readable medium may include removable and non-removable storage devices including, but not limited to, Read Only Memory (ROM), Random Access Memory (RAM), compact discs (CDs), digital versatile discs (DVD), etc. Generally, program modules may include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Computer-executable instructions, associated data structures, and program modules represent examples of program code for executing steps of the methods disclosed herein. The particular sequence of such executable instructions or associated data structures represents examples of corresponding acts for implementing the functions described in such steps or processes. Software and web implementations of various embodiments of the present invention can be accomplished with standard programming techniques with rule-based logic and other logic to accomplish various database searching steps or processes, correlation steps or processes, comparison steps or processes and decision steps or processes. It should be noted that the words "component" and "module," as used herein and in the following claims, is intended to encompass implementations using one or more lines of software code, and/or hardware implementations, and/or equipment for receiving manual inputs.

Claims

1. A method executed by a processing unit (120) of a computer (900) for generating a set of computer readable instructions, the method comprising:

• using a first digital diagram (10) that represents flowchart and comprising graphical elements (21-26; 40),

• analyzing by the processing unit each graphical element to detect each graphical element;

· accessing a memory (12);

• enquiring said memory for data corresponding to said graphical element;

• obtaining a data comprising a computer readable instruction from the memory corresponding to said graphical element; and

• constructing an instruction set by adding each computer readable instruction into a memory space, wherein said instruction set is a computer executable program or part of a computer executable program.

2. The method of claim 1 , further comprising a step of verifying said constructed

instruction set by:

- converting each instruction to a corresponding graphical element;

constructing a second digital diagram using the converted graphical elements; and

comparing the resulted constructed second digital diagram with the first digital diagram.

3. The method of claim 1 or 2, comprising using an image analysis to carry out semantic testing with subsequent automatic program code generation.

4. The method according to any of claims 1-4, wherein if a digital flowchart is used,

arranging a tag that defines the elements and extracts the contents of the element, after which semantic testing and coding takes place.

5. The method of claim 3 or 4, wherein an Artificial Intelligence module is used for

automatic semantic control.

6. The method of any of previous claims, using an oral input, which is trained to recognize spoken words to generate elements and insert instruction.

7. The method of claim 6, comprising checking instructions using an Artificial Intelligence module.

8. The method of claim 1 or 2, comprising analyzing content of each graphical element by the processing unit and using the content as a parameter for the computer readable instruction.

9. The method according to any of claims 1 - 8, comprising generating an error message if an element is not present in the database (12).

10. The method according to any of previous claims, wherein computer executable

program is a source code, object code or machine code.

11. The method according to any of previous claims, comprising using predefined

elements (40), each element comprises a container (41), at least one flexible connection line (41) with an ending connector (43) that can be moved freely and one or several fixed receivers (44), arranged to receive and locks the ending connector (43) from a previous element when the connector is received at the bottom of the receiver (44).

12. The method of claim 11 , comprising disconnecting elements by selecting a locked connector receiver, to be displaced again, for insertion of a new functionality to be added with new elements.

13. A system (100) for generating an instruction set from a first digital flowchart (10), the system comprising:

a controller (900) comprising a processing unit (120);

a communication interface (160);

an arrangement for receiving the digital flowchart;

characterized in

that the processing unit (120) is configured:

to analyze the digital flowchart and detect graphical elements, each graphical element corresponding to a computer readable instruction, look up in a memory for each graphical element to find a corresponding computer readable instruction; and

compile each computer readable instruction to generate a computer readable instruction set.

14. The system of claim 13, further comprising a portion for validating the computer

readable instruction set, comprising a processing unit for converting each computer readable instruction to a graphical element, building a digital flowchart of the graphical elements and comparing the built flowchart with the first flowchart.

15. The system of claim 13 or 14, wherein the processing unit or an Artificial Intelligence module is configured to analyzing content of each graphical element and using the content as parameter for the computer readable instruction.

16. The system according to any of claims 13-15, comprising a workspace (51) on a

monitor and a database comprising predefined elements (40), each element comprises a container (41), at least one flexible connection line (41) with an ending connector (43) that can be moved freely and one or several fixed receivers (44), arranged to receive and locks the ending connector (43) from a previous element when the connector is received at the bottom of the receiver (44).

17. A computer program product, which when executed by a computer generates a set of computer readable instructions, the computer program product comprising:

• an instruction set for using a first digital diagram (10) that represents flowchart and comprising graphical elements (21-26; 40),

• an instruction set for analyzing by the processing unit each graphical element to detect each graphical element;

• an instruction set for accessing a memory (12);

• an instruction set for enquiring said memory for data corresponding to said

graphical element;

• an instruction set for obtaining a data comprising a computer readable instruction from the memory corresponding to said graphical element; and

• an instruction set for constructing an instruction set by adding each computer readable instruction into a memory space, wherein said instruction set is a computer executable program or part of a computer executable program.