Patent Description:
Recently, an increasing number of computer software products is used both for personal needs and for business needs in the form of applications, throughout the present patent document simply called "apps". Such apps may be used in a mobile context as well as on cloud computing platforms and "on premise" and may provide a specific set of functions. The present invention generally relates to the development and the creation of such apps, especially developing an app comprising updating a workflow of the app.

<CIT> discloses a graphic editing method and storage medium on which is recorded a program for graphic editing. Herein, a flowchart including objects A through C is displayed on the monitor of a computer. If an object D is inserted between objects A and B, object D is dropped on a line AB. By this operation, objects A and D are automatically connected, and objects D and B are automatically connected.

<CIT> discloses a system and a method for editing a graphical diagram. A graphical diagram, such as a graphical program, is displayed on a display device. User input may be received editing the graphical diagram, thereby generating an edited graphical diagram. Placement of one or more elements in the graphical diagram may be adjusted in response to the editing based on determined forces applied to the one or more elements in the edited graphical diagram based on the said editing, resulting in an adjusted edited graphical diagram. The adjusted edited graphical diagram may be displayed on the display device, which may include displaying an animation illustrating the movement of the elements to an equilibrium state in which the forces balance and movement ceases. The editing, adjusting, and displaying may be performed sequentially and/or concurrently, as desired.

Currently, there exist product systems and solutions which support managing or developing such apps. Such product systems may benefit from improvements.

Variously disclosed embodiments comprise methods and computer systems that may be used to facilitate managing an app.

A third aspect of the invention concerns a computer program product according to claim <NUM>.

A fourth aspect of the invention concerns a computer-readable medium according to claim <NUM>. By way of example, the described computer-readable medium may be non-transitory and may further be a software component on a storage device.

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.

The foregoing has outlined rather broadly the technical features of the present disclosure so that those skilled in the art may better understand the detailed description that follows. Additional features and advantages of the disclosure will be described hereinafter that form the subject of the claims. Those skilled in the art will appreciate that they may readily use the conception and the specific embodiments disclosed as a basis for modifying or designing other structures for carrying out the same purposes of the present disclosure.

Also, before undertaking the detailed description below, it should be understood that various definitions for certain words and phrases are provided throughout this patent document and those of ordinary skill in the art will understand that such definitions apply in many, if not most, instances to prior as well as future uses of such defined words and phrases. While some terms may comprise a wide variety of embodiments, the appended claims may expressly limit these terms to specific embodiments.

Herein, inventive aspects relating to the moving borderline are illustrated in <FIG>. The other illustrated examples are not according to the invention insofar as the features of the independent claims are not included and are present for illustration purposes.

Various technologies that pertain to systems and methods for managing apps, especially developing an app comprising updating a workflow of the app, in a product system will now be described with reference to the drawings, where like reference numerals represent like elements throughout. The drawings discussed below, and the various embodiments used to describe the principles of the present disclosure in this patent document are by way of illustration only and should not be construed in any way to limit the scope of the disclosure. Those skilled in the art will understand that the principles of the present disclosure may be implemented in any suitably arranged apparatus. It is to be understood that functionality that is described as being carried out by certain system elements may be performed by multiple elements. Similarly, for instance, an element may be configured to perform functionality that is described as being carried out by multiple elements. The numerous innovative teachings of the present patent document will be described with reference to exemplary non-limiting embodiments.

An app generally refers to a software program which on execution performs specific desired tasks. In general, several apps are executed in a runtime environment containing one or more operating systems ("OSs"), virtual machines (e.g., supporting Java™ programming language), device drivers, etc..

Apps, including native apps, can be created, edited, and represented using traditional source code. Examples of such traditional source code comprise C, C++, Java, Flash, Python, Perl, and other script-based methods of representing an app. Developing, creating and managing such script-based apps, or parts of such script-based apps can be accomplished by manual coding of suitably trained users.

Developers often use Application Development Frameworks ("ADFs") (which are by themselves applications or apps) for implementing/developing desired apps. An ADF provides a set of pre-defined code/data modules that can be directly/indirectly used in the development of an app. An ADF may also provide tools such as an Integrated Development Environment ("IDE"), code generators, debuggers, etc., which facilitate a developer in coding/implementing the desired logic of the app in a faster/simpler manner.

In general, an ADF simplifies app development by providing reusable components which can be used by app developers to define user interfaces ("UIs") and app logic by, for example, selecting components to perform desired tasks and defining the appearance, behavior, and interactions of the selected components. Some ADFs are based on a model-view-controller design pattern that promotes loose coupling and easier app development and maintenance.

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 disconnecting visual depictions of logical elements within a visual modeling environment. Visual model-based representations of apps can use symbols, shapes, lines, colors, shades, animations, and/or other visual elements to represent logic, data or memory structures or user interface elements. In order to program a traditional script-based app, programmers are typically required to type out detailed scripts according to a complicated set of programming syntax rules. In contrast, programming a visual model-based app can, in some cases, be done by connecting various logical elements (e.g., action blocks and/or decision blocks) to create a visual flow chart that defines the app's operation. Similarly, defining data structures (e.g., variable types, database objects, or classes) and/or user interface elements (e.g., dropdown boxes, lists, text input boxes) in a visual model-based app can be done by drawing, placing, or connecting visual depictions of logical elements within a virtual workspace, as opposed to typing out detailed commands in a script. Visual-model based apps, including native apps, can therefore be more intuitive to program and/or edit compared to traditional script-based apps. In the present document, an approach is suggested to manage apps, especially to develop an app comprising a trained function, which may involve the explained visual model-based representations.

For brevity, references to a "model," a "visual model," or an "application" or "app" should be understood to refer to visual model-based apps, including native apps, unless specifically indicated. In some cases, such visual model-based apps can represent complete, stand-alone apps for execution on a computer system. Visual model-based apps can also represent discrete modules that are configured to perform certain tasks or functions, but which do not represent complete apps - instead, such discrete modules can be inserted into a larger app or combined with other discrete modules to perform more complicated tasks. Examples of such discrete modules can comprise modules for validating a ZIP code, for receiving information regarding current weather from a weather feed, and/or for rendering graphics.

Visual models may be represented in two forms: an internal representation and one or more associated visual representations. The internal representation may be a file encoded according to a file format used by a modeling environment to capture and define the operation of an app (or part of an app). For example, the internal representation may define what inputs an app can receive, what outputs an app can provide, the algorithms and operations by which the app can arrive at results, what data the app can display, what data the app can store, etc. The internal representation may also be used to instruct an execution environment how to execute the logic of the app during run-time. Internal representations may be stored in the form of non-human-readable code (e.g., binary code). Internal representations may also be stored according to a binary stored JSON (java script object notation) format, and/or an XML format. At run-time, an execution engine may use an internal representation to compile and/or generate executable machine code that, when executed by a processor, causes the processor to implement the functionality of the model.

The internal representation may be associated with one or more visual representations. Visual representations may comprise visual elements that depict how an app's logic flows, but which are not designed to be compiled or executed. These visual representations may include, for example, flowcharts or decision trees that show a user how the app will operate. The visual models may also visually depict data that is to be received from the user, data that is to be stored, and data that is to be displayed to the user. These visual models may also be interactive, which allows a user to manipulate the model in an intuitive way. For example, visual representations may be configured to display a certain level of detail (e.g., number of branches, number of displayed parameters, granularity of displayed logic) by default. However, users may interact with the visual representation in order to show a desired level of detail-for example, users may display or hide branches of logic, and/or display or hide sets of parameters. Details relating to an element of the visual model may be hidden from view by default but can appear in a sliding window or pop-up that appears on-screen when the user clicks on 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 into another section, or copy/paste branches of logic from a first model into a second model. In some cases, parts of the model may contain links to other parts of the model, such that if a user clicks on a link, the user will automatically be led to another part of the model. A viewing user may interact with a visual representation in at least some of the same ways that the viewing user might interact with the model if it were displayed within a modeling environment. In other words, the visual representation may be configured to mimic how the model would appear if it were displayed within a visual modeling environment. A single internal representation may correspond to multiple visual representations that use different styles or formatting rules to display app logic. For instance, multiple visual representations corresponding to the same internal representation may differ from one another in their use of color, elements that are comprised or omitted, and use of symbols, shapes, lines, colors, and/or shades to depict logic flow.

Approaches involving the above-described functionalities of visual model-based representations, visual model-based apps, and/or visual models are sometimes understood to be comprised by a so-called low-code application development platform or low-code app development platform. By way of example, such a low-code application development platform may further be described as software that provides a development environment used to create application software through graphical user interfaces and configuration instead of traditional hand-coded computer programming. A low-code model may enable developers of varied experience levels to create applications using a visual user interface in combination with model-driven logic. Such low-code application development platforms may produce entirely operational apps or require additional coding for specific situations. Low-code app development platforms may reduce the amount of traditional hand coding, enabling accelerated delivery of business apps. A common benefit is that a wider range of people can contribute to the app's development - not only those with formal programming skills. Low-code app development platforms can also lower the initial cost of setup, training, deployment, and maintenance.

With reference to <FIG>, a functional block diagram of an example computer system or data processing system <NUM> is illustrated that facilitates managing apps <NUM>, especially developing an app <NUM> comprising updating a workflow <NUM> of the app <NUM>. The processing system <NUM> may comprise a (visual model-based) app development platform <NUM> including at least one processor <NUM> that is configured to execute at least one application software component <NUM> from a memory <NUM> accessed by the processor <NUM>. Herein, the app development platform <NUM> may comprise the above-described functionalities of visual model-based representations, visual model-based apps, and/or visual models and, by way of example, be a visual model-based app development platform or a low-code app development platform. The application software component <NUM> may be configured (i.e., programmed) to cause the processor <NUM> to carry out various acts and functions described herein. For example, the described application software component <NUM> may comprise and/or correspond to one or more components of an app development application that is configured to generate and store product data in a data store <NUM> such as a database. Furthermore, the described application software component <NUM> may comprise and/or correspond to one or more components of an app creation or development application.

