EP3049920A1

EP3049920A1 - Method and device for the automated production and provision of at least one software application

Info

Publication number: EP3049920A1
Application number: EP14789530.4A
Authority: EP
Inventors: Rudolf Markus Petri
Original assignee: Individual
Current assignee: Individual
Priority date: 2013-09-27
Filing date: 2014-09-26
Publication date: 2016-08-03
Also published as: WO2015044374A1; US20160239272A1; US10296305B2

Abstract

The invention relates to a method and to a computer-implemented device for the automated production and provision of at least one client/server based, preferably web-based software application with a user interface for a user. At least the following are provided therefor: an application platform into which a user can log in; at least one client-specific database (CSD), in which the data can be stored; at least one application model (AM) which is stored in the client-specific data base (CSD) and which is used to produce the at least one software application (AW), the function of the software application (AW), a user interface (GUI) and the data structure can be mechanically processed using the application model (AM); and a model engine (ME) on the application platform for access to data of the client-specific database (CSD). According to the invention, the model engine (ME) reads out the application model (AM) during the run-time after a user has logged in, and initially generates, based on the application model (AW), a software application (AW) with application logistics (AL) and user interfaces (GUI) during the run-time. Said application logistics (AL) define the processes which can be performed by the software application (AW) when in operation and the user can access, via the user surface (GUI), data from the client-specific database (CSD). User instructions on the user surface (GUI) relating to a defined data object are transferred during the run-time to the model engine (ME) and the model-engine (ME) permits the user access to the data which is associated with the data object and which is from the client-specific database (CSD) by reverting back to the application model (AM) and the application logistics (AL) created therefrom during the run-time.

Description

Method and device for the automated generation and provision of at least one software application

description

In particular, the present invention relates to a method and a computer-implemented device for the automated generation and provision of at least one client / server-based, preferably web-based software application with a user interface for a user.

The traditional creation and delivery of software applications for use is based on methods and techniques in which software applications are first created by programming and then installed and commissioned in an operating environment.

Software developers first describe the functional data structure in a concrete data model (class model), design the architecture of the program and formulate or "translate" the algorithms to be used into the programming language (source code). Supports technologies, processes, and tools that facilitate or partially automate the process of individual steps in the process.

State of the art in the field of model-driven development of software applications is, for example, the so-called "Model Driven Software Development" (English for "model-driven software development", short MDSD) / "Model Driven Architecture" (English for "model-driven architecture", short MDA ) - Approach that is often supported on the tool side through Integrated Development Environments (IDE) or frameworks. Model Driven Software Development creates the architecture of the application to be created as well as parts of the source code (class model) from a model (diagram in the graphical modeling language "Unified Modeling Language", UML diagram for short). within which the programmer creates an application, ie they usually define the application architecture, the control flow of the application and the interfaces for the specific classes that must be created and registered by the programmer The parts of the source code created using the MDSD method with the IDE or the framework must still be programmed after generation and supplemented with source code for the (graphical) user interface (GUI), the database connection and the interfaces ,

The source code must be translated into machine language after generation, deprogramming and supplementation with a compiler in order to make the program machine-readable and thus executable. Even with changes to existing software, the source code must be regenerated over and over again, bundled into a program and transferred to the runtime environment.

Finally, the created or changed software must be installed on a computer, if necessary configured and put into operation in order to be used by the users.

In summary, in conventional methods for developing and providing client / server-based - preferably web-based - applications, tools must first be used to program the source code of the application, which contains, among other things, the commands to the processor controlling the later application program.

- the source code is translated with tools to machine-readable code and linked / compiled into an application program,

- the application program can be installed on a computer, and

- Run the application program at runtime with a runtime environment and controlled. Common to all current software development and deployment techniques and techniques is that creating or modifying software applications requires defining and mapping the application logic of a software application before translating the source code into machine language and installing and deploying the resulting software application can. This process is often time-consuming and not without programming knowledge and thus usually not possible without software specialists. While greater flexibility and adaptability can be achieved through the use of business rules and / or expert systems that allow, within certain limits, the behavior of a software application to be controlled at runtime and changed without compilation, this is an option The control of all other components and aspects of an application - data management, application logic, user interface - is therefore not possible, and the resulting flexibility only applies to software applications that already exist and in which rule-based technology is implemented. The flexible generation of completely new applications is therefore not possible.

For larger server and database based software systems, e.g. Often in business solutions, in addition to the programming know-how for the installation and commissioning special IT skills are required, which require more IT specialists.

However, with the need for greater agility, the business departments and corporate administration of enterprises of all sizes are increasingly facing the need for rapid availability of software solutions for their current tasks and problems - whether through completely new applications or adapting existing applications to changing requirements and framework conditions , This also applies to the need for solutions that are only needed on a short-term basis or that need only be used interim or project-based.

However, users are typically unable to resolve technical issues related to application creation, deployment, and operation. The previous methods and technologies of software development and supply are therefore not particularly suitable for companies that need to remain agile in the face of growing competition.

Proceeding from this, the object of the present invention is to provide a method and a computer-implementable device with which a client / server-based, preferably web-based software application with a user interface can be generated automatically for a user and can be used for this Allow users to access data from a database without having to install the software application on a user's computer. In addition, the software application should also be adaptable to the needs of the user in a particularly simple manner and require the least possible compilation effort.

This object is achieved in particular both with the method of claim 1 and with the device of claim 15.

Hereby a possibility is proposed, with which automatically from a technically oriented application model at runtime - that is, completely without programming, compilation or installation - client / server-based, preferably web-based software applications generated and in a runtime environment (on an application platform) Usage can be provided. A generated soft application does not have to be compiled or installed either on the (client) computer of a user or on a computer for the application platform, eg a (web) server. Rather, the transition from modeling to using a software application occurs without programming, compilation, and installation, so database building, application logic programming, or user interface configuration are not required to build new or change existing software applications. A method according to the invention with which at least one client / server-based, preferably web-based software application with a user interface-preferably several software applications-is automatically generated and provided comprises at least the following steps: Provision of an application platform into which a user can log in via a network, such as the Internet or an intranet, Provision of at least one client-specific database in which data can be stored

Providing at least one application model stored in the client-specific database for generating the at least one software application, wherein the application model describes the mode of operation - and thus the subject matter, content and configuration - of the software application, a user interface and the data structure, and

Providing a model engine on the application platform for processing at least one application model and the access to data of the client-specific database, wherein in the inventive method further the model engine after logging in a user reads the application model at runtime and only at runtime based on the An application model generates a software application with application logic and user interface, wherein the application logic defines the processes that can be executed by the software application in operation and the user can access data from the client-specific database via the user interface, and

Commands of the user at the user interface concerning a particular data object are passed on to the model engine at runtime and the model engine accesses the user from the client-specific database using the application model and the application logic created at runtime in order to thereby in particular display and / or edit the data and / or enter and store new data.

The field of application of the present invention is thus the creation of (client / server-based, preferably web-based) software applications and their provision on an application platform for immediate use, eg as "software as a service". The application platform thus provides a runtime environment in which software components, such as the model engine, are executable to generate and provide the software application. The application platform therefore has the task of using system tools to combine the software applications defined in application models via the respectively defined configuration with the functional application modules contained in the application platform, make them executable and ready for use. It is thus needed to create a software application at all and provide it to a user. Client-specific here means that on a computer of the application platform, ie in particular on the same server, databases of multiple clients (customers) can be stored without the individual clients have access to each other databases. A client-specific database with an application model to be read can thus be one of several client-specific databases that are stored in a central database of the application platform. Accordingly, several client-specific databases and / or several preconfigured application models can be stored in a database of the application platform.

