High performance computing architecture for artistic work competition

Abstract

Various embodiments of a high performance computing architecture for use in an artwork competition system are disclosed. In one embodiment, a system includes a generator module and a planner module. The generator module receives data to be used in generating the element representation and generates the element representation based at least in part on a particular state change operation. The generator module is configured to generate a single element representation after merging the plurality of state change operations into the particular state change operation. 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 queue system comprising one or more queues based at least in part on the identifiers, assigns priority values to the element representations, and assigns priority values to the element representations. And generate a plan for the interfacing unit based at least in part on the element representation.

Description

[0001] Cross - Reference to Related Applications

[0002] This application claims priority to U.S. Patent Application No. 18 / 056,311, titled "HIGH PERFORMANCE COMPUTING ARCHITECTURES FOR WORK OF ART COMPETITIONS", filed on November 17, 2022, which is hereby incorporated by reference in its entirety. Background Art

[0003] Artists can create many different forms of works through many different media, including musical compositions, visual and graphic arts, theatrical performances, and even culinary creations. For example, the experience of artworks can be enhanced by attracting an audience including a variety of artists and other users via an online social networking environment. Many conventional media for communicating information about artworks do not provide users with sufficient means to express their views on the relative value of different artworks. Similarly, artists do not have sufficient avenues or communication media to showcase their talents and compare their artworks with other artists in similar fields of artistic creation. To address the problems with current methods and systems for experiencing and evaluating artworks, more effective computer - implemented tools, strategies, and technologies are needed to help artists and other users share and compare artworks and ultimately enhance their enjoyment of different artistic creations. Brief Description of the Drawings

[0004] Many aspects of the present disclosure can be better understood with reference to the following drawings. The components in the drawings are not necessarily drawn to scale, but rather are emphasized to clearly illustrate the principles of the present disclosure. Additionally, in the drawings, like reference numerals designate corresponding parts throughout several views.

[0005] Figure 1 is a schematic block diagram of a networking environment according to various embodiments of the present disclosure.

[0006] Figure 2 illustrates an example of the functionality implemented in part as a generator module executing in a computing environment in a networking environment as Figure 1 a flowchart.

[0007] Figure 3 illustrates an example of the functionality implemented in part as a planner module executing in a computing environment in a networking environment as Figure 1 a flowchart.

[0008] Figure 4is a schematic block diagram that provides an example illustration of a computing environment employed in a Figure 1 networked environment according to various embodiments of the present disclosure. SUMMARY OF THE INVENTION

[0009] A system of one or more computers can be configured to perform particular operations or actions by causing software, firmware, hardware, or a combination thereof to be installed on the system, which, when operating, cause the system to perform the actions. One or more computer programs can be configured to perform particular operations or actions by including instructions that, when executed by a data processing apparatus, cause the apparatus to perform the actions.

[0010] One general aspect includes a system. The system further includes at least one computing device. The system further includes a generator module executable in the at least one computing device, wherein, when executed, the generator module causes the at least one computing device to at least: receive data to be used in a generated element representation; evaluate instructions for the generated element representation; generate the element representation based at least in part on a particular state change operation, wherein the generator module is configured to generate a single element representation after combining a plurality of state change operations into the particular state change operation.

[0011] The system further includes a planner module executable in the at least one computing device, wherein, when executed, the planner module causes the at least one computing device to at least: receive the element representation from the generator module; assign an identifier to the element representation for sorting the element representation relative to at least one previous element representation; sort the element representation in a queue system including one or more queues based at least in part on the identifier; assign a precedence value to the element representation; and generate a plan for an interfacing unit based at least in part on the element representation. Other embodiments of this aspect include corresponding computer systems, apparatus, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the method.

[0012] Embodiments 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 an art competition. The planner module is further configured to at least: receive an event; dynamically delete the currently generated plan in response to the event; and generate a different plan for the interface connection unit in response to the event. The planner module is further configured to splinter a particular operation into multiple operations for parallel and / or concurrent execution. The planner module is further configured to generate a plan at least in part based on a work completion time limit or in response to one or more state changes when interfacing with the state module. The planner module in other scenarios may generate a plan in relation to tasks or operations present in a queue system, which may take into account priority values associated with the tasks or operations. When executed, the state module causes at least one computing device to at least: manage one or more states; perform at least one of the following on one or more states: create operation, read operation, update operation, or delete operation; 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 perpetual network connection to the art competition system. The state module is further configured to at least prevent duplicate data, out-of-order data, and expired data. The element representation may further include an element representation module executable in at least one computing device, wherein when executed, the element representation module causes at least one computing device to at least: generate one or more interface connection unit elements at least in part based on an instruction set and one or more data structures. When executed, the representation module causes at least one computing device to at least: receive a plan for the interface connection unit from the planner module; and generate an interface connection unit at least in part based on the plan for the interface connection unit. Embodiments of the described techniques may include hardware, methods or processes, or computer software on a computer-accessible medium. Detailed Description

[0013] This disclosure relates to high-performance computing architectures for use in art competition systems and / or other systems. There are numerous problems with art competition systems that can be improved with an appropriate computing architecture. For example, as each artist participates in the competition, gains points, loses points, moves up or down in the rankings, the position number, artist name, and their score points must be continuously updated. The music general rankings may include thousands of artists operating continuously in the competition system. Various embodiments of this disclosure introduce a generator module that is capable of processing extremely large, finely updated versions of the rankings in just a few milliseconds, and a portion of whose ranking data may still be consistent with the previous data. The processes described now operate only on new data that is inconsistent with the previous ranking data and utilize the processed data that is consistent between the current ranking version and the newer ranking version.

[0014] As will be appreciated by those skilled in the art in light of the present disclosure, certain embodiments may be capable of achieving certain advantages, including some or all of the following: (1) building one or more complex applications while achieving high performance; (2) providing efficient instruction processing when data changes; (3) providing optimized execution when changing; (4) providing a more flexible processing mode; (5) providing a more flexible execution phase; (6) providing split and independent task processing; (7) organizing hardware resource allocation more efficiently; (8) providing unique execution; (9) enhancing processing through system collectives; and so on.

[0015] As will be described, the present disclosure can be used to build one or more complex applications while achieving high performance. Software complexity is increasing. In fact, applications are required to always include more features, utilize more resources, process more instructions and data. This complexity problem affects the field of computer systems that conduct competitions involving works of art. Optimization techniques require configuration in order to work and become effective. Software applications can have multiple running operations and / or sets of operations, and each of them can be uniquely addressed and / or managed for optimal optimization. These operations should be able to interact and work together regardless of how different they are.

[0016] The design goal of a works of art competition system can be that it is autonomous in its various parts within it, capable of being configured both as a whole and independently in its parts, and can be composed of one or more parts that work together and can perform different operations and / or consist of different characteristics. As described herein, an architecture composed of a representation, a generator, and a planner achieves the goal of building complex applications that achieve high performance. The planner can be regarded as the architecture (or sub-architecture) responsible for integrating the generator, is configurable, and / or can configure the associated architecture and operations. The generator can represent a specific set of operations and / or have jurisdiction over a (one or more) defined part of the interface connection unit or element representation, is configurable and can configure the associated element representation architecture. The element representation architecture can contain data and instructions for the interface connection unit elements and is configurable. These architectures are involved together, enabling complex applications to be autonomous (as a whole or in its parts), configurable (as a whole and / or in its parts), and composable, regardless of the technical nature, configuration requirements, optimization techniques, or operations of its parts.

[0017] The present disclosure can also provide efficient instruction processing for data changes. In particular, the system can be instructed to adopt hardware resources in the case of generating new element representations while reusing the already generated representations.

