High-Performance Computing Architecture for Art Competitions

Abstract

Various embodiments are disclosed for a high-performance computing architecture for use in an artistic creation competition system. In one embodiment, the system includes a generator module and a planner module. The generator module receives data used in generating element representations and generates the element representations based at least in part on a specific state change action. The generator module is configured to generate a single element representation after merging multiple state change actions into the specific state change action. The planner module assigns identifiers to the element representations to order the element representations relative to at least one previous element representation, orders the element representations in a queuing system comprising one or more queues based at least in part on the identifiers, assigns priority values ​​to the element representations, and generates a plan for an interface unit based at least in part on the element representations.

Description

[Technical Field]

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS This application claims priority to U.S. patent application Ser. No. 18 / 056,311 ("HIGH PERFORMANCE COMPUTING ARCHITECTURES FOR WORK OF ART COMPETITIONS"), filed November 17, 2022, which is incorporated by reference in its entirety. [Background technology]

[0002] Artists can create works in many different forms, including musical compositions, visual and graphical art, theatrical presentations, and even culinary creations, through many different media. The act of experiencing artistic works can be enhanced, for example, by allowing audiences, including both diverse artists and other users, to review the works through online social networking environments. Many traditional media for communicating information about works of art do not provide sufficient means for users to express opinions regarding the relative value of different works of art. Similarly, artists lack adequate outlets or communication media for showcasing their talents and comparing their artwork with others within similar fields of artistic endeavor. In addressing problems with current methods and systems for experiencing and evaluating works of art, more effective computer-implemented tools, strategies, and techniques are needed to help artists and other users share and compare works of art, ultimately improving enjoyment of different works of art. [Brief explanation of the drawings]

[0003] Many aspects of the present disclosure can be better understood with reference to the following drawings. The components in the drawings are not necessarily to scale, emphasis instead being placed upon clearly illustrating the principles of the present disclosure. Moreover, in the drawings, like reference numerals indicate corresponding parts throughout the several views.

[0004] [Figure 1] FIG. 1 is a schematic block diagram of a networked environment in accordance with various embodiments of the present disclosure.

[0005] [Figure 2] FIG. 2 is a flowchart illustrating an example of functionality implemented as part of a generator module executing in a computing environment in the networked environment of FIG. 1 according to various embodiments of the present disclosure.

[0006] [Figure 3] FIG. 3 is a flowchart illustrating an example of functionality implemented as part of a planner module executing in a computing environment in the networked environment of FIG. 1 according to various embodiments of the present disclosure.

[0007] [Figure 4] FIG. 4 is a schematic block diagram providing one exemplary view of a computing environment employed in the networked environment of FIG. 1, according to various embodiments of the present disclosure. Summary of the Invention

[0008] One or more computer systems may be configured to perform particular operations or actions by virtue of having installed software, firmware, hardware, or a combination thereof that, when in operation, causes the system to perform the operations or take the actions. One or more computer programs may be configured to perform particular operations or actions by virtue of including instructions that, when executed by a data processing device, cause the device to perform the actions.

[0009] One general aspect includes a system. The system also includes at least one computing device. The system also includes a generator module executable on the at least one computing device. When executed, the generator module causes the at least one computing device to at least perform the following steps: receive data used in generating element representations; evaluate instructions to generate the element representations; and generate the element representations based at least in part on a particular state change operation. The generator module is configured to generate a single element representation after merging multiple state change operations into the particular state change operation.

[0010] The system also includes a planner module executable on at least one computing device. When executed, the planner module causes the at least one computing device to at least perform the following steps: receive element representations from the generator module; assign identifiers to the element representations to order the element representations relative to at least one previous element representation; order the element representations in a queuing system comprising one or more queues based at least in part on the identifiers; assign priority values ​​to the element representations; and generate a plan for the interface unit based at least in part on the element representations. Other aspect embodiments include corresponding computer systems, apparatus, and computer programs stored on one or more computer storage devices, each configured to perform the operations of the method.

[0011] An implementation may include one or more of the following features: The system includes one or more modules configurable to use a high-performance computing architecture for a work of art competition. The planner module is further configured to at least receive an event, dynamically delete a currently generated plan in response to the event, and generate a different plan for the interface unit in response to the event. The planner module is further configured to split (splinter) a particular operation into multiple operations for parallel and / or concurrent execution. The planner module is further configured to generate a plan based at least in part on a work completion deadline or in response to one or more state changes when interfaced with a state module. In other scenarios, the planner module can generate plans associated with tasks or operations present in a queuing system, which can take into account priority values ​​associated with the tasks or operations. When executed, the state module causes at least one computing device to manage one or more states; perform at least one create, read, update, or delete operation on the one or more states; and expose one or more interfaces for the generator module and the planner module to interact with the one or more states. The state module is further configured to at least maintain a persistent network connection to the artwork competition system. The state module is further configured to at least prevent data duplication, out-of-order data, and out-of-date data. The element representation may further include an element representation module executable on the at least one computing device. When executed, the element representation module causes the at least one computing device to at least generate one or more interface unit elements based at least in part on the set of instructions and the one or more data structures.When executed, the representation module causes at least one computing device to at least perform the steps of receiving a plan for the interface unit from the planner module and generating the interface unit based at least in part on the plan for the interface unit. Implementations of the described techniques may include hardware, a method or process, or computer software on a computer-accessible medium. DETAILED DESCRIPTION OF THE INVENTION

[0012] The present disclosure relates to a high-performance computing architecture for use in artistic competition systems and / or other systems. Artistic competition systems present numerous problems that can be improved with an appropriate computing architecture. For example, rankings (position numbers), artist names, and their score points must be continuously updated as each artist participates in the competition, gains and loses points, and moves up and down in the rankings. A music generic ranking can include many artists continuously running in a competition system. Various embodiments of the present disclosure introduce a generator module capable of processing extremely large amounts of granularly updated ranking versions in just milliseconds, some of which may still match previous data. The process described herein operates only on new data that conflicts with previous ranking data and utilizes already processed data that conflicts between the current ranking version and the newer ranking version.

[0013] As those skilled in the art will appreciate in light of this disclosure, particular embodiments may be capable of achieving certain advantages, including some or all of the following: (1) building one or more complex applications while enabling high performance, (2) providing efficient instruction processing for data modification, (3) providing optimized execution during modification, (4) providing more flexible processing modes, (5) providing more flexible execution stages, (6) providing splintering and independent task processing, (7) more efficiently organizing hardware resource allocation, (8) providing distinctive execution, and (9) enhancing processing through system collectivity.

[0014] As described, the present disclosure can be used to build one or more complex applications while enabling high performance. Software complexity is constantly increasing. Indeed, applications are constantly including more features, utilizing more resources, and being required to process more instructions and data. This complexity problem impacts the field of computer systems that perform artistic competitions. Optimization techniques require configuration to function and be effective. A software application may have multiple running operations and / or sets of operations, each of which can be uniquely addressed and / or managed to be best optimized. Operations, regardless of how different they are, should be able to interact and work in conjunction with one another.

[0015] A design goal for the artwork competition system may be that it be autonomous in its individual inner parts, independently configurable as a whole and in its parts, capable of performing different actions, and / or configured with different properties, and compositable with one or more parts working together. The architecture comprised of the representations, generators, and planners described herein achieves the goal of building complex applications that enable high performance. The planner module can be considered an architecture (or sub-architecture) responsible for integrating the architecture of the generator modules and can be configurable and / or compose related architectures and operations. The generator modules can represent specific sets of operations and / or have jurisdiction over defined portions of interface units or element representations and can be configurable and compose related element representation architectures. The element representation architectures can contain data and instructions for interfacing unit elements and can be configurable. The participating architectures together enable complex applications to be autonomous (in whole or in part), configurable (in whole and / or in part), and composable, regardless of the technical nature, configuration requirements, optimization techniques, or operations of their parts.

[0016] The present disclosure can also provide efficient instruction processing for data modifications. In particular, the system can be instructed to use hardware resources when generating new element representations while reusing representations that have already been generated.

