Methods and systems for managing apps, particularly for developing apps that include event artifacts

Abstract

A method and system for managing apps, particularly for developing apps including event artifacts. A method implemented by a computer for improved management of an app (120), particularly for improved development of an app (120) including event artifacts (122), comprising: ● providing a user with an app development user interface (UI) (116) of an app development platform (118) for developing an app (120); ● capturing a user's intent to retrieve each event artifact (122) from each deployed and running production app (124) to develop the app (120) in response to user interactions with the app development UI (116); ● bringing each event artifact (122) corresponding to the captured user's intent into the app development UI (116); ● developing the app (120) through the app development UI (116) using each retrieved event artifact (122); A method implemented by a computer is proposed, comprising: a step of placing and executing a developed app (120) on a target device (140); a step of bringing event information (126) corresponding to each event artifact (122) from each production app (124) to a data storage platform (150); a step of providing the event information (126) brought to the data storage platform (150) to the placed and executing app (120) from the data storage platform (150); and a step of generating output data (130) by applying an app algorithm (128) included by the placed and executing app (120) to the provided event information (126).

Description

Technology Field

[0001] The present disclosure relates generally to software management systems, in particular to systems for developing apps that can be used to manage, build, test, deploy, and iterate on apps (collectively referred to herein as product systems). Background Technology

[0002] Recently, an increasing number of computer software products in the form of applications, simply referred to as “apps” throughout this patent document, are being utilized for both personal and business needs. Such apps can be used on cloud computing platforms and “on-premise” as well as in mobile contexts, and can provide a specific set of functions. The present invention generally relates to the development and creation of such apps, in particular, apps comprising event artifacts.

[0003] Currently, product systems and solutions exist that support the management or development of such apps. Such product systems can benefit from improvements.

[0004] Various disclosed embodiments include methods and computer systems that can be used to facilitate the management of the app.

[0005] According to a first aspect of the present invention, a computer-implemented method for managing an app is,

[0006] ● A step of providing the user interface (UI) of an app development platform for developing an app to the user;

[0007] ● A step of capturing the user's intent to retrieve each event artifact from each deployed and running producing app in order to develop the app in response to user interactions with the app development UI;

[0008] ● A step of bringing each event artifact corresponding to the captured user intent into the app development UI;

[0009] ● The stage of developing the app through the app development UI using each imported event artifact;

[0010] ● Step of deploying and running the developed app on a target device;

[0011] ● A step of retrieving event information corresponding to each event artifact from each production app to a data storage platform;

[0012] ● A step of providing event information retrieved from a data storage platform to a deployed and running app from the data storage platform; and

[0013] ● It may include a step of generating output data by applying an app algorithm included by an app that is deployed and running in the provided event information.

[0014] According to a second aspect of the present invention, a computer system may be arranged and configured to execute steps of a method implemented by such computer managing an app. In particular, the described computer system may be arranged and configured to execute the following steps:

[0015] ● A step of providing the user interface (UI) of an app development platform for developing an app to the user;

[0016] ● A step of capturing the user's intent to retrieve each event artifact from each deployed and running production app in order to develop the app in response to user interactions with the app development UI;

[0017] ● A step of bringing each event artifact corresponding to the captured user intent into the app development UI;

[0018] ● The stage of developing the app through the app development UI using each imported event artifact;

[0019] ● Step of deploying and running the developed app on a target device;

[0020] ● A step of retrieving event information corresponding to each event artifact from each production app to a data storage platform;

[0021] ● A step of providing event information retrieved from a data storage platform to a deployed and running app from the data storage platform; and

[0022] ● A step of generating output data by applying an app algorithm included by the app deployed and running on the provided event information.

[0023] According to a third aspect of the present invention, a computer program product may include computer program code that, when executed by a computer system, causes the computer system to perform a method implemented by such computer that manages an app.

[0024] According to a fourth aspect of the present invention, a computer-readable medium may include computer program code that, when executed by a computer system, causes the computer system to perform a method implemented by such computer for managing an application. For example, the described computer-readable medium may be non-transitory and may additionally be a software component on a storage device.

[0025] In some examples, the mentioned app development platform may be a visual model-based and / or low-code app development platform, which is described in more detail below.

[0026] The foregoing has outlined the technical features of the present disclosure somewhat broadly to enable a person skilled in the art to better understand the following detailed description. Additional features and advantages of the present disclosure that form the subject of the claims will be described below. A person skilled in the art will understand that the concepts and specific embodiments disclosed can be readily utilized as a basis for modifying or designing other structures to achieve the same purposes of the present disclosure. A person skilled in the art will also understand that such equivalent configurations do not depart from the spirit and scope of the present disclosure in their broadest form.

[0027] Furthermore, before proceeding with the following detailed description, it should be understood that various definitions of specific words and phrases are provided throughout this patent document, and that a person skilled in the art will understand that such definitions apply to prior and future uses of such defined words and phrases in many, if not most, instances. While some terms may encompass a wide range of embodiments, the appended claims may expressly limit these terms to specific embodiments. Brief explanation of the drawing

[0028] FIGS. 1 through 8 illustrate functional block diagrams of exemplary systems that each facilitate the management of apps in a product system. FIGS. 9 through 13 illustrate flowcharts of exemplary methods that facilitate the management of apps in a product system, respectively. FIG. 14 illustrates a block diagram of a data processing system in which an embodiment can be implemented. Specific details for implementing the invention

[0029] Now, various technologies relating to systems and methods for managing apps, particularly apps including event artifacts, in product systems will be described with reference to the drawings, and the same reference numerals throughout the drawings indicate the same elements. The drawings discussed below and the various embodiments used to explain the principles of the present disclosure in this patent document are merely for illustrative purposes and should not be construed as limiting the scope of the present disclosure in any way. A person skilled in the art will understand that the principles of the present disclosure may be implemented in any appropriately arranged device. It should be understood that a function described as being performed by specific system elements may be performed by a plurality of elements. Similarly, for example, an element may be configured to perform a function described as being performed by a plurality of elements. Many of the innovative teachings of this patent document will be described with reference to exemplary non-limiting embodiments.

[0030] An app generally refers to a software program that performs specific desired tasks upon execution. Typically, some apps operate on one or more operating systems ("OS"), virtual machines (e.g., Java TM It runs in a runtime environment that includes support for programming languages), device drivers, etc.

[0031] Apps, including native apps, can be created, edited, and represented using traditional source code. Examples of such traditional source code include C, C++, Java, Flash, Python, Perl, and other script-based methods for representing apps. Developing, creating, and managing such script-based apps, or parts of such script-based apps, can be achieved through manual coding by appropriately trained users.

[0032] Developers often use Application Development Frameworks ("ADFs") (which are applications or apps themselves) to implement or develop the apps they want. An ADF provides a set of predefined code and data modules that can be used directly or indirectly in the development of an app. An ADF can also provide tools such as Integrated Development Environments ("IDEs"), code generators, and debuggers that facilitate developers from coding or implementing the desired logic of an app in a faster or simpler way.

[0033] Generally, ADFs simplify app development by providing reusable components that can be utilized by app developers to define user interfaces ("UIs"), and by providing app logic through, for example, selecting components to perform desired tasks and defining the appearance, behavior, and interactions of the selected components. Some ADFs are based on the Model-View-Controller design pattern, which promotes loose coupling and easier app development and maintenance.

[0034] According to another approach, apps can also be created, edited, and represented using visual model-based representations. Unlike traditional source code implementations, such apps can be created, edited, and / or represented by drawing, moving, connecting, and / or separating visual depictions of logic elements within a visual modeling environment. Visual model-based representations of apps may utilize symbols, shapes, lines, colors, shading, animations, and / or other visual elements to represent logic, data, or memory structures, or user interface elements. To program traditional script-based apps, programmers are typically required to type out detailed scripts according to a complex set of programming syntax rules. In contrast, programming visual model-based apps can, in some cases, be done by connecting various logic elements (e.g., action blocks and / or decision blocks) to create a visual flowchart that defines the app's behavior. Similarly, in visual model-based apps, defining data structures (e.g., variable types, database objects, or classes) and / or user interface elements (e.g., dropdown boxes, lists, text input boxes) can be done by drawing, placing, or connecting visual representations of logic elements within a virtual workspace, in contrast to typing out detailed commands in a script. Therefore, visual model-based apps, including native apps, can be more intuitive for programming and / or editing compared to traditional script-based apps. In this document, an approach is proposed for managing apps, specifically for developing apps that include event artifacts that may contain the described visual model-based representations.

[0035] For the sake of brevity, references to "model," "visual model," "application," or "app" should be understood to refer to visual model-based apps, including native apps, unless specifically indicated otherwise. In some cases, such visual model-based apps may represent complete, standalone apps for execution on a computer system. Visual model-based apps may also represent individual modules configured to perform specific tasks or functions but not complete apps; instead, such individual modules may be embedded within a larger app or combined with other individual modules to perform more complex tasks. Examples of such individual modules may include modules for validating ZIP codes, receiving information about the current weather from a weather feed, or rendering graphics.

[0036] Visual models may be represented in two forms: an internal representation and one or more associated visual representations. An internal representation may be a file encoded according to a file format used by the modeling environment to capture and define the behavior of the app (or part of the app). For example, an internal representation may define the inputs the app can receive, the outputs the app can provide, the algorithms and behaviors that enable the app to reach results, the data the app can display, and the data the app can store. Internal representations may also be used to instruct the execution environment on how to execute the app's logic during runtime. Internal representations may also be stored in the form of human-unreadable code (e.g., binary code). Internal representations may also be stored in binary-stored JSON (JavaScript Object Notation) format and / or XML format. At runtime, the execution engine may use the internal representation to compile and / or generate executable machine code that enables the processor to implement the model's functions when executed by the processor.

[0037] Internal representations can be associated with one or more visual representations. Visual representations may include visual elements that illustrate how the app's logic flows but are not designed to be compiled or executed. These visual representations may include, for example, flowcharts or decision trees that show the user how the app will function. Visual models can also visually depict data to be received from the user, data to be stored, and data to be displayed to the user. These visual models can also be interactive, allowing the user to manipulate the model in an intuitive manner. For example, visual representations may be configured by default to display a specific level of detail (e.g., the number of branches, the number of displayed parameters, the granularity of the displayed logic). However, users can interact with the visual representation to display a desired level of detail—for example, users can display or hide branches of logic and / or display or hide sets of parameters. Details regarding elements of the visual model may be hidden from the view by default, but may appear in a sliding window or popup that appears on the screen when the user clicks the appropriate element. Users may also zoom in or out of the model and / or pan across different parts of the model to examine different parts of the model. Users may also copy or paste branches of logic from one section of the model to another, or copy and paste branches of logic from a first model to a second model. In some cases, parts of the model may include links to other parts of the model, so that when a user clicks a link, the user will automatically be led to another part of the model. The viewing user may interact with the visual representation in at least some of the same ways in which the viewing user can interact with the model if it were displayed within the modeling environment.That is, a visual representation can be configured to mimic how a model would appear if it were displayed within a visual modeling environment. A single internal representation can correspond to multiple visual representations that use different styles or formatting rules to display app logic. For example, multiple visual representations corresponding to the same internal representation may differ from one another in the use of color, elements included or omitted, and symbols, shapes, lines, colors, and / or shading to depict the logic flow.