[0018] The present disclosure may also provide optimized execution for changes. In one scenario, an interface connection unit (or the entire system) may be composed of multiple generators (and their associated element representation architectures). Interactions, events, or updates (such as network responses) may cause not just one but multiple changes in, for example, the system, a data repository, the interface connection unit, or any other part of the system. For example, an artist may click a challenge button, so the appearance of the button must change because he can no longer send a challenge request, and his statistics regarding the amount of challenges he has sent must be updated. In the above example, from the user's perspective, it may not be necessary to handle these two changes in two separate "generations", and this is not necessary from the system's perspective either. As will be described, the system and / or architecture may be configured to handle one or more changes in a single process. In various embodiments, more than one generator is not required; one generator may be able to cause one or more changes.

[0019] The present disclosure may also provide a more flexible processing mode. Various operations may occur in a computer system conducting an art competition, and further configurations may be applied to improve performance, enabling the system to evaluate which order of operations to run. For example, a voter requests information about a battle through the competition system to listen and vote: while the voter's system waits for a response, the voter's system may be able to run other instructions or process other data, such as updating the notification number in the interface connection unit. As will be described, the competition system may be configured to organize the processing of sequential, concurrent, and / or parallel operations.

[0020] The present disclosure may also provide a more flexible execution phase. For example, in a scenario, a particular operation is characterized by high processing costs, such as an interface connection unit element continuously displaying updated competition results. Thus, the operation may severely affect system behavior and cause problems (such as stalls or delays) in another part of the system (such as the processing of user-specific updates), which may occur less frequently or require less power than more extensive system competition updates. The architecture should enable the system to manage and execute any kind of operation in combination with each other. To build a high-performance computer system for conducting a competition involving artworks, the system may be built in stages, which may represent various execution tasks.

[0021] The present disclosure may also provide split and independent task processing. A recurring goal, especially in resource-intensive areas of a computer system conducting an art competition, is the ability to fully control ongoing operations, future operations, and system behavior in relation to confirmable factors (such as inputs). An architecture providing such a configuration achieves at least two purposes: exercising absolute control over the machine and performance improvement.

[0022] The present disclosure can also organize the allocation of hardware resources more efficiently. For example, there can be system-defined and / or user-defined activities or operations (such as static settings or dynamic settings, including settings derived from user behavior), which may require more resources and / or may have privileges over other activities or operations. Artist users can be more focused on this type of update when reviewing the challenges they have received or sent. The interface connection unit can display many types of ongoing activities. The functionality of a computer system for conducting a competition involving artworks can be improved to provide the ability to specifically allocate resources.

[0023] The present disclosure can also provide a unique execution. Designing a competition system architecture that includes phases is a clear improvement. There are scenarios where the system may be required to resolve them through additional enhancement processes: a user may be viewing information related to a specific competition or genre, but the system may have operations scheduled during the execution phase. The user may decide to view information about another competition. Thus, there may be two user-initiated operations, such as causing the system to request information and the interface connection unit to display the information. The competition system may need to be able to insert these two operations during its execution phase, evaluate instructions on whether to run them, and in which mode to operate the instructions.

[0024] The present disclosure can also enhance processing through system collectivity. When computer systems running artworks competitions perform operations in cooperation, the systems may require additional configuration to further improve performance. For example, multiple (any type) of entities (such as element representations) can be received by another system. The receiving system may have to be designed to be able to receive and display these representations, perform update and comparison operations using these representations, and be fully integrated when they are processed by the receiving system. As will be described, the systems can be complementarily organized to execute their tasks faster and be able to receive and integrate entities.

[0025] In the following discussion, a general description of the system and its components is provided, and then its operation is discussed.

[0026] Reference Figure 1 , a networking environment 100 according to various embodiments is shown. The networking environment 100 includes a computing environment 103 and one or more client devices 106 that communicate data with each other via a network 109. The network 109 includes, 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 other suitable networks, etc., or any combination of two or more such networks.

[0027] The computing environment 103 can include, for example, a server computer or any other system that provides computing capabilities. Alternatively, the computing environment 103 can employ multiple computing devices that can be arranged in, for example, one or more server clusters or computer clusters or other arrangements. Such computing devices can be located in a single facility or can be distributed across many different geographical locations. For example, the computing environment 103 can include multiple computing devices that can together constitute a hosted computing resource, a grid computing resource, and / or any other distributed computing arrangement. In some cases, the computing environment 103 can correspond to elastic computing resources, where the capacity of allocated processing, network, storage, or other computing-related resources can vary over time.

[0028] According to various embodiments, various applications and / or other functionality can be executed in the computing environment 103. Additionally, various data is stored in a data repository 112 accessible to the computing environment 103. As can be appreciated, the data repository 112 can represent multiple data repositories 112. For example, the data stored in the data repository 112 is associated with the operation of various applications and / or functional entities described below.

[0029] Components executed on the computing environment 103 include, for example, an art competition system 115, one or more status 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, and other applications, services, processes, systems, engines, or functionality not discussed in detail herein. The art competition system 115 is executed to conduct an art competition. As used herein, an "artwork" can include a variety of artistic creations by different types of artists, including, for example, but not limited to, musical works (and their remix versions), visual and graphic arts, theatrical performances, and culinary creations, etc.

[0030] The art competition system 115 can employ, for example, a web application programmed for conducting an online competition, as well as a dedicated news and voting system and other features. The online competition environment can be provided with an online tournament where artists compete with each other through a competition module with the goal of obtaining victory points to win and advancing through a champion designation framework. For example, the art competition system 115 can be programmed for uploading and comparing artists' songs, and in some embodiments, the songs can be limited to original works created by the artists.

[0031] Competitions can be conducted by an artist selecting an audio / video track of their artwork to be played, displayed, or otherwise accessed via the artwork competition system 115. For example, the winners of these competitions can be determined by an online user audience comparing the artworks and casting votes to determine the winner. Other features provided by the artwork competition system 115 can include voting, information, and news systems designed to handle communications related to the artwork and related topics. Various embodiments can be configured to be accessed, for example, through a combination of web-based social network services, application software, and tablet computer and mobile device implementations, including various systems of interconnected computers and devices. In other implementations, the high-performance architecture described herein, when implemented in the artwork competition system 115, can be implemented in any combination with any of the following modules: profile module, competition module, news module, log module, storage module, analysis module, automation module, advertising module, sales module, communication module, championship module, scoring module, ranking module, correspondence module, voter module, artist module, voting module, and / or other modules.

[0032] Various embodiments of the artwork competition system 115 are further described in U.S. Patent No. 9,669,299, entitled "Conducting Artistic Competitions in a Social Network System" and issued on June 6, 2017, which is hereby incorporated by reference in its entirety.

[0033] (One or more) status modules 118 are executed to manage status information for the artwork competition system 115. For example, the status module 118 can be capable of performing create, read, update, delete, or other operations on the status it manages. The status module 118 can also expose one or more interfaces for other modules and / or architectures to interact with its status.

[0034] (One or more) generator modules 121 interact with (one or more) state modules 118 and may perform create, read, update, delete, or other operations on associated modules and / or may perform operations outside of their own modules. (One or more) generation modules 121 may be locally stateful and may be able to perform create, read, update, delete, or other operations on their local state. (One or more) generator modules 121 may receive inputs and / or entities to be used in the generation of element representations. For example, (one or more) generator modules 121 may evaluate element generation instructions (such as including statements, data, or entities). (One or more) generator modules 121 may also perform the generation of element representations in relation to state changes of associated state modules 118, the local state of (one or more) generator modules 121, and / or received inputs or entities. (One or more) generator modules 121 may also store information about the state interfaces being used and combine the operations of the state interfaces such that the generation of element representations is performed once, rather than once for each state change operation. (One or more) generator modules 121 may also generate interface connection unit element representations. The element representations generated as discussed above may also be considered modules, as described below.

[0035] (One or more) element representation modules 124 may correspond to an instruction set for generating one or more interface connection unit elements. (One or more) element representation modules 124 may correspond to a data structure for generating one or more interface connection unit elements. (One or more) element representation modules 124 may correspond to data, values, information, and entities for generating one or more interface connection unit elements. (One or more) element representation modules 124 may correspond to data structures, data, values, information, or entities that constitute or are associated with one or more interface connection unit elements.

