Patent ID: 12206548

In the drawings, like reference numbers represent corresponding parts throughout.

DETAILED DESCRIPTION

FIG.1Ais a block diagram that illustrates an example of a system100that is capable of generating dynamically configurable applications. In the example, the system100includes a client device110A and a server120that exchange data communications over a network105. Although a single client device is depicted inFIG.1A, in some implementations, multiple client devices can be configured to run a single application based on exchanging communications with the application server120(as depicted inFIG.1B). The client device110A is associated with an end-user101that accesses an application running on the server120. The end-user101can be a user with limited technical experience and/or training such as a business-related professional.

In general, the system100enables the end-user101to create, configure and/or adjust applications running on the server120without requiring the user to manually select the appropriate protocol to construct the application. During an exemplary application creation process, the end-user101accesses an application designer112on the client device110A to provide configuration information for an application to be created. The user input received through the application designer112is transmitted to the server120over the network105. An application configuration module122on the server120generates an application configuration based on accessing a configuration repository124. The application configuration module122selects content to be included in the application from a content library126. The application configuration module122generates a configuration template for the application and transmits the configuration template to the server120. The server120configures the application based on the received application template, stores associated content, and configuration files in a corresponding application container115. Once the application has been created on the server120, the client device110A enables the end-user to access the application on the client device110A through the network105. The end-user101can also dynamically adjust the configuration while the application is still running as depicted inFIG.1Band described in detail below.

As described throughout, “accessing” an application refers to the display of an application on an electronic computing device that does not actually execute the application that is displayed. For example, the client device110A “accesses” an application when the client device110A provides a display of an instance of the application that runs on the server120. The end-user of the client device110A can interact with and/or manipulate user interface elements that are displayed while the client device110A accesses the application. In this regard, an “active instance” of the application refers to an application running on the server120during which the client device110A accesses the application, which results in the display of the application running on the server120. As described in detail below, the system100is capable of adjusting the configuration of the application during an active instance such that the application configuration is updated while the client device110A still accesses the application.

Referring now to the components of the system100, the client device110A can be any type of personal electronic computing device that is capable of accessing an application that runs on the server120. For example, the client device110A can be a smartphone, a tablet-computing device, a notebook-computing device, a wearable device, a desktop computing device, or any other type of network-enabled computing device.

The server120can be any type of application server configured to run, host, and/or support application services and other functionalities associated with applications that are accessed on the client device110A. For example, the server120can provide application services related to application configuration protocols, security and slate maintenance, database access. The server120can also be capable of using different services, frameworks and/or platforms that enables applications to be hosted in suitable application environments of different devices. For example, the server120can use an ASP.NET model-view-control (MVC) framework, a Web API framework, among others. As described throughout, this capability of the server120flexibility in designing applications with various functions, capabilities, and/or runtime options on the client device110A.

FIG.1Bis a block diagram that illustrates an example of a process for adjusting a configuration of an application while the application is running on a client device. The server120, in this example, exchanges communications with multiple client devices110that each run instances of the application. For instance, the client devices110can be associated with a group of end-users that use the application for a specified business process such as tracking task completions for a common project. In other instances, the application can be used for other purposes as described throughout. In the example depicted, an end-user associated with one of the client devices110adjusts a configuration of the application while the application is being accessed on one or more of the other client devices. The adjustment, in this example, is therefore processed by the system100while the application is still being accessed in a production environment.

As depicted inFIG.1B, the system100generally processes the adjustments to the application in several stages, which are represented in the figure as stages “(1),” “(2),” “(3),” “(4),” “(5),” “(6),” and “(7).” At stage (1), an end-user submits a user input through a configuration interface112aof the application designer112. The configuration interface112acan be used to, for example, adjust names of data fields that are displayed on the application, create a new data field and/or a data association, adjust the configuration of existing data fields, among others. In some instances, the configuration interface112acan provide similar options to an end-user as those depicted inFIGS.2B-2E, which depict interfaces for creating a new application.

At stage (2), the client device transmits an application configuration request102to the server120over the network105(not shown). The application configuration request102identifies adjustments that were provided by the end-user101on the configuration interface112a. For example, the application configuration request102identifies data fields that are to remain unchanged and data fields that are to be adjusted after the application has been adjusted according to the user input received on the configuration interface112a.

At stage (3), the application configuration module122generates a new configuration template104for the application based on information included within the received application configuration request102. For instance, if the application configuration request102indicates that a new data field is to be added to the application, the application configuration module122may identify content from the content library126that corresponds to the new data field. As an example, if a data field to be added references a specific collection of container objects, application templates, or other types of files, the application configuration module122may identify corresponding collection of content within the content library126. In another instance, if the application configuration request102indicates that an existing data field is to be adjusted such that it references additional content, the application configuration module122may similarly identify content from the content library126that corresponds to the new content to be referenced.