[0017] The present disclosure may also provide optimized execution for changes. In some scenarios, an interface unit (or the entire system) may be composed of multiple parts, with multiple generator modules (and their associated element representation architectures). An interaction, event, or update (such as a network response) may trigger not just one but multiple changes, for example, in the system, in the data store, in the interface unit, or in any other part of the system. For example, an artist may click a challenge button, and therefore the button's appearance must change because no more challenge requests can be sent and statistics regarding the amount of challenges sent must be updated. In the above example, processing two changes in two separate "generations" from the user's perspective may not be necessary, and is not required from the system's perspective. As described below, a system and / or architecture can be configured to process one or multiple changes in a single process. In various embodiments, multiple generators are not required, and one generator may be able to trigger one or more changes.

[0018] The present disclosure may also provide more flexible processing modes. A wide variety of operations may occur in a computer system conducting an artistic competition, and further configurations may be applied to improve performance, allowing the system to assess which order of operations to perform. For example, a voter may request information about a battle to listen to and vote for through the competition system. While the voter's system is waiting for a response, the voter's system may be able to execute other instructions, such as updating a notification number in an interface unit, or process other data. As described, the competition system may be configured to orchestrate the processing of sequential, simultaneous, and / or parallel operations.

[0019] The present disclosure may also provide more flexible execution stages. For example, in some scenarios, certain operations are characterized by high processing costs, such as an interface unit element continuously displaying updated battle results. As a result, the operation may severely impact system behavior and cause problems, such as outages or delays, in other parts of the system, such as processing user-specific updates, which may be less recurrent or require less power than broader system battle updates. The architecture should enable the system to manage and execute any type of operation in conjunction with one another. To build a high-performance computer system for performing artistic competitions, the system may be built in stages that can represent various execution tasks.

[0020] The present disclosure may also provide for partitioning and independent task processing. Particularly in the resource-intensive field of computer systems that perform artistic competitions, a recurring goal to be achieved is the ability to fully control system behavior relative to ongoing operations, future operations, and acknowledgeable factors such as inputs. An architecture that provides such a configuration achieves at least two objectives: exercising absolute direction across the entire machine results in improved performance.

[0021] The present disclosure may also organize hardware resource allocation more efficiently. For example, there may be system-defined and / or user-defined (such as static or dynamic settings, including those derived by user actions) activities or operations that may require more resources and / or have more privileges than others. Artist users may review challenges they have received or sent and focus more on this type of update. An interface unit may display many types of ongoing activities. The functionality of computer systems that conduct competitions involving artistic works may be improved to provide the ability to specifically allocate resources.

[0022] The present disclosure may also provide a distinctive execution (stage). Designing a competition system architecture that includes stages is a crucial improvement. There are scenarios in which the system may be required to address the scenario with additional reinforcement procedures. A user may be viewing information related to a particular competition or genre, but the system may have scheduled actions in the execution stage. The user may decide to view information for another competition. Thus, there may be two user-triggered actions: the system being prompted to request information, and the interface unit displaying the information. The competition system may need to be able to insert two actions into its execution stage and evaluate whether to execute those instructions and in what mode to operate the instructions.

[0023] The present disclosure may also enhance processing through system collectivity. When computer systems running an artwork competition perform operations in a coordinated manner, the system may require additional configuration to further improve performance. Multiple entities (of any type), such as element representations, may be received by another system, for example. The receiver system may have to be constructed to receive and display the representations, utilize the representations for update and comparison operations, and fully integrate them as they are processed by the receiver system. As described, the system may be organized in a complementary manner to perform its tasks faster and to be able to receive and integrate entities.

[0024] In the following discussion, a general description of the system and its components is provided, followed by a discussion of its operation.

[0025] 1, a networked environment 100 according to various embodiments is shown. The networked environment 100 includes a computing environment 103 and one or more client devices 106 that are in data communication with each other via a network 109. The network 109 may include, for example, the Internet, an intranet, an extranet, a wide area network (WAN), a local area network (LAN), a wired network, a wireless network, a cable network, a satellite network, or any other suitable network, or any combination of two or more such networks.

[0026] Computing environment 103 may comprise, for example, a server computer or any other system that provides computing power. Alternatively, computing environment 103 may employ multiple computing devices that may be arranged, for example, in one or more server or computer banks or other configurations. Such computing devices may be located in a single installation or may be distributed across many different geographic locations. For example, computing environment 103 may include multiple computing devices that may together comprise hosted computing resources, grid computing resources, and / or any other distributed computing configuration. In some cases, computing environment 103 may correspond to elastic computing resources, in which the allocated capacity of processing, network, storage, or other computing-related resources may change over time.

[0027] Various applications and / or other functionality may be executed in computing environment 103 according to various embodiments. Also, various data may be stored in data store 112 accessible to computing environment 103. Data store 112 may represent multiple data stores 112, as can be appreciated. Data stored in data store 112 may be associated with the operation of various applications and / or functional entities, for example, as described below.

[0028] Components executing on the computing environment 103 may include, for example, an artistic production competition system 115, one or more state modules 118, one or more generator modules 121, one or more element representation modules 124, one or more planner modules 127, one or more representation modules 130, a queue system 133 including one or more queues, or other applications, services, processes, systems, engines, or functions not described in detail herein. The artistic production competition system 115 executes to stage an artistic production competition. As applied herein, "artistic production" may include a wide variety of artistic works by various types of artists, including, for example, but not limited to, musical compositions (and mixed versions thereof), visual and graphical art, theatrical presentations, and culinary creations, among others.

[0029] The artistic competition system 115 may employ, for example, web application software programmed to conduct online competitions, as well as dedicated news and voting systems, among other features. The online competition environment may comprise online tournaments in which artists compete against each other through a competition module with the goal of winning and earning victory points to advance through a championship designation framework. The artistic competition system 115 may be programmed, for example, to upload and compare songs by artists, and in some embodiments may be limited to only original works created by the artists.

[0030] Competitions may be conducted by artists selecting audio / video tracks for artworks that are played, displayed, or otherwise accessed through the artwork competition system 115. Winners of these competitions may be determined, for example, by an online audience of users who compare and vote on artworks to determine the winner. Other features provided by the artwork competition system 115 may include voting, information, and news systems designed to handle communications related to artworks and related topics. Various embodiments may be configured to be accessed through a combination of tablet and mobile device implementations, including, for example, web-based social networking services, application software, and various systems of interconnected computer and device networks. In other implementations, the high-performance architecture described herein, when implemented in the artwork competition system 115, may be implemented in any combination with any one of the profile module, battle module, news module, journal module, store module, analytics module, automation module, advertising module, sales module, communication module, championship module, scoring module, ranking module, correspondence module, voting module, artist module, voting module, and / or other modules.

[0031] Various embodiments of the artistic competition system 115 are further described in U.S. Patent 9,669,299 (“Conducting Artistic Competitions in a Social Network System,” issued June 6, 2017), which is incorporated herein by reference in its entirety.

[0032] The state module 118 executes to manage state information for the operation of the artwork competition system 115. For example, the state module 118 may be able to create, read, update, delete, or perform other operations on the state that it manages. The state module 118 may also expose one or more interfaces that allow other modules and / or architectures to interact with its state.

[0033] The generator module 121 interacts with the state module 118 and can create, read, update, delete, or perform other operations on associated modules and / or can perform operations outside of its own module. The generator module 121 can be locally stateful and can create, read, update, delete, or perform other operations on its local state. The generator module 121 can receive inputs and / or entities used in generating element representations. The generator module 121 can evaluate element generation instructions, including, for example, statements, data, or entities. The generator module 121 can also perform element representation generation with respect to state changes of the associated state module 118, the local state of the generator module 121, and / or the received inputs or entities. The generator module 121 can also store information about state interfaces in use and merge state interface operations to trigger one execution of element representation generation rather than one per state change operation. The generator module 121 can also generate interface unit element representations. The generated element representations described above can also be considered modules, as will be explained below.