[0036] (One or more) Planner modules 127 may receive an element representation module 124 from a generator module 121. (One or more) Planner modules 127 may store information about the state interfaces in use and combine the operations of the state interfaces so that they are performed once, rather than once for each state change operation. (One or more) Planner modules 127 may elaborate interface connection unit plans, including listing or describing the interface connection unit elements to be represented and the processes to be used to perform interface connection unit creation. (One or more) Planner modules 127 may store interface connection unit plans. After further receiving the element representation module 124, the planner module 127 may compare the representation module 130 associated with the current plan with the subsequently received representation module 130 and determine changes to the plan and the processes for performing the changes. (One or more) Planner modules 127 may output the current interface connection unit plan.

[0037] (One or more) Representation modules 130 may receive and evaluate interface connection unit plans from a planner module 127. (One or more) Representation modules 130 may also construct interface connection units.

[0038] Data stored in the data repository 112 includes, for example, one or more interface connection unit plans 136, status information 139, one or more collaboration plans 142, one or more interface connection unit elements 145, one or more element representations 148, one or more dynamic elaboration plans 151, and potentially other data.

[0039] Client device 106 represents multiple client devices 106 that may be coupled to network 109. Client device 106 may include, for example, a processor-based system such as a computer system. Such a computer system may be implemented in the form of a desktop computer, laptop computer, personal digital assistant, cellular phone, smartphone, set-top box, music player, web tablet computer, tablet computer system, gaming console, e-book reader, smartwatch, head-mounted display, voice interface device, or other device. Client device 106 may include a display, for example, including one or more devices such as a liquid crystal display (LCD) monitor, a gas plasma-based flat panel display, an organic light emitting diode (OLED) display, an electrophoretic ink (Eink) display, an LCD projector, or other types of display devices, etc.

[0040] The client device 106 can be configured to execute various applications, such as client application 154 and / or other applications. The client application 154 can be executed in the client device 106, for example, to access network content provided by the computing environment 103 and / or other servers, so as to generate an interface connection unit, such as a user interface, on a display. To this end, the client application 154 can include, for example, a browser, a dedicated application, etc., and the interface connection unit can include a web page, an application screen, etc. The client device 106 can be configured to execute applications other than the client application 154, such as, for example, an email application, a social networking application, a word processor, a spreadsheet, and / or other applications.

[0041] Next, a general description of the operations of the various components of the networking 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. The element representation 148 is an entity that represents an instruction set, a data structure, data, a value, information (i.e., the interface connection unit plan 136), one or more interface connection unit elements 145, and / or one or more of the data structures, data, values, information that make up the interface connection unit and / or one or more interface connection unit elements 145 for generating an interface connection unit. In addition, 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, a mutable and / or immutable data structure.

[0042] Modules such as the generator module 121, the element representation module 124, the planner module 127, the representation module 130, the state module 118, etc. can be configured as entities that represent one or more of an instruction set, a data structure, data, a value, information, and an input.

[0043] The generator module 121 can include an instruction set for detecting changes in inputs, states, data structures, values, or any other relevant data and / or information that affect one or more element representations 148. If the relevant data remains the same, then the generator module 121 outputs the previously stored element representation 148 from the data repository 112, while in the opposite case when the relevant data does not remain the same, a new element representation 148 is generated. For example, the stored element representation 148 can exist in the persistent memory structure of the generator module 121, the element representation 148 can be shared among modules, or can exist 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 input can be any entity, state, instruction to be executed, data structure, data, information, value, generated element representation 148, and / or other generator modules 121.

[0044] When the relevant data and / or entities change, the art competition system 115 may be required to update the interface connection unit elements 145 and the associated architecture. The element representation 148 generation process and the generated element representation 145 involve additional memory, processor time, and power to perform the update. In various embodiments, the generator module 121 avoids additional execution of the element representation 148 generation and the creation of the element representation 148, which reduces memory consumption, accelerates processor operations, and enables the updated competition system to utilize less processing power by storing the inputs, states, and entities associated with the element representation 148. The generator module 121 may perform a comparison operation on the element representation 148, connecting the stored associated entities with the associated entities to be used for the next element representation 148 generation and / or the creation of the element representation 148.

[0045] Greater benefits are achieved with an increased amount of updates. Due to the adoption of the generator module 121, the process of conducting a competition involving artworks can handle a larger amount of information and operations. For example, a ranking module including position numbers, artist names, and their score points can be continuously updated as each artist participates in the competition, gains and loses points, and their ranking goes up or down. The music genre ranking can include numerous artists operating continuously in the art competition system 115. The generator module 121 can process an extremely large number of finely updated ranking versions in just a few milliseconds. A portion of their ranking data may still be consistent with the previous data. The process can operate only on the new data that is inconsistent with the previous ranking data and can then utilize the processed data that is consistent between the current ranking version and the newer ranking version.

[0046] The planner module 127 may be configured to compare the current interface connection unit plan 136 with the new element representation 148 received by the generator module(s) 121. The current interface connection unit plan 136 includes one or more element representations 148, which in turn may have child and sibling element representations 148, or may be primary, superordinate, subordinate, equalordinate, and / or the first or last element representation 148. The planner module 127 may also be configured to directly reference the element representation 148 received by the planner module 127 from the generator module 121, or the planner module 127 may construct its element representation 148 based on the data of the received element representation 148.

[0047] The interface connection unit plan 136 can be interpreted and structured according to any model, or include one or more models, such as graphs, lists, sets, multisets, trees, queues, priority queues, maps, multimaps, containers, arrays, collections, and / or stacks. Each element representation 148 can hold a specific value, such as, for example, a type, a unique identifier, a property, an attribute, and / or a superordinate, subordinate, or equivalent hierarchical element representation 148. When comparing a new with the current (one or more) element representations 148 or a set or list of element representations 148, the planner module 127 can be configured not to compare two element representations 148 in the case where the new and the current element representations 148 have different types, and replace the entire (one or more) element representations 148, set, list, or a part of the set with the new one. Instead, the planner module 127 can be configured to only update the data representing its characteristics and additional information.

[0048] The planner module 127 can also be configured to build and update its element representation 148 data structure and use only the received element representations 148 as a means for performing building, comparison, update, and / or other processes. Alternatively, the planner module 127 can directly reference and / or integrate the received data structure and / or combine its data structure with the received data structure. The planner module 127 can additionally be configured to constitute one or more data structures to track the current and newer element representations 148 in order to perform its tasks. In some cases, the structures can share data between them and have any degree of integration and association with any other data structure. The planner module 127 can associate the element representation 148 data structure with any other data structure in order to execute its instructions. For example, the planner module 127 can establish references between the current element representation 148 data structure and the newer element representation 148 data structure and / or between the element representation 148 data structures.

[0049] The Planner Module 127 can, for example, use an identifier (such as a unique identifier) to place the Element Representation 148 in the correct order and compare the current version of the Element Representation 148 with a newer version. The Planner Module 127 can output the Interface Connection Unit Plan 136 as a unique optimized set of operations to the (one or more) Representation Modules 130, thereby minimizing the system resource usage for building or updating the interface connection units of the (one or more) visualizations and enabling acceleration of the operations. For example, the state operations (such as create, read, update, delete) and / or state interfaces and / or lists of inputs, data, entities or any type of reference or structure involved in the generation of the Element Representation 148 can be maintained by the (one or more) Generator Modules 121 and / or the (one or more) Planner Modules 127 to perform related state changes together, resulting in the generation of a unique optimized Element Representation 148 instead of performing it once for each operation / entity change, which would be performed multiple times and use more resources by the relevant architecture (such as the (one or more) Generator Modules 121 and / or the (one or more) Planner Modules 127).

[0050] Accordingly, the problems of intermediate, redundant or long workloads and / or their representations in the interface connection units are greatly improved. As shown, due to the reduction in time, processing power, memory and bandwidth, this architecture results in performance improvement.