At step (4), the application configuration module122performs error and consistency checks on the configuration template104. In doing so, the application configuration module122verifies that adjusting the present configuration of the application using the configuration template104will not impair the existing operations of other components of the application and/or the operations of other applications or components that have dependencies with the components of the adjusted application (e.g., the adjustment is not logically incomplete to render components inoperative). The application configuration module122also determines whether any adjustments provided by the end-user are using components that were modified outside of an application ecosystem associated with the server120(e.g., modified versions of content that is included within the content library126). As described inFIG.4, if the application configuration module122determines that the user has provided an adjustment that involves an altered component, the end-user's account is disallowed from making any further changes to the application.

At step (5), the application configuration module122generates a backup106of the current configuration for the application that is to be adjusted. The back106is generated prior to adjusting the application using the configuration template104to enable the server120to revert back to the current configuration once the configuration template104has been implemented. The backup106can include all necessary application files (e.g., content, settings, executable files, etc.) that can be used to revert the configuration of the adjusted application.

The backup106can stored in a configuration repository124that stores multiple different configurations of the application at different time points after an initial configuration. For example, as depicted and discussed in detail with respect toFIG.3, the configuration repository124can include the most recent prior configuration of the application. Each iteration can correspond to different adjustments provided by end-users such that the application can be reverted to the most recent iteration from a current configuration (e.g., reverting from a second iteration to a first iteration once a second iteration has been implemented, or reverting from a third iteration to the second iteration once the third iteration has been implemented).

At stage (6), the server120adjusts the configuration of the application using the configuration template104. As described throughout, this adjustment is performed in a manner that preserves the existing structure and functionalities of the application prior to being updated and/or other already configured applications on the server120that have dependencies on the application after it has been updated. Additionally, the server120is capable of adjusting the application while one or more of the client devices110are accessing the application such that an update specified on the configuration interface112acan be implemented during use of the application without requiring an end-user to exit or otherwise restart a running instance of the application.

At stage (7), the server120transmits an instruction108that enables the client devices110to access the application in its adjusted configuration according to the configuration template104. The instruction108is provided in response to a request from a client device to access the application after it has been updated by the server120in stage (6). As an example, an end-user accesses the application on a client device in its initial configuration (e.g., prior the adjustment using the configuration template104). While the application is being accessed, the server120adjusts the configuration of the application as described above. After the configuration adjustment is complete, the next request from the client device to the server120will result in the server120transmitting the instruction108to enable the client device to access the application in its adjusted configuration according to the configuration template104.

At stage (8), the client devices110outputs a display of the application running in the configuration adjusted according to the configuration template104. The client devices110are capable of accessing the application in its updated configuration without requiring an end-user to terminate an active instance of the application that was initiated on a client device prior to the start of the application adjustment in step (6).

Examples of different types of adjustments can be implemented using the configuration adjustment procedure described above. For instance, if the application configuration request102includes instructions specifying the creation and addition of a new data field to the application, the server120can update a stored application container115associated with the application to include additional content and configuration files associated with the new data field, which are invoked by the server120and from an associated data repository. In another example, if the application configuration request102specifies the removal of an existing data field, then applicable content and/or configuration files within the application container115that are associated with the data field to be removed can be temporarily disabled. In addition, any dependencies for these disabled components can be adjusted to prevent execution errors for other configured applications or other components of the application to be updated.

As described above, the server120is capable of updating the configuration of the application in real-time (e.g., at the time point shortly after the configuration template104has been generated) and during an active instance of the application (e.g., while the application is being accessed on one or more of the client devices110). To accomplish this in a manner that does not substantially degrade an end-user's experience on the application, the server120temporarily runs a backup application while adjusting the configuration of the application using the configuration template104. Thus, if an end-user adjusts a display of the application on the client device while the server120is adjusting the configuration of the application, the client device accesses a temporary backup configuration of the application until the adjustment process has been completed, after which the server120instructs the client device to display the adjusted application. In this example, the transition from the application that runs in the first configuration to the application that runs in the second configuration appears to be substantially imperceptible to an end-user as displayed on the client device.

FIG.2Ais a block diagram that illustrates an example of a process for creating a dynamically configurable application on the application designer112. The end-user can use the application designer112on the client device110A to create a new application and adjust the configuration of an already-configured application (such as the example described above inFIG.2A). The descriptions that follow are provided in reference to application creation for simplicity. However, similar operations and/or procedures may be used by the system100when adjusting the configuration of an already-configured application according to user input submitted by an end-user.