[0034] Element representation module 124 may correspond to a set of instructions for generating one or more interface unit elements. Element representation module 124 may correspond to a data structure for generating one or more interface unit elements. Element representation module 124 may correspond to data, values, information, and entities for generating one or more interface unit elements. Element representation module 124 may correspond to data structures, data, values, information, or entities that make up or are associated with one or more interface unit elements.

[0035] The planner module 127 may receive the element representation modules 124 from the generator module 121. The planner module 127 may store information about the state interfaces in use and merge state interface actions to trigger one execution rather than one execution per state-changing action. The planner module 127 may elaborate an interface unit plan, including listing or describing the interface unit elements to be represented and the process used to execute the creation of the interface unit. The planner module 127 may store the interface unit plan. Upon receiving further element representation modules 124, the planner module 127 may compare the representation modules 130 associated with the current plan with successively received representation modules 130 to determine changes to the plan and the process for executing the changes. The planner module 127 may output the current interface unit plan.

[0036] The representation module 130 can receive and evaluate plans for interface units from the planner module 127. The representation module 130 can also construct the interface units.

[0037] The data stored in data store 112 includes, for example, one or more interface unit plans 136, state information 139, one or more coordination plans 142, one or more interface unit elements 145, one or more element representations 148, one or more dynamic refinement plans 151, and potentially other data.

[0038] Client device 106 represents a plurality of client devices 106 that may be coupled to network 109. Client device 106 may comprise, for example, a processor-based system such as a computer system. Such a computer system may be embodied in the form of a desktop computer, laptop computer, personal digital assistant, mobile phone, smartphone, set-top box, music player, web pad, tablet computer system, game console, e-book reader, smart watch, head-mounted display, audio interface device, or other device. Client device 106 may include a display comprising one or more devices such as, for example, a liquid crystal display (LCD) display, a gas plasma-based flat panel display, an organic light-emitting diode (OLED) display, an electrophoretic ink (E-ink) display, an LCD projector, or other type of display device.

[0039] Client device 106 may be configured to execute various applications, such as client application 154 and / or other applications. Client application 154 may be executed on client device 106, for example, to access network content served by computing environment 103 and / or other servers, thereby generating interface units, such as user interfaces, on a display. To this end, client application 154 may comprise, for example, a browser, a dedicated application, etc., and interface units may comprise network pages, application screens, etc. Client device 106 may be configured to execute applications beyond client application 154, such as, for example, email applications, social networking applications, word processors, spreadsheets, and / or other applications.

[0040] Next, an overview of the operation of the various components of the networked environment 100 is provided. First, the generator module 121 can be configured such that for each execution of element generation, the generator module 121 outputs one or more element representations 148. An element representation 148 is an entity that represents one or more of a set of instructions, data structures, data, values, information for generating an interface unit (i.e., the interface unit plan 136), one or more interface unit elements 145, and / or data structures, data, values, information that make up the interface unit and / or one or more interface unit elements 145. Furthermore, the element representation 148 can also be configured as a module, the element representation module 124. The output element representation 148 can also represent, for example, mutable and / or immutable data structures.

[0041] Modules such as generator module 121, element representation module 124, planner module 127, representation module 130, and state module 118 may be configured as entities that represent one or more of instructions, data structures, data, values, information, and sets of inputs.

[0042] The generator module 121 may include a set of instructions that detects changes in input, state, data structure, value, or any other relevant data and / or information that affect one or more element representations 148. If the relevant data remains the same, the generator module 121 outputs the already stored element representation 148 from the data store 112, while in the opposite case, where the relevant data does not remain the same, it generates a new element representation 148. For example, the stored element representation 148 may reside in a persistent memory structure of the generator module 121, the element representation 148 may be shared between modules, or may reside in another part of the computing environment 103. The inputs processed by the generator module 121 and / or other modules are not limited. For example, the inputs may be any entity, state, instructions to be executed, data structure, data, information, values, generated element representations 148, and / or other generator modules 121.

[0043] The artwork competition system 115 may be required to update the interface unit elements 145 and interrelationship architecture as associated data and / or entities change. The element representation 148 generation procedure and the generated element representations 145 involve additional memory, processor time, and power to perform the updates. In various embodiments, the generator module 121 avoids additional execution of generating and creating element representations 148, thereby reducing memory consumption, accelerating processor operation, and utilizing less processing power to achieve an updated competition system by storing inputs, states, and entities associated with the element representations 148. The generator module 121 may perform comparison operations on the element representations 148 to connect the stored associated entities to associated entities used in generating and / or creating the next element representation 148 of the element representation 148.

[0044] Greater benefits are realized with an increased volume of updates. The process of conducting artistic competitions can handle larger amounts of information and operations by employing the generator module 121. For example, a ranking module containing rankings, artist names, and their score points may be continuously updated as each artist competes, gains and loses points, and moves up and down in the rankings. A music genre ranking may include numerous artists running continuously in the artistic competition system 115. The generator module 121 can process a very large number of granularly updated ranking versions in just milliseconds. Some of the ranking data may still match previous data. The process can operate only on new data that conflicts with previous ranking data and then utilize already processed data that conflicts between the current ranking version and the newer ranking version.

[0045] The planner module 127 can be configured to compare the current interface unit plan 136, which includes one or more element representations 148. The element representations can have child and sibling element representations 148, or can be primary, superior, subordinate, equal ordinate, and / or first or last element representations 148, and can be compared to new element representations 148 received by the generator module 121. The planner module 127 can be further configured to directly reference the element representations 148 that the planner module 127 receives from the generator module 121, or the planner module 127 can construct the element representations 148 from the data of the received element representations 148.

[0046] The interface unit's plan 136 can be interpreted and structured according to any model or to include one or more models, such as a graph, list, set, multiset, tree, queue, priority queue, map, multimap, container, array, collection, and / or stack. Every element representation 148 may have specific values, such as a type, a unique identifier, properties, attributes, and / or a higher, lower, or equal ladder element representation 148. When comparing a new element representation 148 and a current element representation 148 or a collection or list of element representations 148, the planner module 127 may be configured to not compare the two element representations 148 and replace the entire element representation 148, collection, list, or collection portion with the new one if the new element representation 148 and the current element representation 148 are of different types. Conversely, the planner module 127 may be configured to only update the data and additional information describing its characteristics.

[0047] The planner module 127 may be further configured to use only the received element representation 148 as a means to build and update the data structure of its element representation 148 and to perform building, comparing, updating, and / or other processes. Alternatively, the planner module 127 may directly reference and / or integrate and / or combine the received data structure with its data structure. The planner module 127 may be further configured to construct one or more data structures for tracking the current and newer element representations 148 to perform its tasks. The structures may, in some cases, share data between themselves and may have any degree of integration and association with any other data structures. The planner module 127 may associate the data structure of the element representation 148 with any other data structures to perform its instructions. For example, the planner module 127 may establish references between the data structure of the current element representation 148 and the data structure of the newer element representation 148 and / or between the data structures of the element representations 148.

[0048] The planner module 127 can use identifiers, such as unique identifiers, to, for example, place the element representations 148 in the correct order and compare current versions of the element representations 148 with newer versions. The planner module 127 can output the plan 136 of the interface unit as a unique, optimized set of operations to the representation module 130, thereby minimizing the use of system resources for building or updating the visualized interface unit and resulting in an accelerated operation. For example, the state operations (e.g., create, read, update, delete) and / or state interfaces and / or inputs, data, entity lists, or any type of reference or structure involved in generating the element representation 148 can be maintained by the generator module 121 and / or planner module 127 such that related state changes are executed together, resulting in the generation of the unique, optimized element representation 148, instead of executing one execution for each operation / entity change, which would result in multiple executions using more resources by the associated architecture, such as the generator module 121 and / or planner module 127.

[0049] Thus, the problem of medium, lengthy or long workloads and / or their representation in the interface unit is significantly improved. As demonstrated, the architecture provides increased performance through reduced time, processing power, memory and bandwidth.