A model engine is understood to mean a software component which makes it possible to link metadata elements of the application model with the data from the client-specific database. A model engine can thus be used by a database management system to store, read, update, and delete data from a database. Here, the model engine has a translation and coordination function to generate from data elements of the application model specific data objects of the software application as well as to interpret commands on the user interface and process conditions stored in the application model, so that the command to access data the client-specific database and is displayed in the user interface. Thus, the model engine is particularly capable of an application model that after logging in a user z. B. via a control unit of the application platform in a main memory of a computer through which the application platform is provided was loaded, read and then generate and display a user interface from the model information stored in the application model. Accordingly, the model engine can also be seen as an application generating device. An application model thus completely describes the software application. It defines, among other things, access to the initial (root or start) interface of the software application after the user logs in, as well as how a command entered through the provided user interface and forwarded to the model engine the data in the client-specific database leads to thereby in particular display and / or edit the data and / or enter and store new data. The application model can thus specify the object, content, configuration, and operation of the software application and serve to assemble, configure, and control software applications at runtime from provisioned application building blocks. Preferably, the application model is described in an XML document that can be read by the model engine to generate the software application at runtime.

The solution according to the invention thus makes it possible to use the limited resources of a data processing system more efficiently and to save additional, often very expensive resources. If many different (specialized) software applications are needed, many different software systems may need to be used. Since each software system requires its own system resources and, if necessary, its own technical configuration, the simultaneous operation of several different systems on a computer system is not efficient and may even be critical if the technical configurations are conflicting. For example, problems often occur with a change in the overall configuration of the DP system due to the replacement or release of components. Using the solution according to the invention, all software applications can be mapped only by means of application models and no different software systems have to be used. All applications (including individual applications) are operated on just one application platform. Any number of different applications can be deployed at the same time without having to install stand-alone software. This is possible because, on the one hand, only database and application model differ from client to client or from software application to software application and, on the other hand, the system can process any number of different application models in parallel and any number of databases can be addressed in parallel. Such a system thus spares system resources, for example by avoiding redundancies in system administration and by sharing or efficiently distributing resources. Furthermore Conflicts due to different technical configurations, which may be necessary when operating different software systems, are prevented. Thus, in one embodiment of a method according to the invention for a user's access to a set of data (data record) of a data object stored in the client-specific database by the model engine

- first read the application model,

then an object instance to the data object in a memory (the computer that provides the application platform) generated and

the set of data belonging to the data object is read from the client-specific database before

- A visualization of the object instances is generated depending on the read data on the user interface.

In order to increase the flexibility to provide different software applications, the application model preferably includes at least a meta-model and an application configuration model. The meta-model defines generic metadata elements as well as data field structures for the user interface and / or attributes associated with the metadata elements. In turn, the application configuration model specifies such a meta-model and defines data objects for the software application that derive from metadata elements of the meta-model by assigning concrete or all metadata elements specific roles to the software application to be created and deployed in the application configuration model. The metadata elements are preferably self-referential, i. they can consist of additional metadata elements.

During the compilation-free generation of the software application from an application model with meta model and application configuration model, the meta model is preferably read at runtime and a class instance of a specific type and a attribute defined for each attribute for a metadata element are generated for each metadata element of a given hierarchy level ,

For example, the meta-model may include a schema definition that describes metadata elements. In a preferred variant of the invention, the meta-model in particular defines with which view types (views) a meta-element attribute, and thus in particular with which view types (views) a data field type can be represented. Here, view types and standardized user interface elements can be implemented as building blocks in the application platform. Thus, the type of visualization of object instances generated by the model engine can also be predetermined by a view type defined for the data object in the application model. Furthermore, any change in the meta-model can also lead to a change in the structure of the data provided from the client-specific database and possibly to a change of the software application at runtime. In this case, for example, an (XML) file which contains the meta-model is modified, whereby the data management is then changed in the case of an associated change in the specifications within the meta-model. Such a dynamic adaptation of the software application can take place, in particular, during runtime, so that the application model read by the model engine can be changed after the software application has been generated and during its use. For example, the meta-model describes meta-data attributes for the metadata elements and associates them with standardized user interface elements and, in the client-specific database, data field types such that the meta-model for the software application data objects defines the representation of a data field structure in the user interface.

In the application configuration model, in turn, machine, i. from the application platform, legibly described how the software application user interface to be displayed after the user log-in is to be built from the standardized user interface elements.

For example, in an application configuration model, it is at least

- to which role (for which type) a metadata element is pronounced in the software application, so that the functionality of a metadata element belongs to a specific data object of the software application, and

- how object instances of a data object are displayed in the user interface. Where appropriate, also be determined herein which access rights have a role.

For example, an application configuration model defines one or more software applications (eg, customer relationship management (CRM), product management, event management, music database management, etc.) An application configuration model is assigned, which defines the possible deployable software application (s) and is stored in the client-specific database For each user, a user account is also created, which assigns the user to one or more clients The user after logging in automatically via a corresponding provided on the application platform client and rights management the intended for him application configuration model by the - preferably from at least one metamodel and at least one application configuration model built - application model could In addition, certain functions of the software application may be described in a machine-readable manner that can be executed at runtime. Under such a function, e.g. storing the date of the most recent access to the client-specific database in the database when the software application is terminated, or performing mathematical operations on some or all of a database's data such as database. the calculation and storage of the sum of all instances of a particular data object stored in the database (for example, the total number of all the albums in a music database). For this purpose, for example, certain rules and / or workflows are predefined in the application model.

In this context, it is considered advantageous to implement generic function blocks in the application platform that are specified at runtime by the application model and configured to provide the executable functions. In particular, the creation of new application models for software applications offered on the application platform is facilitated by e.g. In the case of comparable functions, the generic function blocks can always be used and, if necessary, have to be adapted only slightly.

In one embodiment, the application model includes, preferably in addition to a meta-model and an application configuration model Organization model in which at least one organizational structure of the organization, within which the software application to be generated at runtime is to be used, and / or a business process, which is to be mapped with the software application to be generated at runtime, are stored. An organizational model thus includes, for example, a (static) structural model and, in this case, authorizes authorizations for processes and / or reporting structures provided by the generated software application. Alternatively or additionally, an organization model may specify a business process model (dynamic, ie adapted for the respective software application within the same and the same organization) and hereby specifies the business processes which are to be technically supported by the generated software application.

In one embodiment, the model engine comprises for the individual (sub) models of an application model, e.g. the metamodel, the application configuration model, and the organization model, different processing modules. So it can be provided that the model engine

a first processing module for processing the meta-model,

a second processing module for processing the application configuration model and

- a higher-level generation unit

comprises, wherein the higher-level generation unit queries the first and second processing modules after loading the meta-model by means of the first processing module and after loading the application configuration model by means of the second processing module into a main memory for generating the software application and generates the software application at runtime.

In one exemplary embodiment, the model engine has a (third) processing module for reading out an organization model which is contained in the application model and via which a check of the access rights to be granted in the software application is made possible at runtime. The organizational model defines this, e.g. Users (groups) and structure information.

For example, a first module, the meta-model processing module (also called "Meta Model Manager"), reads the meta-model into memory and at runtime generates the concrete objects (instances), ie the concrete records The application configuration model processing module, in turn, reads the application configuration model into the memory, that is, the XML file that describes the application context of the software application. A third module, the Organizational Model Processing Module, reads out a functional organizational model, checks the access rights to applications, processes / workflows, data objects, etc. of the software application based on the roles and structure information defined there In the model engine, the information required to generate the software application is queried by the three modules, ie which data objects are specifically assigned, how they are formed at runtime (inheritance), how the display is to be displayed on the user interface and which functions are used from the application platform etc.) and generates the software application at runtime.