[0051] The Planner Module 127 can also utilize a stack model and / or a queue model and / or a recursive or iterative process when refining and / or updating the (one or more) Interface Connection Unit Plans 136 to process the Element Representation 148 and / or its data structure and / or evolve the processing in independent tasks in order to dynamically organize the execution order. The independent tasks can be formulated as data structures associated with one or more Element Representations 148 and / or any values of one or more Element Representations 148 or any other data structures.

[0052] The Planner Module 127 can store the specific values, the inputs and / or the state involved of the Element Representation 148 together with the Element Representation 148 to effectively compare it with the received newer version. For example, the refinement can start from the main (or the first or the last in its corresponding order) Element Representation 148 and then refine the subordinate Element Representations 148 including all equally ranked Element Representations 148 until all nested Element Representations 148 are refined. The equally ranked Element Representations 148 can be processed in a specific direction.

[0053] The planner module 127 can be configured to collect all inputs and states associated with each element representation 148, as well as the element representation 148 itself, and form a list. Such a list can be iterated, for example, during element generation to refine the plan and / or compare element representations 148 (e.g., compare between new and current element representations 148).

[0054] The planner module 127 can be configured to organize different processing queues for element representations 148 present in the list or representations not in the list. The planner module 127 can additionally be instructed to determine whether the element representation 148 has an associated state and / or input. The presence or absence mentioned above can determine whether the planner module 127 can process the element representation 148 in a concurrent or parallel manner, or whether the planner module 127 performs sequential processing. The planner module 127 can arrange all element representations 148 that can be processed sequentially in a first queue in the queue system 133, and arrange element representations 148 that can be processed concurrently or in parallel in a second queue in the queue system 133. The planner module 127 can be configured to process the inputs and / or states associated with the element representation 148 all at once during the final stage of plan refinement.

[0055] Operations on the inputs and states associated with the element representation 148 (such as create, read, update, and delete operations) can be performed by the generator module 121, the planner module 127, or other modules. For example, the generator module 121 can output the results of such operations, or alternatively, these operations can be performed by the planner module 127 when refining the plan for the element representation 148. For example, in a scenario where the element representation 148 generated is always the same if the inputs, data, entities, and state values used to generate the element representation 148 are always the same, the planner module 127 can compare the new inputs and / or states used to generate the element representation 148 with the current inputs and / or states without involving other processes, such as one-to-one value comparison or immutability comparison models.

[0056] For example, the planner module 127 and / or the architecture running such instructions can be made to execute operations faster because they can now identify and distinguish tasks that may or may not involve specific procedural steps (such as sequential processing or parallel and / or concurrent processing). For example, the ability to distinguish between operations that need to be performed in a specific order and operations that do not need to be performed in a specific order enables a reduction in operation time because the system is precisely instructed which tasks can be accelerated and run simultaneously, and which tasks require waiting.

[0057] The architecture can involve hash instructions, for example, when generating and / or comparing data structures. Hashing can 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. For example, this applies regardless of the data scheme (such as mutable or immutable data design) used by the art competition system 115. Immutable data structures can be used to manage the refinement plan between the current element representation 148 and the newer element representation 148.

[0058] The immutable element representation data design can instruct the processor to determine changes by comparing the memory locations of the element representations 148 and recursively or iteratively process the entire element representation 148 model. The planner module 127 can be instructed to start refining from the primary or first representation structure to the final nested representation structure and use a specific direction when encountering a set or list of representation structures.

[0059] The generator module 121 can be configured to, for example, assign priority values to inputs and / or states involved in representation generation and / or integrate the element representations 148 into a priority ranking system, allowing the planner module to assign greater or lesser priority to some element representations 148 within a representation generation or between complete representation generations. Such priority values and priority ranking systems can be organized, for example, by the planner module 127 or other modules. The priority system can be organized by implementing a tree data structure formed by item data structures, which consist of a value and at most two subordinate items. The priority order of the items can define that the value of the superior item can be less than or equal to the subordinate item, or the value of the superior item can be greater than or equal to the subordinate item.

[0060] (One or more) generator modules 121 can be structured as entities that are also capable of storing and persisting values, data structures, data, information, inputs, and states. (One or more) generator modules 121 can also interface with other modules and / or architectures that are instructed to perform storage and / or persistence. The generator module 121 or other architectures can detect when values, data structures, inputs, and states change. For example, changes can be detected by executing or re-executing the generation module or modules, execution interfaces, execution create / read / update / delete interfaces, event architectures, queue architectures, and executing instructions during read, create, update, and delete operations.

[0061] 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 the start element representation 148 is generated or before the result of its operation is output 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 has built an interface connection unit. Specific instructions may be assigned for the first element representation 148 generation and / or successive generations. Further, instructions may be executed in response to the generator module 121 or other modules being deleted (such as, for example, before, during, and after). The generator module 121 may also be configured to persist the element representation 148 and / or its data in the state module 118 or other architectures.

[0062] In addition, states, data, information, inputs, and instructions may be associated with stage-specific runners to evaluate their changes and determine whether and / or when the runner and / or its instructions must run. The configuration may be configured to run only when the associated entity has changed, been removed, or been replaced by another entity. The configuration may include a set of instructions to be run before, during, and after any process. For example, operations, create / read / update / delete interface operations, and / or operations on states may be executed as one enhanced operation instead of multiple runner executions. For example, it is additionally beneficial for modules, architectures, runners, instructions associated with the entity being manipulated, because the associated set of entities has undergone all the processing as specified by the instructions and will not be executed once for each entity when there is no such requirement or benefit, otherwise the instructions may still be configured to run once per change. The configuration may run at a specific stage, and the instructions may be configured to be run or postponed or run regardless of the specific instruction configuration.

[0063] For example, the applied architecture prevents the interface connection unit from being blocked by executing selected instructions (when beneficial) after the representation module 130 has built and / or updated the visual interface connection unit. In other examples, the applied architecture runs selected instructions before an exact stage (such as building and / or updating the visual interface connection unit) to prevent the user from visualizing unnecessary or ongoing interface connection unit updates, which additionally brings further performance improvements because fewer interface connection unit versions are visualized and fewer system resources are consumed when beneficial. Additionally, the applied architecture may also improve interaction consistency by preventing the user from interacting with temporary or ongoing versions of the visual interface connection unit.

[0064] The planner module 127 using its own stack model, for example, can also be configured to identify the generated element representations 148 and assign higher or lower priorities to them. The stack model can also be complementary to the queue model. The planner module 127 can process the generated element representations 148 in parallel or concurrently, rather than using a sequential approach. The planner module 127 can also be able to start, pause, restart, or delete the refinement of one or more generated element representations 148 simultaneously. The planner module 127 can also be configured to incorporate iterative statements and / or iterative processes, such as, for example, to process or transform data or confirm the completion of an operation, handle concurrent or parallel operations, process instructions according to a priority system, and / or remit values during execution. The iterative process can organize iterations and executions sequentially, and each can represent the start or end of each task and / or the entire representation generation process. For example, during a phase indicating the end of a task, the planner module 127 can process a list containing element representations 148 associated with inputs and / or states. The foregoing configuration example can include running recursive statements and / or recursive processes.

[0065] The event-driven architecture can be further integrated into the art competition system 115. For example, events can be responsible for changes in inputs and / or states and / or element representations 148, thus starting 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, for example, to organize task execution in combination with other models (such as the stack model and the queue model).

[0066] Independent task data structure formulation can include time-related data, such as time estimates, limits, measurements, and recordings, and / or priority values (e.g., bits, numbers, booleans, strings, sets, or any other data type) to execute one or more tasks. When using any capable model, the instruction order can occur independently, and instruction sets can be executed at different times, such as, for example, deferring an instruction set until a condition is met or applying a preemption process and / or prepending a task.