[0050] The planner module 127 may also utilize stack models and / or queue models and / or recursive or iterative procedures to process the element representations 148 and / or their data structures when refining and / or updating the interface unit's plan 136, and / or evolve the processing in independent tasks to dynamically organize the execution order. An independent task may be formulated as one or more element representations 148 and / or a data structure associated with any value of one or more element representations 148, or any other data structure.

[0051] The particular values, involved inputs, and / or state of an element representation 148 may be stored by planner module 127 along with the element representation 148 for efficient comparison with received new versions. For example, refinement may start with the primary (or first or last in its respective order) element representation 148 and then refine the subelement representations 148, including all equally-ranked element representations 148, until all nested element representations 148 have been refined. The equally-ranked element representations 148 may be processed in a particular direction.

[0052] The planner module 127 may be configured to collect all inputs and states associated with each element representation 148, and the element representations 148 themselves, and construct a list. Such a list may be iterated, for example, between new and current element representations 148 during element generation to refine a plan and / or compare element representations 148.

[0053] The planner module 127 can be configured to organize separate processing queues for element representations 148 present in the list or for representations not present in the list. The planner module 127 can be further instructed to determine whether the element representation 148 has associated state and / or inputs. Such presence or absence can determine whether the planner module 127 can employ concurrent or parallel processing for the processing of the element representation 148, or whether the planner module 127 undertakes sequential processing. The planner module 127 can arrange all element representations 148 that can be processed sequentially in a first queue within the queue system 133 and element representations 148 that can be processed simultaneously or in parallel in a second queue within the queue system 133. The planner module 127 can be configured to process the inputs and / or states involved in the element representations 148 all at once during the final stage of plan refinement.

[0054] Operations such as create, read, update, and delete operations on inputs and state associated with element representation 148 may be performed by generator module 121, planner module 127, or other modules. For example, generator module 121 may output the results of such operations, or alternatively, the operations may be performed by planner module 127 when refining a plan for element representation 148. For example, in scenarios where generated element representations 148 always result in the same element representations 148 if the inputs, data, entities, and state values ​​used to generate them are always the same, planner module 127 may compare new inputs and / or state used to generate element representation 148 with the current inputs and / or state without the involvement of other procedures such as one-to-one value comparisons or immutable comparison models.

[0055] The planner module 127 and / or architecture that executes such instructions can enable operations to be performed faster because it can identify and distinguish between tasks that may or may not involve specific procedural steps, such as sequential processing or parallel and / or concurrent processing. The ability to distinguish, for example, between operations that must be performed in a specific order and those that do not, results in reduced operation times because the system is instructed precisely as to which tasks can be accelerated and performed simultaneously and which tasks must wait.

[0056] The architecture may include hashing instructions, for example, when generating and / or comparing data structures. Hashing may also determine whether an element representation 148 has changed since its first generation, which specific values ​​have changed, or whether the processor is dealing with an entirely new element representation 148. This is true regardless of the data scheme used by the artwork competition system 115, for example, a mutable or immutable data design. Immutable data structures may be used to manage the refinement of plans between current element representations 148 and newer element representations 148.

[0057] The invariant element representation data design can determine changes by comparing memory locations of element representations 148 and instruct the processor to recursively or iteratively process the entire element representation 148 model. The planner module 127 can be instructed to start the refinement from a main or first representation structure to the last nested representation structure and to use a particular direction when a set or list of representation structures is encountered.

[0058] The generator module 121 may be configured, for example, to assign priority values ​​to inputs and / or states involved in representation generation and / or to integrate the element representations 148 into a priority ranking system, allowing the planner module to give more or less priority to some element representations 148 within or across complete representation generation. Such priority values ​​and priority ranking systems may be organized, for example, by the planner module 127 or by other modules. The priority system may be organized by implementing a tree data structure formed by an item data structure consisting of a value and up to two subordinate items. The priority of an item may define that the value of the superior item may be less than or equal to the subordinate item, or greater than or equal to the subordinate item.

[0059] The generator module 121 can be configured as an entity that can store and persist values, data structures, data, information, inputs, and states. The generator module 121 can also interface with other modules and / or architectures that are instructed to store and / or persist. The generator module 121 or other architectures can detect when values, data structures, inputs, and states change. Changes can be detected, for example, by running or re-running the generator module or modules, executing interfaces, executing create / read / update / delete interfaces, executing event architectures, queue architectures, executing instructions during read, create, update, and delete operations.

[0060] The generator module 121 and / or the planner module 127 may be configured to execute instructions before, during, and after any stage of their execution, such as, for example, before starting generation of element representations 148 or before outputting the results of their operations to the planner module 127, and / or during the processing of the planner module 127 or before the planner module 127 outputs a plan. Additionally, the generator module 121 and / or the planner module 127 may execute instructions after the representation module 130 constructs the interface unit. Particular instructions may be assigned to the generation and / or successive generations of the first element representation 148. Instructions may also be executed in response to the generator module 121 or other modules being removed, for example, before, during, and after. The generator module 121 may further be configured to persist the element representations 148 and / or their data in the state module 118 or other architecture.

[0061] Additionally, state, data, information, input, and instructions can be associated with stage-specific runners to evaluate those changes and determine whether and / or when the runner and / or its instructions must execute. A configuration can be configured to execute only if the associated entity is changed, deleted, or replaced by another entity. A configuration can include sets of instructions that execute before, during, and after any procedure. For example, operations, create / read / update / delete interface operations, and / or operations on state can be executed as one consolidated operation instead of multiple runner executions. For example, it further benefits instructions associated with entities operated on by modules, architectures, runners, and related entity set groups to have undergone all processing specified by the instructions. When there is no requirement or benefit to do so, there is no one execution per entity; otherwise, instructions can still be configured to execute one execution per change. A configuration can be executed at a specific stage, and instructions can be configured to be executed, deferred, or executed regardless of the specific instruction configuration.

[0062] For example, the applied architecture prevents the interface unit from being blocked by executing selected instructions after the representation module 130 builds and / or updates the visualized interface unit when it is beneficial to do so. In other examples, the applied architecture executes selected instructions before the precise stage, such as building and / or updating the visualized interface unit, preventing the user from visualizing unnecessary or in-progress interface unit updates, which further results in fewer interface unit versions being visualized and fewer system resources being consumed when it is beneficial to do so, resulting in further performance improvements. Furthermore, the applied architecture can also improve interaction consistency by preventing the user from interacting with temporary or in-progress versions of the visualized interface unit.

[0063] The planner module 127 may be further configured to identify generated element representations 148 and assign them higher or lower priorities, for example, using its own stack model. The stack model may be further complemented with a queue model. The planner module 127 may process generated element representations 148 in parallel or simultaneously, instead of using a sequential approach. The planner module 127 may also start, pause, resume, or delete the refinement of one or many generated element representations 148 simultaneously. The planner module 127 may further be configured to incorporate iterative statements and / or procedures, for example, to process or transform data, or to verify the performance of an operation, to handle concurrent or parallel operations, to process instructions according to a priority system, and / or to pass values ​​during execution. The iterative procedures may organize iterations and executions in a sequence, each representing the start or end of each task and / or the entire representation generation process. For example, during a stage representing the end of a task, the planner module 127 may process a list including element representations 148 associated with inputs and / or states. Examples of the former configurations may include the execution of recursive statements and / or recursive procedures.

[0064] An event-driven architecture can be further integrated into the operation of the artwork competition system 115. For example, an event can be responsible for a change in input and / or state and / or element representation 148, thus triggering the execution of the state module 118, the generator module 121, the planner module 127, the representation module 130, other modules, and / or any other instructions associated with the event. The event architecture can also be implemented by the planner module 127, which can orchestrate task execution in conjunction with other models, such as stack and queue models.

[0065] The independent task data structure formulation can include time-related data such as time estimates, limits, measurements, and records, and / or priority values ​​(e.g., bits, numbers, Booleans, strings, sets, or any other data type) for executing one or more tasks. Instruction ordering can occur independently when utilizing any possible model, and sets of instructions can be executed at different times, for example, by postponing a set of instructions until a condition is met, or by applying preemption procedures and / or prepending tasks.