As already mentioned, different application models can be stored in a database of the application platform for different software applications, so that only one specific application model is read by the model engine at runtime to provide one of several different software applications and a user interface based on this application model is generated. in particular a first basic or start-up user interface that is displayed directly after a user logs in.

In one variant, at least one client-specific database and / or at least one preconfigured application model is stored in a local database of a user, while the application platform is provided by a server system. The application platform can thus be operated centrally, in particular in the "cloud", while the data storage for a software application of a user generated at runtime is locally stored there.

To facilitate the delivery of application models to individual users and / or clients, standard application models and / or standard meta-models may be stored on the application platform. A standard application model or standard meta-model is then modifiable by an application-modeling device executable on the application platform to make it customizable for an individual software application. A modified standard application model or meta-model is then storable via the application model creation device as another application model or metamodel. Alternatively or additionally, it may be provided that an application model is formed only from a reference to a standard application model and possibly a special configuration model, wherein in the configuration model only any deviations from the respective standard application model are specified.

A standard application model is preferably kept here in an application model memory. Such an application model memory is preferably stored in a central database in which the client-specific databases are also stored.

A further aspect of the present invention is a computer-implemented device for the automated generation and provision of at least one client / server-based, preferably web-based software application with a user interface for a user as claimed in claim 17. Such a device which can be used on a computer, in particular a ( Web) server is installed, can be designed and provided in particular for carrying out a method according to the invention.

An inventive device comprises at least the following: an application platform into which a user, preferably via a network, can log in, at least one client-specific database on the application platform in which data can be stored, at least one application model stored in the client-specific database the generation of the at least one software application, wherein the application model describes the functioning of the software application, a user interface and the data structure are processable, and a model engine on the application platform for processing at least one application model and accessing data of the client-specific database. At runtime - after a user has logged in - the application model can be read out by means of the model engine, and based on the application model, also by means of the model engine, a software application can be generated that contains a user interface via which the user can access data from the client-specific Database can access. The model engine is designed in such a way that commands of the user at the user interface of the software application that it relates to, which are related to a specific data object are passed on to the model engine at runtime and the model engine to the user using the application model Access to data belonging to the data object allowed.

The application platform can have a control device which loads the application model from the client-specific database after logging in of a user and loads it into the working memory of a computer on which the device is installed.

By designing and providing a device according to the invention for carrying out a method according to the invention, the advantages and features explained above for a method according to the invention are likewise valid for a device according to the invention and vice versa.

For example, a device according to the invention may comprise an application model creation device and / or an application model memory.

As already briefly described, an easily manageable and variable possibility is provided to use any number of models at runtime simultaneously and / or in parallel, and thus to run any number of software applications based on any number of different application models on the same platform. The models can also be optimized during runtime.

In advance, for example, the application model of the software application is generated from an application-independent meta-model and an application-related configuration model. Subsequently, a client-specific database is created from an empty database and the application model. At runtime, one finally reads in the application platform

Application generating device, the model engine used in the client application-specific database and automatically generates the immediately usable software application from the application logic and interface description contained therein as well as the generic views (GUI) and functions contained in the application platform.

In addition, a computer program product is proposed for operating a computer, in particular a web server, which has machine-readable code which, when executed on the computer, is designed to cause the computer to carry out a method according to the invention.

A further aspect of the present invention is a machine-readable storage medium having machine-readable program code which is designed to be executed on a computer, in particular a web server, and to cause the computer to execute a method according to the invention when executing the program code.

Furthermore, a computer-implemented device for producing a computer program product is proposed, by means of which a method according to the invention can be executed, in which an application model comprises at least one meta model and one application configuration model. Such a device according to the invention comprises at least:

a first generation module for creating a meta-model, wherein metadata elements are defined in the meta-model and data field structures for the user interface, attributes and / or functions associated with the metadata elements are defined, and

a second creation module for creating an application configuration model, wherein the meta-model is specified via the application configuration model and data objects for the software application are derived from metadata elements of the meta-model by providing concrete roles in the application configuration model for the software application to be created and deployed at runtime be assigned to.

To facilitate the creation of an application model with meta-model and application configuration model, at least one build module defines at least one graphical user interface through which an operator may create a meta-model and / or an application-configuration model. Such is the creation and thus In particular, the configuration of a software application generated only at runtime also possible without detailed programming knowledge based on user-generated components of the later to be read by the model engine application model.

In one embodiment, the meta-model and / or the application configuration model include at least one XML document, and the first and / or second generation modules are provided to create and / or modify an XML document to create the respective model. In particular, it may be provided that the model engine works with application models that are described exclusively in XML documents. Technically, therefore, only XML files are created and / or changed when generating an application model here. In one variant, the device comprises, in addition to the first creation module (meta-model creation module) and the second creation module (application configuration model creation module), a third creation module for creating an organization model already mentioned above (organization model creation module). The individual modules of the device thus serve here to create the corresponding submodels of the application model.

Further advantages and features of the present invention will become apparent in the following description of exemplary embodiments with reference to the figures.

Hereby show:

Fig. 1 is a flowchart for a variant embodiment

inventive method;

Fig. 2 is a schematic representation of a variant embodiment

inventive device;

Fig. 3 is a schematic representation of the generation of a graphic

UI at runtime through a model engine based on an application model; excerpts the content of an application model for an embodiment of a software application;

4B is a schematic representation of the generation of a

Data storage from a meta-model for the embodiment of Fig. 4A;

4C is a schematic representation of the generation of a

Class model with classes and class attributes at runtime through a model engine from a meta model for the

Embodiment of Fig. 4A;

5A is a schematic representation of an instantiation at runtime according to a conventional object-oriented approach for developing a software application for the embodiment of FIG.

4A;

5B shows a schematic representation of an instantiation at runtime according to the inventive method for the embodiment of FIG. 4A;

6A is a schematic representation of the functions of a

User interface of a device for creating in particular an application model for a software application;

6B is a schematic representation of the functions of

Application platform on which based on the inventive solution a software application is executable.

FIG. 1 initially shows a flow chart for an embodiment variant of a method according to the invention for the automated generation and provision of a client / server-based, preferably web-based software application AW with a user interface GUI for a user. In this case, the illustrated flowchart also includes phases for the creation of an application model AM and the assignment of user rights by a tenant management device CA (English, "serves administrator"), which in advance (Section I in Figure 1) by a provider the software application AW are to be made before it is automatically generated when needed at runtime (Section II) and provided for use, ie, is usable.

The core of the illustrated embodiment variant is the generation and provision of the software application at runtime without programming.

In this case, an application model designer AM (application model designer) of an application-independent meta-model MM and an application-related configuration model or application configuration model AKM generates a (here: data-oriented) application model AM of the application. not shown) and the application model AM a client-specific database CSD (engl., "serves specific database"). At runtime, a model engine ME reads out the application model AM lying in the client-specific database CSD. This model engine generates the software application AW from an application logic AL described in the application model AM and a surface description OB also contained therein, as well as from generic functions and generic view types (views) for the graphical user interface GUI. The generic functions and view types are implemented in an application platform on which, as the runtime environment, in particular the application model creation device AMD, the client management device CA and the model engine ME are executable.

A variant embodiment of a computer-implemented device S1 according to the invention, with which the variant of a method according to the invention described with reference to FIG. 1 is executed, is illustrated in FIG. With the device S1 not only an automatic generation and provision of software applications at runtime on a preferably web-based application platform is possible, but also a creation of the software applications before a first use using the application model creation device AMD and the client management device CA.