By way of example, the app development platform <NUM> may be cloud-based, internet-based and/or be operated by a provider providing app development and creation support, including e.g., supporting low-code and/or visual model-based app development. The user may be located close to the app development platform <NUM> or remote to the app development platform <NUM>, e.g., anywhere else, e.g., using a mobile device for connecting to the app development platform <NUM>, e.g., via the internet, wherein the mobile device may comprise an input device <NUM> and a display device <NUM>. In some examples, the app development platform <NUM> may be installed and run on a user's device, such as a computer, laptop, pad, on-premises computing facility, or the like.

Examples of product systems that may be adapted to comprise the app management and/or development comprising updating a workflow of the app features described herein may comprise the low-code software development platform of Mendix Inc. , of Boston, Massachusetts, USA. This platform provides tools to build, test, deploy, iterate, develop, create and manage apps <NUM> and is based on visual, model-driven software development. However, it should be appreciated 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 and stores product data in a database. Also, examples of databases that may be used as one or more data stores described herein comprise database server applications such as Oracle, Microsoft SQL Server, or any other type of data store that is operative to store data records.

It should be appreciated that it can be difficult and time-consuming to manage apps <NUM>, especially developing an app <NUM> comprising updating a workflow <NUM> of the app <NUM>, in complex app development and/or management environments. For example, advanced coding or software development or management knowledge of users may be required, or selections of many options need to be made consciously, both involving many manual steps, which is a long and not efficient process.

To enable the enhanced management apps <NUM>, especially developing an app <NUM> comprising updating a workflow <NUM> of the app <NUM>, the described product system or processing system <NUM> may comprise at least one input device <NUM> and at least one display device <NUM> (such as a display screen). The described processor <NUM> may be configured to generate a graphical user interface (GUI) <NUM> through the display device <NUM>. Such a GUI <NUM> may comprise GUI elements such as buttons, links, search boxes, lists, text boxes, images, scroll bars usable by a user to provide inputs through the input device <NUM> that cause updating the workflow <NUM> and/or developing the app <NUM>. By way of example, the GUI <NUM> may comprise an app development UI <NUM> provided to a user for developing the app <NUM>.

The application software component <NUM> and/or the processor <NUM> are configured to provide an app development user interface (UI) <NUM> of an app development platform <NUM> to a user for developing the app <NUM>.

As mentioned above, the app development platform <NUM> may comprise the above-described functionalities of visual model-based representations, visual model-based apps, and/or visual models and, by way of example, be a visual model-based app development platform or a low-code app development platform. The app development UI <NUM> may provide an interactive user interface of the app development platform <NUM> which supports and enables the user to develop the app <NUM>. By way of example, the app <NUM> may be or comprise a software program which on execution performs specific desired tasks.

The application software component <NUM> and/or the processor <NUM> are further configured to display at least two workflow artifacts <NUM> of a workflow <NUM> of the app <NUM> to the user in the app development UI <NUM>.

Herein, a workflow <NUM> may generally be considered to comprise an orchestrated and repeatable pattern of activity, enabled by the systematic organization of resources into processes that may transform materials, provide services, or process information. A workflow <NUM> may be depicted as a sequence of operations, the work of a person or group, the work of an organization of staff, or one or more simple or complex mechanisms. In the context of apps <NUM> and the development of apps <NUM>, the workflow <NUM> may describe or characterize the pattern of activity which may be executed by the developed and deployed app <NUM>. The workflow <NUM> may, in some sense, express a logic of the app <NUM>. Hence, executing the workflow <NUM> which may correspond to the given business logic, and which may be comprised by the developed and deployed app <NUM> may contribute to fulfill a certain business need. In some examples, the workflow <NUM> may comprise two or more workflow artifacts <NUM> which may form the mentioned pattern, and which may correspond to single activities of the mentioned pattern.

In some app development platforms <NUM>, such a workflow <NUM> may be known as a microflow or a nanoflow. Like workflows <NUM> of apps <NUM> in general, such microflows or a nanoflows may perform actions, e.g., the above-mentioned workflow artifacts <NUM>, such as creating and updating objects, showing pages, and making choices. Such choices may be decisions, i.e., e.g., workflow artifacts <NUM> that may make a choice based on a condition and follow one and only one of the outgoing paths. For example, for an app <NUM> in the context of onboarding new hires, you need to use a decision to follow different paths when a new hire works remotely or when they work from the office. In an industrial context, the app <NUM> may comprise a decision on whether to stop the production process of a device, e.g., a production machine, e.g., based on input data <NUM> of the device, such as condition monitoring data or status data relating to the device. In some examples, the mentioned device may correspond to the below mentioned target device <NUM> or other device. Such decision workflow artifacts <NUM> may, e.g., comprise an exclusive split which is an element that makes a choice based on a condition and follows (exactly) one of the outgoing sequence flows. Such decision workflow artifacts <NUM> may, e.g., further comprise an inheritance split which is an element that makes a choice based on the type of a certain variable. For each specialization of the variable, the workflow <NUM> can continue in a different way. Further, such decision workflow artifacts <NUM> may, e.g., comprise a parallel split which may be used to have parallel processes in your workflow <NUM>. Such parallel processes or the above-mentioned outgoing sequence flows may also be understood as partial flows <NUM> of a workflow <NUM> which are explained below. For example, when onboarding a new employee, you can have several processes running in parallel: the human recourses department preparing necessary documents, the IT department preparing a workstation, and the administration department scheduling a training for the employee. In some examples, such decision workflow artifacts <NUM> may be understood as a split artifact <NUM> which is explained below.

Accordingly, there may be workflow artifacts <NUM> which may merge processes running in parallel or which combine multiple sequence flows into one sequence flow. There may, e.g., be situations where the workflow <NUM> has been separated in the part preceding the merge to execute specific actions. After this, the same action needs to be executed for all the separated flows. In this situation a merge can be used to avoid redundancy. In some examples, such merge workflow artifacts <NUM> may be understood as a merge artifact <NUM> which is explained below, and which merges partial flows <NUM>.

Especially in the context of low code app development, the workflow <NUM> may be understood as a visual way of expressing what traditionally ends up in textual program code.

In some app development platforms <NUM>, microflows may run in the runtime server and may therefore, in some examples, not be used in offline apps, while nanoflows may run directly on the browser or the target device <NUM> and may, in some examples, be used in an offline app. Furthermore, most of the actions in nanoflows may run directly on the target device <NUM>, so there may also be a speed benefit for logic which does not need access to the server.

By way of example, the workflow artifacts <NUM> may correspond to one or more activities executed by the app <NUM>, e.g., accessing input data <NUM>, manipulating the input data <NUM>, generating output data <NUM>, user interactions, such as capturing queries of the app user, displaying data, e.g., input data <NUM> or output data <NUM> to the app user, or transmitting the output data <NUM> to some other app or device, e.g., the device connected to the target device <NUM>. The workflow artifacts <NUM> may further relate, as already mentioned above, to creating and updating objects, showing pages, and making choices.

The application software component <NUM> and/or the processor <NUM> are further configured to capture the user's intent to insert an additional workflow artifact 122a into the workflow <NUM> in response to user interactions with the app development UI <NUM>.

, for the purposes of further developing the app <NUM>, the user may want to insert an additional workflow artifact 122a into the workflow <NUM>. The user may, in some examples, express his or her intent by dragging and dropping the additional workflow artifact 122a in the workflow <NUM> displayed in the app development UI <NUM>. This may be done, e.g., by dragging and dropping the additional workflow artifact <NUM> between two neighboring workflow artifacts <NUM> or on one of the workflow artifacts <NUM>, for example, using the input device <NUM>. Herein, it should be appreciated, that in some examples, the additional workflow artifact 122a may be an additional action that the user wants to insert in the existing workflow <NUM> of the app <NUM> which he or she develops.

In further examples, the additional workflow artifact 122a may be chosen from a library or from templates which are made available to the user by the app development platform <NUM> and/or which may be created by the user and/or which may be imported by the user from somewhere else, e.g., from other data sources available in the internet.

It should be appreciated, that in some examples, the user intent may be to move one of the workflow artifacts <NUM> of the workflow <NUM> from an initial position to a final position within the workflow <NUM>. This user intent may be understood as deleting this specific workflow artifact <NUM> at the initial position from the workflow 124and inserting the specific workflow artifact <NUM> at the final position in the workflow <NUM>. Herein, the insertion of this specific workflow artifact <NUM> at the final position in the workflow <NUM> may be understood as inserting this specific workflow artifact <NUM> as the additional workflow artifact 122a into the workflow <NUM> at the final position. The resulting overlap <NUM> at the final position may then be removed according to the approach described below.

The application software component <NUM> and/or the processor <NUM> are further configured to insert the additional workflow artifact 122a into the workflow <NUM> according to the captured user's intent.

The app development platform <NUM> may then put the additional workflow artifact 122a in the workflow <NUM> as desired by the user. In some examples, the previously defined workflow <NUM> may not yet be rearranged to accommodate the additional workflow artifact 122a. In further examples, if the additional workflow artifact 122a is inserted between a preceding workflow artifact 122p and a following workflow artifact 122f, the additional workflow artifact 122a may be put at the initial position of the following workflow artifact 122f or in the vicinity the initial position of the following workflow artifact 122f, e.g., towards the preceding workflow artifact 122p, to obtain the amended workflow <NUM>'.

The application software component <NUM> and/or the processor <NUM> are further configured to determine an overlap <NUM> of at least two of the workflow artifacts <NUM> caused by the inserted workflow artifact 122a.

Generally, inserting the additional workflow artifact 122a may lead to an overlap <NUM> of workflow artifacts <NUM> of the workflow <NUM> which now comprises the inserted workflow artifact 122a as well. Herein, an overlap <NUM> may be understood as one of the workflow artifacts <NUM>, 122a of the workflow <NUM> to extend over or past and cover a part of another workflow artifact <NUM>, 122a of the workflow <NUM>. The respective overlapping workflow artifacts <NUM>, 122a may have the size as displayed to the user in the app development UI <NUM> or the respective overlapping workflow artifacts <NUM>, 122a may have a larger size than displayed in the app development UI <NUM>. Therefore, in some examples, the respective overlapping workflow artifacts <NUM>, 122a may also overlap when displayed on the app development UI <NUM>. In other examples, the respective overlapping workflow artifacts <NUM>, 122a may be displayed in the app development UI <NUM> to be closer to each other than other, neighboring workflow artifacts <NUM>. In such examples, the respective overlapping workflow artifacts <NUM>, 122a may be displayed in the app development UI <NUM> as not overlapping although they do overlap since the respective overlapping workflow artifacts <NUM>, 122a may have a larger size, respectively, than displayed in the app development UI <NUM>.