In the example depicted in the figure, the application creation process includes an application definition phase202, a form configuration phase204, a collaboration configuration phase206, and an application generation phase208.FIG.2Aillustrates one example of an application creation process. In various other implementations, the system100may enable end-users to use different processes for creating different types of applications.

User interfaces that are presented to an end-user at each corresponding phase are depicted inFIGS.2B-E.FIG.2Billustrates an example of an interface200B that is presented to the end-user at the application definition phase202.FIGS.2C-Dillustrate examples of interfaces200C and200D that are presented to the end-user at the form configuration phase204.FIG.2Eillustrates an example of an interface200E that is presented to the end-user at the collaboration configuration phase206.

Referring initially toFIG.2B, an example of an interface200B for naming an application to be created is depicted. The end-user is presented the interface200B once he/she runs the application designer112and selects an option to create a new application. In some instances, if the end-user has already created other applications, he/she is directed to an interface that lists the previously configured applications. Once the end-user is directed to the interface200B, he/she can provide input to provide an application name for the application to be created and a brief description of the application. The end-user can specify a single entry name and a plural entry name, which identify the application all database repositories associated with the system.

Referring now toFIG.2C, an example of an interface200C for configuring forms of an application to be created is depicted. The interface200C allows the end-user to define, for example, different fields of a form that is presented to a user when using the application. In the example depicted, the end-user can customize fields of a form that is presented to any user when creating and/or updating record entries that are submitted through the application. As shown, examples of preconfigured fields include “Title,” “Status,” “Priority.” The user can customize the configuration of these fields by specifying a field type, and adjusting a configuration associated with each field. For example, for the “Priority” field, which includes a list of prioritizations, the end-user can adjust the field configuration to add a new prioritization, remove an existing prioritization, or modify an existing prioritization.

The end-user can also use the interface200C to create one or more entirely new customizable fields. For example, the customizable fields can include text fields (e.g., single-line entry), number fields (e.g., numeric entry of integer or decimal formats, etc.), paragraph fields (e.g., multi-line text entry), date and/or time fields, single or multiple selection list fields (e.g., of user-specified text option), among others. When specifying configurations each field, the end-user can specify, for example, field requirements (e.g., a required format for entry), instructional text to display below the field, an assistance tool to display next to the field label, and/or a placeholder text to display within the field. After specifying the fields to include in the form, and the configurations for each field, the end-user can preview the form as it would be displayed in a configured application.

Referring now toFIG.2D, an example of an interface200D for previewing a form of an application is depicted. As shown, the interface200D presents a preview of the form that an end-user has recently configured while specifying options through the interface200C. In the example depicted, the interface200D provides a preview of an exemplary form that is used by users of a collaboration to submit records that pertain to project tasks. In other examples, forms can be used for other types of business processes such business operations, processes, among others. In addition, the end-user can view the form as it would appear in a generated application such that he/she may revert to the interface200C to make any adjustments as needed.

Referring now toFIG.2E, the interface200E for specifying users that can view and access the application is depicted. The interface200E allows an end-user to specify users and/or groups of users that can view or edit forms that are provided through the application. For example, individuals can be selected from a corporate directory of employees, personal contacts of the end-user creating the application, or contacts that are associated with an internal or external account of the end-user (e.g., a social media account, an email account, etc.). Once the end-user has selected that can view or edit the application, he/she can complete the application creation process by providing an input on the “Create Application” button.

Referring back toFIG.2A, once the end-user has completed the front-end of the application creation process through the interfaces200B-E (e.g., on the client device110A), the application configuration module122generates a configuration template for the application to be created in the back-end (e.g., on the server120) at the application generation phase208. As discussed throughout, a “configuration template” can include data that is required to configure new application or adjust a configuration of an existing application. For example, the configuration template can include application content obtained from the content library126that is determined to be relevant to the configurations specified by the end-user, executable instructions for one or more client devices that will run the application, and/or any other necessary configuration files that are associated with the application. The application configuration module122packages the obtained content and files to generate the configuration template and transmits the configuration template to the server system120to view and modify the application to be created.

FIG.3is a block diagram that illustrates an example of a system300that is capable of reverting the configuration of an application to a prior configuration. In the example depicted, an application that runs on a client device302is modified twice to generate to three different versions of the application (e.g., versions310A,310B, and310C). In this example, each version represents a distinct configuration of the same application. In some implementations, the system300is a component of the system100that is depicted inFIG.1A. In such implementations, the application configuration module122can perform the reversions that are depicted inFIG.3.