The device S1 includes an application platform with a (generic) user interface GUI, the model engine ME and a central database DB, in which several client-specific databases CSDi .. _{x are} stored. From these client-specific databases, the structure of two databases CSDi and CSDx is shown in greater detail by way of example, in which data sets DS are stored. In addition, the device S1 comprises the client management device CA and the application model creation device AMD, which run as tools on the application platform. Using the AMD application model builder, concrete platform-dependent meta-models and application configuration models can be created and managed based on an abstract platform-independent meta-meta-model (not shown). By way of example, FIG. 2 shows an individual meta-model MMi of the client-specific database CSDi and a standard meta-model MMSTANDARD.1 which are stored in an application model repository AMR of the device S1 as part of a standard application model AMSTANDARD.I becomes.

A metamodel MMi or MMSTANDARD.I is a schema definition that describes building blocks in the form of metadata elements. From a meta model MMi or MMSTANDARD.I, a (client-specific) database model (without figure) is derived.

With a meta-model MMi or MMSTANDARD.I, moreover, a part of the surface of the (software) application AW is already modeled. The meta-model MMi or MMSTANDARD.I defines the representation of the data field structure of the data object types in the user interface GUI by describing meta-element attributes in the metamodel MMi or MMSTANDARD.I and the generic user interface GUI data field types and standardized user interface elements (eg input fields with cardinalities ) are assigned automatically.

The application configuration model AKMi or AKMSTANDARD I defines the remaining part of the surface. It defines for each data object of the application AW with which view types (views) it should be displayed in which contexts (eg single view, list view). The view types and standardized user interface elements are each implemented as building blocks in the application platform. Here, in the present case, the presentation on the user interface GUI can be subsequently modified by means of the application model creation device AMD. An application configuration model AKMi or AKMSTANDARD I describes the structure and process organization basics and conditions of a software application AW the respective client-specific database CSDi or CSDx (ie organizational units, processes, roles, users, rights), the business processes to be supported and corresponding workflows, a concrete data storage DH (compare FIG. 4B), the case-related configuration of the generic user interface GUI consisting of basic elements (views), the interaction of all model components as well as the behavior of the software application AW (among other things via rules). The application configuration model, in FIG. 2 by way of example AKMi or AKMSTANDARD.-I, accordingly specifies the subject, content, configuration and mode of operation of an application AW and serves to assemble the application AW at runtime from the application modules, to configure them and to control their behavior.

An application configuration model AKMi or AKM _S TANDARD is also used to specify the respective meta-model MMi or MMSTANDARD, ie to form concrete objects from the abstract objects defined with the metamodel MMi or MMSTANDARDJ by filling the abstract objects with concrete data at runtime and thus concretized, typed and configured. In this case, predefined attributes can also be modified via the respective meta-model MMi or MMSTANDARDJ. In each case a meta-model MMi or MMSTANDARDJ and an application configuration model AKMi or AKMSTANDARD together form an application model AMi or a standard application model AMSTANDARD.L The respective application model AMi or AMSTANDARD.1 completely describes a software application. In contrast to conventional software development, a (software) application AW is not defined by a concrete professional class model that has to be programmed, but by an application model AMi or

AMsTANDARD -

An application model can be provided here as a standard application model AMSTANDARD or as an individual application model AMi. It accordingly describes a standard software application or an individual software application.

In the example of FIG. 2, for the client-specific database CSD _X, a possibility is illustrated of storing an application model AM ₂ for the software application AW to be generated at runtime, which consists only of references V-AMSTANDARD to the standard application model AMSTANDARD, I and possibly Deviations AB-AMSTANDARD is formed by the standard application model AMSTANDARD. A standard application model AMSTANDARDJ can therefore be extended or modified at any time by additional configuration information created with the application model creation device AMD, the standard application models still being kept in the application model memory AMR.

It should be noted, however, that a final determination is not associated with the original purpose of an application model as a standard or individual application. A once created application model AMi or a standard application model AMSTANDARDJ can be used as often as desired by referencing or copying and optionally modified as a new application model (in a client-specific database CSDi .. _x and / or the application model memory AMR) are stored. Consequently, the device S1 can simultaneously contain and use any number of application models.

A data storage DH of an application is created in advance with the aid of the client management device CA. For this purpose, an empty database (not shown) is first created, the desired application model, e.g. AMi, passed to the database. There, from the meta-model contained in the application model, for the application model AMi from the meta-model MMi, the database model, i.e. the concrete data structure, is generated in which the actual data can then be stored. The creation of an application and at the same time its provision for use takes place automatically at runtime. After a user logs into the device S1, a control unit of the application platform (not shown) right-controlled loads the application model, e.g. AMi, and it loads in the main memory of the computer (without figure) on which device S1 is installed.

If the user wants to process a business object (eg customer), the corresponding request is forwarded to the model engine ME, which reads out the instantiated application model AMi (eg for a CRM application), evaluates the configuration information from the application model AMi and, at runtime, the corresponding one The object of the application is generated by converting abstract data model objects (such as "organization") into concrete objects (such as "customer (company)") at runtime and assigning them to the application. Object relationships (such as "belong to an organization (s) persons") are also at runtime using the Application configuration model AKM evaluated and typed (ie, for example, can be assigned to a "customer" only a "contact person (customer)" and not any person). To represent the object, the Model Engine ME forwards the necessary parameters to the generic GUI blocks with which the user interface GUI is then generated.

The model engine ME thus provides the objects that are necessary for the processing and display of corresponding data. If a data record is to be processed by calling a function, the model engine ME generates the required object in the working memory at runtime. Objects have the class "model instance." The class "model instance" consists of the class "ModelElement" and the parameter defined for this "ModelElement" in the application configuration model AKM. The model engine ME therefore generates model instances for further processing by means of factory methods and evaluation of the application model AM.

The model engine ME is implemented in such a way that it can map and manage any models or structures. A functional class model of the model engine ME itself basically consists of two classes: nodes and attributes. Nodes can contain attributes. Furthermore, nodes can be linked to any other nodes. If an application model is transferred, the model engine ME is able to derive a framework of nodes with properties (attributes) from this model. A specialized logic, which must already be defined in the conventional software development during the programming, is given by this mechanism only at runtime in the form of the respective application model. This will be explained in more detail in particular in connection with the attached FIGS. 4C and 5B by means of an exemplary software application.

The execution of functions and the display of other GUI views at runtime are determined by the actions of the user or user

Application model AM dependent on defined conditions. Each request or command (e.g., "Show customer data") is first directed to the model engine ME.

This evaluates the request based on the application model, e.g. AMi, off, fetches the data associated with the affected data object from the database of the client CSDi, calls a special one if necessary for executing the operations defined in the object

Function module on (eg "Generate document") and provides the data according to the Application model AMi defined information, ie, with the corresponding view, on the user interface GUI.

For example, the application platform automatically assigns each data area a list view and corresponding basic functions - such as display, add, edit, delete, copy - to. Also, each record DS may automatically be assigned, for example, a detail view and associated basic functions - such as add, edit, save, delete, copy. For each view type (view) is preferably already a basic configuration deposited, which is specified by information or specifications from the associated application configuration model AKMi or possibly even changed. The basic configuration may include, for example, indexing, presentation as a table with empty column names (as transfer parameters), filter functions, basis functions, etc., which may be provided by the application configuration model in the form of data object information, assigning selected fields of the data object to columns of the table , the assignment of special functions, etc. is specified (see also Figure 3).

If the user requests e.g. From a list of objects (customers, prospects, contact persons, etc.) by selecting a data object (eg customer) the associated records DS (eg the customer data), the model engine ME reads the application model (eg AMi) and generates the object instances in memory. The model engine ME requests the values for the data object from the client-specific database (CSDi) via a database access layer (component of the database DB, not shown separately) and transfers the visualization of the object instances according to the information stored in the application model (AMi) via the associated view type (here: a list view) - to the generic user interface GUI. For the actual visualization, the generic user interface GUI provides the view type and, according to the assignment made in the data model, the standardized user interface elements belonging to the data object and displays them on the user interface GUI. The data field structure and representation in the user interface GUI is automatically removed from the Metamodel (MMi) derived.