In most examples, the inserted workflow artifact 122a may at least partly overlap with one of the workflow artifacts <NUM> which was already comprised by the workflow <NUM> prior to the insertion of the inserted workflow artifact 122a.

The application software component <NUM> and/or the processor <NUM> are further configured to determine a flow direction <NUM> of the workflow <NUM> from the preceding workflow artifact 122p to the following workflow artifact 122f, the preceding and the following workflow artifact 122p, 122f preceding and following the inserted workflow artifact 122a, respectively.

In some examples, the workflow <NUM> may be characterized by certain flow direction <NUM> linking the preceding workflow artifact 122p with the following workflow artifact 122f. The flow direction <NUM> may indicate the flow of workflow artifacts <NUM> and may, e.g., define that the preceding workflow artifact 122p may be executed before the following workflow artifact 122f may be executed. By way of example, the flow direction <NUM> may be indicated with arrows in the app development UI <NUM>.

Hence, the flow direction <NUM> or sequence flow may, in some examples, be understood as a flow that may be shown in the app development UI <NUM> using one or more arrows that link(s) the workflow artifacts <NUM>, such as events, activities, decisions, etc., with each other. Hereby, the flow direction <NUM> may define the order of execution. The flow direction <NUM> may generally flow in one direction where workflow artifacts <NUM> follow each other up one by one. When two activities or workflow artifacts <NUM> shall be linked together, the flow direction <NUM> or a sequence flow may be used.

For the sake of clarity, the flow direction <NUM> may link the proceeding workflow artifact 122p and the following workflow artifact 122f such that first, the proceeding workflow artifact 122p is executed and then, the following workflow artifact 122f is executed.

The application software component <NUM> and/or the processor <NUM> are further configured to determine at least one workflow artifact <NUM> of the workflow <NUM> which needs to be moved along the determined flow direction <NUM> to avoid the determined overlap <NUM>.

The determination of the workflow artifact(s) <NUM> to be moved may involve the determination if the determined overlap <NUM> may be removed by moving a corresponding workflow artifact <NUM> of the workflow <NUM> along the determined flow direction <NUM>. If the determined overlap may be removed by moving the respective workflow artifact <NUM>, this respective workflow artifact <NUM> may be identified as the workflow artifact <NUM> to be moved. In many cases, the workflow artifact <NUM> to be moved may be the following workflow artifact 122f, i.e., the workflow artifact 122f which is following the inserted artifact 122a in the workflow <NUM> after the insertion of the inserted workflow 122a. In some examples, the workflow artifact <NUM> to be moved may be the preceding workflow artifact 122p, i.e., the workflow artifact 122p which is preceding the inserted artifact 122a in the workflow <NUM> after the insertion of the inserted workflow 122a.

The application software component <NUM> and/or the processor <NUM> are further configured to determine an updated workflow <NUM>' by moving the respective, determined workflow artifact <NUM> along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

The determined workflow artifact <NUM> to be moved may then be moved in the workflow <NUM> along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed to obtain an updated workflow <NUM>'. Generally, by way of example, the movement of the determined workflow artifact <NUM> may be stopped as soon as the determined overlap <NUM> is removed. Moving the determined workflow artifact <NUM> may sometimes be called nudging since the determined workflow artifact <NUM> may only gently or gradually be moved, but also since this approach tries to keep the general layout of the workflow <NUM>.

The application software component <NUM> and/or the processor <NUM> are further configured to display at least the preceding workflow artifact 122p, the inserted workflow artifact 122a, and the following workflow artifact 122f to the user in the app development UI <NUM>.

Herein, in some examples, the preceding workflow artifact 122p, the inserted workflow artifact 122a, and the following workflow artifact 122f may be displayed to the user after the insertion of the inserted workflow artifact 122a and after moving the determined workflow artifact <NUM> to obtain the updated workflow <NUM>'. In other words, at least the three mentioned workflow artifacts 122p, 122a, 122f of the updated workflow <NUM>' may be displayed to the user in the app development UI <NUM>.

Displaying the proceeding workflow artifact 122p, the inserted workflow artifact 122a, and the following workflow artifact 122f in the app development UI <NUM>, may allow the user to retrace the amendments made to the original workflow <NUM> to obtain the updated workflow <NUM>' and to check the updated workflow <NUM>'. In some examples, the user may confirm or discard the updated workflow <NUM>' by corresponding user interactions with the app development UI <NUM>. Generally, the suggested update mechanism of the workflow <NUM> to obtain the updated workflow <NUM>' may provide very good results which may both comply with the user's insert intent and provide an updated workflow <NUM>' which may readily be used by the app development platform <NUM> to create or develop the app <NUM>.

The application software component <NUM> and/or the processor <NUM> aer further configured to develop the app <NUM> through the app development UI <NUM> by using the updated workflow <NUM>'.

Using the updated workflow <NUM>', the app <NUM> may be developed through the app development UI <NUM> which may interact, by way of example, with an ADF, IDE, visual model-based representations or the above-mentioned (low-code) app development platform <NUM> to accomplish the development of the app <NUM>. Herein, the app development platform <NUM> together with the updated workflow <NUM>' may particularly be suitable to support non-expert users to insert the additional workflow artifacts <NUM> in the workflow and then to develop the app <NUM> comprising the updated workflow <NUM>'.

The application software component <NUM> and/or the processor <NUM> are further configured to determine a moving borderline <NUM> in the workflow <NUM>, wherein the moving borderline <NUM> intersects the preceding workflow artifact 122p and is perpendicular to the determined flow direction <NUM>; and to determine the updated workflow <NUM>' by only moving one or more workflow artifacts <NUM> which are arranged in the workflow <NUM> at the same side of the moving borderline <NUM> as the inserted artifact 122a or the removed workflow artifact 122r.

The use of the described moving borderline <NUM> may be particularly advantageous for more complex or advanced workflows <NUM>. Such more complex workflows <NUM> may comprise curves at which workflow artifacts <NUM> may be arranged so that the workflow <NUM> may cross or intersect the determined moving borderline <NUM> once or several times. Imagine, for example, a workflow <NUM> with an S-shape or a Z-shape, wherein the moving borderline may be a vertical line which splits this workflow <NUM> into the right half and the left half. It is obvious that such a workflow <NUM> crosses or intersect this moving borderline <NUM> three times, namely at the top, at the middle and at the bottom of the shape of the workflow <NUM>.

The moving borderline <NUM> may be determined to intersect the workflow <NUM> at the preceding workflow artifact 122p and may be perpendicular to the determined flow direction <NUM>. The updated workflow <NUM>' may then be determined by only moving artifacts <NUM> which are arranged at the same side of the moving borderline <NUM> as the inserted workflow artifact 122a or the removed workflow artifact 122r. In other words, in some examples, workflow artifacts which are arranged at the same side of the moving borderline <NUM> as the preceding workflow artifact 122p may not be moved.

This rather simple approach may turn out to be very efficient and failsafe. It is rather easy to implement and yet considerably contributes to preserve the layout of the workflow <NUM>.

In some examples, the workflow <NUM> may intersect the determined moving borderline <NUM> at least twice, wherein optionally, the workflow <NUM> may include an S-shape or a Z-shape, as explained above, or the workflow <NUM> may include a U-shape as illustrated in <FIG> and explained below.

It should be appreciated that the suggested method may particularly be suitable to preserve the layout of the workflow <NUM> to obtain the updated workflow <NUM>' after the insertion of the additional workflow artifact 122a. This may e.g., be achieved by avoiding overlapping workflow artifacts <NUM>, by avoiding crossing flows in the workflow <NUM>, by avoiding resetting the user's layout of the workflow <NUM>, and/or by allowing for future expansion of the workflow <NUM>, e.g., by introducing decision splits, loops, etc..

Hence, the suggested method may make sure that an updated workflow <NUM>' may be obtained which may be interpreted by the app development platform <NUM> in a meaningful and consistent way. Therefore, the suggested method may avoid contradictions and broken or crossing flows in the updated workflow <NUM>' which may lead to inconsistencies and issues when the app development platform <NUM> tries to develop or create the app <NUM> based on such an inconsistent or contradictory, updated workflow <NUM>'. The suggested method may consequently considerably help to facilitate the app development, especially, for non-expert app developers.

Other approaches, e.g., relating to macro layout algorithms, such as dot, twopi, neato or the Sugiyama algorithm, may tend to rewrite the entire graph layout which may have severe drawbacks. For example, a user, esp. a non-expert app developer, might not recognize his or her initial workflow <NUM> anymore might get lost during the development of his or her app <NUM>. This might particularly hinder further amendments, such as the insertion of yet further workflow artifact <NUM> to the workflow <NUM>, which, however, is regularly required many times during the development of a workflow <NUM> of an app <NUM> or of an app <NUM>.

Further, according to yet other approaches, the user may take care of the layout of the workflow <NUM> himself or herself to obtain the updated workflow <NUM>' after the insertion of the additional workflow artifact 122a. This approach, however, may involve many manual steps, e.g., involving manual coding, which may only be performed by suitably trained users. Also, this approach is time-consuming and error-prone.

Contrary to these other approaches, the suggested method may embody a sort of low-code approach for a user to create a logic layout of the workflow <NUM> and to develop the app <NUM>. Particularly, the suggested method may take away the burden from the user to manually amend or correct a workflow logic when adding, but also when moving or deleting workflow artifacts <NUM> in a workflow <NUM>. Advantages of the suggested approach comprise visually displaying to the user what is amended by the suggested update of the workflow <NUM>. Hence, the user may still keep the control of the applied changes, also since according the suggested approach, only small changes may be done to the workflow <NUM> which is hence corresponding to a "micro" aspect opposed to the above-mentioned macro layout algorithms.