[0067] The event architecture can be implemented to expose an interface for data transmission and reception to one or more recipients, for example. Further configurations can include serialization of data structures. The event data structure can be a clone of the data received from the event system and / or defined with appropriate types. Additionally, the data structure can be transmitted to be associated with another data structure and optionally delete any previous associations or accessibility.

[0068] The Planner Module 127 can be configured to split an operation into multiple sets of executable operations and / or entities, data, values, data structures, information, instructions that can be processed by the planner or other modules. For example, the Planner Module 127 can split an operation to manage an unexpectedly long operation and allow manipulation of the interface connection unit. Additionally, the splitting can allow any degree of concurrency or parallel execution of different types of operations with any number of execution threads. For example, an interactivity event can transmit data, information, indicating that the plan in refinement is no longer relevant. Accordingly, the Planner Module 127 can be configured to delete that plan and refine a new plan.

[0069] In this regard, the Planner Module 127 can stop an ongoing refinement without first completing the plan and immediately start refining and outputting a new plan. For example, a voter may be listening to a competition between two artists and their artworks via the Artwork Competition System 115. Then, the user clicks to navigate to the user's own profile. In this case, the Planner Module 127 is outputting an interface connection unit for the competition and an associated media stream, such as a song track. The described architecture allows the Planner Module 127 to dynamically delete the current plan and immediately start refining and outputting a new plan (i.e., the listener's own profile), thus determining performance improvements and an excellent interface connection experience. The architecture can be configured to handle events, execute specific instructions for specific events associated with a particular element representation 148, or act on received data, information, executing default instructions inside the Generator Module 121, in other parts of the architecture, or in a combination of the two processes without additional instructions.

[0070] The Planner Module 127 can be configured to refine and output a plan to the Representation Module 130 according to a priority system. The Planner Module 127 can consider one or more factors related to the priority system. For example, the Planner Module 127 can stage (phase) a data structure for representation generation and evaluation according to a priority value (e.g., bits, numbers, boolean values, strings, sets, or any other data type). Other factors can be, for example, a work completion time limit and / or estimate. The Planner Module can initially output only a part of the generated and successively output the remainder. The staged structure can integrate new representation generation with the remaining representations held in the structure.

[0071] As an example, when data is received via an interactive event, the architecture can improve efficiency by implementing instructions to stop ongoing refinement without first completing the plan. Since the unrefined remainder of the ongoing plan (which is obsolete due to the event in this example) is not processed, time, memory, processing power, and bandwidth can be saved. Additionally, for example, since the planner module 127 is now able to output the plan to the presentation module 130 while still refining the plan by using the stack model and independent task data structure formulation. The user can receive the interface connection unit faster without waiting for the entire set of presentations to be fully processed. The planner module 127 can also be able to allocate more time, memory, processing power, and bandwidth to specific parts of the architecture and / or element presentation 148 with a priority system. This improves the user experience because system resources are mainly directed to the parts of the interface that the user is more interested in, more focused on, and / or interacting with. This can also improve performance because for specific cases, the architecture can be allowed to pause any processing activities of the lower-ranked parts in the priority system.

[0072] The architecture (or the generator module 121, planner module 127, or other modules and / or instructions) can be configured to defer the execution of the entire instruction set, execute the entire instruction set, and / or execute and defer instructions partially. For example, the architecture can immediately run specific statements and / or instructions and / or defer other instructions in the same instruction set.

[0073] For example, the architecture can be configured to organize queues in the queue system 133 for instructions, inputs, states, data, information, events, user interaction events that perform (and / or cause) changes to the interface connection unit and assign them a specific (or lower / equal / higher) priority ranking, and / or insert them into a specific (or lower / equal / higher) priority queue and / or other queues with different priority rankings. For example, entities, instructions, events, user interaction events, inputs, states, data, or information that do not perform and / or do not cause changes to the interface connection unit and / or do not have to be run immediately and are integrated with the event and / or interactive architecture can be inserted into the queue.

[0074] Queues can also be organized for specific types (such as events, interaction events) and / or for instructions or entities that modify the way the architecture runs and / or processes. Queues can be constituted and integrated for the event architecture, thereby causing changes to how the architecture effectively processes instructions and / or data to run in sequence, out of order, in parallel, and / or concurrently.

[0075] The queue system 133 can be structured as a queue to be executed in order and / or a queue that does not require execution in order. Instructions, inputs, states, data, information, events, user interaction events that execute (and / or cause) an interface connection unit change can be executed in order, while if they do not modify the interface connection unit and / or are not associated with the interactivity and event architecture, they can be executed out of order, concurrently, and / or in parallel. For example, given an instruction set, the configuration can execute instructions that do not modify what the interface connection unit represents and defer the execution of instructions that modify the interface connection unit until after an element representation 148 is generated or any other process (such as plan refinement). Alternatively, the configuration can execute both types of instructions or defer both types of instructions.

[0076] The configuration can be instructed to immediately process instructions originating from the user interactivity architecture (and, for example, in order) and defer other operations (such as state module 118 operations and / or operations that cause the interface connection unit to be modified). Additionally, the architecture can be configured to process events in order, requiring that previous events be processed before new events and their instructions, implementing a queue, stack, event handling structure, and / or any other architecture.

[0077] When running an instruction or set of instructions, the architecture can queue any direct and indirect modifiers of the interface connection unit into a specific priority queue and queue instructions or data that do not modify the interface connection unit and / or instructions or data related to the interactivity and event architecture of the interface connection unit into a specific queue. For example, modifiers related to the interactivity and event architecture of the interface connection unit can be processed in the same queue in combination with a concurrent and / or parallel architecture. Additionally, the architecture can be implemented individually, jointly, and / or through any combination. Additionally, any sequential, concurrent, and / or parallel architecture can be configured to allow any degree of concurrency, parallelism, or sequential processing.

[0078] For example, the computing environment 103 can be configured to use time recording and limits as priority values to manage operations and / or entities. Time ranges can additionally be configured to cluster operations and / or entities associated with time recording and limits. Additionally, the priority values can be represented by numbers, bits, booleans, strings, or any other type. Sets can be implemented, such as sets of bits (e.g., numbers or booleans), to represent one or more priority values and their queues 133. Bitwise operations and shifts can be performed to read and manipulate priority values represented as bits and / or bit sets that include one or more bit priority values, evaluate the priority and / or ranking of any operation, instruction, or entity, or depend on different levels of operations. For example, operations (or any create, read, update, delete, join, and / or merge operations on one or more priority values) can be performed using numbers and booleans and their corresponding procedures.

[0079] For example, the computing environment 103 can evaluate the existence of works to be executed by evaluating whether a time value and / or a bit priority value (including a set of priority values) is set. The architecture can be configured to share priority values and sets of priority values with upper, lower, or peer entities. Additionally, the architecture can be instructed to change priority values and the queues of entities and operations. The configuration can use the presence or absence of priority values and / or sets of priority values to determine (one or more) changes or (one or more) updates within the computing environment 103. These evaluations can additionally be used to optimize operations, because modules associated with changes or updates can be executed again, while modules without (one or more) changes or (one or more) updates are not. The configuration can be instructed to use a set of values representing a priority queue to concurrently and / or parallelly process tasks belonging to different queues 133. As an example, the set of queue values can allow lower priority tasks to be executed while higher priority tasks are waiting for data for a network request without performing any operations. For example, a priority value can be assigned to an entity associated with an element representation 148. The priority value of the element representation 148 can represent a set of values representing its associated entity, and / or represent (and / or contain) (one or more) associated (and / or lower) element representation priority values.

[0080] As another example, a queue system 133 can be configured, which includes a highest priority queue, a queue for events to be made to execute more than once, a standard queue, a secondary priority queue, and a "waiting state" queue. As explained above, more queues, such as numbered queues, can be added. For example, priority values in any form of implementation can represent any entity, such as instructions, modules, data structures, data, values, information, inputs, numbers, bits, boolean values, strings, and sets.