In addition to the generic user interface elements, functions of the (software) applications AW are preferably also implemented in the application platform as generic function modules and are specified and configured at runtime by the respective application model, eg AMi or AM ₂ . By doing For example, the application model defines whether a function should be displayed as a button or automatically triggered. If the latter should be the case, it is further specified which conditions should lead to an execution of the function. For example, it can be defined that a specific function is executed after saving a data set DS if the current date is "today." If the function is to be displayed as a button, the application model stores which label the button receives and which preconditions If necessary, ie, whether the execution of the function should be dependent on the rights, it is also defined in an application model which data object (eg person, task, appointment) should be transferred from the data model as transfer parameter and which postconditions exist, ie For example, if and what should be done after the function has been executed, this means, for example, that an attribute "last contact" for a data object person is updated to "today" and a follow-up is created.

A solution according to the invention differs from the conventional methods of software development and provisioning in that it involves the transition from the model definition to the use of a software application AW without programming, compilation and installation. The solution according to the invention also offers the possibility of simultaneously using any number of application models AM at runtime and thus to operate any number of applications AW based on any number of different meta models MM on the same platform. The application models AM can also be optimized at runtime. In contrast, conventional methods require a rigid metamodel.

With the solution according to the invention, consequently, considerable advantages for the application creation and provision can be achieved. These include:

- High flexibility, speed, security and maintainability - new applications or changes and extensions to existing applications AW, e.g. in the data objects and structures, can be implemented without programming and are available immediately, since only the (technical) application models AM have to be created or edited, which can also take place at runtime;

- Application creation, provisioning and operation are integrated on the preferably web-based application platform - source code compilation, Installation and the like and other development tools, operating or runtime environments, etc. are not necessary;

Reduction of dependency on hard-to-reach IT know-how - technical knowledge is no longer needed to create software applications AW, as business users can create new applications themselves and use them immediately.

At an embodiment illustrated with Figures 4A-4C and 5A-5B, the operation of the solution according to the invention will be explained in more detail. The aim is to create a database application AW (called "jukebox") for the management of audio and video CDs / albums, which in addition to the elementary functions such as displaying, editing, saving and deleting, also the sorting of the data records , which allows you to print out lists and search for data, display a list of the data objects contained in list views and display the information about a data object in the form of a detailed view.

In FIG. 4A, the content of an application model AM (shown in abstract) for this embodiment of a software application with its meta-model MM and its application configuration model AKM is shown in excerpts. The illustrated application model AM further defines certain rules, that is, in particular functions that are to be executed at runtime, as well as workflows. FIG. 4B schematically shows the generation of a data storage DH for the software application "Jukebox" from the meta-model MM, while FIG. 4C schematically illustrates the generation of a class model with classes and class attributes from the meta-model MM at runtime by a model engine ME. FIGS. 5A and 5B compare the different instantiations at runtime in a conventional object-oriented approach and in the solution according to the invention for the software application "jukebox".

It is assumed that there is already a meta model MM with the abstract data objects "person" and "product" that can be used. The application model builder AMD first builds the application model AM for the Jukebox application by selecting the meta-model MM and assigning it to the application by referencing inheriting the basic properties of the data objects, which can now be extended to meet specific application needs At the same time, inherited properties can also be marked, for example, to hide data fields at runtime.

The metamodel MM already defines the basic functions based on a schema definition and models the user interface of the application, since the metamodel MM specifications based on referencing automatically apply to the application model AM of the "Jukebox" application Metamodel MM was created by copying a standard metamodel MMSTANDARD I.

In addition to the meta model MM, the application model creation device AMD now also describes an application configuration model AKM. Here, in the model for the jukebox, e.g. the following specifications have been made: For the data management DH:

^{■ Data} object "Person": should be specified by the role "Artist"

^{■ Data} object "Product": should be specified by the role "Album"

For the presentation on the user interface GUI:

■ List view for "Artist": Display of the columns "Artist name",

"Date of birth", "genre" etc.

^■ Display name of the record type

(for example, for referencing): Artist name For user management:

^■ Roles: Jukebox administrator

^■ Rights: Jukebox administrator is allowed to use all functions at all

Execute data

^■ User: Peter Müller, receives the role Jukebox administrator

Specifically, for example, the application configuration model for the role "artist" is described as derived from the meta-role "person" of the metamodel MM. The Role "Artist" is defined here by a parameter "Role" in the application configuration model AKM, which is to be assigned the value "Artist", where the assignment to the meta role "Person" takes place via a path. In the example shown, for the "Jukebox" application, there is a data area called "Artists" in which a particular view type defined in the AKM application configuration model - eg a list view

- for "Artist" all records of the type "Artist" are listed. The application configuration model AKM defines that for each newly created person the role "Artist" is to be set and at the same time only those persons (in the list) are shown who also have the role "Artist". Here, therefore, a data object "Artist" is derived via a parameter "Role" from the data area "Person" of the meta-model MM An adaptation or extension of the data object "Artist" could take place via further parameters by means of the application configuration model AKM. For example, using the AKM application configuration model, the artist data item could be expanded to include an artist name field that does not exist in the person metadata element.

The application "Jukebox" is completely described by the application model AW comprising the meta-model MM and the application configuration model AKM, in particular its database model DBM for the database DB standing behind it (compare FIG. 4B).

In the application model AM, for example, it is also defined that a function "link dataset" should be displayed as a button with the name "link dataset". A link should be possible between the data objects "Product" and "Person". Postconditions are not defined. The right to perform the function has been assigned to the Jukebox administrator. The data storage DH of the application "Jukebox" is in advance - not by the user

- Created with the help of the client management device CA. For this purpose, a database (without a figure) is created, the created application model AM is transferred to the database for the "Jukebox" application, and the specific data structure is automatically generated.The generation of the "Jukebox" application at runtime after a user logs in is as already described above described. The abstract objects "Person" and "Product" are specified by the roles "Artist" and "Album" respectively. As shown in particular with FIG. 4C, the meta-model MM is read in at runtime for this purpose. In this case, a new class instance of a specific type is generated for each metadata element defined in the meta-model MM, which lies on a defined hierarchical level and is identified in a specific manner, in the FIGURE 4C a class of the type "ModelElement" This applies to the metadata elements "person" and "product", both of which lie on the same level, since a ModelElement can have any number of attributes, so any metadata element at a lower level (eg "last name" or "ID") In this way, all metadata elements from the meta-model MM can be read in and created as a class instance for the software application "Jukebox".

From the model engine ME, a framework of nodes with properties (attributes) is derived from this, in that links already defined in the meta-model MM are read in the same way and mapped in each case as ModelAttributes. For example, the user now wants to collect data about an album and assign it to an artist ("artist"), assuming that a record for an "artist" data object has already been created and the user has opened the list of albums. The marking of the desired album record and the call of the function "show" (by pressing a button "Show") on the user interface GUI causes the corresponding request to be routed to the model engine ME. This reads from the application model AM, among other things, the information on the data object "Album", to the rights of the user and for presentation in the GUI GUI, generates the instance to the data object "album" in memory, through the database access layer, the data for the selected Album from the (client-specific) database CSD and transfers the data for display in the GUI user interface to the view "detail view" defined for the application model AM for the display of individual data objects The command is passed to the model engine ME, which in turn reads the application model AM, evaluates the user's rights, passes the command to release the record for processing to the database DB or the client-specific database CSD and the Command to change the display in the edit / input mode to the user interface GUI passes.