[0066] The event architecture may be implemented, for example, by exposing an interface for sending and receiving data to one or more recipients. Further configuration may include serialization of data structures. The event data structure may be a clone of the data received from the event system and / or may be defined with appropriate types. Furthermore, a data structure may be sent in association with another data structure, optionally removing any previous association or accessibility.

[0067] Planner module 127 may be configured to divide an operation into multiple sets of entities, data, values, data structures, information, and instructions that can be executed and / or processed by the planner module or other modules. For example, planner module 127 may divide an operation to manage unexpectedly long operations and allow interface units to be manipulated. Furthermore, a splinter may allow any degree of simultaneous or parallel execution of different types of operations by any number of execution threads. For example, an interactivity event may convey data or information that indicates the plan in refinement is becoming less relevant. Therefore, planner module 127 may be configured to delete the plan and refine a new plan.

[0068] The planner module 127 can then stop the ongoing refinement and immediately begin refining and outputting a new plan without first completing the plan. For example, a voter may be listening to a competition between two artists and their artworks via the artwork competition system 115. The user then clicks to navigate to the user's own profile. In this case, the planner module 127 outputs interface units for the competition and associated media streaming, such as a music track. The described architecture allows the planner module 127 to dynamically delete the current plan and immediately begin refining and outputting a new plan (i.e., the listener's own profile), determining improved performance and a superior interface experience. The architecture can be configured to process events with specific instructions to be performed for specific events associated with specific element representations 148, or to act on received data, information, execute default instructions without additional instructions within the generator module 121, or in a combination of the two procedures.

[0069] The planner module 127 can be configured to refine a plan according to a priority system and output it to the representation module 130. The planner module 127 can take into account one or many factors related to the priority system. For example, the planner module 127 can stage a data structure for representation generation and evaluation according to a priority value (e.g., bit, number, Boolean, string, set, or any other data type). Other factors can be, for example, task completion time constraints and / or estimates. The planner module may output only a portion of the generation initially and the rest sequentially. The stage structure can integrate the new representation generation with the remaining representations held within the structure.

[0070] As an example, upon receiving data due to an interactivity event, the architecture can implement instructions to stop ongoing refinement without first completing the plan, improving efficiency. Time, memory, processing power, and bandwidth can be saved in this example because the unrefined remainder of the ongoing plan, rendered obsolete by the event, is not processed. Furthermore, the planner module 127 can now output the plan to the representation module 130 while still refining the plan, for example, by using a stack model and independent task data structure formulation. The user can receive interface units more quickly without having to wait for the entire representation set to be fully processed. The planner module 127 can also allocate more time, memory, processing power, and bandwidth to specific portions of the architecture and / or element representations 148 using a priority system. This improves the user experience because system resources are primarily directed to portions of the interface that the user is more interested in, focused on, and / or interacting with. This may also improve performance, as the architecture may be allowed to suspend any processing activity for lower ranked parts in the priority system in certain cases.

[0071] The architecture (or generator module 121, planner module 127, or other modules and / or instructions) may be configured to postpone execution of an entire instruction set, execute an entire instruction set, and / or partially execute and postpone instructions. For example, the architecture may immediately execute a particular statement and / or instruction and / or postpone other instructions in the same instruction set.

[0072] For example, the architecture can be configured to organize queues from the queue system 133 for instructions, inputs, states, data, information, events, user interaction events that execute (and / or cause) a change in an interface unit, assign them a specific (or lower / equal / higher) priority rank, and / or insert them into a specific (or lower / equal / higher) priority queue and / or other queues with different priority ranks. For example, entities, instructions, events, user interaction events, inputs, states, data, or information that do not cause the execution and / or change of an interaction unit and / or that do not need to be executed immediately and integrated with the event and / or interactivity architecture may be inserted into a queue.

[0073] Queues may also be organized for specific types of events, interaction events, etc., and / or for instructions or entities that change how the architecture executes and / or processes. Queues can be configured and integrated into an event architecture that causes changes in how the architecture effectively processes instructions and / or data to execute in order, unordered, in parallel, and / or simultaneously.

[0074] The queue system 133 may be configured as queues that are executed sequentially and / or queues that do not have to be executed sequentially. Instructions, inputs, states, data, information, events, and user interaction events that execute (and / or cause) changes to interaction units may be executed sequentially, but if they do not modify the interaction units and / or are not associated with the interactivity and event architecture, they may be executed unordered, simultaneously, and / or in parallel. For example, given a set of instructions, the configuration may execute instructions that do not modify the representations of the interface units and postpone execution of instructions that modify the interface units until after any other steps, such as generating element representations 148 or refining a plan. Alternatively, the configuration may execute both types of instructions or postpone both types of instructions.

[0075] The architecture may be instructed to process instructions coming from the user interactivity architecture immediately (e.g., in order) and postpone other operations, such as operations of the state module 118 and / or operations that modify the interface units. Additionally, the architecture may be configured to process events in order, requiring previous events to be processed before processing new events and their instructions, implementing queues, stacks, event processing structures, and / or any other architecture.

[0076] When executing an instruction or set of instructions, the architecture may enqueue into a particular precedence queue any direct and indirect modifiers of the interface unit, specific queue instructions or data that do not modify the interface unit, and / or instructions or data related to the interface unit's interactivity and event architecture. For example, modifiers related to the interface unit's interactivity and event architecture may be processed in the same queue along with concurrent and / or parallel architectures. Furthermore, the architectures may be implemented singly, in combination, and / or in any combination. Furthermore, any sequential, concurrent, and / or parallel architecture may be configured to enable any degree of concurrent, parallel, or sequential processing.

[0077] For example, the computing environment 103 may be configured to use time records and limits as priority values ​​to manage operations and / or entities. Time ranges may additionally be configured to cluster operations and / or entities associated with the time records and limits. Furthermore, priority values ​​may be represented by numbers, bits, Booleans, strings, or any other type. Sets, e.g., sets of bits (e.g., numbers or Booleans), may be implemented to represent one or more priority values ​​and their queues 133. Bitwise operations and shifts may be performed to read and manipulate priority values ​​represented by bits and / or sets of bits comprising one or more bit priority values ​​to evaluate the priority and / or ranking of any operation, command, or entity or to rely on different levels of operation. For example, numbers and Booleans and their respective processes may be used to perform operations (or any create, read, update, delete, combine, and / or merge operations on one or more priority values).

[0078] The computing environment 103 can evaluate the presence of work to be performed by, for example, evaluating whether time values ​​and / or bit priority values, including a set of priority values, are set. The architecture can be configured to share priority values ​​and sets of priority values ​​with higher, lower, or equal ordinate entities. Furthermore, the architecture can be instructed to modify priority values ​​and queues of entities and operations. The architecture can use the presence or absence of priority values ​​and / or sets of priority values ​​to determine changes or updates within the computing environment 103. These evaluations can further be utilized to optimize operations, as modules associated with changes or updates can be re-executed while modules without changes or updates are not executed. The architecture can be instructed to work simultaneously and / or in parallel on tasks belonging to different queues 133 using sets of values ​​representing priority queues. As an example, a queue value set can allow a lower priority task to execute while a higher priority task waits for data from a network request without performing any operations. For example, entities associated with element representations 148 can be assigned priority values. The priority values ​​of element representations 148 may include representatives of sets representing the values ​​of the associated entities and / or representatives (and / or inclusive) of associated (and / or subordinate) element representation priority values.

[0079] As another example, queuing system 133 may be configured to include a top priority queue, a queue for events that are to be executed multiple times, a standard queue, a minor priority queue, and a "waiting" queue. As discussed above, more queues may be added, such as numbered queues. Priority values, in any implementation, may represent any entity, such as, for example, an instruction, a module, a data structure, data, a value, information, an input, a number, a bit, a Boolean, a string, and a set.

[0080] The computing environment 103 can be configured to record execution times and resource usage for modules and / or architectures to monitor performance and enable optimal configuration to better manage general and / or specific operations. The monitoring interface can be combined with the state module 118, the generator module 121, the planner module 127, the representation module 130, other modules, architectures, independent task data structures, generative execution, entities, or any operation.