It should further be appreciated, that the suggested approach may be applicable to the above-mentioned app development platforms <NUM> which provide workflows <NUM> as a microflows or a nanoflows.

It should also be appreciated that in further examples, the application software component <NUM> and/or the processor <NUM> may further be configured to determine at least one position <NUM> in the workflow <NUM> at which to insert the additional workflow artifact 122a using the captured user's intent and a trained function <NUM>.

A trained function <NUM> may, e.g., be understood to be or comprise a machine learning algorithm, a deep learning model, an artificial neural network or more generally an artificial intelligence-based function. Alternative terms for "artificial neural network" are "neural network", "artificial neural net" or "neural net" and an example may be a convolutional neural network.

The trained function <NUM> may generally receive data input which is then processed using the trained function <NUM> to generate data output. It should be appreciated that in some examples, the trained function <NUM> may be used for pattern recognition, data mining, image recognition, speech recognition, etc., and may particularly be useful for processing large amounts of data.

In the present context, the trained function <NUM> may, in some examples, comprise a recommendation engine which may make a recommendation or several recommendations to the user with respect to a position <NUM> or several different positions <NUM> in the workflow at which to insert the additional workflow artifact 122a into the workflow <NUM>. Herein, the mentioned data input may comprise data on one or more meaningful positions <NUM> for inserting respective additional workflow artifacts 122a into workflows <NUM>. The data input may, in some examples, originate from users that have previously amended their respective workflow <NUM> by inserting additional workflow artifacts 122a to create or develop respective apps <NUM>. In some examples, only such input data may be considered in which the amended workflow <NUM>' resulted in a successfully developed and deployed app <NUM>. The trained function <NUM> may use such data input, process the data input, and then output data output comprising one or more recommended positions <NUM> at which the user of the currently developed workflow <NUM> and app <NUM> may insert the currently inserted workflow artifact 122a.

In some more advanced examples, the user may initially only provide a certain desired functionality of the app <NUM> and the trained function <NUM> may then determine the additional workflow artifact 122a which needs to be inserted into the workflow <NUM> and which corresponds best to the functionality desired by the user. In such more advanced examples, the trained function <NUM> may therefore sort of translate the captured user's intent to insert the desired functionality into the required additional workflow artifact 122a. Herein, the corresponding data input may, in some examples, originate from users that have previously input a desired functionality and inserted additional workflow items 122a into the workflow to (successfully) create or develop respective apps <NUM>.

It should be appreciated, that the suggested update mechanism of the workflow <NUM> after the insertion of the additional workflow item 122a may support both a regular, non-expert app developer user and a user who is supported by the trained function <NUM>. In some examples, the trained function <NUM> may very quickly and conveniently determine the suitable position <NUM> at which the additional workflow artifact 122a shall be inserted. However, in many cases, the trained function <NUM> or some other artificial intelligence-based function may not be able to update the workflow <NUM> in a meaningful way. Hence, the trained function <NUM> may be limited to only determine the right position <NUM> for the insertion of the additional workflow artifact 122a but may not carry out the subsequent step of suitably updating, rearranging or reordering the workflow <NUM> after the insertion of the additional workflow artifact 122a. In many examples, a workflow <NUM> established only by regular, non-expert app developer users supported by the trained function <NUM> or some other artificial intelligence-based function but without the suggested update mechanism of the workflow <NUM> would comprise inconsistencies or conflicts which might cause severe issues for the app development platform <NUM> when developing a corresponding app <NUM>. Also, in many cases, the trained function <NUM> without suggested update mechanism of the workflow <NUM> would lead to a messed-up and confusing workflow <NUM> which would be very hard for both a user and the app development platform <NUM> to interpreted in a meaningful way.

In some examples, the application software component <NUM> and/or the processor <NUM> may further be configured to display the respective, determined position <NUM> to the user in the app development UI <NUM> and to capture the user's intent to approve at least one of the respective, determined position <NUM> in response to user interactions with the app development UI <NUM>.

Displaying the respective, determined position <NUM> to the user and getting the user's approval to at least one of the respective, determine position(s) <NUM> may, in some examples, help to train and refine the trained function <NUM>. Over time, the trained function will improve its accuracy so that the likelihood that a determined position <NUM> fits well and is approved by the user is getting greater and greater.

In further examples, the application software component <NUM> and/or the processor <NUM> may further be configured to move the workflow artifacts <NUM> of the workflow <NUM> following the inserted artifact 122a along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

In such examples, (all) the workflow artifacts <NUM> following the inserted artifact 122a may be moved along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed, wherein the moved workflow artifacts <NUM> may comprise the following workflow artifact 122f, i.e., the workflow artifact 122f which follows the inserted artifact 122a. This approach of updating the workflow <NUM> is particularly simple and easy to implement, but nonetheless results in a well-arranged updated workflow <NUM>'. Such scenarios may particularly be suitable for rather simple and linear workflows <NUM>, e.g., in which the workflow artifacts <NUM> following the inserted artifact 122a are more or less arranged along one line, e.g., the determined flow direction <NUM>.

It should be appreciated that in some examples, the application software component <NUM> and/or the processor <NUM> may further be configured to determine the overlap <NUM> of at least two of the workflow artifacts <NUM> caused by a previously moved workflow artifact <NUM>; to determine the flow direction <NUM> of the workflow <NUM> from the preceding workflow artifact 122p to the following workflow artifact 122f, the preceding workflow artifact 122p and the following workflow artifact 122f preceding and following the previously moved workflow artifact <NUM>, respectively; to determine at least one workflow artifact <NUM> of the workflow <NUM> which needs to be moved along the determined flow direction <NUM> to avoid the determined overlap <NUM>; and to determine the updated workflow <NUM>' by moving the respective, determined workflow artifact <NUM> along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

In these examples, in the previous step, the previously determined workflow artifact <NUM> has already been moved, whereby the movement of this previously determined workflow artifact <NUM> may cause the current overlap <NUM>. In this case, the previously described method can be applied again so that firstly, this new overlap <NUM> may be determined, secondly, the new flow direction <NUM> of the present workflow <NUM> may be determined, whereby the present workflow <NUM> corresponds to the previously updated workflow <NUM>' taking into account the movement of the previously moved workflow artifact <NUM>. The new flow direction <NUM> takes into account the workflow artifact 122p preceding the previously moved artifact <NUM> and the workflow artifact 122f following the previously moved artifact <NUM>. Thirdly, at least one workflow artifact <NUM> may be determined which needs to be moved to avoid the determined current overlap <NUM>, and fourthly, the current workflow <NUM> may be updated to obtain an amended updated workflow <NUM>' by moving the respective determined workflow artifact <NUM> along the determined new flow direction <NUM> at least until the determined overlap <NUM> is removed.

In this way, an overlap <NUM> which has previously been caused by moving a workflow artifact <NUM> to remove a previously existing overlap <NUM> may be removed. This procedure may be iterated, i.e., repeated again and again, until all iteratively caused overlaps <NUM> in the workflow <NUM> may be removed.

In some examples, the application software component <NUM> and/or the processor <NUM> may further be configured to capture the user's intent to remove a selected workflow artifact 122r from the workflow <NUM> in response to user interactions with the app development UI <NUM>; to remove the selected workflow artifact 122r from the workflow <NUM> according to the captured user's intent; to determine a gap <NUM> between the preceding workflow artifact 122p and the following workflow artifact 122f, the preceding workflow artifact 122p and the following workflow artifact 122f preceding and following the removed workflow artifact 122r, respectively; to determine the flow direction <NUM> of the workflow <NUM> from the preceding workflow artifact 122p to the following workflow artifact 122f; and to determine the updated workflow <NUM>' by moving the following workflow artifact 122f in opposite direction to the determined flow direction <NUM> until the determined gap <NUM> is closed.

Generally, removing one of the workflow artifacts <NUM> may lead to a gap <NUM> between the artifacts 122p, 122f preceding and following the removed workflow artifact 122r. Herein, a gap <NUM> may, in some examples, be understood as too much space between two neighboring workflow artifacts <NUM> of the workflow <NUM>, e.g., such that, e.g., an additional workflow artifact 122a might be inserted in the gap <NUM> without causing an overlap <NUM>. Preferably, such gaps <NUM> are avoided to maintain a well-organized workflow <NUM> which, by way of example, also allows for easier readability to the user.

After determining the flow direction <NUM> of the workflow <NUM> from the preceding workflow artifact 122p to the following workflow artifact 122f, the updated workflow <NUM>' may be obtained by moving the following workflow artifact 122f in opposite direction to the determined flow direction <NUM> until the gap <NUM> is closed. The opposite direction may hereby mean that the direction of movement of the following workflow artifact 122f is exactly opposed or rotated by <NUM>° with respect to the determined flow direction <NUM>.

In some examples, (all) the workflow artifacts <NUM> following the removed workflow artifact 122r or following the following workflow artifact 122f may be moved in opposite direction to the determined flow direction <NUM>. This approach of updating the workflow <NUM> is particularly simple and easy to implement, but nonetheless results in a well-arranged updated workflow <NUM>'. Such scenarios may particularly be suitable for rather simple and linear workflows <NUM>, e.g., in which the workflow artifacts <NUM> following the removed artifact 122r are more or less arranged along one line, e.g., the determined flow direction <NUM>.

It should be appreciated, that in some examples, the user intent may be to move one of the workflow artifacts <NUM> from an initial position to a final position within the workflow <NUM>. This user intent may be understood as deleting this specific workflow artifact <NUM> at the initial position and inserting the specific workflow artifact <NUM> at the final position in the workflow <NUM>. Herein, the removal of this specific workflow artifact <NUM> at the initial position in the workflow <NUM> may be understood as removing this specific workflow artifact <NUM> as the selected workflow artifact 122r from the workflow <NUM> at the initial position. The resulting gap <NUM> at the initial position may then be closed according to the approach described above.