The user can now enter the data and execute the corresponding function by clicking on a button "Link record", whereby - according to the mechanisms already described and the definitions defined in the application model AM - the list of linkable data objects is displayed first, ie "Artist ". After highlighting the "Artist" data object, executing the "Show" function and displaying the existing "Artist" records in a list with the columns "Artist name", "Date of birth" and "Genre the desired" Artisf record can be selected and the " The link is created by saving the "Album" record in the client-specific database CSD by executing a "save" function, whereby the storage of data is effected by the data storage DH generated from the data retention scheme edited record (eg "Artist") and due to the model engine ME known meta-model MM, the record can be written to the appropriate place in the data DH, (then under "Persons").

More complex commands and functions are mapped using the rules of the application model AM. The rules are defined in the application model AM according to the standards usual for rule-based systems. The execution of a command defined here is triggered by a condition and a trigger and is carried out automatically.

For example, a "calculatesum" function defined under "Rules" in the application model AM for the "Jukebox" application calculates the total value of the album collection based on purchase prices of each album.This function "calculatesum" sums up the purchase prices of all albums and updates them a previously determined and stored in the client database CSD total value of the album collection when a new album (Album ID = "new") is added to the collection and the corresponding record DS for the new album was saved. As described above, the model engine ME reads out the application model AM with the rules stored there, evaluates the conditions according to the application model AM, transfers the parameters to the other Execution of the respective command and accepts the result for further processing, ie, for example, for display on the user interface GUI.

Although only one embodiment variant for a particular software application "jukebox" has been illustrated in detail with reference to FIGS. 4A-4C and 5A-5B, the solution according to the invention is of course not limited thereto, as has been explained in particular with reference to FIGS a database DB of the application platform completely different application models for different software applications AW and for various client-specific databases CSDi .. _x Thus, it can different (preferably web-based) software applications on an application platform, eg as "Software as a Service", without programming and compilation not only created in a simple way, but also generated automatically at runtime and provided for immediate use.

Furthermore, surface functions GUI-FK of a user interface of a computer-implemented device for creating, in particular, an application model AM for a software application and the application platform on which a software application can run are illustrated by way of example with FIGS. 6A and 6B. Here, in a further development of the exemplary embodiment illustrated in particular in FIG. 1, the generation and provision of a software application AW with support of stored business processes is possible by providing an organizational model OM in addition to a meta-model MM and an application configuration model AKM.

FIG. 6A shows system tools whose functions can be used by an operator via a user interface in order to generate an application model AM for a software application in a simple manner and without in-depth programming knowledge. In this case, an application model AM should comprise a plurality of submodels or submodels in the form of a meta model MM, an application configuration model AKM and an organization model OM.

The meta-model MM

- Defines the data objects and their relationships / structures as well as the appearance on the interface and

- describes the data management incl. its visualization. The organizational model OM

- Describes the relevant organizational background and framework conditions for the application, i. Organizational Units, Tasks, Jobs and Staffing / Users (including, but not limited to, user rights from a structural model that is part of the Organizational Model)

- forms the relevant process model for the application area with the ideal-typical processes, activities, associated, roles, inputs and outputs / result types u. a. off and on

- describes the business processes to be supported by the application (as the basis for workflow support).

The application configuration model AKM

- defines the application (metadata of the application) and the context

- Specifies the metamodel MM

- substantiates and, if necessary, changes an already stored basic configuration as well

- Specifies and configures generic functions provided by the application platform.

The device shown schematically in FIG. 6A now has inter alia an application model creation device AMD with several modules for the individual submodels of the application model, thus a meta-model creation module MMD, an organization model creation module OMD and an application configuration model creation module AKMD. In addition, in addition to the application model creation device AMD, a rule creation module RD, a workflow creation module WFE, a test tool TS, and (standard) view building blocks VW are provided. The surface functions GUI-FK realized by this will be described in more detail below.

The meta-model creation module MMD (English, "meta model designer") is used to describe the data storage DH of a software application AW and to manage the created meta-models Using a meta-model MM, the data objects and object relationships / structures of an application AW are to be defined with it For example, the metamodel is technically available as an XML schema file The organizational models OM and application configuration models AKM are also described in XML documents: XML is not a programming language, but only a metalanguage, so XML documents themselves contain no commands and loops like a programming language (and therefore no instructions the processor, as is the case with conventional "hard-coded" applications.) In order to still be able to create, deploy, and control applications based on the XML documents, the documents will later be evaluated by the Model Engine ME to derive the commands to create.

The meta model MM already defines object-related rules (in particular plausibility checks) and models the user interface GUI of the application AW. In addition, it defines the representation of the data field structure of the data object types in the user interface GUI by automatically assigning standardized GUI elements of the generic user interface (for example input fields together with cardinalities) to the data field types described in the meta model MM. The view types and standardized GUI elements are implemented as building blocks in the application platform. The organizational model creation module OMD (model organization designer) is used to model both the process organization and the task-related, functional structures of an organization or project (as a time-limited organization) the software application AW to be created needs to be.

An organizational model OM therefore includes, for example, at least one structural model, a process model and a business process model separately. The structural model and the process model lay a rather static view of an organization, as it depicts its organizational structure and the ideal process organization. The information from a structural model can be used, for example, to assign structural, that is, task-oriented authorizations, evaluate reporting structures in the user company differentiated according to organizational units, manage components and functions in business management, in particular HR applications, or handle tasks arising in the context of business workflows Assign to editors. For example, a process model describes the ideal process structure of an organization, based on the classic division / categorization into core, management, and support processes. The processes are broken down hierarchically and displayed in more detail from level to level. The detailed steps of a process defined in this way not only serve as documentation, but can also be reused as process blocks in other contexts. In contrast to the structural model or to the process model, the business process model is dynamically oriented. It describes the concrete business processes that are to be technically supported, among others, by the software application AW to be created. To model the business processes, the individual process modules (activities) are selected from the (static) process model according to the business processes to be supported, brought into the desired sequences and combined with linking and execution rules. The business processes depicted in this way will later be used as the basis for execution as workflows.

The application-specific configuration settings are bundled in the application configuration model AKM, which are managed using the application configuration model creation module. Specifically, an application configuration model AKM serves to specify the meta model MM, ie to form concrete objects from the abstract objects defined with the meta model MM by filling the abstract objects with concrete data at runtime and thus concretizing, typing and configuring them. The predefined attributes can also be modified. The application configuration model AKM also concretizes and, where appropriate, changes the already stored basic configuration (index, table with empty column names (as transfer parameters), filter functions, basic functions) of a view type (view) that is assigned to a data area ( eg by data object information, columns of the table (= selected fields of the data object), assignment of special functions, etc.). The application configuration model AKM also specifies and configures the functions implemented in the application platform as generic function modules. In the final application model AM, for example, it is defined whether a function should be displayed as a button or automatically triggered. If the latter is to be the case, it is further specified which conditions should lead to an execution of the function (eg after saving a data record as well as if the current date is "today".) If the function is to be displayed as a button, then The created application model AM stores, which label the button receives and which preconditions exist, eg, whether the execution of the function should be dependent on the rights.Furthermore, it is defined which data object (eg person, task, appointment) from the meta model as transfer Parameter and which postconditions exist, ie, whether and after the execution of the Function is still to take place (eg "last contact" to "update today", create follow-up, etc.).

The application model creation device AMD furthermore also has overarching functionalities which serve to create the application model AM from the abovementioned submodels and the other application components (rules, etc.). Such an application model AM is created by controlling the interaction of the submodels (MM, OM and AKM), model building blocks and application components and the concrete characteristics of the business objects via configuration. The various configuration options of the individual submodels and application components (from the meta-model to the business logic of the application AW to be created) are functionally combined in the application model creation device AMD. Some application components are z. B. can be created separately by the rule creation module RD and the workflow creation module WFE.

