Method for executing and transferring computer programs in a computer network, in particular for controlling microscopes
By providing multiple execution environment databases in the computer network, the problem of lack of flexibility in computer program execution in the prior art is solved, complex function calls and program flow control are realized, and development and execution efficiency is improved.
Patent Information
- Application Number
- CN201980006173.5
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Priority Date
- 2018-03-01
- Filing Date
- 2019-02-28
- Publication Date
- 2025-04-15
- Estimated Expiration
- 2039-09-11
AI Technical Summary
The prior art lacks flexibility when executing computer programs in computer networks and cannot effectively handle complex function calls and program flow control, resulting in inefficient program development and execution.
By providing multiple databases of different execution environments in a computer network, computer programs allow calls to multiple functions and handle the passing of function return values through explicit or implicit buffer storage mechanisms, supporting complex function calls and program flow control.
It realizes more flexible design and execution of computer programs in computer networks, simplifies the program development process, improves execution efficiency, and reduces the energy consumption of computing networks.
Smart Images
Figure CN111448547B_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the execution of computer programs in a computer network, in particular for controlling a microscope. Such a computer network may also be referred to as a computing cloud. It goes without saying that the present invention relates not only to computer networks provided by a service provider ("public cloud"), but also to computer networks operated exclusively for the organization executing the computer program ("private cloud"), or to hybrid forms of these.
[0002] The invention also relates to a method of converting a computer program from one representation into another, in particular into a machine-executable representation.
[0003] For the purposes of this invention, a computer program is a sequence of computing instructions, particularly function calls. Background Art
[0004] In a computer network, physical computers or virtual computers can be connected to each other, for example via networks such as "Ethernet" (IEEE 802.3) and "WLAN" (IEEE 802.11) or bus systems such as "CAN" (ISO 11898), "FireWire" (IEEE 1394). For example, virtual computers can be connected via virtual network interfaces.
[0005] In a computer network, individual functions of a computer program may be in the form of program files (hereinafter also referred to as executable modules) that are separately executable in different execution environments, e.g., exactly one function (and thus one executable module) per execution environment. A call to the function will then start the associated executable module in its execution environment. The execution environment may be a virtual machine or a (virtual) container.
[0006] The virtual machine contains not only executable modules (including any library files dynamically linked to the executable file), but also the operating system kernel. The virtual machine may contain other files or other data (such as databases) required for the execution of the module, and may simulate the existence of the computer through software. The computer is virtual.
[0007] On the other hand, containers do not contain an operating system kernel. In this instance, virtualization occurs at the level of the application environment, that is, the runtime environment of the executable module. Modules running on the same computer in different containers use the same operating system kernel - the core of the computer. Other resources of the computer can be divided between multiple containers or shared by them. However, containers are isolated from each other and basically from the rest of the computer. Only defined resources of the computer can be accessed from the container (such as a specific file or directory). An environment separated from other containers and other system resources is called a namespace. Libraries, files and other data contained in a namespace can only be used by (multiple) modules contained in the same namespace. However, they are not accessible from containers outside the namespace.
[0008] For example, the Linux operating system provides containers and namespaces via the interfaces "LXC", "LXD" or "runc" and known control groups (cgroups). For example, the software "Docker" (http: / / www.docker.com) provides container management.
[0009] In the prior art, the project "dray" (http: / / dray.it) discloses the automatic execution of computer programs in a computer network by means of containers managed by Docker. Similar to anonymous pipes, multiple functions are called in sequence, which are contained in different containers in the form of corresponding executable program files. The return value of each called function is passed as an input parameter to the next function. For this purpose, the return value is read in a) from the standard output channel (stdout) or b) from the standard error output channel (stderr) or c) from a file previously specified by name and automatically passed to the directly next function via its standard input channel (stdin). The container is automatically started and ended as required (that is, for example, when the contained function is called).
[0010] Compared to anonymous pipes, encapsulating functions as executable modules in isolated containers has several advantages. In addition to improving security, robustness, and scalability, it is easier to maintain modules, including their dependencies (libraries), independent of the dependencies of other modules.
[0011] However, a disadvantage of the known solution is that only rigid procedures can be performed. Therefore, the executable computer program is not flexible. Summary of the invention
[0012] The object of the invention is to improve a method of the type cited at the outset and a corresponding device such that a computer program can be designed and executed more flexibly. According to certain aspects, it is also believed that the development of computer programs is simplified and accelerated.
[0013] This object is achieved by a method having the features specified hereinafter and by a device having the features specified hereinafter.
[0014] Advantageous developments of the invention are specified below.
[0015] Within the context of the present invention, it is recognized that greater flexibility can be achieved in executing computer programs in a computer network, since in the case of at least one function call to a related function, multiple return values from multiple preceding function calls can be transmitted as separate parameters. For each function call, the container is preferably loaded as an execution environment and unloaded again when the called function is completed.
[0016] While, for example, the prior art involves closing the container after the first function has finished and its return value has been read and the read value is simply copied to the standard input channel of the second function and then discarded, the more flexible form proposed here requires that each return value be buffered, either explicitly in a variable specified in the computer program, or implicitly in a memory not accessible by explicit instructions of the computer program if the first function in the computer program to be executed is directly included as a parameter (function parameter) in the call to the second function. This allows function calls to be significantly more complex and flexible.
[0017] Other functions called in a computer program may have one or more parameters (function parameters) passed to them, or they may be parameterless. Each function may return one or more values, or may have no return value. The values returned by a function may be explicitly buffered as the contents of a variable and / or passed directly in a function call as parameters to the function. The contents of a variable may be passed as parameters during a subsequent function call.
[0018] Therefore, the following steps are provided for executing a computer program:
[0019] - providing a computer network, said computer network comprising at least two computers connected to each other via a network, each computer having its own main memory,
[0020] - providing at least three different images of an execution environment, each of said images comprising a respective executable module, wherein each of these modules provides a respective function (which returns at least one result value), and said execution environment containing the module is executable on at least one of said computers in its own namespace; wherein said module calls the operating system kernel of the associated computer and the execution environment returns a value output by the module as a result of the function provided by it,
[0021] - receiving a computer program having at least a) a first instruction that calls a first function that returns a first result value; b) a second instruction that calls a second function that returns a second result value, and c) a third instruction that calls a third function with the first result value as a first parameter and with the second result value as a second parameter,
[0022] - starting the execution environment with the module providing the first function, and receiving its return value as the first result value,
[0023] - starting the execution environment with the module providing the second function, and receiving its return value as the second result value,
[0024] - starting an execution environment with a module providing said third function, wherein said first result value and said second result value are passed as parameters to said module.
[0025] Within the context of the present invention, it is also recognized that greater flexibility can be achieved in the execution of computer programs in a computer network, because the computer program has not only function calls but also instructions for controlling the program flow, such as instructions for conditionally executing program segments and jump instructions (conditional or unconditional).
[0026] Therefore, the following steps are provided for executing a computer program:
[0027] - providing a computer network, said computer network comprising at least two computers connected to each other via a network, each computer having its own main memory,
[0028] - providing a plurality of different images of an execution environment, each of said images comprising a respective executable module, wherein each of these modules provides a respective function (which returns at least one result value), and the execution environment containing the module is executable on at least one of said computers in its own namespace, wherein said module calls the operating system kernel of the associated computer, and the execution environment returns a value output by the module as a result of the function provided by it,
[0029] - receiving a computer program having at least a) a first instruction, which calls a first function that returns a first result value; b) a second instruction, which contains a condition based on the first result value, and c) a third instruction, which calls a third function,
[0030] - starting the execution environment with the module providing the first function, and receiving its return value as the first result value,
[0031] - checking the condition indicated in said second instruction,
[0032] - determining that the condition is satisfied, and starting an execution environment with a module providing the third function.
[0033] According to a specific aspect, it is also recognized in the context of the present invention that the development of computer programs can be simplified and accelerated by providing a database in a computer network in which the computer program is to be executed, the database containing the execution environment of the function modules and the interface definition thereof, wherein the interface definition of the execution environment (or the modules contained therein) includes the data type of the result value of the contained module and the data type (s) of the (s) parameter (s) of the contained module.
[0034] In this way, static typing of variables and function parameters can be implemented and checked. Runtime errors can thus be avoided in favor of compile-time errors, which simplifies and speeds up the entire development process. In the prior art, incorrect data types can only be identified at runtime, which means that the correction cycle is significantly longer.
[0035] The database containing the execution environment can be advantageously configured so that, in addition to having a first interface definition of the data type of the result value and parameter of each of the modules, it also contains a second interface definition of the user input interactively expected by the relevant module, conveniently also including the corresponding data type of (multiple) user input. In this way, user input can be received at any time during execution. However, in particular, the computer program can advantageously be executed so that all user inputs of all modules are queried and received before even starting to execute the computer program, which means that the process will not be interrupted indefinitely by user queries. Another advantage is that the same module can be used in a large number of different computer programs without changing the content. Through two interface definitions (data types of result values and parameters, and parameters to be received interactively).
[0036] Conveniently, the database may contain the corresponding execution environments in reference and / or image form.
[0037] Therefore, the following steps are provided for converting a computer program from one representation to another, in particular to a machine executable representation:
[0038] - providing a computer network, said computer network comprising at least two computers connected to each other via a network, each computer having its own main memory,
[0039] - providing a database containing a plurality of different execution environments, each of said database comprising respective executable modules, wherein each of these modules provides a respective function (which returns at least one result value), and the execution environment containing the module is executable on at least one of said computers in its own namespace, wherein said module calls an operating system kernel of the relevant computer, and the working environment returns a value output by the module as a result of the function thus provided, wherein said database contains, in addition to each of said modules, its own interface definition and is connected to a network, said interface definition describing the function provided by the relevant module,
[0040] - reading a computer program having at least a) a first instruction that calls a first function that returns a result value; b) a second instruction that calls a second function that takes the received result value of the first function as a parameter,
[0041] - reading in from the database a first interface definition of a first module providing the first function, wherein the first interface definition describes the first function by means of at least one data type which contains a result value of the first function,
[0042] - reading in from the database a second interface definition of a second module providing the second function, wherein the second interface definition describes the second function by means of at least one data type it contains for a parameter of the second function, and
[0043] - comparing the data type of the result value of the first function with the data type of the argument of the second function,
[0044] - determine inequality between two data types, and
[0045] -Send an error to the input device and / or terminate the conversion process.
[0046] The first instruction and the second instruction may be identical by virtue of the result value of the first function being transmitted as a parameter of the second function. In particular, in such an example, the first function and the second function may be identical by virtue of recursively calling the function.
[0047] When the converted program instructions are executed, the instructions contained in the converted representation are executed, and it is advantageously determined that, for one of the instructions, the function called in the instruction is provided by one of the execution environments contained in the database, and then i) the relevant execution environment is loaded onto one of the computers; ii) the module contained therein is executed on the relevant computer; iii) the value output by the module is read in as the result value of the function provided by the module.
[0048] After the result value is read in, the associated execution environment can be unloaded in step iv). Loading as needed and unloading after the function call is completed reduces the energy consumption of the computer network and reduces the participation cost.
[0049] In a particularly advantageous embodiment, the microscope is connected to the network via a control computer and, when one of the instructions contained in the converted representation is executed, a control instruction is transmitted from the executing computer to the microscope, in particular triggering image recording on the microscope, wherein the recorded image is transmitted from the control computer to one of the other computers. In this way, if it is determined during the execution of the computer program that an image previously recorded with the microscope and transmitted in the computer network does not meet a predetermined criterion, the image recording can be repeated, in particular without delays due to user interaction. Such a criterion can be, for example, a threshold value for an image quality measurement or a threshold value for a number of identifiable fluorescent markers.
[0050] In this case, the prior art requires termination of the execution of the computer program after a new manually triggered image recording and repetition of the entire process. Advantageously, with embodiments according to the invention, only the image recording and the instructions of the computer program directly or indirectly derived from the recorded images need to be repeated.
[0051] Conveniently, none of the execution environments contains an operating system kernel that can be called by the relevant modules. The modules are then advantageously provided only by container virtualization.
[0052] Furthermore, it may be advantageous to provide the execution environment contained in the database in a stateless manner.
[0053] In other advantageous embodiments, before the instructions contained in the computer program are executed, the possible calculation time and the call frequency are predicted for each function contained in the computer program. In this way, the expected total calculation time and the expected execution duration can be determined. Before the execution starts, one or both of these variables can be displayed to the user via a control element for terminating the execution, so that the user can terminate the execution in time.
[0054] The present invention also includes a computer network configured to perform any of the above methods, in particular having a microscope connected to the computer network via a control computer, wherein the control computer is configured so that it receives control instructions for the microscope from one of the other computers and controls the microscope according to the instructions.
[0055] The present invention allows to greatly simplify and automate complex workflows in microscopy without requiring the user to know the details of the process. The user only needs to place the sample to be examined under the microscope and start the workflow in the form of a computer program executed in the computing cloud. If necessary, the user is then asked to provide predetermined inputs. BRIEF DESCRIPTION OF THE DRAWINGS
[0056] The present invention is explained in more detail below based on exemplary embodiments.
[0057] In the attached figure:
[0058] Figure 1 shows a computer network with a microscope,
[0059] FIG. 2 shows three modules and their interfaces provided in the corresponding execution environment, and
[0060] Figure 3 A flow chart showing a computer program executed on a computer network.
[0061] In all the figures, corresponding parts are provided with the same reference numerals. DETAILED DESCRIPTION
[0062] Figure 1 Schematically shown is a computer network V in the form of a computing cloud, which, purely by way of example, comprises three computers 1 / 2 / 3, which are connected to one another via an Ethernet switch 6, a database server 4 and an access point server 5. The access point server 5 is accessible from the Internet 7. A microscope 8 with a control computer 9 is connected to the access point server 5 via the Internet 7 and, via the latter, to the computer network V. Alternatively, further computers can be arranged between the control computer 9 and the Internet 7, which have a user interface and form an input device. In this way, the computer program can in particular contain instructions with image data, which trigger the display of these image data on other computers.
[0063] Each of the computers 1 / 2 / 3 / 4 / 5 has its own processor and its own main memory. They are therefore physical computers. For the sake of clarity, only the processor 1.1 and the main memory 1.2 of the first computer 1 are provided with reference numerals. For example, a Linux operating system with containers and control groups is provided on each of the computers 1 / 2 / 3 / 4 / 5. The computers 1 / 2 / 3 together form a Docker cluster.
[0064] The database of the database server 4 contains multiple images as containers of execution environments of the same number of executable modules, each module providing exactly one corresponding function that accepts a non-negative natural number of parameters and returns a result value at the end of its execution. The database also contains a first interface definition for each of these functions, which describes the number of parameters of the function and the data type of the parameters. In addition, the database contains a second interface definition for each of the functions, which describes several user inputs that the relevant modules expect to interact with and the data type of the user inputs. In addition, the database can also contain a version declaration for each execution environment. This allows different versions of the same module to be provided in parallel. This makes the new version of the module available without adjusting the existing computer program. For this reason, the required version of the function can be specified as a meta parameter when calling the function.
[0065] The execution environments are executable on computers 1 / 2 / 3 in their own corresponding namespaces to call the operating system kernel of the relevant computers, because they do not contain the operating system kernel themselves as containers. For this reason, they can be made and started by Docker. The Docker cluster automatically determines on which computer 1 / 2 / 3 to load (generate from its image) and expand the execution environment to be started. In each execution environment, in order to execute the provided function, the parameters required by the executable module contained are set to, for example, (multiple) environment variables. For example, the executable module can then read them as its parameters. At the end of execution, it outputs the result of the function, for example in a file specified as a parameter or on a standard output channel.
[0066] Modules can be written in any (even different) programming language and use any library. They only need to behave according to the interface definition regarding parameters accepted and result values returned. Other images with versions of the module can be installed into the database without any effort. To this end, the database
[0067] To execute the computer program in the computer network V, the access point server 5 receives the computer program in machine-executable form, for example from the control computer 9 or from a network server (not shown), which can in particular be part of the computer network V.
[0068] As an example, a user may first enter a computer program in an editor (e.g., on the other computer or on the network server) in the language of a specific application (domain-specific language), or load the computer program from a mass storage device. The editor may graphically represent the computer program in the language of a specific application, for example, in text form and / or as a flowchart. The user may edit the computer program in text form or in graphical form. When appropriate, the editor will automatically change the flowchart in the text form of the computer program. Conversely, when appropriate, the text form will also be automatically changed in the flowchart. Before executing the computer program, it is converted from the representation of the language of the specific application to a machine executable representation within the computer network V (e.g., on the control computer 9 or the network server). The intermediate conversion of the language of the specific application into other programming languages may occur before the conversion of other programming languages into machine executable representations.
[0069] For conversion, first read in the language of the specific application program. If a first instruction and a second instruction are identified, the first instruction calls a first function that returns a result value and the second instruction calls a second function with the result value of the received first function as a parameter, then read in the interface definition of the module providing the two functions from the database and compare the data type described therein of the result value of the first function with the data type described therein of the relevant parameter of the second function. If it is found that they are not equal, then first a check is performed to determine whether both cases involve image data types. If so, the representation of the conversion of the computer program has an instruction inserted therein, which calls a function that converts the result value into the image data type of the relevant parameter. In particular, the function call can be performed like other function calls of the computer program by executing the modules contained in the database in the execution environment. Therefore, the computer program can contain a fast call to the same function, instead of performing this implicit type conversion by transparent function calls.
[0070] If it is determined that the different data types are not two image data types, an error is sent to the user's input device, that is, in this example to the aforementioned other computer or the aforementioned network server, in particular the editor there, and / or the conversion process is terminated. The editor can visually inform the user of the different data types so that the user can correct the program error without having to first execute the computer program in a time-consuming manner until the erroneous instruction.
[0071] The computer system V is equipped so that, during the execution of a computer program, it records the loading of all execution environments required for this purpose and the execution of all modules contained therein (including the parameters transmitted to them), and in particular their periodic completion (including the relevant result values and the required calculation time) in a database, for example, of a database server 4. This means that after the system stops running, whether due to a crash or due to periodic maintenance, the execution can be resumed using the last incompletely executed or unexecuted module, without having to repeat the function call that has already succeeded. This also applies if multiple computer programs are executed in parallel. For each computer program to be executed on the computer network, the recording is carried out separately.
[0072] The recorded actually required computing time can be used in particular to predict the expected computing time.
[0073] Advantageously, a computer program that has been executed once can be executed again in a shorter time after only partial changes have been made to its instructions or input data. To this end, the execution protocol is used to determine which instructions remain unchanged in all function modules in the computer program and in all function modules called by each of the instructions, that is, in the parameters used by the instructions. Because files external to the computer program can also be transmitted as parameters to the functions of the program (for example, via a file path or URL statement), it is also determined that there are no changes in this regard. When the computer program is executed again, only those instructions that are determined to be unchanged are actually executed. For all instructions that are determined to be unchanged, the return value of the last call will be loaded from the database instead.
[0074] One or more functions called by the computer program can trigger the image recording on the microscope 8 by means of the control computer 9 and transmit suitable commands via the Internet 7. The control computer then sends the image data determined as part of the image recording to the computer network V via the Internet 7. There they can be stored, for example, on a database server 4. After complete receipt of the image data, the module providing the relevant function returns an object as result value, which represents the image data and can be specified as a parameter in a subsequent call to an image processing function.
[0075] FIG. 2 schematically shows three different modules included in the execution environment, for example, the image and interface definition of the module are included in Figure 1 in the database shown.
[0076] Figure element 2A depicts a module with a function "FunkA", which does not accept any input parameters, does not require interactive user input, but returns exactly one result value OUT1, for example of the image data object type. For example, the function provided by the module triggers image recording in a connected microscope 8 and returns the recorded image as result value.
[0077] Figure element 2B depicts a module with a "FunkB" function that accepts exactly one parameter IN1 (e.g., again of image data object type), requires two interactive user inputs, and returns exactly one result value OUT2 (e.g., again of image data object type). For example, the user inputs need to be of floating point number and color value types. The function provided by the module segments the received image data based on two digital values, e.g., input by the user, which specify, for example, a threshold and a dye. The detected segments are returned as result values OUT2 of object list data type.
[0078] Figure element 2C depicts a module with a "FunkC" function that accepts exactly two parameters IN2 (e.g., image data object type) and IN3 (e.g., object list type) and does not require any interactive user input, but returns exactly one result value OUT3, for example in the case of such an integer type. The function provided by this module classifies each object represented by an image segment contained in the accepted object list IN2, for example, based on the image data in the image segment. The image data from the accepted image IN2 is used for this purpose. The function then returns an object list OUT3, which contains a class statement for each segment contained in IN3.
[0079] Computer programs can be designed using the following three modules, for example:
[0080] img:=FunkA()
[0081] sgm:=FunkB(img)
[0082] cls:=FunkC(img,sgm)
[0083] Here, "img", "sgm" and "cls" are variable identifiers to which memory locations are assigned. The returned result value is stored in the associated memory location and is read again and passed to the relevant function when the variable is used as a function parameter.
[0084] Figure 3 The sequence of the converted computer program is schematically shown in steps S1-S7, each step calling a function by starting an executable module contained in the database in a corresponding execution environment. The computer program contains a plurality of instructions, each of which includes a condition based on a previously determined result value of one of the referenced functions. During program execution, when a conditional instruction (e.g. a conditional jump) is reached, the condition is checked and the conditional instruction is executed only if the check shows that the condition is met.
[0085] In this way, conditional jumps can be used to provide an execution loop or alternatively provide a branch after step S3. Therefore, further branches can be implemented by conditional jumps after step S5.
[0086] Reference numerals list
[0087] V Computer Network
[0088] 1 First Computer
[0089] 1.1 Processor
[0090] 1.2 Main Memory
[0091] 2 Second Computer
[0092] 3 Third Computer
[0093] 4 Database Server
[0094] 5 Access Point Server
[0095] 6 Switches
[0096] 7 Internet
[0097] 8 Microscope
[0098] 9 Control Computer
Claims
1. A method for automating complex work procedures in a microscope by executing a computer program in a computer network, comprising the following steps: The computer network comprises at least two computers connected to each other via a network, each computer having its own main memory. The user positions the sample to be examined in a microscope which is connected to the computer network via a control computer. providing a database containing a plurality of different execution environments, each of said database comprising a respective executable module, wherein each of said modules provides a respective function, and the execution environment containing said module is executable on at least one of said computers in its own namespace, wherein said module calls an operating system kernel of the relevant computer, and said execution environment returns a value output by said module as a result of the function provided thereby, wherein said database contains in addition to each of said modules its own interface definition and is connected to said network, said interface definition describing the function provided by the relevant module, receiving a computer program via the computer network, the computer program having at least a) a first instruction that calls a first function that returns a first result value; b) a second instruction that calls a second function that returns a second result value, and c) a third instruction that calls a third function with the first result value as a first parameter and with the second result value as a second parameter, The user starts the working program in the form of the computer program, Through the computer network, starting an execution environment with a module providing the first function, and receiving its return value as a first result value, Through the computer network, starting the execution environment with the module providing the second function, and receiving its return value as the second result value, An execution environment is started via the computer network with a module providing the third function, wherein the first result value and the second result value are transferred to the module as parameters.
2. The method according to claim 1, further comprising: A database containing the execution environment is provided, wherein, in addition to each of the modules, the database contains its own interface definition and is connected to the network, the interface definition describing the functions provided by the relevant module.
3. A method for automating complex work procedures in a microscope by executing a computer program in a computer network, comprising the following steps: The computer network comprises at least two computers connected to each other via a network, each computer having its own main memory. The user positions the sample to be examined in a microscope which is connected to the computer network via a control computer. providing a database containing a plurality of different execution environments, each of said database comprising a respective executable module, wherein each of said modules provides a respective function, and the execution environment containing said module is executable on at least one of said computers in its own namespace, wherein said module calls an operating system kernel of the relevant computer, and said execution environment returns a value output by said module as a result of the function provided thereby, wherein said database contains in addition to each of said modules its own interface definition and is connected to said network, said interface definition describing the function provided by the relevant module, receiving a computer program via the computer network, the computer program having at least a) a first instruction that calls a first function that returns a first result value; b) a second instruction that includes a condition based on the first result value, and c) a third instruction that calls a third function, The user starts the working program in the form of the computer program, Through the computer network, starting an execution environment with a module providing the first function, and receiving its return value as a first result value, checking the condition indicated in the second instruction, It is determined that the condition is satisfied, and an execution environment is started via the computer network with a module providing the third function.
4. The method according to claim 3, further comprising: A database containing the execution environment is provided, wherein, in addition to each of the modules, the database contains its own interface definition and is connected to the network, the interface definition describing the functions provided by the relevant module.
5. The method according to claim 2 or 4, further comprising: The database containing the execution environment is provided such that the database contains, in addition to each of the modules, its own second interface definition, which describes the user inputs expected for the interaction of the relevant module.
6. A method for automating complex working procedures in a microscope by converting a computer program from one representation to another in a computer network, comprising the following steps: The computer network comprises at least two computers connected to each other via a network, each computer having its own main memory. The user positions the sample to be examined in a microscope which is connected to the computer network via a control computer. providing a database containing a plurality of different execution environments, each of said database comprising a respective executable module, wherein each of said modules provides a respective function, and the execution environment containing said module is executable on at least one of said computers in its own namespace, wherein said module calls an operating system kernel of the relevant computer, and said execution environment returns a value output by said module as a result of the function provided thereby, wherein said database contains in addition to each of said modules its own interface definition and is connected to said network, said interface definition describing the function provided by the relevant module, A computer program is read in via the computer network, the computer program having at least a) a first instruction, the first instruction calling a first function that returns a result value; and b) a second instruction, the second instruction calling a second function that uses the result value received by the first function as a parameter, The user starts the working program in the form of the computer program, reading in a first interface definition of a first module providing the first function from the database via the computer network, wherein the first interface definition describes the first function by means of at least one data type containing its result value, A second interface definition of a second module providing the second function is read from the database via the computer network, wherein the second interface definition describes the second function by means of at least one data type of a parameter of the second function, and comparing the data type of the result value of the first function with the data type of the argument of the second function, Determine inequality between two data types, and Sends an error to the input device and / or terminates the conversion process.
7. The method according to claim 6, wherein: The method is for converting the computer program from a representation into a machine executable representation.
8. The method according to claim 6, wherein: For the execution environment contained therein, the database contains not only the interface definitions of the provided functions, but also the interface definitions of additional parameters to be received by the input device.
9. A method of executing a computer program, the computer program being converted according to the method of claim 6, wherein: The instructions contained in the converted representation are executed and it is determined that, for one of the instructions, the function called in the instruction is provided by one of the execution environments, and then i) the relevant execution environment is loaded onto one of the computers; ii) the module contained therein is executed on the relevant computer; iii) the value output by the module is read in as the result value of the function provided by the module.
10. The method according to claim 9, wherein: After reading in the result value, iv) uninstalling the related execution environment.
11. The method according to any one of claims 1, 3, 6 and 9, wherein: The microscope is connected to the network via a control computer and when one of the instructions contained in the converted representation is executed, the control instructions are transmitted from the executing computer to the microscope.
12. The method according to claim 11, wherein: The control instructions are transmitted from the executing computer to the microscope to trigger image recording on the microscope, wherein the recorded image is transmitted from the controlling computer to one of the other computers.
13. The method according to any one of claims 1, 3, 6 and 9, wherein: None of the execution environments contains an operating system kernel that can be called by the dependent modules.
14. The method according to any one of claims 2, 4, 6 and 9, wherein: The database contains the execution environment in the form of corresponding references and / or images.
15. The method according to any one of claims 2, 4, 6 and 9, wherein: The interface definitions contained in the database for the functions provided by the modules include data types of input parameters and data types of result values of the corresponding functions.
16. The method according to any one of claims 2, 4, 6 and 9, wherein: The execution environment contained in the database is stateless.
17. The method according to any one of claims 1 to 4 or 9 to 10, wherein: Before instructions contained in the computer program are executed, a possible computation time and calling frequency are predicted for each function contained in the computer program.
18. The method of any one of claims 1, 3, 6 and 9, wherein all interactive user input for all modules is requested and received prior to commencing execution of the computer program.
19. A computer network configured to perform the method according to any one of claims 1 to 18.
20. The computer network of claim 19, wherein: The computer network has a microscope connected to the computer network via a control computer, wherein the control computer is configured such that it receives control instructions for the microscope from one of the other computers and controls the microscope according to the instructions.