[0081] The computing environment 103 can be configured to record the execution time and resources utilized for modules and / or the architecture in order to monitor performance, thereby allowing an optimal configuration to better manage general and / or specific operations. The monitoring interface can be associated with the status module 118, the generator module 121, the planner module 127, the representation module 130, other modules, the architecture, independent task data structures, generated executions, entities, or any combination of operations.

[0082] The architecture and / or module can be configured to defer the collection of instructions and / or modules until a condition is met or an operation is required to be performed, and / or selectively perform one or more operations when determining which instruction to run. Additionally, the architecture and / or module can implement instructions to start, pause, resume, or delete the interface capabilities with other modules, architectures, or their inputs, outputs, and changes (such as, for example, instruction sets, modules, data structures, data, values, states, and element representations 148). Instructions can be run to identify and collect one or more data to generate an identification structure to allow the architecture and / or module to perform create, read, update, delete, and / or compare operations. The architecture and module can be configured as one or more upper, lower, or peer entities.

[0083] All architectures and their instructions can be executed on a networked computer system. The networked architecture can provide performance improvements and an excellent user experience. For example, the computing environment 103 that executes the generator module 121 and / or the planner module 127 can provide a presentation plan to the presentation module 130 running on another computer system. The networked computer system can also run the same architecture and process the output received from the architecture running on the networked system in order to execute the same architecture on the recipient computer system. For example, the computing environment 103 that runs the generator module 121 and / or the planner module 127 provides a presentation plan to the presentation module 130 running on another computer system. The presentation module 130 can be configured to immediately construct an interface connection unit once one or more data independent entities (in this case, the interface connection unit element representation 148 (and / or related data)) are provided. The presentation module 130 can be in the process of receiving the entire presentation plan simultaneously. The generator module 121, the planner module 127, and / or other modules running on the provider system can process each independent entity in a different manner. For example, the voter profile interface, the interface connection unit composed of multiple elements, and other interface connection units can take more time to process. The interface representing voter statistics can take more time to process than an element representing only the voter name. To provide the desired output, additional data and / or more processing are involved.

[0084] The recipient module can be configured to independently process data entities at the moment of receipt, using a concurrent and / or parallel model. As a result, the interface connection unit is constructed more quickly without deferring the presentation execution until the entire presentation plan is complete, and the construction of the element representation 148 can start in any order.

[0085] The Planner Module 127 can be configured to define the Element Representation 148 as an ordered independent data entity and / or an unordered independent data entity, and combine these definitions within the same representation schema. Further configuration can enforce a default order for processing unordered independent data entities, such as the positions they hold and / or will hold throughout the Element Representation schema. This default order can be superseded by a priority schema and / or an event schema or any other schema.

[0086] The Planner Module 127 can be further configured to utilize a substitute for the Element Representation 148 (and / or its associated data), replacing it with the original independent data entity. Specific values can be added to the Element Representation 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 and / or includes unordered independent entities.

[0087] Definitions can exist within the Element Representation 148 structure for use by modules to execute the instructions they hold. Definitions can assume any form, such as additional information such as strings and / or symbols, and be implemented as meaningful values for modules to determine how and / or where to operate within the Element Representation 148 structure or any other data structure. Definitions can specify the structure and / or a part of one or more Element Representations 148. For example, the start and / or end of one or more unordered independent data entities and / or their replacement structure. For example, a definition can also indicate that other schemas running on other computer systems handle a specified part of the Element Representation 148 structure or any other data structure.

[0088] The Element Representation 148 structure can include executable instructions for use by other modules on other computer systems. For example, the instructions can include instructions for replacing a replacement structure with an original structure.

[0089] For example, specific values such as identifiers can be combined for replacement operations. When a schema receives an Element Representation schema refined from another networked schema, the schema can further refine the schema to fully integrate the received schema with the schema or module. Since the representative structure of the Element Representation schema has been constructed, performance is improved. Thus, the schema can directly execute the integration process, resulting in less resource consumption and faster operation. For example, the received schema that is constructed and shown can be associated with an event schema and an interaction schema and / or any other schema.

[0090] For example, the constructed interface connection unit plan 136 is processing the original data structure while the user is interacting with another replacement structure. It can be indicated to the architecture to pause the current processing to prioritize the processing of the original data structure associated with the replacement with which the user has interacted. As an example, additional definitions can be used to determine superordinate, subordinate, coequal, or any other relationships to be assigned higher, lower, or equal priorities.

[0091] Networked architectures can collaborate to establish which architecture performs 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 that includes element representations 148 generated according to their configuration and combined with instructions for receiving networked architectures to perform other element representation generation on their computer systems. Further configurations can include serialization and deserialization of the dynamic refinement plan 151, as well as replacement processes for structures or models that cannot be serialized.

[0092] Establishing the collaboration plan 142 can include implementing identifiers, architecture identifiers, extensions, and / or any supplementary data or metadata. The instructions to be executed (represented as any kind of entity, statement, or data structure) can be combined with the entire instruction set and / or only with identifiers and / or addresses (both in any form), through which the receiving architecture retrieves the instructions to be executed. The replacement model can be processed independently. The receiving model can be implemented to retrieve networked architectures during the process of refining entities related to the instructions to be executed.

[0093] For example, the collaboration plan 142 can include configurations that indicate to networked architectures to perform operations expected to be performed by another networked architecture for any reason, such as an error. For example, the dynamic plan configuration can also include any of the previously mentioned content, such as replacement models or independent processing and receiving models, and is adopted by providers, receivers, and any networked architectures. The inputs and outputs of networked architectures and / or the entities representing the instructions to be executed can be unrestricted. The inputs, outputs, and entities can be composed of any structure or value and / or transitional model. The architecture can start from any transitional stage and continue processing and integrating until completion.

[0094] (One or more) state modules 118 may be configured to execute instructions to organize, store, and manage state data, values, and data structures. For example, the architecture may incorporate one state module 118 for one or more states. The state module 118 may incorporate interfaces to retrieve data or instructions and execute instruction statements to further manipulate the data or instructions. Additionally, the state module 118 may perform create / read / update / delete operations on its state and apply data models (such as immutable or mutable data design models). Each state operation may be assigned to a specific type and / or value and associated with instructions to be executed when one or more specific types occur to output one or more versions of (one or more) states as required by the implemented model. The state and its versions may be integrated and / or result in one or more states. Instructions may include previous states to perform their operations or integrate them into the output. State operations may be incorporated within iterative or recursive processes and / or event and / or queue models. The state architecture may expose interfaces to other modules, architectures, networked architectures, or computer systems to manipulate its state, operations, and / or collaborate in operations on the state. The state architecture may allow other parts of the overall architecture to perform create / read / update / delete operations and track changes. The state module may transmit state, data, or information related to state changes. The state module may be configured to expose state data, structures, and retrieval interfaces from which modules independently access the state. (One or more) state modules 118 and their data and interfaces may also be received as input by other modules and / or be configured as (one or more) upper modules from which to collect data.

[0095] The state module 118 may run enhanced instructions to optimize its state, thereby preventing data duplication, out-of-order data, or expired data. For example, relevant data may be searched for and added only if not found. The overwrite operation will succeed only if the supposed new data is not expired, or the delete operation will perform deletion only if the data is found. The read operation may be allowed to directly replace data. The create, update, or any other operation may be configured to create a holding structure and / or upper structure for the data to be created and / or updated. For example, if relevant data is not found, the operation may be converted into another type of operation, such as, for example, an update operation converted into a create operation.

[0096] The status module 118 can incorporate a structure for recording executed data operations and instructions for deleting unnecessary records. Delete operations can be tracked and associated with corresponding creation operations to ensure a specific order of execution. Read operations can track all create / read / update / delete operations performed on their data and determine whether the information collected is duplicate, obsolete, or to be deleted compared to the data stored and / or previously received data. Additionally, read operations can employ an iterative or recursive process to determine the relevance of each entity constituting the data or compare the data with data already stored or with architectural or received instructions.