[0038] Approaches involving the aforementioned functions of visual model-based representations, visual model-based apps, and / or visual models are sometimes understood to be encompassed by so-called low-code development platforms. For example, such low-code development platforms can be further described as software that provides a development environment used to create application software through graphical user interfaces and configurations instead of traditional hand-coded computer programming. Low-code models can enable developers of various experience levels to create applications using visual user interfaces along with model-driven logic. Such low-code development platforms may produce entirely functional apps or require additional coding for specific situations. Low-code app development platforms can enable the accelerated delivery of business apps by reducing the amount of traditional hand-coding. A general advantage is that a wider range of people, not just those with formal programming skills, can contribute to app development. Low-code app development platforms can also lower the initial costs of setup, training, deployment, and maintenance.

[0039] Referring to FIG. 1, a functional block diagram of an exemplary computer system or data processing system (100) is illustrated to facilitate the management of apps (120), particularly an app (120) including an event artifact (122). The processing system (100) may include a (visual model-based) app development platform (118) comprising at least one processor (102) configured to execute at least one application software component (106) from memory (104) accessed by the processor (102). Here, the app development platform (118) may include the aforementioned functions of visual model-based representations, visual model-based apps, and / or visual models, and may be, for example, a visual model-based app development platform or a low-code app development platform. The application software component (106) may be configured (i.e., programmed) to cause the processor (102) to perform various operations and functions described herein. For example, the described application software component (106) may include and / or correspond to one or more components of an app development application configured to generate product data and store it in a data store (108), such as a database. Furthermore, the described application software component (106) may include and / or correspond to one or more components of an app creation or development application.

[0040] For example, the app development platform (118) may be cloud-based, internet-based, and / or operated by a provider that provides app development and creation support, including, for example, support for low-code and / or visual model-based app development. The user may be located near the app development platform (118) or remotely from the app development platform (118), for example, elsewhere, using a mobile device to access the app development platform (118) via the internet, for example, and the mobile device may include an input device (110) and a display device (112). In some examples, the app development platform (118) may be installed and run on the user's device, such as a computer, laptop, pad, on-premises computing facility, etc.

[0041] Examples of product systems that may be adapted to include app management and / or development including the event artifact features described herein may include the low-code software development platform of Mendix Inc., Boston, Massachusetts, USA. This platform provides tools for building, testing, deploying, iterating, developing, creating, and managing apps (120) and is based on visual model-driven software development. However, it should be understood that the systems and methods described herein may be used in other product systems (e.g., product lifecycle management (PLM), product data management (PDM), application lifecycle management (ALM) systems) and / or any other type of system that generates product data and stores it in a database. Additionally, examples of databases that may be used as one or more data stores described herein include database server applications such as Oracle, Microsoft SQL Server, or any other type of data store that operates to store data records.

[0042] It should be understood that managing apps (120) in complex app development and / or management environments, particularly developing apps (120) that include event artifacts (122), can be difficult and time-consuming. For example, advanced coding or software development or management knowledge may be required of users, or the selection of many options may need to be conscious, both of which involve many manual steps that are long and inefficient processes.

[0043] To enable the development of enhanced management apps (120), particularly an app (120) containing event artifacts (122), the described product system or processing system (100) may include at least one input device (110) and at least one display device (112) (such as a display screen). The described processor (102) may be configured to generate a graphical user interface (GUI) (114) through the display device (112). Such a GUI (114) may include GUI elements such as buttons, links, search boxes, lists, text boxes, images, and scroll bars available to a user to provide inputs through the input device (110) that cause the development and, for example, deployment of the app (120). As an example, the GUI (114) may include an app development UI (116) provided to the user to develop the app (120).

[0044] In an exemplary embodiment, the application software component (106) and / or processor (102) may be configured to provide the app development user interface (UI) (116) of the app development platform (118) to the user to develop an app (120).

[0045] As mentioned above, the app development platform (118) may include visual model-based representations, visual model-based apps and / or the aforementioned functions of visual models, and may be, for example, a visual model-based app development platform or a low-code app development platform. The app development UI (118) may provide an interactive user interface of the app development platform (118) that supports and enables a user to develop an app (120). For example, the app (120) may be or include a software program that performs specific desired tasks when executed.

[0046] In some examples, the application software component (106) and / or processor (102) may be further configured to capture the user's intent to retrieve each event artifact (122) from each deployed and running production app (124) to develop the app (120) in response to user interactions with the app development UI (116).

[0047] For example, an event may be an action or occurrence recognized by the software, for example, each production app (124) or app (120) to be developed, which often occurs asynchronously from an external environment such as each production app (124) that can be handled by the software. For example, computer events may be generated or triggered by the system, by a user, or in other ways. Events may be handled in synchronization with the program flow, that is, the software may have one or more dedicated places where events are handled, often an event loop. Sources of events may include each production app (124), (other) users, machines, or devices that can interact with the software, such as each production app (124). The software may also trigger its own set of events in the event loop from time to time, for example, to communicate the completion of a task. Software that changes its behavior in response to events is often said to be event-driven, aiming for interactivity. In that context, each event artifact (122) may be information that characterizes or describes such an event or such type of event.

[0048] Such event artifacts (122) may be included or produced by other apps, such as each production app (124) that can be deployed and executed on some other device (144), for example. The user may interact with the app development UI (116) to express their intention to retrieve each event artifact (122) to develop the app (120). This can significantly facilitate and accelerate the development of the app (120), particularly for users who are non-IT professionals, because a wide variety of different event artifacts (122) may be available for retrieving and using to develop the app (120).

[0049] For example, an event artifact search UI (136) may be provided to the user through the app development UI (116) to allow the user to search for specific event artifacts (122). Subsequently, available event artifacts (122) may be displayed to the user through the event artifact search UI (136) for selection, and the user may select one of the displayed event artifacts (122) to bring into the app development UI (116) for the purpose of developing an app (120). In some examples, all available event artifacts (122) may be displayed to the user through the event artifact search UI (136) for selection, and the user may select one of the displayed event artifacts (122) to bring into the app (120) for the purpose of developing an app (120).

[0050] In some examples, available event artifacts (122) may be stored in a repository (150) of event artifacts (122). Such a repository (150) may be provided, for example, by GitHub, Inc. in San Francisco, California, USA. In other examples, the repository (150) of event artifacts (122) may be included by an app development platform (118) or a data processing system (100).

[0051] In additional examples, it should be understood that the application software component (106) and / or processor (102) may be further configured to bring each event artifact (122) corresponding to the captured user intent into the app development UI (116). For example, bringing in may be done by a "drag and drop" or "dropdown" window in the app development UI (116).

[0052] To retrieve each event artifact (122), for example, each event artifact (122) may be copied to the app development UI (116). In some examples, retrieving each event artifact (122) may involve retrieving metadata of each event artifact (122) or related event information (126), which is described in more detail below. Such metadata may include information regarding the origin of the event artifact, such as each production app (124), (other) users, machines, or devices. The mentioned metadata may include possible states that may change when the event occurs during the operation of each production app (124), such as, for example, information regarding start, stop, pending, completion, or possible changes or transitions between states. In some examples, the metadata mentioned may include information regarding the type and / or format of each event artifact (122) or related event information (126), such as integers, decimals, text strings, Boolean data, etc., and more complex or synthetic information such as pictures, photographs, sound data, etc. may also be used.

[0053] In the case of an exemplary production app (124) in a retail domain, each event artifact (122) may be associated with a new purchase order from a customer, and the metadata mentioned for each event artifact (122) may include information regarding the customer, vendor, product, quantity, price, delivery date, etc. In an industrial environment, the production app (124) may be used to operate or monitor a machine or other device (144), and thereby each event artifact (122) may be associated with a malfunction of another device (144) that may require service action. In this environment, the metadata mentioned may include typical normal operation scenarios of the other device (144) and / or different typical error scenarios, such as scenarios of broken or worn hardware parts, such as software bugs or IT security issues.

[0054] In some examples, retrieving each event artifact (122) may further include connectivity information that may be required to allow obtaining or retrieving each event artifact (122) and / or event information (126) described below from each production app (124). Such connectivity information may allow establishing a communication connection between each production app (124) and the (consuming) app (120), which may include, for example, intermediate communication participants such as the data storage platform (150) described below.

[0055] Retrieving each event artifact (122) may, in some examples, allow each piece of information to be used during the development and / or creation phase of the app (120) or during the deployment and / or operation of the created app (120).

[0056] In additional examples, the application software component (106) and / or processor (102) may be further configured to develop an app (120) through an app development UI (116) using each of the imported event artifacts (122).

[0057] Using each of the imported event artifacts (122), the app (120) can be developed through an app development UI (116) that can achieve the development of the app (120) by interacting with, for example, an ADF, an IDE, visual model-based representations, or the aforementioned (low-code) app development platform (118). Here, the app development platform (118) can facilitate supporting non-expert users to use each of the event artifacts (122) to develop the app (120) together with each of the event artifacts (122).

[0058] For example, the application software component (106) and / or processor (102) may be further configured to deploy and execute an app (120) developed on a target device (140).

[0059] Here, the app (120) may be understood as being deployed when activities are required to make the app (120) available for use by the app user on the target device (140). The app deployment process may include several interrelated activities having possible transitions between them. These activities may occur on the producer side (e.g., by the app developer) or on the consumer side (e.g., by the app user or end user), or both. In some examples, the app deployment process may include at least the release of the app (120) and the installation and activation of the app (120). The release activity may follow from a completed development process and is sometimes classified as part of the development process rather than the deployment process. It may include actions necessary to prepare a system (e.g., the app development platform (118) or an online app store) for assembly and transmission to the computer system(s) (e.g., the app development platform (118)) on which it will be executed at production. Accordingly, it may sometimes include determining the resources required for the system to operate at acceptable performance and planning and / or documenting subsequent activities of the deployment process. For simple systems, the installation of the app (120) may include establishing some form of command, shortcut, script, or service for running the software of the app (120) (manually or automatically). For complex systems, it may involve configuring the system by possibly asking end-user questions regarding the intended use of the app, or directly asking them how they want the end-user questions configured, and / or making all required subsystems ready for use.Activation may be an activity of launching an executable component of software or an app (120) for the first time (which should not be confused with the common use of the term activation regarding software licenses, which is a function of digital copyright management systems). Once the app (120) is deployed on each target device (140), the app (120) may be operated to fulfill the business needs of the app (end) user.