The role of Rule Authoring Module is to define and capture business rules and facts, and to enable centralized management, review, and deployment. Business rules (such as "When the sun is shining, the ice cream costs 50 cents more.") Play an important role in almost all areas of the company, describing not only the organizational knowledge and control information relevant to these areas of business, but also the business logic of Software systems designed to support these business units determine how a software system or business process controlled by an AW software application should behave.

The business rules are preferably managed in a central repository, maintained and stored in a revision-proof manner, to make them available for the creation of applications AW, and also for the basic behavior of an application AW later on In the context of the use of the application AW, the business rules can still be changed, simulated, checked and made available at runtime Structured tasks and processes, in particular the business processes defined in the organizational / process model, should also be processed with the help of a workflow Management "can be supported in terms of information technology and, if necessary, automated, for which the workflow creation module WFE is helpful.

A workflow is a workflow (alternatively business transaction or general operation) that is built up of individual activities that relate to parts of a business process or other organizational processes. The workflow describes the operational-technical view of the (business) processes to be supported. Ideally, this description is made so precisely that the following activity is determined by the outcome of the preceding one. The individual activities are therefore dependent on each other. A workflow has a defined start, an organized process and a defined end. He is the part of the (business) process that can be carried out with IT support. Workflows are characterized by a coordinative character. A workflow is typically achieved by sequencing and parallelizing the work steps. Synchronous activities are strictly separated.

The workflow creation module WFE is used to model and configure concrete workflows. Here it can realize the following functions:

- takeover of the business processes / workflows from the organizational model OM,

- Graphic modeling '/ concretization and specification of the workflows (e.g.

Differentiation into different work processes according to the rights and roles of the users),

- verification of work processes (for example, whether an event is planned at any given time in the workflow),

- Simulation of workflows / workflows as well

- Configuration of the rights and roles of users.

The test tool TS also provides functionalities for the constructive and analytical quality assurance in order to avoid any errors in the created application model AM or in a software application AW generated thereby, or at least to be able to determine them at an early stage.

From FIG. 6B, functions provided by the application platform are outlined using different functional components, such as the model engine ME. Here, in addition to the model engine ME, a rule engine RE, a workflow engine WE, a function module FK and a system administration module SYS are provided. As explained above, the model engine may include different processing modules for the submodels MM, OM, and AKM of an application model AM, eg, a meta-model processing module, an application configuration model processing module, and an organization model manager processing module.

The technical components of the rule engine RE comply with common standards for rule engines and consist of e.g. out:

- Rule interpreter,

- Core Rules Execution and

- Rules Set (number of different classes of rules). The workflow engine WE is equipped, for example, with the following technological core components:

- Workflow GUI (necessary classes for the presentation of the graphical workflow),

- Core Workflow Engine (for managing, executing and creating workflows) and

- Worklist handler (controls the cooperation of the individual process participants).

Furthermore, functions that can be used or can be called up within an application model are made available via the function module FK. Functions essentially determine what a generated software application AW can do. For example, they serve to perform operations on data and to produce processing results. In practice, the operations can be composed of a wide variety of parameters and thus can be arbitrarily complex. In the context of an embodiment according to the invention, functions are implemented as standard functions, so that they can be combined at runtime with any application models AM and application components. A distinction is made between elementary functions, complex functions and configurable functions. Elementary functions are ever-recurring, basic functions from which other functions can be formed. Examples include saving, copying or deleting data or sending e-mail. The complex functions are composed of elementary functions by means of basic operations, concatenation, differentiation or integration. They can also be model-specific configurable. Examples of complex functions are: - sorting and searching,

- Import and export of data as well

- Upload and download files.

The configurable functions must be adapted to the specific application model. Examples of such functions are:

- Definition of a schema for invoice number assignment or

- Conversion of an object into another object (for example, an offer in an order and ultimately a monthly recurring invoice). The functions are implemented in the application platform as generic function blocks, which must be developed conventionally. However, the configurable functions can be specified and configured at runtime by the application model AM. In the application model AM, for example, - as described above - defines whether a function should be displayed as a button or automatically triggered.

The system administration module is a central technical component of the application platform. Its task is to provide the administrative interfaces for setting up and managing the entire system and to support its smooth operation. It preferably provides the following functionalities:

- administration and configuration of general system parameters,

- set up and administration of clients (manual creation, copy clients, automatic creation of standard clients and preconfigured solutions, etc.) and client types (productive preparation clients, client models, etc.),

- user and user group administration and

- Role and rights management.

In summary, the invention proposes a method and a technical device for automatically generating software applications AW without having to be able to program, compile and / or install.

Applications are preferably first defined / described with the help of appropriate tools in holistic models and then generated and configured model-driven with the necessary data structures (classes / data and business objects), business / application logic and views. In contrast to conventional software applications whose context is permanently defined in the source code, an application is only created at runtime, ie when the user logs in. Only at this time is an application model AM, for which the user is authorized, loaded into the cache of the web / application server and read into a model engine ME and processed. The application AW itself is generated from the application logic AL and surface description contained in the application model AM and the generic application modules contained in the application platform. In this case, in the application model AM, all information relevant for an application AW is shown (including the application purpose or context, the roles and access rights of the user, etc.). After checking the roles and rights of the user, the appropriate startup screen is generated. Also with each further action in the application AW (whether executed by the user or automatically by the system), first the application model AM is read out and processed, which then specifies the further behavior of the application AW.

Intermediate changes of the application model AM automatically lead to a corresponding update of the application AW the next time the user logs on.

To create and use the applications AW, server and client-side operations must be performed. Components of an overall system comprising at least one (web) server and at least one client are accordingly in a preferred embodiment:

- Server side:

o databases,

o web server,

o application platform and

o Creation modules (tools) for creating the models as well

- Client side:

o Browser (where calculations are performed on functions implemented in Java Script)

In the technical implementation of a method according to the invention, a database is not necessarily required (eg for the storage of application models AM). It is also possible to work with file systems if only XML documents / files are used. However, if a database is used, a non- Relational database server considered advantageous (eg an XML database). Nevertheless, the use of other database technologies is basically possible. Each client is set up its own database. The databases can be assigned to any number of database servers. These in turn can be operated completely independently of the application platform and distributed as desired. Among other things, it is possible to operate only the application platform centrally (eg in the "cloud"), while the data storage is carried out locally.The application platform can also be parallel by addressing the various databases in which the different application models AM are located to provide any number of different applications.

In a "cloud" solution based on the invention can be achieved, moreover, that a user in his own (individual or individualized) software applications know-how and its data for security reasons secured locally and thus stored locally, without on The data management and the application models AM, in which the business / application logic AL of the software applications AWA is mapped, can be distributed arbitrarily, ie also to local resources.

LIST OF REFERENCE NUMBERS

AB-AMSTANDARD deviations from the standardized application model

AKM application configuration model

AKMSTANDARD Standard Application Configuration Model

AKMD Application Configuration Model Builder

AL application logic

AM application model

AMD application model creation device

AMR application model storage

AMSTANDARD standard application model

AW (software) application

CA tenant management device

CSD client-specific database

DB database

DBM database model

DH data management

DS records

FK function module

GUI user interface

GUI-FK interface functions

ME model engine

MM meta model

MMSTANDARD standard meta-model

MMD Meta Model Creation Module

OB surface description

OM organization model

OMD Organizational Model Builder

PL-FK platform functions

RD Rule Creation Module

RE rule engine

S1 Device for the automated generation and provision of at least one software application

SYS system administration module

TS test tool

V-AMSTANDARD Reference to standardized application model VW view building blocks

WE workflow engine

WFE workflow authoring module

Claims

claims