In some examples, the inserted workflow artifact 122a may be inserted into a loop <NUM> of workflow artifacts <NUM>, wherein the loop <NUM> may have a loop size <NUM> and a loop border <NUM>, and wherein the application software component <NUM> and/or the processor <NUM> may further be configured to determine an overlap <NUM> of a workflow artifact <NUM> comprised by the loop <NUM> and the loop border <NUM>, the overlap <NUM> being caused by the workflow artifact 122a inserted into the loop <NUM>; and to determine the updated workflow <NUM>' by expanding the loop size <NUM> of the loop <NUM> along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

Herein, a loop <NUM> may be used to execute repeated actions comprising one or more workflow artifacts <NUM> may be visualized as a frame. For each iteration, the flow inside the loop <NUM> may be executed. In some examples, the loop <NUM> may be configured to iterate over a list or be based on a Boolean expression. The iteration over the list may comprise executing the workflow artifacts <NUM> of the loop <NUM> for each of the entries of the list. The iteration based on the Boolean expression may comprise executing the workflow artifacts <NUM> of the loop <NUM>, e.g., while a condition is true. In some examples, the loop <NUM> may contain all types of workflow artifacts <NUM>, e.g., also used in microflows or nanoflow, except for start events and end events which start or end the workflow <NUM>. Further, a loop <NUM> may contain workflow artifacts <NUM> corresponding to break events and continue events.

In order to accommodate the workflow artifacts <NUM> comprised by the loop <NUM>, the loop <NUM> may have a certain loop size <NUM> and may be limited by a loop border <NUM> which may both be displayed in the app development UI <NUM> as a frame of a corresponding size.

If the inserted workflow artifact 122a is inserted into the loop <NUM>, an overlap <NUM> of at least one of the workflow artifact <NUM> of the loop <NUM> and the loop border <NUM> may occur. First, this overlap <NUM> may be determined and then, an updated workflow <NUM> may be determined by expanding the loop size <NUM> and hence of the loop border <NUM> of the loop <NUM> along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed. Herein, the flow direction <NUM> may be determined from the workflow artifact 122p preceding the inserted workflow artifact 122a to the workflow artifact 122f following the inserted workflow artifact 122a. Expanding the loop size <NUM> along the determined flow direction may, in some examples, mean that the start or entry point of the loop <NUM> in the workflow <NUM> remains unchanged, whereas the endpoint or exit point of the loop <NUM> in the workflow <NUM> may be moved along the determined flow direction <NUM> thereby expanding or enlarging the loop size <NUM> and the loop border <NUM> until the determined overlap <NUM> is removed. In some examples, expanding the loop size <NUM> may involve expanding the loop border <NUM> along the determined flow direction <NUM> accordingly.

By way of example, the application software component <NUM> and/or the processor <NUM> may further be configured to determine an overlap <NUM> of the expanded loop <NUM> and the workflow artifact 122lf following the loop <NUM>; to determine the flow direction <NUM> of the workflow <NUM> from the expanded loop <NUM> to the workflow artifact 122lf following the loop <NUM>; and to determine the updated workflow <NUM>' by moving the workflow artifact 122lf following the loop <NUM> along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

In this example, in the previous step, the loop size <NUM> has already been expanded to remove a previously existing overlap <NUM> between a workflow artifact <NUM> comprised by the loop <NUM> and the loop border <NUM>, whereby the expansion of the loop size <NUM> causes the current overlap <NUM>. In this case, a new overlap <NUM> may be determined, whereby now the expanded loop <NUM> with its expanded loop border <NUM> and the workflow artifact 1221f following expanded loop <NUM> may overlap. Then, the flow direction <NUM> may be determined which now takes into account these two items, namely the expanded loop border <NUM> and the workflow artifact 1221f following expanded loop <NUM>. Finally, the updated workflow <NUM>' may be determined by moving the workflow artifact 1221f following expanded loop <NUM> along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

In this way, an overlap <NUM> which has previously been caused by expanding the loop <NUM> may be removed.

In some examples, the preceding workflow artifact 122p may be a split artifact <NUM> starting partial flows <NUM> of the workflow <NUM>, wherein the application software component <NUM> and/or the processor <NUM> may further be configured to determine the flow direction <NUM> of the workflow <NUM> from the following workflow artifact 122f to the workflow artifact 122ff following the following workflow artifact 122f; and to determine the updated workflow <NUM>' by arranging the inserted artifact 122a at an initial position <NUM> of the following artifact 122f and by moving the following workflow artifact 122f along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

In these examples, preserving the layout of the workflow <NUM> may be challenging. To meet this challenge, the flow direction <NUM> of the workflow <NUM> is determined by considering the workflow artifact 122f following the inserted workflow artifact 122a and the workflow artifact 122ff following the workflow artifact 122f following the inserted workflow artifact 122a. In other words, the determination of the flow direction <NUM> is postponed or relocated by one couple of workflow artifacts <NUM> from the couple of workflow artifacts 122p-122f to the couple of workflow artifacts 122f-122ff.

The updated workflow <NUM>' may then be determined by arranging the inserted artifact 122a at the initial position <NUM> or <NUM> at which the following artifact 122f was initially positioned. This following workflow artifact 122f may then be moved along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed. In some examples, the determined overlap <NUM> relate to an overlap <NUM> of at least two of the workflow artifacts <NUM> caused by the inserted workflow artifact 122a. In many cases, the inserted workflow artifact 122a and the following workflow artifact 122f may overlap.

The mentioned split artifact <NUM> may, by way of example, correspond to the decision workflow artifacts <NUM> explained above.

In further examples, the following workflow artifact 122f may be a merge artifact <NUM> merging partial flows <NUM> of the workflow <NUM>, wherein the application software component <NUM> and/or the processor <NUM> may further be configured to determine the flow direction <NUM> of the workflow <NUM> from the workflow artifact 122pp preceding the preceding workflow artifact 122p to the preceding workflow artifact 122p; and to determine the updated workflow <NUM>' by moving the preceding workflow artifact 122p in the opposite direction to the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

Also in these examples, preserving the layout of the workflow <NUM> may be challenging. To meet the challenge, the updated workflow <NUM>' may be determined by moving the preceding workflow artifact 122p in the opposite direction to the determined flow direction <NUM> at least until the determined overlap <NUM> is removed. Again, the opposite direction may hereby mean that the direction of movement of the preceding workflow artifact 122p is exactly opposed or rotated by <NUM>° with respect to the determined flow direction <NUM>. Herein, the preceding workflow artifact 122p may be the workflow artifact 122p which precedes the inserted workflow artifact 122a and the workflow artifact 122pp may precede the preceding workflow artifact 122p. In some examples, all the workflow artifacts 122p preceding the inserted workflow artifact 122a may be moved in the opposite direction to the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

In some examples, the updated workflow <NUM>' may further be determined by arranging the inserted artifact 122a at the initial position <NUM> or <NUM> at which the preceding artifact 122p was initially positioned.

The mentioned merge artifact <NUM> may, by way of example, correspond to the merge workflow artifacts <NUM> explained above.

In further examples, the application software component <NUM> and/or the processor <NUM> may further be configured to deploy the developed app <NUM> comprising the updated workflow <NUM>' on a respective target device <NUM> of the app <NUM>.

The (type of) target device <NUM> may, e.g., be a mobile platform, e.g. a smartphone, smartwatch, handheld, pad, laptop or the like, or a desktop device, e.g. including desktop computers, or other "smart" devices, e.g. smart television sets, fridges, home or industrial automation devices, wherein smart television sets may e.g. be a television set with integrated Internet capabilities or a set-top box for television that offers more advanced computing ability and connectivity than a contemporary basic television set. The different kinds of platforms may involve different operating systems, e.g., linux, unix, iOS, macOS, Microsoft Windows or the like. It should be appreciated that the user ("app developer") developing the app <NUM> may be (and generally is) a different person than the user ("app customer", "customer user" or "end user") using or running the app <NUM> deployed on his or her target device <NUM>.

Further, by way of example, the respective target device <NUM> may be or comprise a manufacturing operation management (MOM) system, a manufacturing execution system (MES), and enterprise resource planning (ERP) system, a supervisory control and data acquisition (SCADA) system, or any combination thereof.

By way of example, the app <NUM> may be deployed in the runtime of the respective target device <NUM>. Herein, the runtime of the respective target device <NUM> may be understood as runtime system, also called runtime environment, primarily implementing portions of an execution model. When treating the runtime system as distinct from the runtime environment (RTE), the first may be defined as a specific part of the application software (IDE) used for programming, a piece of software that provides the programmer a more convenient environment for running programs during their production (testing and similar) while the second (RTE) would be the very instance of an execution model being applied to the developed program which is itself then run in the aforementioned runtime system. The runtime environment may provide an environment in which programs, here the app <NUM>, run. This environment may address a number of issues including the management of application memory, how the program or the app <NUM> accesses variables, mechanisms for passing parameters between procedures, interfacing with the operating system, and otherwise. Typically, the runtime system will have some responsibility for setting up and managing the stack and heap, and may include features such as garbage collection, threads or other dynamic features built into the language.

Further, an app <NUM> may be understood as deployed if the activities which are required to make this app <NUM> available for use by the app user on the respective target device <NUM> are completed. The app deployment process may comprise several interrelated activities with possible transitions between them. These activities may occur at the producer side (e.g., by the app developer) or at the consumer side (by the app user or end user) or both. In some examples, the app deployment process may comprise at least the release of the app <NUM> and the installation and the activation of the app <NUM>. The release activity may follow from the completed development process and is sometimes classified as part of the development process rather than deployment process. It may comprise operations required to prepare a system (here: e.g., the app development platform <NUM> or an on-line app store) for assembly and transfer to the computer system(s) (here: e.g., the respective target device <NUM>) on which it will be run in production. Therefore, it may sometimes involve determining the resources required for the system to operate with tolerable performance and planning and/or documenting subsequent activities of the deployment process. For simple systems, the installation of the app <NUM> may involve establishing some form of command, shortcut, script or service for executing the software (manually or automatically) of the app <NUM>. For complex systems, it may involve configuration of the system - possibly by asking the end user questions about the intended app use, or directly asking them how they would like it to be configured - and/or making all the required subsystems ready to use. Activation may be the activity of starting up the executable component of software or the app <NUM> for the first time (which is not to be confused with the common use of the term activation concerning a software license, which is a function of Digital Rights Management systems).