[0060] In some examples, each target device (140) may be a smartphone, smartwatch, handheld, pad, laptop, etc., or a desktop device including, for example, desktop computers, or other “smart” devices, for example, smart television sets, refrigerators, home or industrial automation devices, and smart television sets may be, for example, a television set with integrated internet capabilities or a set-top box for television that provides more advanced computing capabilities and connectivity than a basic television set of the time.

[0061] Additionally, for example, each target device (140) may be a manufacturing operation management (MOM) system, a manufacturing execution system (MES), and an enterprise resource planning (ERP) system, a supervisory control and data acquisition (SCADA) system, or any combination thereof, or may include these.

[0062] In some examples, each device (140) on which the app (120) can be deployed and executed may utilize each event artifact (122) of each production app (124) on which the app (120) can be deployed and executed on another device (144). In some examples, the other device (144) may be or may include, in some examples, an actuator such as a sensor, an electric motor, a valve or robot, an inverter supplying the electric motor, a gearbox, a PLC (programmable logic controller), a communication gateway, and / or generally industrial automation products and other parts or components related to industrial automation. Each target device (140) may be part of a complex production line or production plant, for example, a bottle filing machine, a conveyor, a welding machine, a welding robot, etc. In some examples, if another device (144) belongs to a lower level of the automation pyramid, such as a sensor / actuator or field level, each target device (140) may belong to a higher level of the automation pyramid, such as a field level or control level.

[0063] Additionally, it should be understood that in some examples, the application software component (106) and / or processor (102) may be further configured to bring event information (126) corresponding to each event artifact (122) from each production app (124) to the data storage platform (150).

[0064] In some examples, event information (126) may be considered as live or current information regarding each event artifact (122), thereby allowing each event artifact (122) to form a framework for the corresponding event information (126). The event information (126) may include specific changes in state, such as start, stop, or completion, corresponding to the above descriptions regarding each event artifact (122), for example, when the event just occurs during the operation of each production app (124).

[0065] In the case of the exemplary production app (124) in the retail domain example above, the event information (126) may be or may include information that a specific customer purchase order has just been received, processed, stopped, or completed. In some examples, the event information (126) may further include information regarding a specific customer, specific vendor, specific product, specific quantity, specific price, specific delivery date, etc. of a specific purchase order. In the case of the exemplary production app (124) in the industrial environment example above, the event information (126) may be or may include information that a specific operational state or malfunction of another device (144) has just occurred. In these examples, the event information (126) may include information that a production step has been completed or information that a specific error scenario is now applied to another device (144), such as a specific new detection of a broken or worn hardware part, such as a software bug or an IT security issue.

[0066] Retrieving event information (126) from each production app (124) to the data storage platform (150) may, in some examples, be done as soon as the event information (126) is generated by each production app (124). This allows some kind of live or latest information regarding the event information (126) corresponding to each event artifact (122) to be generated by each production app (124). In other examples, the above retrieving may be done at a given frequency, for example, once per minute or hour, thereby allowing each production app (124) to automatically transmit the event information (126) to the data storage platform (150) or the data storage platform (150) to actively poll each production app (124) for recent event information (126). Additionally, retrieving event information (126) can be understood as transmitting data of event information (126) from each production app (124) to the data storage platform (150). For example, the described retrieving of event information (126) from each production app (124) to the data storage platform (150) can be performed asynchronously so that the relevant communication participants, in particular each production app (124) to the data storage platform (150), are only loosely coupled.

[0067] For example, the data storage platform (150) may include Apache Kafka, an open-source stream-processing software platform developed by the Apache Software Foundation. Apache Kafka provides an integrated, high-throughput, low-latency platform for handling real-time data feeds. In some examples, Apache Kafka may be closer to each production app (124) and / or each device on which each production app (124) is running, and may have higher throughput and higher availability. It should be understood that bringing event information (126) from each production app (124) to the data storage platform (150) can enable asynchronous communication and low-level coupling. Accordingly, the use of the data storage platform (150) may be particularly advantageous in some examples, even if each production app (124), each device on which each production app (124) is running, (consumption) app (120), and / or target device (140) are not always available, because the data storage platform (150) still allows communication and retrieval of event information (126). Additionally, it should be understood that in some examples, the data storage platform (150) may allow partial or complete rollback of event information (126) in the event of data corruption regarding event information (126) or in the event related to event information (126) being cancelled or rolled back.

[0068] The data storage platform (150) may be, for example, a cloud-based platform accessible from anywhere via the internet. The data storage platform (150) may be hosted by one of the major cloud computing providers, such as Amazon Web Services, Alibaba, SAP, Google, etc.

[0069] Alternatively, the data storage platform (150) may be an on-site platform that may include appropriate computing facilities located on the company's premises for managing the company's artifact information, for example. Hybrid versions or virtual private cloud solutions may also be possible for the data storage platform (150). In some examples, the data storage platform (150) may be included in or integrated with the app development platform (118) or the data processing system (100).

[0070] Additionally, it should be understood that the concept of introducing a data storage platform (150) between the production app (124) and the (consuming) app (120) can be considered as a data broker or a message broker in some examples. In some examples, the data storage platform (150) can function as an intermediary computer program module capable of converting a message (here, event information (126)) from the formal messaging protocol of the sender (here, each production app (124)) to the formal messaging protocol of the receiver (here, (consuming) app (120)). Furthermore, the concept of introducing a data storage platform (150) between the production app (124) and the (consuming) app (120) can be understood, for example, as an architectural pattern for message (here, event information (126)) verification, conversion, and routing. It mediates communication between applications (here, each production app (124) and (consumption) app (120)) to exchange messages and minimizes the mutual awareness that applications must have of each other in order to effectively implement decoupler.

[0071] For example, the application software component (106) and / or processor (102) may be further configured to provide event information (126) brought to the data storage platform (150) to the deployed and running app (120) from the data storage platform (150).

[0072] After the event information (126) is retrieved from each production app (124) to the data storage platform (150), the event information (126) can be provided from the data storage platform (150) to the deployed and running (consuming) app (120), for example, transmitted.

[0073] The provision of event information (126) from the data storage platform (150) to the (consuming) app (120) may be performed, in some examples, as soon as the event information (126) is brought into the data storage platform (150), and in additional examples, as soon as the event information (126) is generated by each producing app (124). This allows some kind of live or up-to-date information regarding the event information (126) corresponding to each event artifact (122) to be generated by each producing app (124). In other examples, the above-mentioned bringing may be performed at a given frequency, for example, once per minute or hour, thereby allowing the data storage platform (150) to automatically transmit the event information (126) to the (consuming) app (120) or the (consuming) app (120) to actively poll the data storage platform (150) for recent event information (126). For example, the two communication steps—a) from each production app (124) to the data storage platform (150) and b) from the data storage platform to the (consuming) app (120)—can be performed asynchronously so that the relevant communication participants, in particular each production app (124) and the (consuming) app (120), can be loosely coupled.

[0074] In some examples, the application software component (106) and / or processor (102) may be further configured to apply an app algorithm (128) included by the deployed and running app (120) to the provided event information (126) to generate output data (130).

[0075] In some examples, the app (120) includes an app algorithm (128) corresponding to a given business logic or the purpose of the app. The app algorithm (128) may accept provided event information (126) as input data that is processed according to the app algorithm (128) to generate output data (130). In the case of the above retail domain example, the app algorithm (128) may accept a new specific purchase order as input data and then process this new specific purchase order to generate output data (130) that may include, for example, triggering the generation of an invoice that may be sent to a buyer, the assembly of the purchased product, or the collection of the purchased product from a storage warehouse. In the case of the above industrial environment example, the app algorithm (128) may accept a new specific operating state or error or defect message as input data and then process this new specific operating state or specific error or defect message to generate output data (130) which may include triggering the next production step, shutdown, maintenance, or repair of another device (144) that may be operated or monitored by the production app (124), for example.

[0076] The proposed approach may provide several advantages, including the inclusion of more data sources, such as a repository (150) (or multiple repositories) capable of providing multiple event artifacts (122) that can be reused by the user for the development, deployment, and execution of the app (120). Additionally, the proposed approach may provide greater insight into the business or industrial environment in which the app (120) may be utilized. This greater insight may be achieved through event triggers that can be beneficial for automating and optimizing sequences of actions and activities that could previously be performed to a greater extent using manual steps or different, potentially independent software application programs, which may already be performed in the business or industrial environment but may cause data or process discrepancies. Thus, higher availability and reliability may also be achieved by using the proposed approach, for example, by allowing asynchronous communication or by distributing computational or communication workloads among several apps (120). An additional advantage of the proposed approach is that, due to its simplicity, it may be available to non-IT professionals and, for example, to so-called citizen users who rely on or prefer low-code app development.

[0077] Additionally, it should be understood that the proposed approach has the advantage of hiding the complexity of integration, such as version control or payload management, from the user developing, deploying, and running the app (120). At the same time, the proposed approach may allow for more complexity and more complexity management in a simple way by providing the possibility to combine event artifacts (122) from different production apps (124), for example, with business logic or app algorithms (128) implemented in or included by the app (120). In some examples, N-1 communication can be conveniently set up by the user by retrieving corresponding event artifacts (122) from different production apps (124) or from different other devices (144) where the same or different production apps (124) are running. In additional examples, even NN-communication can be realized by the user by developing two or more (different) (consuming) apps (120) in which corresponding event artifacts (122) can be taken from different production apps (124) or from different other devices (144) where the same or different production apps (124) are running. Additionally, the proposed approach can allow for new types of complexity or processes, and, for example, many processes can now be simplified by avoiding approval emails.

[0078] In some examples, the application software component (106) and / or processor (102) may be further configured to display the generated output data (130) to the user of the target device (140) through the user interface (142) of the target device (140).