[0081] The architecture and / or modules may be configured to defer collection of instructions and / or modules until a condition is met or required to execute the operation, and / or to selectively execute operations when determining which instructions to execute. Additionally, the architecture and / or modules may implement instructions to start, pause, resume, or remove their interface capabilities with other modules, architectures, or their inputs, outputs, and modifications, such as, for example, instructions, modules, data structures, data, values, states, and sets of element representations 148. Instructions may be executed to identify and collect one or more data to generate an identification structure that enables the architecture and / or modules to perform create, read, update, delete, and / or compare operations. The architecture and modules may be organized as one or more superior, subordinate, or equal ordinate entities.

[0082] All architectures and their instructions can be executed on a networked computer system. A networked architecture can provide improved performance and a superior user experience. For example, a computing environment 103 executing the generator module 121 and / or the planner module 127 can provide a representation plan to a representation module 130 running on another computer system. The networked computer system can also execute the same architecture and process output received from the architecture executed on the networked system to execute the same architecture on a receiver computer system. For example, a computing environment 103 executing the generator module 121 and / or the planner module 127 provides a representation plan to a representation module 130 running on another computer system. The representation module 130 can be configured to construct interface units upon being provided with one or more data-independent entities, in this case, interface unit element representations 148 (and / or associated data). The representation module 130 may be in the process of receiving the entire representation plan at the same time. The generator module 121, planner module 127, and / or other modules running on the provider system may process each independent entity differently; for example, voter profile interfaces, multi-element interface units, and other interface units may take more time to process. An interface representing voter statistics may take more time to process than an element representing only the voter name. Additional data may be involved and / or further processing may be performed to provide the desired output.

[0083] The receiver module can be configured to employ a concurrency and / or parallelism model to process data entities independently as they are received, so that the interface units are constructed faster without postponing the execution of representations until the entire representation plan is complete and construction of element representations 148 can begin in any order.

[0084] The planner module 127 may be configured to define element representations 148 as ordered and / or unordered independent data entities and to combine definitions within the same representation plan. Further configurations may implement a default order for processing unordered independent data entities, such as the position they hold and / or will hold in the overall element representation plan. The default order may be replaced by a priority architecture and / or an event architecture or any other architecture.

[0085] The planner module 127 can further be configured to utilize substitute element representations 148 (and / or their associated data) that replace the original, independent data entities. Specific values ​​can be added to the element representations 148 to define, for example, whether the element representation 148 is the original element representation 148 or a substitute, an identifier, or whether the data is an unordered, independent entity and / or includes an independent entity.

[0086] Definitions may exist within the structure of element representations 148 that are used by modules to execute the instructions they contain. Definitions may take any form, such as additional information, such as strings and / or notations, and are implemented as meaningful values ​​for modules to determine how and / or where to operate within the structure of element representations 148 or any other data structure. A definition may specify the structure of one or more element representations 148 and / or portions thereof, such as the beginning and / or end of one or more unordered, independent data entities and / or their replacement structures. A definition may also instruct other architectures running on other computer systems, for example, to process specified portions of the structure of element representations 148 or any other data structure itself.

[0087] The structures of element representation 148 may include executable instructions for use by other modules on other computer systems. For example, the instructions may include instructions for substituting a replacement structure for an original structure.

[0088] For example, specific values ​​such as identifiers can be incorporated for alternative operations. When an architecture receives a refined element representation plan from another networked architecture, the architecture can further refine the plan to fully integrate the received plan with the architecture or module. Performance is improved because the representation structure of the element representation plan is already built. Thus, the architecture can directly perform the integration procedure, leading to less resource consumption and faster operation. For example, the received plan that is built and presented can be associated with an event architecture and an interactivity architecture and / or any other architecture.

[0089] For example, the constructed interface unit plan 136 is processing an original data structure while a user interacts with another permutation structure. The architecture can be instructed to pause the current processing and give priority to processing the original data structure associated with the permutation with which the user interacted. Additional definitions can be used, for example, to determine higher, lower, or equal ordinates, or any other relationship to which higher, lower, or equal priority should be assigned.

[0090] The networked architectures can cooperate to establish which architectures perform which operations. For example, element representation generation can be performed by one or more networked architectures. The networked architectures can output a dynamic refinement plan 151, which includes element representations 148 generated according to their configuration and incorporates instructions for receiving networked architectures to perform other element representation generation on their computer systems. Further configuration can include serialization and deserialization of the dynamic refinement plan 151, as well as substitution procedures for non-serializable structures or models.

[0091] Establishing the coordination plan 142 can include implementing identifiers, architecture identifiers, extensions, and / or any supplemental data or metadata. The instructions to execute can incorporate the entire set of instructions, as representing any kind of entity, statement, or data structure, and / or can incorporate only an identifier and / or address (both in any form) from which the receiver architecture retrieves the instructions to execute. The replacement model can be processed independently. The receiver model can be implemented to search the networked architecture in the process of refining the entities associated with the instructions to execute.

[0092] The coordination plan 142 may include configurations that instruct the network architecture to perform actions that would be expected to be performed by another network architecture for any reason, such as an error. The dynamic planning configurations may also include any of the above, such as alternative or independent processing and receiving models, and may be employed, for example, by the provider, recipient, and any network architecture. The network architecture may have unlimited entities representing inputs and outputs and / or instructions to execute. The inputs, outputs, and entities may be configured with any structure or value and / or transition model. The architecture may start at any transition stage and continue processing and integration until completion.

[0093] The state module 118 may be configured to execute instructions for organizing, storing, and managing state data, values, and data structures. The architecture may incorporate, for example, one state module 118 for one or more states. The state module 118 may incorporate interfaces for retrieving data or instructions and executing instruction statements to further manipulate the data or instructions. Additionally, the state module 118 may perform create / read / update / delete operations on those states and enforce data models, such as immutable or mutable data design models. Each state operation may be assigned a specific type and / or value and associated with instructions to be executed upon the occurrence of one or more specific types to output one or more versions of the state required by the implemented model. States and their versions may be merged and / or result in one or more states. Instructions may include previous states for performing those operations or integrating them into outputs. State operations may be incorporated within iterative or recursive procedures and / or event and / or queue models. The state architecture can expose interfaces to other modules, architectures, network architectures, or computer systems to manipulate their state, operations, and / or collaborate on operations on state. The state architecture can allow other parts of the overall architecture to perform create / read / update / delete operations and trace changes. State modules can send information related to state, data, or state changes. State modules can be configured to expose state data, structures, and search interfaces where modules have independent access to state. State modules 118 and their data and interfaces can also be received as inputs by other modules and / or can be configured as higher-level modules from which data is collected.

[0094] The state module 118 can execute enhanced instructions to optimize its state and prevent data duplication, out-of-order data, or out-of-date data. For example, it can search for relevant data and add it only if it is not found. An overwrite operation succeeds only if the presumed new data is not outdated, and a delete operation deletes only if the data is found. A read operation can allow data to be directly replaced. A create, update, or any other operation can be configured to create a holding structure and / or superstructure for the data to be created and / or updated. An operation can change to another type of operation, such as from an update operation to a create operation, if, for example, relevant data is not found.

[0095] The state module 118 may incorporate structures for recording data operations performed and instructions for deleting unnecessary records. Delete operations may be tracked and associated with each create operation to ensure a specific order of execution. A read operation may track all create / read / update / delete operations performed on its data and establish whether the collected information is duplicated, outdated, or should be deleted by comparing it with stored data and / or previously received data. Furthermore, a read operation may employ an iterative or recursive procedure to determine the relevance of each entity that makes up the data, or to compare the data with already stored data or architectural or received instructions.