[0097] The status module 118 and / or other architectures and / or associated modules can also be configured to additionally improve performance to integrate a dynamic networking interface for create / read / update / delete operations. The networked status module 118 can establish a permanent connection with a computer system that conducts an art competition and / or performs operations to enable an art competition. The permanent data collection architecture allows the status module 118 to optimize its operations. The networked status module 118 can receive data when it becomes available from the computer system without performing further or continuous retrieval operations. The networked status module 118 can receive the operation type and the data to be processed and execute instructions regarding the status. Additionally, the status module 118 can also receive instructions for performing retrieval operations, for example, statistical data including the number of comments created by voters.

[0098] The status module 118 receives instructions from the art competition system 115 to retrieve, for example, the number of comments created, from the permanent data collection architecture and / or the networked interface. Based on the permanent data collection architecture instructions and / or the collection instructions of the networked interface, the status module 118 can accurately perform retrieval operations on the data that the status module 118 is specifically instructed to process at that time.

[0099] The networked status module 118, configured to receive create / read / update / delete operation commands and related data and receive instructions for retrieval, can execute models dynamically and independently, resulting in performance improvement. For example, a specific status module 118 can receive specific instructions or operation commands to execute different operation models, or the status module 118 can receive new specific instructions to apply to status data processed in different ways until the new instructions are executed.

[0100] The term "visualize" or "show" does not limit the description to a specific interface connection unit, but rather means a reference to any interface connection unit that can be perceived in any way and can be an object of cognitive function. The listing of the above entities, data structures, and other definitions is for illustrative purposes only and is not meant to be limiting. In fact, for example, any other constructs such as functions, classes, objects, and bit masks can also be included. Any architecture can be implemented for any module that can be used to conduct a competition involving artworks.

[0101] Next, referring to Figure 2 , a flowchart is shown that provides an example of the operation of a portion of the generator module 121 according to various embodiments. It should be understood that Figure 2 the flowchart only provides an example of many different types of functional arrangements that can be used to implement the operation of a portion of the generator module 121 as described herein. As an alternative, Figure 2 the flowchart can be considered as depicting an example of the elements of a method implemented in a computing environment 103 ( Figure 1 ).

[0102] Starting from block 203, the generator module 121 receives data to be used in generating the element representation 148. In block 206, the generator module 121 evaluates one or more instructions for generating the element representation 148. In block 209, the generator module 121 generates the element representation 148 based at least in part on a specific state change operation. The generator module 121 is configured to generate a single element representation 148 after combining multiple state change operations into a specific state change operation. In other scenarios, even if the state does not change, the generator module 121 can generate the element representation 148. For example, at the start of a session after logging in, the generator module 121 can generate the element representation 148 without a state change and without combining multiple state change operations. Alternatively, the generator module 121 can generate the element representation 148 when the state is not associated with the element representation 148. In block 212, the generator module 121 combines multiple state change operations into a specific state change operation. Thereafter, the operation of the portion of the generator module 121 ends.

[0103] Next, referring to Figure 3 , a flowchart is shown that provides an example of the operation of a portion of the planner module 127 according to various embodiments. It should be understood that Figure 3 the flowchart only provides an example of many different types of functional arrangements that can be used to implement the operation of a portion of the planner module 127 as described herein. Alternatively, Figure 3The flowchart can be regarded as an example depicting the elements of a method implemented in a computing environment 103 ( Figure 1 ) according to one or more embodiments.

[0104] Starting from block 303, the planner module 127 receives an element representation from the generator module 121. In block 306, the planner module 127 assigns an identifier, such as a unique identifier, to the element representation 148. For example, the planner module 127 can assign an identifier to the element representation 148 to sort the element representation 148 with previous element representations 148. In another example, the planner module 127 can use another identifier to insert the element representation 148 into the queue system 133. In block 309, the planner module 127 sorts the element representation 148 at least in part based on the identifier assigned to the element representation 148. In block 312, the planner module 127 assigns a priority value to the element representation 148. In block 315, the planner module 127 generates a plan for the interface connection unit at least in part based on the element representation 148. In block 318, the planner module 127 receives events via the system, such as user interactivity events, expiration events, notification events that change the generated interface connection unit, and / or any other type of event. For example, assume that a user is participating in an art competition and the competition expires. The system can be configured to close the current interface connection unit and generate a new interface connection unit to take the user back to a previous location. In block 321, the planner module 127 dynamically deletes the current plan in response to the event. In block 324, the planner module 127 generates a different plan for the interface connection unit in response to the event. Thereafter, the operation of the said part of the planner module 127 ends.

[0105] Referring Figure 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, for example, having a processor 403 and a memory 406, both coupled to a local interface 409. To this end, each computing device 400 can include, for example, at least one server computer or similar device. The local interface 409 can include, for example, a data bus, accompanied by an address / control bus or other bus structures as may be recognized.

[0106] Both data and several components executable by the processor 403 are stored in the memory 406. In particular, stored in and executable by the processor 403 in the memory 406 are: the art competition system 115, one or more status 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, and potentially other applications. A data repository 112 and other data may also be stored in the memory 406. In addition, an operating system may be stored in the memory 406 and executable by the processor 403.

[0107] It can be understood that there may also be other applications stored in the memory 406 and executable by the processor 403, as can be recognized. When any of the components discussed herein are implemented in software form, any of a variety of programming languages may be used, such as, for example, C, C++, C#, Objective C, Perl, PHP, Visual Ruby, or other programming languages.

[0108] Multiple software components are stored in the memory 406 and executable by the processor 403. In this regard, the term "executable" means a program file in a form that can ultimately be run by the processor 403. Examples of executable programs can be, for example, a compiled program that can be translated into machine code, the format of which can be loaded into the random access portion of the memory 406 and run by the processor 403; source code expressed in an appropriate format, such as object code capable of being loaded into the random access portion of the memory 406 and executed by the processor 403; or source code that can be interpreted by another executable program to generate instructions in the random access portion of the memory 406 for execution by the processor 403, and so on. The executable program can be stored in any part or component of the memory 406, including, for example, random access memory (RAM), read-only memory (ROM), hard disk drive, solid state drive, USB flash drive, memory card, optical disc (such as compact disc (CD) or digital versatile disc (DVD)), floppy disk, magnetic tape, or other memory components.

[0109] This document defines the memory 406 as including both volatile and non-volatile memories as well as data storage components. A volatile component is one that does not retain a data value after power is removed. A non-volatile component is one that retains data after power is removed. Thus, the memory 406 can include, for example, random access memory (RAM), read-only memory (ROM), hard disk drives, solid state drives, USB flash drives, memory cards accessed via a memory card reader, floppy disks accessed via an associated floppy disk drive, optical discs accessed via an optical disc drive, magnetic tapes accessed via a suitable tape drive, and / or other memory components, or a combination of any two or more of these memory components. Additionally, RAM can include, for example, static random access memory (SRAM), dynamic random access memory (DRAM), or magnetic random access memory (MRAM) and other such devices. ROM can include, 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.

[0110] In addition, the processor 403 can represent multiple processors 403 and / or multiple processor cores, and the memory 406 can represent multiple memories 406 operating in parallel processing circuits. In such a case, the local interface 409 can be a suitable network that facilitates communication between any two of the multiple processors 403, between any processor 403 and any memory 406, or between any two memories 406, etc. The local interface 409 can include additional systems designed to coordinate such communication, including, for example, performing load balancing. The processor 403 can be electrical or some other available configuration.

[0111] Although the art competition system 115, status module 118, generator module 121, element representation module 124, planner module 127, representation module 130, queue system 133, and other various systems described herein can be implemented in software or code executed by general-purpose hardware as discussed above, as an alternative, they can also be implemented in dedicated hardware or a combination of software / general-purpose hardware and dedicated hardware. If implemented in dedicated hardware, each can be realized as a circuit or state machine employing any one or a combination of a variety of techniques. These techniques can include, but are not limited to: discrete logic circuits having logic gates for implementing various logic functions when one or more data signals are applied, application-specific integrated circuits (ASICs) having appropriate logic gates, field-programmable gate arrays (FPGAs), or other components, etc. Such techniques are generally well known to those skilled in the art and are not described in detail herein.