[0079] To this end, the target device (140) may include a user interface (142) that can be displayed on a display device (such as a display screen) of the target device (140), for example. In this context, the target device (140) may be implemented by, for example, a smartphone, or an industrial automation product such as a PLC or an inverter, or by part of a complex production line or production plant, for example, a bottle filling machine, a conveyor, a welding machine, a welding robot, etc.

[0080] The generated output data (130) can be displayed to the (end) user of the target device (140) through the user interface (142), thereby enabling the user to trigger additional actions, such as triggering the next production step, shutdown, maintenance, or repair of the target device (140) or another device (144) connected to the target device (140).

[0081] Each target device (140) may be caused or triggered to display output data (130) generated, for example, by an app development platform (118) or by a deployed and running app (120).

[0082] In additional examples, the application software component (106) and / or processor (102) may be further configured to use the generated output data (130) to analyze, monitor, operate, and / or control the target device (140) or other devices (144) connected to the target device (140), or to use the generated output data (130) to analyze and / or monitor the users of each target device (140).

[0083] Each target device (140) or other device (144) may be analyzed, monitored, operated, and / or controlled using the generated output data (130). In some examples, actions to analyze, monitor, operate, and / or control the target device (140) or other device (144) may be performed by the app development platform (118), the target device (140), or the other device (144). Thus, for example, the app development platform (118) may monitor or control the target device (140) or the other device (144). Additionally, for example, the target device (140) may analyze or control the other device (144). This may be made possible, in some examples, by appropriate event artifacts (122) and corresponding appropriate event information (126) that may contain data and information that may be useful or necessary for analyzing, monitoring, operating, and / or controlling the target device (140) or the other device (144).

[0084] For example, an app development platform (118) or a target device (140) may be caused or triggered to analyze, monitor, operate, and / or control the target device (140) or another device (144), for example, by the app development platform (118) or by an app (120) that is deployed and running.

[0085] It should also be understood that in some examples, the production app (124) is deployed and running on another device (144), and the other device (144) can be analyzed, monitored, operated, and / or controlled by the app development platform (118) or the target device (130) using the generated output data (130).

[0086] In additional examples, the app development platform (118) or the target device (140) may also be caused or triggered, for example by the app development platform (118) or by the deployed and running app (120), to analyze and / or monitor the user of the target device (140) using the generated output data (130). In such more novel examples, the target device (140) may be or include a smartphone, smartwatch, handheld, pad, laptop, etc., and the other device (144) may be a human, for example, the end user of each target device (140), or an animal or plant, wherein the health, behavior, etc. of the human, animal or plant may be analyzed or monitored using the app (120). In some examples, the mentioned steps may be performed directly by the app development platform (118).

[0087] Additionally, it should be understood that in some examples, each event artifact (122) may include at least one event notification and / or at least one event-delivery status transmission.

[0088] In the context of event notification and event-delivery status transmission, a reference is made to the website https: / / martinfowler.com / articles / 201701-event-driven.html.

[0089] In some examples, event notification may occur when a system (here, a production app (124) or a data storage platform (150)) transmits event messages (here, event information (126)) to other systems (here, a data storage platform (150) or a (consuming) app (120)) to notify them of a change in that domain. A key element of event notification may be that the source system may not expect any response to the transmitted message. For example, if the recipient of the event notification responds, there may be a marked separation between the logic flow transmitting the event and any logic flow responding to some reaction to that event. The approach to event notification may be advantageous because it implies a low-level coupling between one production app (124) and the other data storage platform (150) or (consuming) app (120).

[0090] For example, event-forwarded state transmission can be used to update a client of a system (here, the data storage platform (150) or (consuming) app (120)) in a manner that does not require the client to contact the source system (here, the production app (124) or the data storage platform (150)) to perform additional work. For example, a customer management system can transmit an event whenever a customer changes details (such as an address) with events containing details of the changed data. Subsequently, the recipient can use the changes to update their own copy of the customer data and thus have no need to communicate with the main customer system to perform their work in the future. The event-forwarded state transmission approach can allow for greater resilience because the recipient systems can function even if the customer system becomes unavailable or inaccessible. Latency can be reduced because there may be no remote calls required to access customer information, which may imply that the communication workload can be reduced. Thanks to the use of the data storage platform (150), the challenge of keeping all states up to date can be satisfied, so there is no longer a need to actively call the sender for more information when needed.

[0091] Additionally, each event artifact (122) including an event notification or an event-delivery status transmission may be understood to include information characterizing or describing the event notification, the event-delivery status transmission, or information of such type. For example, a specific event notification or event-delivery status transmission related to a specific operation or error scenario, such as a software bug or IT security issue, or a scenario involving a broken or worn-out hardware part, may correspond to the event information (126).

[0092] In some examples, each event artifact (122) may include each event channel (132) containing at least one event artifact (122) from each deployed and running production app (124).

[0093] In some examples, an event channel (132) may be understood as a bundle of correlated event artifacts (122), and this bundle of correlated event artifacts (122) may again be an event artifact (122). In some software architectures, an event channel (132) may be similar to a topic. The use of event channels (132) may facilitate, for example, retrieving event artifacts (122) for app development purposes, or may facilitate routing event information (126) from each production app (124) to a data storage platform (150) and ultimately to a (consuming) app (120). In some examples, it should be understood that creating such an event channel (132) may facilitate collecting and managing correlated event artifacts (122) and event information (126).

[0094] In the case of the retail domain example above, the event channel (132) may group all orders related to one (or more) specific product(s) or all information related to one (or more) specific buyer(s), such as purchase, billing, and delivery information. In the case of the industrial environment example above, the event channel (132) may group all events related to one (or more) specific machine(s) or device(s), or all information related to the occurrence of one (or more) specific error scenario(s).

[0095] In some examples, each event channel (132) may include the aforementioned event notifications and / or event-forward status transmissions. In additional examples, each event channel (132) may include only one or more event notification(s). And in other examples, each event channel may include one or more event-forward status transmission(s). Here, in some cases, using only one event-forward status transmission may be reasonable because it can facilitate tracking the most recent status. Nevertheless, in other cases, two or more event-forward status transmissions may be used to track events or status transmissions that are related to the same topic, such as a specific buyer, but do not interfere with each other, such as changes in order status and changes in billing information for this specific buyer.

[0096] For example, each event channel (132) may be defined or managed by the developer or user of each production app (124). The user who develops or runs the (consuming) app (120) may then retrieve each event channel (132) during app development and consume the information provided by each event channel (132) during the execution of the (consuming) app (120).

[0097] In additional examples, each event channel (132) may further include at least one event artifact (122) from a deployed and running production app (124) and at least one event artifact (122') from at least one second deployed and running production app (124').