Once the app <NUM> has been deployed on the respective target device <NUM> or in the runtime of the respective target device <NUM>, the app <NUM> may be run or operated.

By way of example, the application software component <NUM> and/or the processor <NUM> may further be configured to cause to apply the updated workflow <NUM>' of the developed app <NUM> to input data <NUM> to generate output data <NUM>; and to cause to analyze, monitor, operate and/or control the respective target device <NUM>, or a device connected to the respective target device <NUM> using the generated output data <NUM> and/or to cause to analyze and/or monitor the respective target device's <NUM> user using the generated output data <NUM>.

Once the app <NUM> has been deployed on the target device <NUM> or in the runtime of the target device <NUM>, the app <NUM> may be run or operated which may imply that the amended workflow <NUM>' of the app <NUM> may be put into action on (live) input data <NUM> to produce (actionable) output data <NUM>.

By way of example, the respective target device <NUM> may not be connected to the app development platform <NUM> or to the internet, e.g., when or after the deployment of the developed app <NUM> on the respective target device <NUM> of the app <NUM>. Further, in some examples, the respective target device <NUM> may not be connected to the app development platform <NUM> or to the internet when or after the amended workflow <NUM>' of the developed app <NUM> is applied to the input data <NUM>.

In some examples, the target device <NUM> may comprise or be the app development platform <NUM>.

In an example embodiment, the app <NUM> may be deployed on a respective target device <NUM>. In some examples, the respective target device <NUM> may be physically connected or communicatively connected to the other device or connected such, that the respective target device <NUM> may at least detect the input data <NUM> from the other device, e.g., by optically inspecting the other device. The other device may, in some examples, be or comprise a sensor, an actuator, such as an electric motor, a valve or a robot, an inverter supplying an electric motor, a gear box, a programmable logic controller (PLC), a communication gateway, and/or other parts or components relating to industrial automation products and industrial automation in general. The respective target device <NUM> may be part of a complex production line or production plant, e.g., a bottle filing machine, conveyor, welding machine, welding robot, etc..

In some examples, if the other device belongs to a lower level of the automation pyramid, such as the sensor/actuator or the field level, then the respective target device <NUM> may belong to a higher level of the automation pyramid, such as field level or the control level.

In this context, the respective target device <NUM> may be caused or triggered, e.g., by the app development platform <NUM>, to apply the amended workflow <NUM>' to the input data <NUM> to generate the output data <NUM>. The generated output data <NUM> may be used to analyze, monitor, operate and/or control the respective target device <NUM> or the other device. In further examples, the respective target device <NUM> may be caused or triggered, e.g., by the app development platform <NUM>, to analyze, monitor, operate and/or control the respective target device <NUM> or the other device using the generated output data <NUM>. In some examples, the mentioned steps may directly be performed by the app development platform <NUM>.

In further examples, the respective target device <NUM> may also be caused or triggered, e.g., by the app development platform <NUM>, to apply the updated workflow <NUM>' to the input data <NUM> to generate the output data <NUM>. The generated output data <NUM> may be used to analyze and/monitor the respective target device's <NUM> user. In further examples, the respective target device <NUM> may be caused or triggered, e.g., by the app development platform <NUM>, to analyze and/monitor the respective target device's <NUM> user using the generated output data <NUM>. In such more exotic examples, the respective target device <NUM> may be or comprise a smartphone, smartwatch, handheld, pad, laptop or the like and the other device may be a human, e.g., the end user of the respective target device <NUM>, or an animal or plant, wherein the human's, the animal's or the plant's health, behavior, etc. may be analyzed or monitored using the amended workflow <NUM>' and the app <NUM>. In some examples, the mentioned steps may directly be performed by the app development platform <NUM>.

It should also be appreciated that in further examples, only new overlaps <NUM> may be detected and in some examples, old overlaps which existed previously may not be considered or tried to be resolved.

By way of example, the following rule set may be applied, whereby objects may be understood as the above-mentioned workflow artifacts <NUM>:.

The rules may be run in the above order.

As explained above, moving one the workflow artifacts <NUM> may result in new overlaps <NUM> which should also be resolved.

Generally, preceding objects should, in most examples, not be moved.

It should be appreciated that the described the application software component <NUM> and/or the processor <NUM> may carry out an analogous method of managing an app <NUM>, especially developing an app <NUM> comprising updating a workflow <NUM> of the app <NUM>.

Further, a computer-readable medium <NUM> which may comprise a computer program product <NUM> is shown in <FIG>, wherein the computer program product <NUM> may be encoded with executable instructions, that when executed, cause the computer system <NUM> or and/or the app development platform <NUM> to carry out the described method.

For the sake of completeness, the two app development UIs <NUM> illustrated in <FIG> are briefly explained. In the upper app development UI <NUM>, the insertion of the additional workflow artifact 122a in the workflow <NUM> is illustrated, wherein the workflow <NUM> may already comprise the preceding workflow artifact 122p and the following workflow artifact 122f. An overlap <NUM> of the inserted workflow artifact 122a and the following workflow artifact 122f may be determined which may be caused by the insertion of the additional workflow artifact 122a. Further, the flow direction <NUM> of the workflow <NUM> may be determined, wherein the flow direction <NUM> may be directed from the preceding workflow artifact 122p to the following workflow artifact 122f. The following workflow artifact 122f may be determined to be the workflow artifact <NUM> which may be needed to be moved to remove the determined overlapped <NUM>, wherein the following workflow artifact 122f may need to be moved along the determined flow direction <NUM>, as indicated with the dashed arrow.

In the lower app development UI <NUM>, the status of the workflow <NUM> after the insertion of the additional workflow artifact 122a is illustrated. And updated workflow <NUM>' may be obtained by moving the inserted workflow artifact 122a along the determined flow direction <NUM> until the overlapped <NUM> is removed. According to the updated workflow <NUM>', the previous workflow artifact 122p may be followed by the inserted workflow artifact 122a which may be followed by the following workflow artifact 122f.

By way of example, the additional workflow artifact 122a may be put at the initial position of the following workflow artifact 122f or in the vicinity the initial position of the following workflow artifact 122f, e.g., towards the preceding workflow artifact 122p, to obtain the amended workflow <NUM>'.

With reference to <FIG>, a functional block diagram of another example computer system or data processing system <NUM> is illustrated that facilitates managing apps <NUM>, especially developing an app <NUM> comprising updating a workflow <NUM> of the app <NUM>.

In this example, a position <NUM> in the workflow <NUM> may be determined at which to insert the additional workflow artifact 122a using the captured user's intent and a trained function <NUM>. By way of example, the determined position <NUM> may displayed to a user and the user may approve the determined position <NUM> by his or her interactions with the app development UI <NUM>.

Further, the app <NUM> comprising the updated workflow <NUM>' may be deployed on a target device <NUM>. The updated workflow <NUM>' of the developed and deployed app <NUM> may be applied to input data <NUM> to generate output data <NUM>. By way of example, the input data <NUM> may be provided by the target device <NUM>, the other device, a device connected to the target device <NUM> or the target device's user. In some examples, the generated output data <NUM> may be used to analyze, monitor, operate and/or control the target device <NUM> or the device connected to the target device <NUM>. In other examples, the generated output data <NUM> more may be used to analyze and/or monitor the target device's user.

<FIG> illustrates a flow diagram of an example methodology that facilitates managing an app in a product system.

In the upper half of <FIG>, a workflow <NUM> is illustrated which may comprise a preceding workflow artifact 122p and a following workflow artifact 122f, wherein a flow direction <NUM> of the workflow <NUM> may be determined to point from the preceding workflow artifact 122p to the following workflow artifact 122f. An additional workflow artifact 122a may be inserted into the workflow <NUM> and may cause an overlap <NUM> of the additional workflow artifact 122a with the following workflow artifact 122f. The overlap <NUM> may be determined and it may further be determined that the following workflow artifact 122f may be the workflow artifact <NUM> to be moved along the determined flow direction <NUM> to avoid the determined overlap <NUM>.

The lower half of <FIG> illustrates the updated workflow <NUM>' which may be obtained by moving the determined workflow artifact <NUM> which is in this case the following workflow artifact 122f along the determined flow direction <NUM> at least until the determined overlapped <NUM> is removed. According to the updated workflow <NUM>', the previous workflow artifact 122p may be followed by the inserted workflow artifact 122a which may be followed by the following workflow artifact 122f.

<FIG> illustrates a flow diagram of another example methodology that facilitates managing an app in a product system.

In the upper half of <FIG>, a workflow <NUM> is illustrated which may comprise a preceding workflow artifact 122p, a workflow artifact 122r, and a following workflow artifact 122f, wherein a flow direction <NUM> of the workflow <NUM> may be determined to point from the preceding workflow artifact 122p to the following workflow artifact 122f. The user may choose to remove the workflow artifact 122r which may cause a gap <NUM> between the preceding workflow artifact 122p and the following workflow artifact 122f.

The lower half of <FIG> illustrates the updated workflow <NUM>' which may be obtained by moving the following workflow artifact 122f (which is in this case the workflow artifact <NUM> to be moved) in the opposite direction to the determined flow direction <NUM> at least until the determined gap <NUM> is closed. According to the updated workflow <NUM>', the previous workflow artifact 122p may be followed by the following workflow artifact 122f.

<FIG> illustrates a flow diagram of an example methodology that facilitates managing an app in a product system according to the invention.

In the upper half of <FIG>, a more complex workflow <NUM> is illustrated which may comprise several sequentially arranged workflow artifacts 122pp, 122p, 122f and 122ff, wherein the workflow artifact 122ff is a split artifact <NUM> starting two partial flows <NUM> of the workflow <NUM>. The upper partial flow <NUM> only comprises the workflow artifact 122fffa and the lower partial flow <NUM> comprises another sequence of workflow artifacts 122fffb, <NUM>-4fb, <NUM>-5fb, <NUM>-6fb. Remarkably, the workflow has a U-shape, wherein the opening of the U points to the left.