[0096] The state module 118 and / or other architecture and / or associated modules may be further configured to further improve performance for integrating dynamic network interfaces for creating / reading / updating / deleting actions. The network state module 118 may establish persistent connections to computer systems that run the artistic creation competition and / or perform operations that enable the artistic creation competition to be run. A persistent data collection architecture allows the state module 118 to optimize those operations. The network state module 118 may receive data as it becomes available from the computer systems without performing further or successive retrieval operations. The network state module 118 may receive the action type and the data to be processed and execute state-related instructions. Additionally, the state module 118 may also receive instructions to perform retrieval operations, such as statistics including the number of comments made by voters.

[0097] The state module 118 receives instructions from the artwork competition system 115, for example, to retrieve the number of comments made from the persistent data collection architecture and / or the network interface. Based on the persistent data collection architecture instructions and / or collection instructions via the network interface, the state module 118 can accurately perform the exact retrieval operation of the data that the state module 118 is instructed to process at that time.

[0098] Network state modules 118 configured to receive instructions to receive and retrieve create / read / update / delete operational commands and associated data can dynamically and independently execute models that result in performance improvements. For example, a particular state module 118 can receive specific instructions or operational commands that implement a different operational model, or a state module 118 can receive new specific instructions that apply to differently processed state data until execution of the new instructions.

[0099] The terms "visualized" or "illustrated" do not limit the description to a particular interface unit, but are intended as a reference to any interface unit that can be perceived in any manner and can be the object of a cognitive function. The above entities, data structures, and other definitions are listed for illustrative purposes only and are not meant to be limiting. Indeed, any other constructs, such as functions, classes, objects, and bit masks, may also be included. Any architecture may be implemented for any module that can be utilized to conduct a competition involving an artistic work.

[0100] 2, a flowchart is shown providing an example of some operations of generator module 121 according to various embodiments. It should be understood that the flowchart of FIG. 2 provides only one example of many different types of functional configurations that may be employed to perform some operations of generator module 121 as described herein. Alternatively, the flowchart of FIG. 2 can be viewed as illustrating example elements of a method implemented in computing environment 103 (FIG. 1) according to one or more embodiments.

[0101] Starting in box 203, generator module 121 receives data to be used in generating element representation 148. In box 206, generator module 121 evaluates one or more instructions to generate element representation 148. In box 209, generator module 121 generates element representation 148 based at least in part on a specific state change action. Generator module 121 is configured to generate a single element representation 148 after merging multiple state change actions into the specific state change action. In other scenarios, generator module 121 can generate element representation 148 even when no state changes occur. For example, at the start of a session after logging in, generator module 121 may generate element representation 148 without a state change and without merging multiple state change actions. Alternatively, generator module 121 may generate element representation 148 without a state associated with element representation 148. In box 212, generator module 121 merges multiple state change actions into the specific state change action. The operation of the generator module 121 then terminates.

[0102] Referring now to Figure 3, a flowchart is shown providing an example of some operations of planner module 127 according to various embodiments. It should be understood that the flowchart of Figure 3 provides only an example of many different types of functional configurations that may be employed to implement some operations of planner module 127 described herein. Alternatively, the flowchart of Figure 3 can be viewed as illustrating example elements of a method implemented in computing environment 103 (Figure 1) according to one or more embodiments.

[0103] Starting in box 303, the planner module 127 receives element representations from the generator module 121. In box 306, the planner module 127 assigns identifiers, such as unique identifiers, to the element representations 148. For example, the planner module 127 may assign identifiers to the element representations 148 to order the element representations 148 with previous element representations 148. In another example, the planner module 127 may use another identifier to insert the element representations 148 into the queue system 133. In box 309, the planner module 127 orders the element representations 148 based at least in part on the identifiers assigned to the element representations 148. In box 312, the planner module 127 assigns priority values ​​to the element representations 148. In box 315, the planner module 127 generates a plan for the interface unit based at least in part on the element representations 148. In box 318, planner module 127 receives events via the system, such as user interaction events, expiration events, notification events that generate changes to interface units, and / or any other type of event. For example, assume a user participates in an art competition and the competition expires. The system may be configured to close the current interface unit, create a new interface unit, and return the user to their previous location. In box 321, planner module 127 dynamically deletes the current plan in response to the event. In box 324, planner module 127 generates a different plan for the interface unit in response to the event. The partial operation of planner module 127 then terminates.

[0104] 4, a schematic block diagram of a computing environment 103 according to an embodiment of the present disclosure is shown. The computing environment 103 includes one or more computing devices 400. Each computing device 400 includes at least one processor circuit having, for example, a processor 403 and memory 406, both of which are coupled to a local interface 409. To this end, each computing device 400 may comprise, for example, at least one server computer or similar device. The local interface 409 may comprise, for example, a data bus with an associated address / control bus or other bus structure, as can be appreciated.

[0105] The memory 406 stores both data and several components executable by the processor 403. In particular, stored in the memory 406 and executable by the processor 403 are the artwork competition system 115, one or more state modules 118, one or more generator modules 121, one or more element representation modules 124, one or more planner modules 127, one or more representation modules 130, a queuing system including one or more queues 133, and potentially other applications. The memory 406 may also store the data store 112 and other data. Additionally, an operating system may be stored in the memory 406 and executable by the processor 403.

[0106] As can be appreciated, there may be other applications stored in memory 406 and executable by processor 403. If any component discussed herein is implemented in the form of software, any one of several programming languages ​​may be employed, such as, for example, C, C++, C#, Objective C, Java, JavaScript, Perl, PHP, Visual Basic, Python, Ruby, Flash, or other programming languages.

[0107] Some software components are stored in memory 406 and are executable by processor 403. In this regard, the term "executable" refers to a program file in a format that is ultimately executable by processor 403. An example of an executable program may be, for example, a compiled program that may be loaded into a random access portion of memory 406 and translated into machine code in a format that can be executed by processor 403; source code that may be expressed in a suitable format, such as object code that may be loaded into a random access portion of memory 406 and executed by processor 403; or source code that may be interpreted by another executable program to generate instructions in a random access portion of memory 406 to be executed, such as by processor 403. The executable program may be stored in any portion or component of memory 406, including, for example, random access memory (RAM), read-only memory (ROM), a hard drive, a solid-state drive, a USB flash drive, a memory card, an optical disk such as a compact disc (CD) or digital versatile disc (DVD), a floppy disk, a magnetic tape, or other memory component.

[0108] Memory 406 is defined herein to include both volatile and nonvolatile memory and data storage components. A volatile component is one that does not retain a data value upon loss of power. A nonvolatile component is one that retains data upon loss of power. Thus, memory 406 may comprise, for example, random access memory (RAM), read-only memory (ROM), a hard disk drive, a solid-state drive, a USB flash drive, a memory card accessed via a memory card reader, a floppy disk accessed via an associated floppy disk drive, an optical disk accessed via an optical disk drive, a magnetic tape accessed via an appropriate tape drive, and / or other memory components, or a combination of any two or more of these memory components. Additionally, RAM may comprise, for example, static random access memory (SRAM), dynamic random access memory (DRAM), or magnetic random access memory (MRAM) and other such devices. ROM may comprise, for example, programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), or other similar memory devices.

[0109] Also, processor 403 may represent multiple processors 403 and / or multiple processor cores, and memory 406 may represent multiple memories 406 each operating in parallel processing circuits. In such cases, local interface 409 may be a suitable network facilitating communication between any two of the multiple processors 403, communication between any processor 403 and any two of the memories 406, or communication between any two of the memories 406, etc. Local interface 409 may include additional systems designed to coordinate this communication, including, for example, performing load balancing. Processor 403 may be electrical or of any other available configuration.

[0110] The artwork competition system 115, state module 118, generator module 121, element representation module 124, planner module 127, representation module 130, queue system 133, and various other systems described herein may be embodied in software or code executed by general-purpose hardware as discussed above, but alternatively, they may also be embodied in dedicated hardware, or a combination of software / general-purpose hardware and dedicated hardware. If embodied in dedicated hardware, each may be implemented as a circuit or state machine employing any one or combination of several technologies. These technologies may include, but are not limited to, discrete logic circuits having logic gates for implementing various logical functions upon the application of one or more data signals, application-specific integrated circuits (ASICs) having appropriate logic gates, field-programmable gate arrays (FPGAs), or other components. Such technologies are generally known to those skilled in the art and therefore will not be described in detail herein.