Each version is configured using a corresponding configuration template that is applied by the client device302in response to receiving a modification request submitted by an end-user through the applications designer112. For example, version310A of the application is initially constructed and configured using a configuration template312A. In this example, the version310A represents a newly created application, although in other applications, the version310A can also represent a previously adjusted configuration that is generated prior to versions310A and310B. In addition, version310B of the application is constructed and configured using a configuration template312B that is generated based on a first received modification request, whereas version310C of the application is construction and configured using a second configuration template312C is generated based on a second received modification request.

As shown in the figure, the system300is capable of generating and storing the templates312A-C in a manner that supports reversion to the most recent version of the application. For example, the system300enables a reversion from version310B to310A when configuring the version310B, and a reversion from version310C to310B when configuring the version310C. This is accomplished by storing application configurations in self-contained application containers115(described and depicted with respect toFIG.1A). As described above, the contents of a stored application in the container115can be updated each time a current configuration of the application is updated based on user input provided by the end-user through the application designer112. Prior versions of the application containers115can be remotely stored on the server120for use in a subsequent reversion to a corresponding application version.

FIG.4is a block diagram that illustrates an example of a system400that is capable of performing error and inconsistency checks for when adjusting a configuration of an application. Although the descriptions below are focused on adjustment of an application for simplicity, in some implementations, the operations depicted inFIG.4and described below can be performed for during or after application generation for a newly created application. In addition, in some implementations, the system400is a component of the system100depicted inFIG.1A.

In the example depicted, an end-user101provides a request to adjust an application through the application designer112as described above with respect toFIG.1B. The application configuration module122generates a new application configuration (e.g., the new application configuration104as depicted inFIG.1B). During this process, an update processor122A initially identifies content within the content library126that is determined to be relevant to adjustments provided by the end-user101. For example, if the adjustment creates a new data field, then the update processor122A identifies content (e.g., data files, data associations, object definitions, etc.) that is determined to be associated with the new data field and transmits a data package that specifies the identified content to the audit module122B.

The audit module122B performs a set of evaluation tests to ensure that the content to be used to adjust the configuration of an application does not limit or break application and system functionalities. The results of the evaluation tests can be used to indicate whether adjustments provided by the user will cause an execution error (e.g., logically incomplete data field definitions, inaccurate references to data objects) or if the adjustments are provided using components that have been adjusted outside of an application ecosystem associated with the system. As shown in the figure, the audit module122B uses the results of the evaluation tests to either (1) prevent the end-user101from implementing an adjustment to the current configuration of the application if the results indicate that the adjustment would cause an execution error, or (2) disallow the end-user from making any further adjustments to the application if the results indicate that the user has used a modified version of an application component. Thus, the audit module122B can be used as a protection framework that reduces any system vulnerabilities that may result from allowing the end-user to adjust the configuration of an application.

In the example depicted in the figure, the audit module122B performs different actions based on the results obtained from performing the evaluation tests of new configuration, which are depicted in the figure as results “(A)” and “(B).” These exemplary results are provided for simplicity. In response to obtaining result (A), the audit module122B outputs a notification402to the end-user101on the application designer112indicating that the update was successfully implemented and that the changes are now visible in the application runtime environment. In this example, the audit module122B determines that the new configuration is both consistent with the existing functionalities of the application and any other application dependencies and performs consistently without potentially degrading a user's experience on the application.

In response to obtaining results (B), the audit module122B outputs a notification406indicating that the update was not been implemented and instructs the end-user to reconfigure his/her adjustment through the application designer112. In this example, the audit module122B determines that the new configuration is consistent not consistent with existing functionalities of the application and any other application dependencies, and as a consequence, can potentially render essential application or system functions inoperable. In such circumstances, the audit module122B disallows the end-user101from adjusting the application in a manner that would disrupt core application capabilities.

As described above, the system400provides a protection framework that prevents the end-user101from adjusting the configuration of an application to break existing system or application functionalities. This is accomplished using the audit module122B to perform evaluation tests to determine an anticipated impact of a user-specified adjustment on the application to be adjusted and other applications that have dependencies on the application. In another example, if the user-specified adjustment changes an object definition, the audit module122B may identify all instances of the object definition within an application framework and verify that these instances will not be impacted based on the change in the object definition.

FIG.5is a flowchart that illustrates an example of a process500for adjusting a configuration of an application while the application is running. The operations of the process500can be performed by one or more components of the system100A illustrated inFIG.1A. For example, in some implementations, the operations are performed by the application configuration module122of the server120.