An additional workflow artifact 122a may be inserted into the workflow <NUM> and may cause an overlap <NUM> of the additional workflow artifact 122a with the following workflow artifact 122f. The overlap <NUM> may be determined and it may further be determined that the following workflow artifact 122f may be the workflow artifact <NUM> to be moved along the determined flow direction <NUM> to avoid the determined overlap <NUM>.

Further, a moving borderline <NUM> is determined in the workflow <NUM>, wherein the moving borderline <NUM> intersects the preceding workflow artifact 122p and is perpendicular to the determined flow direction <NUM>. Herein, the workflow artifacts 122pp, 122p, <NUM>-5fb, and <NUM>-6fb are arranged at the opposite site of the moving borderline <NUM> as the inserted workflow artifact 122a. For updating the workflow <NUM> to obtain the updated workflow <NUM>', only workflow artifacts <NUM> are moved which are arranged in the workflow <NUM> at the same site of the moving borderline <NUM> as the inserted workflow artifact 122a.

The lower half of <FIG> illustrates the updated workflow <NUM>' which is obtained accordingly, i.e., by moving only workflow artifacts <NUM> which are arranged in the workflow <NUM> at the same site of the moving borderline <NUM> as the inserted workflow artifact 122a, i.e., in this case the workflow artifacts 122f, 122ff,<NUM>, 122fffa, 122fffb, <NUM>-4fb. Accordingly, the workflow artifacts 122pp, 122p, <NUM>-5fb, and <NUM>-6fb are not moved to obtain the updated workflow <NUM>'.

In the upper half of <FIG>, a more complex workflow <NUM> is illustrated which may comprise a workflow artifact 122pp which is followed by a split artifact 122p, <NUM> which may start three partial flows <NUM>. The upper partial flow <NUM> may comprise two sequentially arranged workflow artifacts 122f and 122ff. The middle partial flow <NUM> may only comprise one workflow artifact 122sp2, and the lower partial flow <NUM> may also only comprise one workflow artifact 122sp3.

An additional workflow artifact 122a may be inserted into the upper partial flow <NUM> of the workflow <NUM> and may cause an overlap <NUM> of the additional workflow artifact 122a with the following workflow artifact 122f. In this example, the flow direction <NUM> of the workflow <NUM> may be determined from the following workflow artifact 122f to the workflow artifact 122ff following the following workflow artifact 122f. The overlap <NUM> may be determined and it may further be determined that the following workflow artifact 122f may be the workflow artifact <NUM> to be moved along the determined flow direction <NUM> to avoid the determined overlap <NUM>. Further, an updated workflow <NUM>' may be determined by arranging the inserted artifact 122a at an initial position <NUM> of the following artifact 122f and by moving the following workflow artifact 122f along the determined flow direction <NUM> at least until the overlap <NUM> of the inserted workflow artifact 122a and the following workflow artifact 122f is removed.

The lower half of <FIG> illustrates the updated workflow <NUM>' which may be obtained by moving the following workflow artifact 122f along the determined flow direction <NUM> and then the workflow artifact 122ff following the following artifact 122f. Hence, the upper partial flow <NUM> now comprises three sequentially arranged workflow artifacts 122a, 122f and 122ff, wherein the layout of the original workflow <NUM> could be preserved.

<FIG> illustrates a flow diagram of yet another example methodology that facilitates managing an app in a product system.

In the upper half of <FIG>, a workflow <NUM> is illustrated which may comprise two partial flows <NUM>. The upper partial flow <NUM> may comprise two sequentially arranged workflow artifacts 122pp and 122p and the lower upper partial flow <NUM> may comprise one workflow artifact 122pf2. The two partial flows <NUM> may be merged by the following workflow artifact 122f which is a merge artifact <NUM>. An additional workflow artifact 122a may be inserted into the upper partial flow <NUM> of the workflow <NUM> and may cause an overlap <NUM> of the additional workflow artifact 122a with the previous workflow artifact 122p.

The flow direction <NUM> of the workflow <NUM> may be determined to point from the workflow artifact 122pp preceding the preceding workflow artifact 122p to the preceding workflow artifact 122p. The updated workflow <NUM>' may then be obtained by moving the preceding workflow artifact 122p in the opposite direction to the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

The lower half of <FIG> illustrates the updated workflow <NUM>' which may be obtained by moving the previous workflow artifact 122p and the workflow artifact 122p which precedes the previous workflow artifact 122p accordingly. Hence, the upper partial flow <NUM> now comprises three sequentially arranged workflow artifacts 122pp, 122p and 122a, wherein the layout of the original workflow <NUM> could be preserved.

By way of example, the additional workflow artifact 122a may be put at the initial position of the preceding workflow artifact 122p or in the vicinity the initial position of the preceding workflow artifact 122p, e.g., towards the workflow artifact 122pp preceding the preceding workflow artifact 122p, to obtain the amended workflow <NUM>'.

In the upper third of <FIG>, a workflow <NUM> is illustrated which may comprise the first workflow artifact 122pp which may be followed by a loop <NUM> comprising to sequentially arranged workflow artifacts 122p and 122f. The loop <NUM> may be followed by a last workflow artifact 1221f, wherein the loop may have loop size <NUM>. An additional workflow artifact 122a may be inserted into the loop <NUM> which may cause an overlap of the inserted workflow artifact 122a with the previous workflow artifact 122p.

The flow direction <NUM> from the preceding workflow artifact 122p to the following workflow artifact 122f may be determined and updated workflow <NUM>' may be determined by moving the following workflow artifact 122f (which may correspond to the workflow artifact <NUM> to be moved) along the determined flow direction <NUM> to avoid the determined overlap <NUM>.

By way of example, the additional workflow artifact 122a may be put at the initial position of the preceding workflow artifact 122f or in the vicinity the initial position of the following workflow artifact 122f, e.g., towards the preceding workflow artifact 122p, to obtain the amended workflow <NUM>'.

This updated workflow <NUM>' is illustrated in the center third of <FIG>. The moved, following workflow artifact 122f, <NUM> which is comprised by the loop <NUM> now overlaps with the loop border <NUM>. This overlap <NUM> may be determined as well as the flow direction <NUM> pointing from the following workflow artifact 122f to the workflow artifact 122lf following the loop <NUM>. The updated workflow <NUM>'' may be obtained by expanding the loop size <NUM> along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed. Herein, expanding the loop size <NUM> may involve expanding the loop border <NUM> along the determined flow direction <NUM> accordingly. The expansion of the loop <NUM>, the loop size <NUM>, and the loop border <NUM> is illustrated in the lower third of <FIG> with the dashed arrow.

This updated workflow <NUM>'' is illustrated in the lower third of <FIG> as well as in the upper half of <FIG>.

The upper half of <FIG> illustrates the updated workflow <NUM>'' which may be obtained by the procedure illustrated in <FIG> and described above. Expanding the loop size <NUM> and the loop border <NUM> may lead to an overlap <NUM> of the expanded loop border <NUM> and the workflow artifact 1221f following the loop <NUM>. The flow direction <NUM> may be determined to point from the expanded loop <NUM> to the workflow artifact 122lf following the loop <NUM>. Then, the updated workflow <NUM>'' may be obtained by moving the workflow artifact 1221f (which may now be the workflow artifact <NUM> to be moved) following the loop <NUM> along the determined flow direction <NUM> at least until the determined overlap <NUM> is removed.

This updated workflow <NUM>‴ is illustrated in the lower half of <FIG>.

Referring now to <FIG>, a methodology M that facilitates managing apps, such as developing an app comprising importing a trained function, is illustrated. The method may start at M02 and the methodology may comprise several acts carried out through operation of at least one processor.

These acts may comprise an act M04 of providing an app development user interface (UI) to a user for developing the app; an act M06 of displaying at least two workflow artifacts of a workflow of the app to the user in the app development UI; an act M08 of capturing the user's intent to insert an additional workflow artifact into the workflow in response to user interactions with the app development UI; an act M10 of inserting the additional workflow artifact into the workflow according to the captured user's intent; an act M12 of determining an overlap of at least two of the workflow artifacts caused by the inserted workflow artifact; an act M14 of determining a flow direction of the workflow from the preceding workflow artifact to the following workflow artifact, the preceding and the following workflow artifact preceding and following the inserted workflow artifact, respectively; an act M16 of determining at least one workflow artifact of the workflow which needs to be moved along the determined flow direction to avoid the determined overlap; an act M18 of determining an updated workflow by moving the respective, determined workflow artifact in the direction of the determined flow direction at least until the determined overlap is removed; an act M20 of displaying at least the preceding workflow artifact, the inserted workflow artifact, and the following workflow artifact to the user in the app development UI; and an act M22 of developing the app through the app development UI by using the updated workflow. At M24 the methodology may end.

It should further be appreciated that the methodology M may comprise other acts and features discussed previously with respect to the computer-implemented method of managing an app, especially developing an app comprising updating a workflow of the app.

<FIG> illustrates a block diagram of a data processing system <NUM> (also referred to as a computer system) in which an embodiment can be implemented, for example, as a portion of a product system, and/or other system operatively configured by software or otherwise to perform the processes as described herein. The data processing system <NUM> may comprise, for example, the computer or IT system or data processing system <NUM> mentioned above. The data processing system depicted comprises at least one processor <NUM> (e.g., a CPU) that may be connected to one or more bridges/controllers/buses <NUM> (e.g., a north bridge, a south bridge). One of the buses <NUM>, for example, may comprise one or more I/O buses such as a PCI Express bus. Also connected to various buses in the depicted example may comprise a main memory <NUM> (RAM) and a graphics controller <NUM>. The graphics controller <NUM> may be connected to one or more display devices <NUM>. 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 comprise IA-<NUM>, x86-<NUM>, and ARM processor architectures.