[0112] Figure 2 and Figure 3The flowchart illustrates the functionality and operation of an implementation of portions of the generator module 121 and the planner module 127. If implemented in software, each block can represent a module, a segment of code, or a portion of code that includes program instructions for implementing the specified logical function(s). The program instructions can be implemented in the form of source code that includes human-readable statements written in a programming language, or in the form of machine code that includes digital instructions recognizable by a suitable execution system, such as a processor 403 in a computer system or other system. The machine code can be converted from the source code, and so on. If implemented in hardware, each block can represent a circuit or multiple interconnected circuits for implementing the specified logical function(s).

[0113] Although Figure 2 and Figure 3 the flowchart illustrates a particular order of execution, it is understood that the order of execution can be different from the order depicted. For example, the order of execution of two or more blocks can be scrambled relative to the order shown. Additionally, Figure 2 and Figure 3 two or more blocks shown successively in Figure 2 and Figure 3 can be executed concurrently or partially concurrently. Further, in some embodiments, one or more of the blocks shown in Figure 2 and Figure 3 can be skipped or omitted. Additionally, for purposes of enhanced utility, accounting, performance measurement, or providing troubleshooting assistance, etc., any number of counters, status variables, warning semaphores, or messages can be added to the logical flow described herein. It should be understood that all such variations are within the scope of the present disclosure.

[0114] Furthermore, any logic or application described herein that includes software or code, including the art competition system 115, the status module 118, the generator module 121, the element representation module 124, the planner module 127, the representation module 130, and the queue system 133, can be implemented in any non-transitory computer-readable medium for use by or in conjunction with an instruction execution system, such as a processor 403 in a computer system or other system. In this sense, the logic can include, for example, statements that include instructions and declarations that can be retrieved from the computer-readable medium and executed by the instruction execution system. In the context of the present disclosure, a "computer-readable medium" can be any medium that can contain, store, or maintain the logic or application described herein for use by or in conjunction with an instruction execution system.

[0115] A computer-readable medium can include any of a variety of physical media, such as, for example, magnetic, optical, or semiconductor media. More specific examples of suitable computer-readable media will include, but are not limited to, magnetic tape, magnetic floppy disk, magnetic hard disk drive, memory card, solid state drive, USB flash drive, or optical disc. Additionally, a computer-readable medium can be random access memory (RAM), including, for example, static random access memory (SRAM) and dynamic random access memory (DRAM), or magnetic random access memory (MRAM). Further, a computer-readable medium can 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.

[0116] Additionally, any logic or application described herein, including the art competition system 115, status module 118, generator module 121, element representation module 124, planner module 127, representation module 130, and queue system 133, can be implemented and structured in various ways. For example, one or more of the described applications can be implemented as modules or components of a single application. Additionally, one or more of the applications described herein can be executed in shared or separate computing devices or combinations thereof. For example, multiple applications described herein can be executed in the same computing device 400, or can be executed in multiple computing devices 400 within the same computing environment 103.

[0117] Unless otherwise expressly stated, disjunctive language such as the phrase “at least one of X, Y, or Z” should be understood in context to generally mean that an item, term, etc. can be either X, or Y, or Z, or any combination thereof (e.g., X, Y, and / or Z). Thus, such disjunctive language is generally not intended and should not be construed to imply that certain embodiments require the presence of at least one of each of X, at least one of Y, or at least one of Z.

[0118] It should be emphasized that the above embodiments of the present disclosure are merely possible examples of implementations set forth for the purpose of clearly understanding the principles of the present disclosure. Many variations and modifications can be made to the above (one or more) embodiments without materially 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. A system, comprising: At least one computing device; A generator module executable in the at least one computing device, wherein when executed, the generator module causes the at least one computing device to at least: Receive data to be used in generating an element representation; Evaluate instructions for the element representation; And Generate the element representation; And A planner module executable in the at least one computing device, wherein when executed, the planner module causes the at least one computing device to at least: Receive the element representation from the generator module; and Generate a plan for an interface connection unit.

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

3. The system according to claim 1, wherein the planner module is further configured to at least: Assign a first identifier to the element representation to sort the element representation relative to at least one previous element representation; Sort the element representation in a queue system including one or more queues at least partially based on the first identifier or a second identifier; Assign a priority value to the element representation; and Wherein the plan for the interface connection unit is generated at least partially based on the element representation.

4. The system according to claim 1, wherein one or more modules can be configured using a high-performance computing architecture for an art competition.

5. The system according to claim 1, wherein the planner module is further configured to at least: Receive an event; Dynamically delete the currently generated plan in response to the event; and Generate a different plan for the interface connection unit in response to the event.

6. The system according to claim 1, wherein the planner module is further configured to split a specific operation into multiple operations.

7. The system according to claim 1, further comprising a state module executable in the at least one computing device, wherein when executed, the state module causes the at least one computing device to at least: Manage one or more states; Perform at least one of the following on the one or more states: create operation, read operation, update operation, or delete operation; and Expose one or more interfaces for interacting with the one or more states.

8. The system according to claim 7, wherein the state module is further configured to at least maintain a permanent network connection with an art competition system.

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

10. The system according to claim 1, wherein the element representation further includes an element representation module executable in the at least one computing device, wherein when executed, the element representation module causes the at least one computing device to at least: Generate one or more interface connection unit elements at least partially based on at least one of the following: an instruction set or one or more data structures.

11. The system according to claim 1, further comprising a representation module executable in the at least one computing device, wherein when executed, the representation module causes the at least one computing device to at least: Receive a plan for the interface connection unit from the planner module; and Generate an interface connection unit based at least in part on the plan for the interface connection unit.

12. A computer-implemented method, comprising: Receiving, by a generator module, data to be used in generating an element representation; Evaluating, by the generator module, instructions for generating the element representation; Generating, by the generator module, an element representation; Receiving, by the planner module, the element representation from the generator module; and Generating, by the planner module, a plan for the interface connection unit.

13. The computer-implemented method according to claim 12, 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 combining a plurality of state change operations into the specific state change operation.

14. The computer-implemented method according to claim 12, further comprising: Assigning, by the planner module, a first identifier to the element representation to sort the element representation relative to at least one previous element representation; Sorting, by the planner module, the element representation in a queue system including one or more queues based at least in part on the first identifier or a second identifier; Assigning, by the planner module, a priority value to the element representation; and wherein the plan for the interface connection unit is generated based at least in part on the element representation.

15. The computer-implemented method according to claim 12, further comprising facilitating an art competition by one or more modules using a high-performance computing architecture.

16. The computer-implemented method according to claim 12, further comprising: Receiving, by the planner module, an event; Dynamically deleting, by the planner module, a currently generated plan in response to the event; and Generating, by the planner module, a different plan for the interface connection unit in response to the event.

17. The computer-implemented method according to claim 12, further comprising splitting, by the planner module, a specific operation into a plurality of operations.

18. The computer-implemented method according to claim 12, further comprising: Managing, by a state module, one or more states; Performing, by the state module, at least one of the following on the one or more states: create operation, read operation, update operation, or delete operation; and Exposing, by the state module, one or more interfaces for interacting with the one or more states.

19. A non-transitory computer-readable medium, the non-transitory computer-readable medium implementing at least one program executable in at least one computing device, wherein when the at least one program is executed, it causes the at least one computing device to at least: Receive data to be used in generating an element representation; Evaluate instructions for generating the element representation; Generate an element representation; and Generate a plan for the interface connection unit.

20. The non-transitory computer-readable medium according to claim 19, wherein when the at least one program is executed, it further causes the at least one computing device to at least: Receive an event; Dynamically delete the currently generated plan in response to the event; and Generate a different plan for the interface connection unit in response to the event.

Images