[0098] Creating such event channels (132) can facilitate the collection and management of correlated event artifacts (122, 122') and event information (126, 126') originating from different production apps (124, 124') and / or different other devices (144, 144') on which each production app (124, 124') can be deployed and executed. While the concept of event channels (132) may allow for the management of more complex scenarios, this complexity can still be conveniently handled by non-IT professionals developing the app (120) because the event channels (132) can also be brought in by the user to develop the app (120).

[0099] To this end, in some examples, the same or different production app(s) (124, 124') may be deployed and executed a) on the same different device (144), but, for example, in different software environments of the different device (144), and / or b) on different different devices (144, 144'). Then, in some examples, for each production app (124, 124') deployed and executed in each production software environment (on the same different device (144) or different different devices (144, 144'), each event channel (132) may be set up. Also, in some examples, two or more event artifacts (122) of these production apps (124, 124') may be combined into a combined event channel (132).

[0100] As already mentioned above, the event channel (132) may be defined or managed by the developer or user of each production app (124, 124') in some examples. The user who develops or runs the (consuming) app (120) may then retrieve each event channel (132) during app development and consume the information provided by each event channel (132) during the execution of the (consuming) app (120).

[0101] Additionally, it should be understood that in some examples, when an amendment to a production app (124) occurs, the application software component (106) and / or processor (102) may be further configured to display to the user at least two options (134) corresponding to the continued use of each event artifact (122) of the original production app (124) or the initiated use of each modified event artifact (122) of the modified production app (124); to capture the user's intention to select one of the displayed options (134); and, if the user chooses to initiate use of each event artifact (122) of the modified production app (124), to bring event information (126) corresponding to each event artifact (122) from each modified production app (124) to a data storage platform (150).

[0102] The developer of each production app (124) may make modifications to each production app (124) by, for example, modifying the input parameters or sources, business logic, and / or output parameters or targets of each production app (124). To do this, the developer of each production app (124) may re-enter the development phase, make corresponding modifications, and create each modified production app (124). Once each such modified production app (124) is developed, it may be deployed and executed on each device (144). Such modifications may also affect event artifact(s) (122) that may be generated as outputs of each production app (124), for example. Accordingly, each modified event artifact (122") and, if applicable, each modified event information (126") may be generated as the output of each modified production app (124"). The modified event artifact (122") and, if applicable, each modified event information (126") may differ from the original event artifact (122) and, if applicable, each event information (126), for example, in their respective types and / or formats.

[0103] When modifying a production app (124), at least two options (134) may be displayed to the user, thereby allowing the user to understand that the user may be the developer of the app (120) or the user of the deployed and running app (120). The options (134) may be displayed to each user, for example, to the developer via the app development UI (116) or to the user of the deployed and running app (120) via the user interface (142) of the target device (140). The available and displayed options (134) may include continuing to use each event artifact (122) of the original production app (124) or starting to use each (if applicable, modified) event artifact (122)(") of each modified production app (124).

[0104] Subsequently, the user may select one of the displayed options (134) by interacting, for example, with each user interface, namely the app development UI (116) for the developer, and the user interface (142) of the target device (140) for the user of the deployed and running app (120). In some examples, when the user chooses to start using each (applicable, modified) event artifact (122)(") of each modified production app (124"), the event information (126) corresponding to each (applicable, modified) event artifact (122)(") may be retrieved from each modified production app (124") to the data storage platform (150). This event information (126) may then be provided from the data storage platform (150) to the deployed and running app (120).

[0105] In some examples, the developer or user of each production app (124, 124") may need to check or verify that useful event artifacts (122, 122") and / or event information (126, 126") can still be provided to the consuming apps (120). In some examples, this may relate to the content, type, or format of the event artifacts (122, 122") and / or event information (126, 126"). In additional examples, the developer or user of each production app (124, 124") may need to provide a suggestion or choice to indicate that modifications have been made to each production app (124) and to select between at least two options (134): a) continued use of each event artifact (122) of the original production app (124) or b) initiated use of each modified event artifact (122) of the modified production app (124). Another In examples, the app development platform (118) may determine the modification of each production app (124) and provide the mentioned options (134) to the user of the app (120), thereby the user may be the developer of the app (120) or the user of the deployed and running app (120).

[0106] In some examples, if a user chooses to start using each event artifact (122) of each modified production app (124) that is incompatible with each event artifact (122) of each production app (124), it should be further understood that the application software component (106) and / or processor (102) may be further configured to bring each event artifact (122) of each modified production app (124) into the app development UI (116); to develop an app (120) through the app development UI (116) using each brought event artifact (122) of each modified production app (124); and to deploy and run the developed app (120) on a target device (140).

[0107] In some examples, a determination is made as to whether each event artifact (122) of each modified production app (124) is still compatible with each event artifact (122) of each (original) production app (124). This determination may consider, for example, the content, type, or format of the event artifacts (122, 122) and / or event information (126, 126). If each event artifact (122) of each modified production app (124) is not compatible with each event artifact (122) of each (original) production app (124), each event artifact (122) of each modified production app (124) may be imported into the app development UI (116). Then, the app (120) uses each imported event artifact (122) of each modified production app (124) to [introduce] the app development UI (116) The app (120) can be updated by (re)developing it. Then, the updated app (120) can be placed and executed on a target device (140).

[0108] Updating the app (120) can, in some examples, contribute to increasing the availability, reliability, and resilience of the app (120) including the event artifact (122).

[0109] In some examples, the application software component (106) and / or processor (102) may be further configured to provide the user with an event artifact search UI (136) for searching in a repository (152) to store event artifacts (122) available for app development.

[0110] In some examples, the repository (150) of available event artifacts (122) may be provided by GitHub, Inc. in San Francisco, California, USA. In other examples, the repository (150) of event artifacts (122) may be included by an app development platform (118) or a data processing system (100). The repository (150) may be searched by a user developing an app (120) for event artifacts (120) that are available in the repository (150) and may be related to or compliant with the user's business needs or may simplify or accelerate the development of the app (120). Where available, at least one suitable event artifact (122) available in the repository (150) may be displayed to the user via an event artifact search UI (136) for selection. After that, the user interacts with the event artifact search UI (136) to make a selection, indicates their intention to retrieve one of the displayed event artifact(s) (122), and can use this event artifact (122) for their app development.

[0111] In some examples, the application software component (106) and / or processor (102) may be further configured to store information regarding output data (130) generated as an event artifact (122) in a repository (152) of event artifacts (122) that are reusable for app development.

[0112] For example, the repository (152) may be the repository (152) described above. Information to be stored in the repository (152) may be related to output data (130) generated by the app algorithm (128) or the app (120), thereby allowing the output data (130) to be processed, abstracted, or generalized so that the output data (130) is suitable for reuse as an event artifact (122) for developing additional apps. Such generalization of the output data (130) may, in some examples, include extracting the content, type, or format of the output data (130) that may be generated by the app algorithm (128) or the app (120). Thus, the event artifact (122) derived from the output data (130) may, in some examples, not include specific values ​​or results of the output data (130), but rather may reflect the content, type, or format that the output data (130) may have.

[0113] In additional examples, output data (130), particularly specific values ​​or results of output data (130), may be provided to other apps as corresponding event information (126) (e.g., via a data storage platform (150)).

[0114] Appropriate processing, abstraction, or generalization of output data (130) that allows for the reuse of output data (130) as event artifacts (122) may, in some examples, be defined or managed by the developer or user of the app (120). A user developing or running another app capable of consuming this event artifact (122) may then retrieve this event artifact (122) during app development and consume the information provided by the app (120) during the execution of the other app.

[0115] In some examples, the output data (130) may be stored in the storage (152) only as an event artifact (122) when the app (120) is successfully deployed and executed on the target device (140) and optionally when the generated output data (130) is verified. Verification of the generated output data (130) may include a successful comparison of the generated output data (130) with the expected output data (130) or expected event artifact (122) (or optionally expected event information (126)) by, for example, comparing each with similar scenarios. For example, the comparison may consider the content, type, or format of the output data (130) or event artifact (122) (or optionally expected event information (126)). After that, the event artifact (122) stored in the repository (152) can be retrieved from the repository (152) and, for example, can be retrieved by other users to develop other apps (120).

[0116] In additional examples, it should also be understood that the application software component (106) and / or processor (102) may be further configured to store information regarding a) an event artifact (122) from a third-party app or b) output data (130) generated from the third-party app event artifact (122) in a repository (152) of event artifacts (122) that are reusable for app development. For example, information regarding the event artifact (122) from the third-party app or output data (130) generated from the third-party app may be processed, abstracted, or generalized so that the information from the event artifact (122) or the third-party app is suitable for reuse as an event artifact (122) for developing additional apps.

[0117] In additional examples, the application software component (106) and / or processor (102) may be further configured to verify each event information (126) corresponding to each event artifact (122) from each production app (124); and only when each event information (126) is verified, to retrieve each event information (126) corresponding to each event artifact (122) from each production app (124) to a data storage platform (150).

[0118] Verification of each event information (126) may include, for example, a successful comparison of each event information (126) with each expected event information (126) by comparing with similar scenarios. The comparison may, for example, consider the content, type, or format of each event information (126) or specific values ​​or results of each event information (126). Additionally, it should be understood that in some examples, verification may include checking whether the event underlying each event information (126) has been successfully completed, i.e., whether the event has not been rolled back or canceled. In some examples, this check for the successful completion of the event may include verifying that each event information (126) can be verified only after a given time period, after which the rollback or cancellation of the event may become sufficiently unlikely or excluded. In additional examples, the check for the successful completion of the event may include confirming the successful completion of the event by a second independent data source, for example, a user or a different app capable of confirming the successful completion of the event.

[0119] In some examples, verification of each event information (126) may be supported by write-ahead logging (WAL), which is a method to ensure data integrity. Briefly, the central concept of WAL is that changes to data files (where tables and indexes exist, e.g., each event information (126)) must be written only after the changes have been logged, that is, after the log records describing the changes have been flushed to the permanent storage. This approach may allow for the recovery of data lost due to a crash using logs from crash events in the production app (124) or optionally the data storage platform (150); and may allow any changes not applied to data pages to be re-executed from the log records.

[0120] In some examples, each event information (126) may be brought from each production app (124) to the data storage platform (150) only when each event information (126) is verified. That is, in these examples, if each event information (126) is not verified (yet), each event information (126) may not be brought from each production app (124) to the data storage platform (150).

[0121] As illustrated in FIG. 1, the (consuming) app (120) may be stored in the data store (108) of the app development platform (118) along with the included app algorithm (128). Additionally, artifact information (122) and optionally event information (126) may be stored in the data store (108). Here, the event artifact (122) may be used for the purpose of developing the app (120) supported by the app development platform (118). The app (120) may be deployed and executed on a target device (140), for example. The event information (126) corresponding to the event artifact (122) may be derived from a production app (124) deployed and running on another device (144). Event information (126) can first be retrieved from a production app (124) to a data storage platform (150), and the data storage platform (150) can then provide the event information (126) to an app (120) that is placed and running on a target device (140). This provision of event information (126) from the data storage platform (150) can be done directly from the data storage platform (150) to the (consuming) app (120) that is placed and running on the target device (140), or it can be done through an intermediate step including the app development platform (118) so that the event information (126) can first be provided from the data storage platform (150) to the app development platform (118), and then from the app development platform (118) to the (consuming) app (120) that is placed and running on the target device (140).

[0122] The target device (140) can generate output data (130) by applying an app algorithm (128) during the execution of the app (120) to the provided event information (126).

[0123] It should be understood that the described application software component (106) and / or processor (102) can perform a similar method of managing the app (120), particularly developing the app (120) including the event artifact (122).

[0124] Additionally, a computer-readable medium (160) that may include a computer program product (162) is illustrated in FIG. 1, and the computer program product (162) may be encoded with executable instructions that cause a computer system (100) and / or an app development platform (118) to perform the described method when executed.

[0125] In some examples, the proposed method may include model-based app development in which a model capable of describing or characterizing the app (120) to be created and / or the functions of the app (120) to be created may be utilized. Similarly, each deployed and running production app (124) may include a model that may differ from the model of the app (120) to be created. For example, each model may include the event artifact (122), event information (126), or more generally information objects mentioned above, wherein these event artifacts (122) or information objects may have specific properties. Additionally, the model may be included or represented by an app algorithm (128). This model may include, for example, pages of the app, and the pages may serve to display information such as each event artifact (122) or information objects (140), or information derived from information objects (140) such as event information (126), to the app user. In additional examples, this model may include routines for processing data related to workflows, e.g., event artifacts (122), event information (126), or information objects, or for interacting with the app user. In some examples, workflows create relationships or pointers between event artifacts (122), event information (126), or information objects (140) that are part of the model. This model may include, for example, a metamodel that can describe the characteristics of elements, where the objects are instances of the elements, and these objects may be included in the aforementioned event artifacts (122), event information (126), or information objects (140).

[0126] Here is an exemplary metamodel describing the characteristics of the elements:

[0127]

[0128] An enumeration is a document consisting of multiple Enumerationvalues, each value having a name and a caption described by a text object, and the name refers to an image.

[0129] There can be 4 types of characteristics:

[0130] 1. Primitive value property: The property value is a primitive type, such as an integer or a string. Refer to 'name' in the example above.

[0131] 2. Primitive List Property: The property value is a list of values ​​of primitive types. For example, a list of column widths.

[0132] 3. Object Value Property: The property value is the contained object. Refer to 'Caption' in the example above. The text object represents translatable text and contains other objects that enumerate translations.

[0133] 4. Object list property: The property contains a list of included objects. Refers to 'values' in the example above.

[0134] Considering a model for developing model-based apps and apps that include event artifacts (122) can provide various advantages. This model may include a domain model that can be understood, for example, as an abstract relational database based on standard UML notation and object-oriented principles. That is, the domain model may be a visual representation of the data that an app (120) or each deployed and running production app (124) contains or constitutes. Such a visual approach to application development is particularly advantageous because it enables the agile building of apps (120) and the rapid building and growing of apps (120) over time. The domain model may include or be composed of three main elements, for example: entities representing objects, attributes that assign characteristics and values ​​to entities, and associations that enable entities to communicate with each other. Associations may be equivalent to, for example, the pointers mentioned above.

[0135] The structure of the model or domain model can determine how the event artifacts (122), event information (126), information objects, and the database for storing the model and / or domain model will look. Each entity can be a database table, and each attribute can be a column in the database. All objects stored in the database (e.g., training courses) can be rows in the corresponding database table. This may mean that if something is not in the domain model, it cannot be added to the database.

[0136] For example, the database table for the entity "Training Course" having these attributes is

[0137]

[0138] When some training events for this training course can be scheduled, it might look like this:

[0139]

[0140] Here, ID may not be an attribute, but the unique identifier mentioned above. The unique identifier may allow all objects, for example, event artifacts (122), event information (126), or information objects, to always have a unique identifier (ID) so that the system can know which object it is.

[0141] Changes to the model and / or domain model can be made as often as desired, and the database will be synchronized when the app (120) is republished. For example, when the name of an entity or attribute, or generally an information object, is changed, the app (120) will still function thanks to the corresponding unique identifier.

[0142] As mentioned above, the model may include a visual representation of the data that the app (120) contains or constitutes. This means, for example, that the model may include all information characterizing the functions of the app (120) to be created. Thus, the model can be regarded as one of the most important work results and core intellectual properties of the user(s) developing the app. Therefore, it is very important to protect the model and ensure that the model is not "broken" when each event artifact (122) and / or event information (126) is brought into the app development UI (116) and optionally into the model or algorithm (128) of the app (120).

[0143] Accordingly, in Nutshell, the proposed method may include, for example, model-based app development that may include at least one of the following features or any combination thereof:

[0144] ● The app (120) to be created may include at least a part of the first model, and the first model characterizes the app (120) to be created and / or the functions of the app (120) to be created,

[0145] ● The first model may optionally include at least one of entities, attributes that assign characteristics and values ​​to the entities, and associations that enable the entities to communicate with each other, or any combination thereof, and the entities represent event artifacts (122), event information (126), or information objects.

[0146] ● The first model may optionally include workflows for processing data related to event artifacts (122), event information (126), information objects or pages of the app (120).

[0147] ● Pages may optionally serve to display to the app user event artifacts (122), event information (126) or information objects or information derived from event artifacts (122), event information (126) or information objects.

[0148] ● Optionally, each deployed and running production app (124) may include at least a part of the second model, and the second model may optionally have at least a part of characteristics or architecture similar to the first model, and the first model may optionally be at least a part different from the second model.

[0149] In some examples where the proposed method involves model-based app development, each deployed and running production app (124) and app to be created (120) may be understood as distributed apps that may include different models, for example. Thus, in some way, the proposed development of the app (120) may involve modeling distributed applications.

[0150] Referring to FIG. 2, a functional block diagram of another exemplary computer system or data processing system (100) that facilitates managing apps (120), particularly apps (120) including event artifacts (122) is shown.

[0151] As illustrated in FIG. 2, an app (120) can be deployed and executed on a target device (140), and an app development platform (118) supports the execution of the app (120) on the target device (140). Event information (126) can be retrieved from a production app (124) to a data storage platform (150), and then the data storage platform can provide the event information (126) to the app (120). In this case, the event information (126) can be provided to the app development platform (118), and then the app development platform can generate output data (130) by applying an app algorithm (128) to the provided event information (126) during the execution of the app (120).

[0152] Referring to FIG. 3, an additional exemplary block diagram of a computer system or data processing system (100) is illustrated to facilitate the management of apps (120), particularly an app (120) including an event artifact (122).

[0153] As illustrated in FIG. 3, both the production app (124) and the (consumption) app (120) are deployed and executed on the app development platform (118). Nevertheless, event information (126) can be brought from the production app (124) (executed on the app development platform (118)) to a data storage platform (150) capable of providing event information (126) to the app (120) (also executed on the app development platform (118).

[0154] Referring to FIG. 4, a functional block diagram of another exemplary computer system or data processing system (100) is shown that facilitates managing apps (120), particularly apps (120) including event artifacts (122).

[0155] As illustrated in FIG. 4, event information (126) is first brought from a production app (124) to a data storage platform (150), and the data storage platform can then provide the event information (126) to an app (120) running on a target device (140) through an intermediate step including an app development platform (118), so that the event information (126) can first be provided from the data storage platform (150) to the app development platform (118), and then from the app development platform (118) to the (consuming) app (120) running on the target device (140). In some examples, the provision of event information (126) from the data storage platform (150) can also be done directly from the data storage platform (150) to the (consuming) app (120) running on the target device (140).

[0156] The target device (140) can generate output data (130) by applying an app algorithm (128) during the execution of the app (120) to the provided event information (126). The generated output data (130) can then be displayed to the user of the target device (140) through the user interface (142) of the target device (140), for example, through a display device included by the target device (140).

[0157] Referring to FIG. 5, a functional block diagram of another exemplary computer system or data processing system (100) is shown that facilitates managing apps (120), particularly apps (120) including event artifacts (122).

[0158] As illustrated in FIG. 5, a user interface (142) for displaying the generated output data (130) may also be located outside the target device (140). In some examples, the user interface (142) may be included by an additional device such as an external display screen, a PLC, a laptop, etc. The target device (140) may be coupled to communicate with the additional device so that the additional device can display the output data (130) generated by an app (130) running on the target device (140). To this end, the target device (140) may transmit the generated output data (130) to the additional device.

[0159] Referring to FIG. 6, a functional block diagram of another exemplary computer system or data processing system (100) is shown that facilitates managing apps (120), particularly apps (120) including event artifacts (122).

[0160] As illustrated in FIG. 6, there may be two production apps (124, 124') that can be deployed and executed on two devices (144, 144') and provide respective event artifacts (122, 122') and respective event information (126, 126'). The (consumption) app (120) may be stored in the data storage (108) of the app development platform (118) along with the included app algorithm (128). Additionally, two sets of artifact information (122, 122') and optionally two sets of event information (126, 126') may be stored in the data storage (108). Here, the two sets of event artifacts (122, 122') may be used for the purpose of developing an app (120) supported by the app development platform (118). The app (120) may be placed and executed on a target device (140), for example. Two sets of event information (126, 126') corresponding to two sets of event artifacts (122, 122') may originate from each production app (124, 124') that is placed and executed on each other device (144, 144'). Each event information (126, 126') may first be brought from each production app (124, 124') to a data storage platform (150), and then the data storage platform may provide each event information (126, 126') to the app (120) that is placed and executed on the target device (140).This provision of each event information (126, 126') from the data storage platform (150) can be done directly from the data storage platform (150) to the (consuming) app (120) that is placed and running on the target device (140), or it can be done in an intermediate step including the app development platform (118) so that each event information (126, 126') can first be provided from the data storage platform (150) to the app development platform (118), and then from the app development platform (118) to the (consuming) app (120) that is placed and running on the target device (140).

[0161] The target device (140) can generate output data (130) by applying an app algorithm (128) to two sets of provided event information (126, 126') during the execution of the app (120).

[0162] It should be understood that in some examples, two sets of artifact information (122, 122') can be bundled using the aforementioned event channel (132).

[0163] Referring to FIG. 7, a functional block diagram of another exemplary computer system or data processing system (100) is shown that facilitates managing apps (120), particularly apps (120) including event artifacts (122).

[0164] As illustrated in FIG. 7, the developer or user of the production app (124) may make modifications to the production app (124) to result in a modified production app (124'). When such modifications are made to the production app (124), at least two options (134) may be displayed to the developer or user of the (consumption) app (120), for example, through the app development UI (116). The displayed options (134) may include an option to continue using the event artifact (122) of the original production app (124) or an option to start using each modified event artifact (122) of the modified production app (124). The developer or user may then input their choice of one of the displayed options (134), and the choice may be captured by this. If the user chooses to start using each event artifact (122) of the modified production app (124), event information (126) corresponding to the event artifact (122) from each modified production app (124) may be brought into the data storage platform (150). This event information (126) may then be provided from the data storage platform (150) to the deployed and running app (120).

[0165] In some examples, the mentioned options (134) may be displayed to the user of the (consuming) app (120) through the display user interface (142) mentioned above.

[0166] Referring to FIG. 8, a functional block diagram of another exemplary computer system or data processing system (100) is shown that facilitates managing apps (120), particularly apps (120) including event artifacts (122).

[0167] As illustrated in FIG. 8, a user (here, a developer of the app (120)) may use an event artifact search UI (136) to search in a repository (152) where event artifacts (122) available for app development may be stored. In some examples, the event artifact search UI (136) may be included by the app development UI (116).

[0168] In additional examples, it should also be understood that information regarding the generated output data (130) of the app (120) is stored in the storage (152) as an event artifact (122), allowing the reuse of the stored event artifact (122) for app development by, for example, other users or developers.

[0169] Referring to FIG. 9, a flowchart of an exemplary method for facilitating the management of an app (120), particularly an app (120) containing an event artifact (122), in a product system (100) is illustrated.

[0170] As illustrated in FIG. 9, each production app (124) may provide event artifacts (122, 122'), such as event notification (122) and event-triggered state transmission (122'). The provided artifacts (122, 122') may be utilized by an app development platform (118) to develop a (consuming) app (120). In some examples, during the development of the (consuming) app (120), the provided artifacts (122, 122') may be brought into the app development UI (118) of the app development platform (118), and the app (120) may be developed using the provided artifacts (122, 122'). Optionally, more than one or two event artifacts (122) may be utilized.

[0171] For example, a similar concept may also be applied to a repository (152) to store event artifacts (122) that can be reused during app development. The event artifacts (122) may be provided to the repository (152) by the developer or user of the first app, for example, the production app (124). The developer or user of the second app, for example, the (consuming) app (120), may search the repository (152) for example, through the event artifact search UI (136). This user may select a suitable event artifact (122) available in the repository (152), bring the selected event artifact (122) into the app development UI (118), and develop the (consuming) app (120) using the brought-in event artifact (122).

[0172] For example, a similar concept may also be applied to a data storage platform (150) that can be arranged between a production app (124) and a (consumption) app (120). Here, event information (126) corresponding to each provided event artifact (122) can be brought from the production app (124) to the data storage platform (150), and the data storage platform can then provide the event information (126) to the (consumption) app (120).

[0173] Referring to FIG. 10, a flowchart of an exemplary method for facilitating the management of an app (120), particularly an app (120) containing an event artifact (122), in a product system (100) is illustrated.

[0174] FIG. 10 includes a first workflow for developing ("design time"), deploying ("deployment time") and executing ("execution time") in the upper half of the production app (124) ("production"), and a second workflow for developing, deploying, and executing ("execution time") in the lower half of the consumption app (120) ("consumption").

[0175] During the development phase of both the production app (124) and the consumption app (120), corresponding business logic reflected by, for example, a corresponding app algorithm (128) may be created using, for example, the app development UI (116) of the app development platform (118). The app algorithm (128) may have appropriate event artifacts (122) that may be embedded or bundled in event channels (132) in some examples.

[0176] During the deployment phase of both the production app (124) and the consumption app (120), each app (124, 120) may be deployed, and communication links to the data storage platform (150) may be set up. This setup may include determining a tenant ID (e.g., for each user or customer) and configuring tenants for each channel (132). In some examples, the tenant may be associated with or correspond to the data storage platform (150).

[0177] During the operation or execution time of the production app (124), the production app (124) may generate event information (126) corresponding to event artifacts (122) that can be published or communicated to the data storage platform (150), for example, by using the channels (132) mentioned above. In some examples, some channels (132) may be combined in a single tenant or data storage platform (150). During the operation or execution time of the consumption app (120), the data storage platform (150) may provide the event information (126) to the consumption app (120), and the provided event information (126) may be of interest to the business logic or app algorithm (128) of the consumption app (120).

[0178] Referring to FIG. 11, a flowchart of an exemplary method for facilitating the management of an app (120), particularly an app (120) containing an event artifact (122), in a product system (100) is illustrated.

[0179] FIG. 11 illustrates a method having some similarities to the method illustrated in FIG. 10. One of the differences may relate to the placement step of both the production app (124) and the consumption app (120), which may simply involve placing each app (124, 120) on each target device.

[0180] Additionally, during the operation or execution time of both the production app (124) and the consumption app (120), there may be different software environments (136) in which each app (124, 120) can be placed. Here, the placement of each app (124, 120) in each software environment (136) may be performed during the placement phase. For each app (124, 120) in each software environment (136) and each event artifact (122) or event channel (132), an individual data storage platform (150) or tenant may be provided. During the operation or execution time of the production app (124), corresponding event information (126) may be brought from each production app (124) placed on each software environment (136) to each data storage platform (150), tenant, or event channel (132). During the operation or execution time of the consumption app (120), the data storage platform (150) may provide event information (126) to each consumption app (120) placed on each software environment (136), and the provided event information (126) may be of interest to the business logic or app algorithm (128) of each consumption app (120). In some examples, each consumption app (120) may receive event information (126) from different data storage platforms (150) or channels (132), and in additional examples, each consumption app (120) may also receive event information (126) from different software environments (136) (see thin line).

[0181] Referring to FIG. 12, a flowchart of an exemplary method for facilitating the management of an app (120) in a product system (100), particularly an app (120) including an event artifact (122), is illustrated.

[0182] As illustrated in FIG. 12, both the production app (124) and the consumption app (120) may include business logic or app algorithms (128) ("Microflow logic"). In the production app (120), the app algorithm (128) may provide event artifacts (122) as outputs, and specific output data (130) regarding the events may be provided as event artifacts (126) ("Outbox table"). Event information (126) may be verified and stored using a write-ahead-log ("WAL") before being provided to a data storage platform (150) ("company default topic", e.g., event channel (132)) via, for example, a "Debezium sidecar".

[0183] Next, the event artifact (122) and the corresponding event information (126) may be provided from the data storage platform (150) to the consuming app (120), and processed by the business logic or app algorithm (128) of the consuming app (120) to generate output data (130) of the consuming app (120).

[0184] In some examples, the user (here, the developer of the consuming app (120)) may use an event artifact search UI (136) to search in a storage (152) where event artifacts (122) available for app development may be stored. In some examples, the event artifact search UI (136) may be included by the app development UI (116).

[0185] In additional examples, it should also be understood that information regarding the generated output data (130) of the consuming app (120) (or producing app) may be stored as an event artifact (122) in the storage (152) to allow the reuse of the stored event artifact (122) for app development by, for example, other users or developers.

[0186] Now, referring to FIG. 13, a method (1300) is illustrated to facilitate managing apps, such as developing an app that includes event artifacts. The method may start at 1302 and may include several operations performed through the operation of at least one processor.

[0187] These actions may include: providing a user interface (UI) of an app development platform to a user to develop an app (1304); capturing a user's intent to retrieve event artifacts from each deployed and running production app to develop an app in response to user interactions with the app development UI (1306); bringing each event artifact corresponding to the captured user's intent to the app development UI (1308); developing an app through the app development UI using each retrieved event artifact (1310); deploying and executing the developed app on a target device (1312); retrieving event information corresponding to each event artifact from each production app to a data storage platform (1314); providing the event information retrieved to the data storage platform from the data storage platform to the deployed and running app (1316); and applying an app algorithm included by the deployed and running app to the provided event information to generate output data (1318). At 1320, the method may be terminated.

[0188] It should be further understood that the method (1300) may include other previously discussed behaviors and features in relation to a method implemented by a computer that manages an app, particularly one that develops an app including event artifacts.

[0189] For example, the method may further include an action of displaying the generated output data to the user of the target device through the user interface of the target device.

[0190] In some examples, the method may further include an operation to use generated output data to analyze, monitor, operate, and / or control a target device or another device connected to the target device, and / or an operation to use the generated output data to analyze and / or monitor the user of each target device.

[0191] It should also be understood that in some examples, the method may further include: displaying to the user at least two options corresponding to the continued use of each event artifact of the original production app or the started use of each event artifact of the modified production app when the production app is modified; capturing the user's intention to select one of the displayed options; and, when the user chooses to start using each event artifact of the modified production app, bringing event information corresponding to each event artifact from each modified production app to a data storage platform.

[0192] For example, if a user chooses to start using event artifacts of each modified production app that are incompatible with event artifacts of each production app, the method may further include: bringing each event artifact of each modified production app into the app development UI; developing an app through the app development UI using the brought event artifacts of each modified production app; and deploying and executing the developed app on a target device.

[0193] In some examples, the method may further include an action of providing the user with an event artifact search UI to search for event artifacts in a repository for storing event artifacts available for app development.

[0194] Additionally, it should be understood that in some examples, the method may further include the operation of storing information about output data generated as event artifacts in a repository of event artifacts reusable for app development.

[0195] For example, the method may further include the operation of verifying each event information corresponding to each event artifact from each production app; and the operation of retrieving each event information corresponding to each event artifact from each production app to a data storage platform only when each event information is verified.

[0196] FIG. 14 illustrates a block diagram of a data processing system (1000, also referred to as a computer system) that may be implemented as part of an embodiment, for example, a product system, and / or another system configured to be operable by software or otherwise to perform the processes described herein. The data processing system (1000) may include, for example, the computer or IT system or the data processing system (100) mentioned above. The illustrated data processing system includes at least one processor (1002) (e.g., CPU) that may be connected to one or more bridges / controllers / buses (1004) (e.g., North Bridge, South Bridge). One of the buses (1004) may include one or more I / O buses, such as a PCI Express bus. Also, in the illustrated example, connected to the various buses may include main memory (1006) (RAM) and a graphics controller (1008). The graphics controller (1008) may be connected to one or more display devices (1010). It should also be noted that, in some embodiments, one or more controllers (e.g., graphics, south bridge) may be integrated with the CPU (on the same chip or die). Examples of CPU architectures include IA-32, x86-64, and ARM processor architectures.

[0197] Other peripheral devices connected to one or more buses may include communication controllers (1012) (Ethernet controllers, WiFi controllers, cellular controllers) operable to connect to a local area network (LAN), a wide area network (WAN), a cellular network and / or other wired or wireless networks (1014) or communication equipment.

[0198] Additional components connected to various buses may include one or more I / O controllers (1016), such as USB controllers, Bluetooth controllers, and / or dedicated audio controllers (connected to speakers and / or microphones). It should also be understood that various peripherals, including input devices (1018) (e.g., keyboard, mouse, pointer, touch screen, touchpad, drawing tablet, trackball, buttons, keypad, game controller, gamepad, camera, microphone, scanner, motion sensing device for capturing motion gestures), output devices (1020) (e.g., printers, speakers), or any other type of device capable of providing inputs to a data processing system or receiving outputs from a data processing system, may be connected to the I / O controller(s) (via various ports and connections). Additionally, it should be understood that many devices referred to as input devices or output devices may be capable of both providing inputs for communication with the data processing system and receiving outputs. For example, the processor (1002) may be integrated into a housing (such as a tablet) that includes a touch screen serving as both an input and a display device. Additionally, it should be understood that some input devices (such as laptops) may include multiple different types of input devices (e.g., a touch screen, a touchpad, a keyboard). Additionally, it should be understood that other peripheral hardware (1022) connected to the I / O controllers (1016) may include any type of device, machine, or component configured to communicate with a data processing system.

[0199] Additional components connected to various buses may include one or more storage controllers (1024) (e.g., SATA). A storage controller may be connected to a storage device (1026), such as one or more storage drives and / or any associated removable media, which may be any suitable non-transient machine-available or machine-readable storage media. Examples include non-volatile devices, volatile devices, read-only devices, writable devices, ROMs, EPROMs, magnetic tape storage, floppy disk drives, hard disk drives, solid-state drives (SSDs), flash memory, optical disk drives (CDs, DVDs, Blu-ray), and other known optical, electric, or magnetic storage device drives and / or computer media. Additionally, in some examples, a storage device such as an SSD may be directly connected to an I / O bus (1004), such as a PCI Express bus.

[0200] A data processing system according to an embodiment of the present disclosure may include an operating system (1028) (which may be stored on a storage device (1026) and / or memory (1006)), software / firmware (1030), and data storage units (1032). Such an operating system may utilize a command-line interface (CLI) shell and / or a graphical user interface (GUI) shell. A GUI shell allows a plurality of display windows to be provided simultaneously in a graphical user interface, each display window providing an interface to a different application or a different instance of the same application. A cursor or pointer in a graphical user interface may be manipulated by a user through a pointing device such as a mouse or a touch screen. The position of the cursor / pointer may be changed and / or events such as clicking a mouse button or touching a touch screen may be generated to trigger a desired response. Examples of operating systems that may be used in a data processing system may include Microsoft Windows, Linux, UNIX, iOS, and Android operating systems. Additionally, examples of data stores include data files, data tables, relational databases (e.g., Oracle, Microsoft SQL Server), database servers, or any other structure and / or device capable of storing data that is retrieveable by a processor.

[0201] Communication controllers (1012) may be connected to a network (1014) (not part of the data processing system (1000)) which may be any public or private data processing system network or a combination of networks as known to those skilled in the art, including the Internet. The data processing system (1000) may communicate with one or more other data processing systems, such as a server (1034) (also not part of the data processing system (1000)), through the network (1014). However, an alternative data processing system may correspond to multiple data processing systems implemented as part of a distributed system in which processors associated with several data processing systems can communicate through one or more network connections and collectively perform tasks described as being performed by a single data processing system. Therefore, when referring to a data processing system, it should be understood that such a system may be implemented across several data processing systems organized into a distributed system that communicates with one another through a network.

[0202] Additionally, the term “controller” means any device, system, or part thereof that controls at least one operation, regardless of whether such device is implemented in hardware, firmware, software, or a combination of at least two of these. It should be noted that the function associated with any particular controller may be centralized or distributed locally or remotely.

[0203] Additionally, it should be understood that data processing systems can be implemented as virtual machines in a virtual machine architecture or a cloud environment. For example, the processor (1002) and associated components may correspond to a virtual machine running in a virtual machine environment of one or more servers. Examples of virtual machine architectures include VMware ESCi, Microsoft Hyper-V, Xen, and KVM.

[0204] A person skilled in the art will be well aware that the hardware described for the data processing system may vary for specific implementations. For example, the data processing system (1000) in this example may correspond to a computer, workstation, server, PC, notebook computer, tablet, mobile phone, and / or any other type of device / system that processes data and operates to perform the functions and features described herein associated with the operation of the data processing system, computer, processor, and / or controller discussed herein. The illustrated examples are provided for illustrative purposes only and are not intended to imply any architectural limitations to the present disclosure.

[0205] Additionally, it should be noted that the processor described herein may be located on a server that is remote from the display and input devices described herein. In such examples, the display and input devices described may be included in a client device that communicates with the server (and / or a virtual machine running on the server) via a wired or wireless network (which may include the Internet). In some embodiments, such a client device may correspond to a portal device that executes a remote desktop protocol with the server to run, for example, a remote desktop application, or to transmit inputs from the input device to the server and receive visual information from the server to display through the display device. Examples of such remote desktop protocols include Teradici’s PCoIP, Microsoft’s RDP, and RFB protocols. In such examples, the processor described herein may correspond to a virtual processor of a virtual machine running on the physical processor of the server.

[0206] As used herein, the terms “component” and “system” are intended to include hardware, software, or a combination of hardware and software. Thus, for example, a system or component may be a process, a process running on a processor, or a processor. Additionally, a component or system may be localized on a single device or distributed across multiple devices.

[0207] Additionally, as used herein, a processor corresponds to any electronic device configured through hardware circuits, software and / or firmware to process data. For example, the processors described herein may correspond to one or more (or combinations) of a microprocessor, CPU, FPGA, ASIC, or any other integrated circuit (IC) or other type of circuit capable of processing data in a data processing system, which may take the form of a controller board, computer, server, mobile phone, and / or any other type of electronic device.

[0208] Those skilled in the art will recognize that, for the sake of brevity and clarity, the entire structure and operation of all data processing systems suitable for use with the present disclosure are not illustrated or described herein. Instead, only as many data processing systems as are unique to the present disclosure or necessary for understanding the present disclosure are illustrated and described. The remainder of the configuration and operation of the data processing system (1000) may follow any of the various current implementations and embodiments known in the art.

[0209] Furthermore, it should be understood that words or phrases used herein are to be interpreted broadly, unless explicitly limited in some examples. For example, the terms “comprise” and “comprise,” as well as their derivatives, mean inclusion without limitation. The singular forms (“a,” “an,” and “the”) are intended to include the plural forms unless the context clearly indicates otherwise. Additionally, the term “and / or,” as used herein, refers to and encompasses any and all possible combinations of one or more of the associated enumerated items. The term “or,” unless the context clearly indicates otherwise, is inclusive of “and / or.” The phrases "associated with" and "associated therewith," as well as their derivatives, can mean to include, be comprised within, interconnect with, contain, be contained within, connect to or with, combine to or with, communicable with, cooperate with, interleave, juxtapose, proximate to, limited to or with, have, have a property of, etc.

[0210] Additionally, terms such as “first,” “second,” “third,” etc. may be used herein to describe various elements, functions, or operations, but these elements, functions, or operations should not be limited by these terms. Rather, these numerical adjectives are used to distinguish different elements, functions, or operations. For example, without departing from the scope of this disclosure, a first element, function, or operation may be referred to as a second element, function, or operation, and similarly, a second element, function, or operation may be referred to as a first element, function, or operation.

[0211] Additionally, the phrase “the processor is configured to perform one or more functions or processes” may mean that the processor is configured to be operable or operable to perform the functions or processes through software, firmware, and / or wired circuits. For example, a processor configured to perform a function / process may correspond to a processor running software / firmware programmed to make the processor perform the function / process, and / or may correspond to a processor having software / firmware in memory or storage devices available to be executed by the processor to perform the function / process. It should also be noted that a processor “configured to perform” one or more functions or processes may also correspond to processor circuits specifically manufactured or “wired” to perform the functions or processes (e.g., ASIC or FPGA designs). Furthermore, the phrase “at least one” preceding an element configured to perform two or more functions (e.g., a processor) may correspond to one or more elements (e.g., a processor) each performing functions, and may also correspond to two or more elements (e.g., processors) each performing different functions among one or more different functions.

[0212] Additionally, the term "adjacent to" may mean that an element is relatively close to an additional element but does not touch it, unless the context clearly indicates otherwise; or that an element touches an additional part.

[0213] Although exemplary embodiments of the present disclosure have been described in detail, those skilled in the art will understand that various changes, substitutions, variations, and improvements disclosed herein may be made in their broadest form without departing from the spirit and scope of the present disclosure.

[0214] Nothing described in this patent document shall be interpreted as implying that any specific element, step, action, or function is an essential element to be included in the scope of the claims: the scope of the subject matter is defined only by the permitted claims.

Claims

Claim 1 As a method implemented by a computer, ● providing a user with an app development user interface (UI) (116) of an app development platform (118) for developing an app (120); ● capturing the user's intention to retrieve each event artifact (122) from each deployed and running production app (124) to develop the app (120) in response to user interactions with the app development UI (116) - each event artifact (122) is information describing an event that occurred in each deployed and running production app (124) -; ● bringing each event artifact (122) corresponding to the captured user's intention into the app development UI (116); ● developing the app (120) through the app development UI (116) using each retrieved event artifact (122); ● deploying and running the developed app (120) on a target device (140); ● each event A method implemented by a computer, comprising: a step of bringing event information (126) corresponding to an artifact (122) from each of the production apps (124) to a data storage platform (150); a step of providing the event information (126) brought to the data storage platform (150) to the deployed and running app (120) from the data storage platform (150); and a step of generating output data (130) by applying an app algorithm (128) included by the deployed and running app (120) to the provided event information (126). Claim 2 A method implemented by a computer according to claim 1, further comprising the step of displaying the generated output data (130) to a user of the target device (140) through the user interface (142) of the target device (140). Claim 3 A method implemented by a computer according to claim 1 or 2, further comprising: ● a step of using the generated output data (130) to perform at least one of analyzing, monitoring, operating, and controlling the target device (140) or another device (144) connected to the target device (140); and ● at least one step of using the generated output data (130) to perform at least one of analyzing and monitoring the user of each target device (140). Claim 4 A method implemented by a computer, wherein each of the event artifacts (122) comprises at least one of (i) at least one event notification and (ii) at least one event-transfer status transmission. Claim 5 A method implemented by a computer, wherein, in claim 1 or 2, each event artifact (122) comprises each event channel (132) comprising at least one event artifact (122) from each deployed and running production app (124). Claim 6 A method implemented by a computer, wherein each of the above event channels (132) comprises at least one event artifact (122) from each of the above deployed and running production apps (124) and at least one event artifact (122') from at least one second deployed and running production app (124'). Claim 7 A method implemented by a computer according to claim 1 or 2, further comprising: ● displaying to the user at least two options (134) corresponding to the continued use of each event artifact (122) of the original production app (124) or the started use of each event artifact (122) of the modified production app (124); ● capturing the user's intention to select one of the displayed options (134); and ● if the user chooses to start using each event artifact (122) of the modified production app (124), bringing event information (126) corresponding to each event artifact (122) from each modified production app (124) to the data storage platform (150). Claim 8 A method implemented by a computer according to claim 7, wherein, when the user chooses to start using each event artifact (122) of each modified production app (124) that is incompatible with each event artifact (122) of each production app (124), the method further comprises: ● bringing each event artifact (122) of each modified production app (124) into the app development UI (116); ● developing the app (120) through the app development UI (116) using each brought event artifact (122) of each modified production app (124); and ● deploying and executing the developed app (120) on a target device (140). Claim 9 A method implemented by a computer, further comprising the step of providing the user with an event artifact search UI (136) for searching in a storage (152) for storing event artifacts (122) available for app development, in accordance with claim 1 or 2. Claim 10 A method implemented by a computer, wherein, in claim 1 or 2, the method further comprises the step of storing information regarding the generated output data (130) as an event artifact (122) in a repository (152) of event artifacts (122) that are reusable for app development. Claim 11 A method implemented by a computer, comprising: ● verifying each event information (126) corresponding to each event artifact (122) from each production app (124); and ● bringing each event information (126) corresponding to each event artifact (122) from each production app (124) to the data storage platform (150) only when each event information (126) is verified. Claim 12 In claim 1 or 2, ● the app (120) to be created may include at least a part of a first model, and the first model characterizes at least one of the functions of the app (120) to be created and the app (120) to be created, ● the first model may optionally include at least one of entities, attributes that assign characteristics and values ​​to the entities, and associations that enable the entities to communicate with each other, or any combination thereof, and the entities represent the event artifact (122), the event information (126), or information objects, and ● the first model may optionally include workflows for processing data related to the event artifact (122), the event information (126), the information objects, or pages of the app (120), and ● the pages may optionally include the event artifact (122), the event information (126), or the information objects, or the event artifact (122), the event A method implemented by a computer that can serve to display information (126) or information derived from the information objects to an app user, and optionally, each of the deployed and running production apps (124) may include at least a part of a second model, and the second model may optionally have at least a part of characteristics or architecture similar to the first model, and the first model may optionally be at least a part different from the second model. Claim 13 A computer system (100, 118) arranged and configured to execute steps of a method implemented by a computer according to paragraph 1 or 2. Claim 14 A computer program stored on a computer-readable medium, comprising computer program code that causes the computer system (100, 118) to perform the method of claim 1 or 2 when executed by the computer system (100, 118). Claim 15 A computer-readable medium (160) comprising a computer program product (162) comprising computer program code that, when executed by a computer system (100, 118), causes the computer system (100, 118) to perform the method of claim 1 or 2.

Images