Other peripherals connected to one or more buses may comprise communication controllers <NUM> (Ethernet controllers, WiFi controllers, cellular controllers) operative to connect to a local area network (LAN), Wide Area Network (WAN), a cellular network, and/or other wired or wireless networks <NUM> or communication equipment.

Further components connected to various busses may comprise one or more I/O controllers <NUM> such as USB controllers, Bluetooth controllers, and/or dedicated audio controllers (connected to speakers and/or microphones). It should also be appreciated that various peripherals may be connected to the I/O controller(s) (via various ports and connections) comprising input devices <NUM> (e.g., keyboard, mouse, pointer, touch screen, touch pad, drawing tablet, trackball, buttons, keypad, game controller, gamepad, camera, microphone, scanners, motion sensing devices that capture motion gestures), output devices <NUM> (e.g., printers, speakers) or any other type of device that is operative to provide inputs to or receive outputs from the data processing system. Also, it should be appreciated that many devices referred to as input devices or output devices may both provide inputs and receive outputs of communications with the data processing system. For example, the processor <NUM> may be integrated into a housing (such as a tablet) that comprises a touch screen that serves as both an input and display device. Further, it should be appreciated that some input devices (such as a laptop) may comprise a plurality of different types of input devices (e.g., touch screen, touch pad, keyboard). Also, it should be appreciated that other peripheral hardware <NUM> connected to the I/O controllers <NUM> may comprise any type of device, machine, or component that is configured to communicate with a data processing system.

Additional components connected to various busses may comprise one or more storage controllers <NUM> (e.g., SATA). A storage controller may be connected to a storage device <NUM> such as one or more storage drives and/or any associated removable media, which can be any suitable non-transitory machine usable or machine-readable storage medium. Examples comprise nonvolatile 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, electrical, or magnetic storage devices drives and/or computer media. Also, in some examples, a storage device such as an SSD may be connected directly to an I/O bus <NUM> such as a PCI Express bus.

A data processing system in accordance with an embodiment of the present disclosure may comprise an operating system <NUM>, software/firmware <NUM>, and data stores <NUM> (that may be stored on a storage device <NUM> and/or the memory <NUM>). Such an operating system may employ a command line interface (CLI) shell and/or a graphical user interface (GUI) shell. The GUI shell permits multiple display windows to be presented in the graphical user interface simultaneously, with each display window providing an interface to a different application or to a different instance of the same application. A cursor or pointer in the graphical user interface may be manipulated by a user through a pointing device such as a mouse or touch screen. The position of the cursor/pointer may be changed and/or an event, such as clicking a mouse button or touching a touch screen, may be generated to actuate a desired response. Examples of operating systems that may be used in a data processing system may comprise Microsoft Windows, Linux, UNIX, iOS, and Android operating systems. Also, examples of data stores comprise data files, data tables, relational database (e.g., Oracle, Microsoft SQL Server), database servers, or any other structure and/or device that is capable of storing data, which is retrievable by a processor.

The communication controllers <NUM> may be connected to the network <NUM> (not a part of data processing system <NUM>), which can be any public or private data processing system network or combination of networks, as known to those of skill in the art, comprising the Internet. Data processing system <NUM> can communicate over the network <NUM> with one or more other data processing systems such as a server <NUM> (also not part of the data processing system <NUM>). However, an alternative data processing system may correspond to a plurality of data processing systems implemented as part of a distributed system in which processors associated with several data processing systems may be in communication by way of one or more network connections and may collectively perform tasks described as being performed by a single data processing system. Thus, it is to be understood that when referring to a data processing system, such a system may be implemented across several data processing systems organized in a distributed system in communication with each other via a network.

Further, the term "controller" means any device, system or part thereof that controls at least one operation, whether such a device is implemented in hardware, firmware, software or some combination of at least two of the same.

In addition, it should be appreciated that data processing systems may be implemented as virtual machines in a virtual machine architecture or cloud environment. For example, the processor <NUM> and associated components may correspond to a virtual machine executing in a virtual machine environment of one or more servers. Examples of virtual machine architectures comprise VMware ESCi, Microsoft Hyper-V, Xen, and KVM.

Those of ordinary skill in the art will appreciate that the hardware depicted for the data processing system may vary for particular implementations. For example, the data processing system <NUM> in this example may correspond to a computer, workstation, server, PC, notebook computer, tablet, mobile phone, and/or any other type of apparatus/system that is operative to process data and carry out functionality and features described herein associated with the operation of a data processing system, computer, processor, and/or a controller discussed herein. The depicted example is provided for the purpose of explanation only and is not meant to imply architectural limitations with respect to the present disclosure.

Also, it should be noted that the processor described herein may be located in a server that is remote from the display and input devices described herein. In such an example, the described display device and input device may be comprised in a client device that communicates with the server (and/or a virtual machine executing on the server) through a wired or wireless network (which may comprise the Internet). In some embodiments, such a client device, for example, may execute a remote desktop application or may correspond to a portal device that carries out a remote desktop protocol with the server in order to send inputs from an input device to the server and receive visual information from the server to display through a display device. Examples of such remote desktop protocols comprise Teradici's PCoIP, Microsoft's RDP, and the RFB protocol. In such examples, the processor described herein may correspond to a virtual processor of a virtual machine executing in a physical processor of the server.

As used herein, the terms "component" and "system" are intended to encompass hardware, software, or a combination of hardware and software. Thus, for example, a system or component may be a process, a process executing on a processor, or a processor. Additionally, a component or system may be localized on a single device or distributed across several devices.

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

Those skilled in the art will recognize that, for simplicity and clarity, the full structure and operation of all data processing systems suitable for use with the present disclosure is not being depicted or described herein. Instead, only so much of a data processing system as is unique to the present disclosure or necessary for an understanding of the present disclosure is depicted and described. The remainder of the construction and operation of data processing system <NUM> may conform to any of the various current implementations and practices known in the art.

Also, it should be understood that the words or phrases used herein should be construed broadly, unless expressly limited in some examples. For example, the terms "comprise" and "comprise," as well as derivatives thereof, mean inclusion without limitation. The singular forms "a", "an" and "the" are intended to comprise the plural forms as well, unless the context clearly indicates otherwise. Further, the term "and/or" as used herein refers to and encompasses any and all possible combinations of one or more of the associated listed items. The term "or" is inclusive, meaning and/or, unless the context clearly indicates otherwise. The phrases "associated with" and "associated therewith," as well as derivatives thereof, may mean to comprise, be comprised within, interconnect with, contain, be contained within, connect to or with, couple to or with, be communicable with, cooperate with, interleave, juxtapose, be proximate to, be bound to or with, have, have a property of, or the like.

Also, although the terms "first", "second", "third" and so forth may be used herein to describe various elements, functions, or acts, these elements, functions, or acts should not be limited by these terms. Rather these numeral adjectives are used to distinguish different elements, functions or acts from each other. For example, a first element, function, or act could be termed a second element, function, or act, and, similarly, a second element, function, or act could be termed a first element, function, or act, without departing from the scope of the present disclosure.

In addition, phrases such as "processor is configured to" carry out one or more functions or processes, may mean the processor is operatively configured to or operably configured to carry out the functions or processes via software, firmware, and/or wired circuits. For example, a processor that is configured to carry out a function/process may correspond to a processor that is executing the software/firmware, which is programmed to cause the processor to carry out the function/process and/or may correspond to a processor that has the software/firmware in a memory or storage device that is available to be executed by the processor to carry out the function/process. It should also be noted that a processor that is "configured to" carry out one or more functions or processes, may also correspond to a processor circuit particularly fabricated or "wired" to carry out the functions or processes (e.g., an ASIC or FPGA design). Further the phrase "at least one" before an element (e.g., a processor) that is configured to carry out more than one function may correspond to one or more elements (e.g., processors) that each carry out the functions and may also correspond to two or more of the elements (e.g., processors) that respectively carry out different ones of the one or more different functions.

In addition, the term "adjacent to" may mean: that an element is relatively near to but not in contact with a further element; or that the element is in contact with the further portion, unless the context clearly indicates otherwise.

Although an exemplary embodiment of the present disclosure has been described in detail, those skilled in the art will understand that various changes, substitutions, variations, and improvements disclosed herein may be made.

Claim 1:
Computer-implemented method of creating an app (<NUM>), including:
• providing an app development user interface (UI) (<NUM>) to a user for developing the app (<NUM>);
• displaying at least two workflow artifacts (<NUM>) of a workflow (<NUM>) of the app (<NUM>) to the user in the app development UI (<NUM>);
• capturing the user's intent to insert an additional workflow artifact (122a) into the workflow (<NUM>) in response to user interactions with the app development UI (<NUM>);
• inserting the additional workflow artifact (122a) into the workflow (<NUM>) according to the captured user's intent;
• determining an overlap (<NUM>) of at least two of the workflow artifacts (<NUM>) caused by the inserted workflow artifact (122a);
• determining a flow direction (<NUM>) of the workflow (<NUM>) from the preceding workflow artifact (122p) to the following workflow artifact (122f), the preceding and the following workflow artifact (122p, 122f) preceding and following the inserted workflow artifact (122a), respectively;
• determining at least one workflow artifact (<NUM>) of the workflow (<NUM>) which needs to be moved along the determined flow direction (<NUM>) to avoid the determined overlap (<NUM>);
• determining an updated workflow (<NUM>') by moving the respective, determined workflow artifact (<NUM>) along the determined flow direction (<NUM>) at least until the determined overlap (<NUM>) is removed;
• displaying at least the preceding workflow artifact (122p), the inserted workflow artifact (122a), and the following workflow artifact (122f) to the user in the app development UI (<NUM>);
• developing the app (<NUM>) through the app development UI (<NUM>) by using the updated workflow (<NUM>');
• determining a moving borderline (<NUM>) in the workflow (<NUM>), wherein the moving borderline (<NUM>) intersects the preceding workflow artifact (122p) and is perpendicular to the determined flow direction (<NUM>); and
• determining the updated workflow (<NUM>') by only moving one or more workflow artifacts (<NUM>) which are arranged in the workflow (<NUM>) at the same side of the moving borderline (<NUM>) as the inserted artifact (122a) or the removed workflow artifact (122r).