Briefly, the process500can include the operations of configuring an application that runs on a server system in a first configuration specified by a first configuration template (510), receiving data indicating that the application is being accessed on a computing device and a request to adjust the first configuration (520), generating a second configuration template while the application is being accessed on the computing device in the first configuration (530), adjusting the application to run in the second configuration using the second configuration template (540), and providing an instruction that enables the client device to access the application running in the second configuration (550).

In more detail, the process500can include the operation of configuring an application that runs on a server system in a first configuration specified by a first configuration template (510). For example, the application configuration module122configures an application that runs on the server120using a first configuration template. The first configuration template can be generated, for example, when the end-user initially creates the application through the application designer112as depicted inFIGS.2A-2E.

The process500can include the operation of receiving data indicating that the application is being accessed on a computing device and a request to adjust the first configuration (520). For example, the application configuration module122obtains the application configuration request102indicating that the end-user101has submitted a request to adjust the application through the configuration interface112a. The application configuration module122additionally obtains data indicating that the application is actively being accessed on one or more of the client devices110.

The process500can include the operation of generating a second configuration template while the application is being accessed on the computing device in the first configuration (530). For example, the application configuration module122generates a new configuration template104while the application is currently accessed on one or more of the client devices110. As described above, the application configuration module122performs a set of evaluation tests. Results of the evaluation tests are used to determine whether the specifications provided by the configuration template104are compatible with existing functionalities of the application to be adjusted and other applications that have dependencies on the application to be adjusted (e.g., whether the configuration template104specifies logically incomplete data definitions).

The process500can include the operation of adjusting the application to run in the second configuration using the second configuration template (540). For example, the application configuration module122adjusts the application using the configuration template104such that, after the adjustment is complete, the application runs in a second configuration specified by the configuration template104. If the application is being accessed by one or more of the client devices110while the server120performs the adjustment, the client devices are configured such that they access a temporary version of the application that runs while the adjustment takes place. The client devices are configured such that the disruptions to the user's experience during an active instance is minimized (e.g., limited latency in switching between application components while accessing the temporary application). As described above, the adjustment can be performed such that the end-user is not required to restart the application being accessed on the client device.

The process500includes the operation of providing an instruction that enables the client device to access the application running in the second configuration (550). For example, after adjusting the application to run in the second configuration, the server120provides the instruction108that enables the client devices110to access the application running in the second configuration.

Various implementations of the systems and methods described here can be realized in digital electronic circuitry, integrated circuitry, specially designed ASICs (application specific integrated circuits), computer hardware, firmware, software, and/or combinations of such implementations. These various implementations can include implementation in one or more computer programs that are executable and/or interpretable on a programmable system including at least one programmable processor, which can be special or general purpose, coupled to receive data and instructions from, and to transmit data and instructions to, a storage system, at least one input device, and at least one output device.

These computer programs (also known as programs, software, software applications or code) include machine instructions for a programmable processor, and can be implemented in a high-level procedural and/or object-oriented programming language, and/or in assembly/machine language. As used herein, the terms “machine-readable medium” “computer-readable medium” refers to any computer program product, apparatus and/or device, e.g., magnetic discs, optical disks, memory, Programmable Logic Devices (PLDs), used to provide machine instructions and/or data to a programmable processor, including a machine-readable medium that receives machine instructions as a machine-readable signal. The term “machine-readable signal” refers to any signal used to provide machine instructions and/or data to a programmable processor.

To provide for interaction with a user, the systems and techniques described here can be implemented on a computer having a display device, e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor for displaying information to the user and a keyboard and a pointing device, e.g., a mouse or a trackball by which the user can provide input to the computer. Other kinds of devices can be used to provide for interaction with a user as well; for example, feedback provided to the user can be any form of sensory feedback, e.g., visual feedback, auditory feedback, or tactile feedback; and input from the user can be received in any form, including acoustic, speech, or tactile input.

The systems and techniques described here can be implemented in a computing system that includes a back end component, e.g., as a data server, or that includes a middleware component, e.g., an application server, or that includes a front end component, e.g., a client computer having a graphical user interface or a Web browser through which a user can interact with an implementation of the systems and techniques described here, or any combination of such back end, middleware, or front end components. The components of the system can be interconnected by any form or medium of digital data communication, e.g., a communication network. Examples of communication networks include a local area network (“LAN”), a wide area network (“WAN”), and the Internet.

The computing system can include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other.

A number of embodiments have been described. Nevertheless, it will be understood that various modifications can be made without departing from the spirit and scope of the invention. In addition, the logic flows depicted in the figures do not require the particular order shown, or sequential order, to achieve desirable results. In addition, other steps can be provided, or steps can be eliminated, from the described flows, and other components can be added to, or removed from, the described systems.

Accordingly, other embodiments are within the scope of the following claims.