[0111] 2 and 3 illustrate the functionality and operation of some implementations of the generator module 121 and the planner module 127. If embodied in software, each block may represent a module, segment, or portion of code comprising program instructions for implementing a specified logical function. The program instructions may be embodied in the form of source code, which includes human-readable statements written in a programming language, or machine code, which includes numerical instructions recognizable by a suitable execution system, such as the processor 403 in a computer system or other system. The machine code may be translated from the source code or the like. If embodied in hardware, each block may represent a circuit or several interconnected circuits for implementing the specified logical function.

[0112] Although the flowcharts in Figures 2 and 3 show a particular order of execution, it is understood that the order of execution may differ from the order shown. For example, the order of execution of two or more blocks may be scrambled relative to the order shown. Also, two or more blocks shown in succession in Figures 2 and 3 may execute concurrently or with partial concurrence. Furthermore, in some embodiments, one or more of the blocks shown in Figures 2 and 3 may be skipped or omitted. Additionally, any number of counters, state variables, alert semaphores, or messages may be added to the logic flows described herein for purposes such as providing enhanced usability, accounting, performance measurement, or troubleshooting assistance. It is understood that all such variations are within the scope of the present disclosure.

[0113] Additionally, any logic or application, including software or code, described herein, including artwork competition system 115, state module 118, generator module 121, element representation module 124, planner module 127, representation module 130, and queue system 133, can be embodied in any non-transitory computer-readable medium for use by or in association with an instruction execution system, such as, for example, processor 403 in a computer system or other system. In this sense, logic may comprise statements, including, for example, instructions and declarations, that may be fetched from a computer-readable medium and executed by an instruction execution system. In the context of the present disclosure, a "computer-readable medium" may be any medium that can contain, store, or maintain the logic or application described herein for use by or in association with an instruction execution system.

[0114] The computer-readable medium may comprise any one of many physical media, such as, for example, magnetic media, optical media, or semiconductor media. More specific examples of suitable computer-readable media include, but are not limited to, magnetic tape, magnetic floppy diskettes, magnetic hard drives, memory cards, solid-state drives, USB flash drives, or optical disks. The computer-readable medium may also be, for example, random access memory (RAM), including static random access memory (SRAM) and dynamic random access memory (DRAM), or magnetic random access memory (MRAM). Furthermore, the computer-readable medium may be read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), or other types of memory devices.

[0115] Additionally, any logic or application described herein, including the operations of artwork competition system 115, state module 118, generator module 121, element representation module 124, planner module 127, representation module 130, and queue system 133, may be implemented and structured in a variety of ways. For example, one or more applications described may be implemented as modules or components of a single application. Furthermore, one or more applications described herein may execute on a shared computing device, separate computing devices, or a combination thereof. For example, multiple applications described herein may execute on the same computing device 400 or on multiple computing devices 400 within the same computing environment 103.

[0116] Disjunctive language, such as the phrase "at least one of X, Y, or Z," is understood differently with the context in which it is generally used to indicate that an item, term, etc., can be either X, Y, or Z, or any combination thereof (e.g., X, Y, and / or Z), unless specifically stated otherwise. Thus, such disjunctive language is generally not intended and should not imply that an embodiment requires that at least one of X, at least one of Y, or at least one of Z be present.

[0117] It should be emphasized that the above-described embodiments of the present disclosure are merely possible examples of implementations, set forth for a clear understanding of the principles of the present disclosure. Many variations and modifications can be made to the above-described embodiments without substantially departing from the spirit and principles of the present disclosure. All such modifications and variations are intended to be included herein within the scope of the present disclosure and protected by the following claims.

Claims

1. at least one computing device; a generator module executable on the at least one computing device, the generator module, when executed, causing the at least one computing device to: receiving data for use in generating the element representation; evaluating an instruction to generate the element representation; generating the element representations; and a planner module executable on the at least one computing device, the planner module, when executed, causing the at least one computing device to: receiving the element representation from the generator module; a planner module for at least generating and executing a plan for the interface unit; A system comprising:

2. 2. The system of claim 1, wherein the generator module generates the element representation based at least in part on a specific state change operation, and the generator module is configured to generate a single element representation after merging multiple state change operations into the specific state change operation.

3. The planner module: assigning a first identifier to the element representation to order the element representation relative to at least one previous element representation; ordering the element representations in a queuing system comprising one or more queues based at least in part on the first identifier or the second identifier; assigning a priority value to the element representation; The system of claim 1 , wherein the plan of the interface unit is generated based at least in part on the element representation.

4. The system of claim 1 , wherein one or more modules are configurable using a high performance computing architecture for artistic creation competitions.

5. The planner module: Receiving an event; and dynamically deleting the currently generated plan in response to the event; generating different plans for the interface unit in response to the event; The system of claim 1 , further configured to perform at least:

6. The system of claim 1 , wherein the planner module is further configured to divide a particular action into multiple actions.

7. a state module executable on the at least one computing device, the state module, when executed, causing the at least one computing device to: Managing one or more states; performing at least one of a create operation, a read operation, an update operation, or a delete operation on the one or more states; exposing one or more interfaces for interacting with said one or more states; The system of claim 1 further comprising a state module that executes at least:

8. The system of claim 7 , wherein the status module is further configured to at least maintain a persistent network connection to an artwork competition system.

9. The system of claim 7 , wherein the state module is further configured to prevent at least data duplication, out-of-order data, and out-of-date data.

10. the element representation further comprises an element representation module executable on the at least one computing device; The executable element representation module, when executed, causes at least one computing device to: The system of claim 1 , further comprising at least one of generating one or more interface unit elements based at least in part on a set of instructions or one or more data structures.

11. further comprising a representation module executable on the at least one computing device; When the representation module is executed, it causes the at least one computing device to:

2. The system of claim 1, further comprising at least: receiving the plan for the interface unit from the planner module; and generating the interface unit based at least in part on the plan for the interface unit.

12. receiving, by a generator module, data for use in generating the element representations; evaluating, by said generator module, instructions to generate said element representations; generating, by said generator module, said element representations; receiving, by a planner module, the element representations from the generator module; generating, by said planner module, a plan for an interface unit; 11. A computer-implemented method comprising:

13. 13. The computer-implemented method of claim 12, wherein the generator module generates the element representation based at least in part on a particular state change operation, and the generator module is configured to generate a single element representation after merging multiple state change operations into the particular state change operation.

14. assigning, by the planner module, a first identifier to the element representation to order the element representation relative to at least one previous element representation; ordering, by the planner module, the element representations within a queuing system comprising one or more queues based at least in part on the first identifier or the second identifier; and assigning, by the planner module, priority values ​​to the element representations, The computer-implemented method of claim 12 , wherein the plan for the interface unit is generated based at least in part on the element representation.

15. 13. The computer-implemented method of claim 12, further comprising facilitating, by one or more modules, an artistic creation competition using a high performance computing architecture.

16. receiving an event by the planner module; dynamically deleting, by the planner module, the currently generated plan in response to the event; generating, by the planner module, different plans for the interface unit in response to the event; The computer-implemented method of claim 12 further comprising:

17. The computer-implemented method of claim 12 further comprising dividing, by the planner module, a particular operation into multiple operations.

18. managing one or more states by a state module; performing, by the state module, at least one of a create operation, a read operation, an update operation, or a delete operation on the one or more states; exposing one or more interfaces by said state module for interacting with said one or more states; The computer-implemented method of claim 12 further comprising:

19. A computer-readable medium embodying at least one program executable on at least one computing device, the at least one program, when executed, at least one computing device; receiving data for use in generating the element representation; evaluating an instruction to generate the element representation; generating the element representation; generating a plan for the interface unit; A non-transitory computer-readable medium that causes at least

20. When executed, the at least one program further causes the at least one computing device to: receiving an event; dynamically deleting the currently generated plan in response to the event; and generating a different plan for the interface unit in response to the event.

Images