1 . A method for automated generation and provision of at least one client / server based software application having a user interface for a user, wherein at least the following is provided: an application platform into which a user can log in, at least one client specific database (CSD) in which Data can be stored, at least one application model (AM) stored in the client-specific database (CSD) for the generation of the at least one software application (AW), wherein the application model (AM) is the functioning of the software application (AW), a user interface (GUI) and the data structure are described as machine-processable, and a model engine (ME) on the application platform for accessing data of the client-specific database (CSD), wherein the model engine (ME) after the login of a user, the application model (AM) Runtime and only at runtime based on the application a software application (AW) with application logic (AL) and user interface (GUI) generated, wherein the application logic (AL) defined by the software application (AW) executable processes and the user via the user interface (GUI) to data from the client-specific database (CSD), and wherein commands of the user at the user interface (GUI) concerning a particular data object at runtime to the model engine (ME) are passed and the model engine (ME) the user recourse the application model (AM) and the application logic (AL) created at runtime allow access to data belonging to the data object from the client-specific database (CSD).

2. The method according to claim 1, characterized in that the

Application Model (AM) at least one metamodel (MM) and an application configuration model (AKM), wherein in the meta-model (MM), generic metadata elements are defined and data field structures for the user interface (GUI), attributes and / or functions associated with the metadata elements are specified, and the metamodel (MM) is specified via the application configuration model (AKM) and data objects for the software application ( AW) derived from metadata elements of the meta-model (MM) by assigning concrete roles to the software application (AW) to be created and deployed in the application configuration model (AKM) metadata elements.

A method according to claim 2, characterized in that the meta-model (MM) comprises a schema definition which describes the metadata elements, and / or in the application configuration model (AKM) is defined with which view types (views) a metadata element can be represented.

Method according to one of claims 2 to 3, characterized in that at runtime, the meta-model (MM) is read in and for each metadata element of a given hierarchical level, a class instance of a certain type and each attribute defined for each metadata attribute meta element attribute.

Method according to one of claims 2 to 4, characterized in that in the application configuration model (AKM) is at least determined

to which role a metadata element in the software application (AW) is pronounced, so that the functionality of a metadata element belongs to a specific data object of the software application,

- how object instances of a data object are displayed on the user interface (GUI).

Method according to one of the preceding claims, characterized in that the application model (AM) comprises an organization model (OM) in which at least one organization and process structure of the organization, within which the software application to be generated at runtime, and / or a Business process that is to be mapped with the software application to be created at runtime.

7. The method according to any one of the preceding claims, characterized in that for the access of a user to a stored in the client-specific database (CSD) set of data (DS) of a data object, the model engine (ME)

- read the application model (AM),

generates an object instance to the data object in a memory,

- reads out the set of data (DS) belonging to the data object from the client-specific database (CSD) and

- Creates a visualization of the object instances in dependence on the read data on the user interface (GUI).

8. Method according to one of the preceding claims, as far as dependent on claim 2, characterized in that the model engine (ME)

a first processing module for processing the meta-model (MM), a second processing module for processing the application configuration model (AKM) and

- a higher-level generation unit

comprises, wherein the higher-level generation unit queries after loading the meta-model (MM) by the first processing module and after loading the application configuration model (AKM) by means of the second processing module into a main memory for generating the software application necessary information from the first and second processing modules and at runtime generates the software application. 9. The method according to claims 6 and 8, characterized in that the model engine (ME) additionally comprises a third processing module for processing the organization model (OM) and queries the parent generating unit in addition to the generation of the software application and information from the third processing module after the organization model (OM) has been loaded into a working memory by means of the third processing module and generates the software application at runtime.

10. The method according to any one of the preceding claims, characterized in that by the application model (AM) certain functions of the software application (AW) are machine readable, which are executable at runtime.

1 1. A method according to claim 10, characterized in that generic function modules are implemented in the application platform, which are specified at runtime by the application model (AM) and configured to provide the executable functions.

12. The method according to any one of the preceding claims, characterized in that a plurality of client-specific databases (CSD) and / or a plurality of preconfigured application models are stored in a database (DB) of the application platform.

13. The method according to any one of the preceding claims, characterized in that at least one client-specific database (CSD) and / or at least one preconfigured application model (AM) in a local database (DB) of a user is deposited and the application platform is provided by a server system.

14. The method according to any one of the preceding claims, characterized in that for different software applications (AM) different application models in a database (DB) of the application platform and / or a local database (DB) of a user are deposited, so that to provide one of several different software applications (AM) a particular application model (AM) by the model engine (ME) is read at runtime and a user interface (GUI) based on this application model (AM) is generated.

Computer-implemented device for the automated generation and provision of at least one client / server-based software application with a user interface for a user, in particular for carrying out a method according to one of claims 1 to 14, wherein the device comprises at least the following: an application platform, in a user can log in, at least one client-specific database (CSD), in which data can be stored, at least one application model (AM) stored in the client-specific database (CSD) for generating the at least one software application (AW), wherein the application model (AM) can be used to machine-operate the functionality of the software application (AW), a user interface (GUI) and the data structure are described, and a model engine (ME) on the application platform for accessing data of the client-specific database (CSD), wherein the application model (AM) after logging in a user at runtime by means of the model engine (ME) is readable and a software application (AW) can be generated at runtime on the basis of the application model (AM) by means of the model engine (ME), which contains a user interface (GUI) via which the user can access data from the client-specific database (CSD), and wherein the model engine (ME) is implemented such that commands of the user at the user-generated user interface (GUI) of the software Application (AW), which relate to a particular data object, are passed to the model engine (ME) at runtime and the model engine (ME) allows the user access to the data object belonging to the data object using the application model (AM) ,

16. Device according to claim 15, characterized in that the

Application platform has a control device that loads the application model (AM) from the client-specific database (CSD) in the main memory of a computer on which the device is installed after logging in a user.

17. A computer program product for operating a computer, in particular a web server, comprising machine-readable code which, when executed on the computer, is designed to cause the computer to carry out a method according to one of claims 1 to 14.

18. A machine-readable storage medium, comprising machine-readable program code that is configured on a computer, in particular a

Web server to be executed and the computer in the execution of To cause program codes to perform a method according to any one of claims 1 to 14.

Computer-implemented device for creating a

The computer program product of claim 17, wherein an application model (AM) comprises at least one of a meta-model (MM) and an application configuration model (AKM), the device having at least the following:

a first generation module (MMD) for creating a meta-model (MM), wherein metadata elements in the meta-model (MM) are defined and data field structures for the user interface (GUI), attributes and / or functions associated with the metadata elements are defined, and

a second creation module (AKMD) for creating an application configuration model (AKM), the application model model (AKM) specifying the meta-model (MM) and data objects for the software application (AW) other than meta-data elements of the meta-model (MM) derive concrete roles for the software application (AW) to be created at runtime in the application configuration model (AKM) metadata elements,

wherein at least one of the build modules (MMD, AKMD) defines at least one graphical user interface over which an operator may create a meta-model (MM) and / or an application configuration model (AKM).

20. Device according to claim 19, characterized in that the meta model (MM) and / or the application configuration model (AKM) comprise at least one XML document and the first and / or second generation module (MMD, AKMD) the generation and / or modification of a XML document to create the respective model (MM, AKM). 21. Device according to claim 19 or 20, characterized in that the device additionally has a third generation module (OMD) for the creation of an organizational model (OM), wherein in the organization model (OM) at least one organization and process structure of the organization, within which the is to be used at runtime software application to be generated, and / or a business process, which is to be mapped with the software application to be generated at runtime, are stored.

22. Device according to claim 21, characterized in that

an operator can also create an organizational model (OM) via the graphical user interface and / or

- The organization model (OM) comprises at least one XML document and the third generation module (OMD) allows the generation and / or modification of an XML document to create the organization model (OM).