Branch Versioning for Process Management
Business process structures and modifications thereto in one or more branches may be reflected in database entries that include a key identifying the node and branch and one or more attributes associated with the node. Various embodiments provide systems, methods, and machine-readable media that facilitate updating the database entries to create a modified branch version of a business process structure, merge the branch version into a parent branch thereof, resolve conflicts between different versions of the business process structure, and/or reconstruct the business process structure within a selected branch context.
This document relates generally to the software-assisted process management, and more particularly to managing multiple versions of a process and process-related data.
BACKGROUNDLarge businesses usually operate in accordance with well-defined business processes. A business process generally corresponds to a particular task to be performed in certain business situations, or “scenarios,” such as when a customer places an order, when supplies for the next month are ordered, or when financial data are gathered and aggregated at the end of a quarter to evaluate the financial performance of the business, to list but a few examples. Under a given scenario, multiple business processes may arise, and each process may, in turn, consist of multiple steps to be carried out in a specified sequence. For example, the process of processing a customer order may involve receiving a purchase request, checking availability of the desired item, informing the customer of an anticipated delivery date if the item is in stock, or of the anticipated date on which the item will be available again if it is on backorder, obtaining the customer's payment information, verifying the payment information, and finally releasing the order to the business's shipping department.
Businesses can implement many of their business processes with the help of existing software packages, such as customer relationship management software, enterprise resource planning software, etc. In addition, platforms and tools are available that help businesses define business processes and integrate the individual software programs, resources, etc. accordingly. The programmatically defined business processes can be modified to reflect any changes made, or anticipated to be made, to the underlying actual business processes. Sometimes, multiple versions of the same business process exist. For example, an active “productive version” of the business process may specify how business is done currently, while a passive “development version” of the process may implement an updated business process that undergoes testing in a restricted, controlled setting prior to business-wide real-world deployment. If changes to the same process are made in parallel in two different versions, conflicts can arise. Anticipating and avoiding such conflicts, or managing them after they have occurred, generally entails a lot of overhead, and has in the past imposed significant limits on the practicable size of business processes. For example, the operations of a large and complex business may heretofore have been defined separately for each business unit, and connections between the business processes of the individual units may have been established and maintained manually.
The present disclosure illustrates embodiments of the inventive subject matter by way of example and not limitation, and with reference to the following drawings:
The description that follows includes systems, methods, techniques, instruction sequences, and computing machine program products that embody illustrative embodiments of the disclosure. For the purposes of explanation, numerous specific details are set forth in order to provide an understanding of various embodiments of the inventive subject matter. It will be evident, however, to those skilled in the art, that embodiments of the inventive subject matter may be practiced without these specific details. In general, well-known instruction instances, protocols, structures, and techniques have not been shown in detail.
The embodiments disclosed herein implement a versioning mechanism for business processes that keeps track of changes made in parallel to multiple versions of the same process, allowing the multiple versions to be developed independently while facilitating their eventual merging into a single productive version. In some embodiments, version-specific data for a business process contains only “delta information” reflecting the modifications made relative to a parent version from which it is derived, rather than a complete definition of the entire modified business process structure. Thus, only a small amount of duplicative data is physically stored, reducing overall memory requirements associated with maintaining multiple process versions. Various embodiments not only reduce user efforts by streamlining version management and integration, but also provide users with a convenient means to obtain an overview of the versions under development and make comparisons therebetween, e.g., for prophylactic use in spotting any compatibility issues or inconsistencies.
In embodiments, business processes may be organized in a process hierarchy that manages different levels—e.g., scenario, process, and process step—in a tree structure. While three levels are used herein for purposes of illustration, different numbers and types of levels may generally be used. The levels that are available for the definition of business-process structures may themselves be defined (e.g., by the user, a system designer, or a system administrator) in a process model.
In some embodiments, the tree structure itself is stored, in computer memory, as a data structure that specifies only the IDs of all the nodes and their hierarchical relations. The data structure may, for instance, take the form of a table using the node ID as the key and the parent node ID as the attribute. To store multiple versions of a node, the key may be extended as illustrated below with respect to
Node attributes may include, for example, a name of the node (e.g., “Process 1” or “Process Step 2a”), a node type (e.g., scenario, process, or process step), type-specific attributes (e.g., a “process” node may have a Boolean attribute indicating whether it is a core process or not, and/or an availability attribute indicating during which hours of the days and days of the week the process is available; and a “process step” node may have a task-type attribute indicating whether the task is a service task, user task, manual task, script task, etc.), a node priority (e.g., critical, high, medium, low), or the owner of the node (e.g., the name of the person who is responsible for a business process, or of the person who created the node or who last modified the node. Objects associated with a node may include documents (e.g., policies and instructions to be followed in carrying out a particular process or process step, forms to be used, etc.), software applications or screens used in the performance of the process or process step, business objects (e.g., data structures maintained for a business unit, employee, customer, supplier, etc. involved with the process, a budget or other resource allocated thereto, and so on), or links to the foregoing. For purposes of this disclosure, it is not important to strictly distinguish between attributes and objects; accordingly, these terms are hereinafter used synonymously.
Of course, business processes and hierarchies may be, and typically are, much more extensive and complex than the example depicted in
In the illustrated embodiment, the system 200 includes a version manager 220 with read and write access to the data structure 210. The version manager 220 may modify the data structure 210, e.g., based on user input, to reflect changes made thereto in a particular version. The user input may be received via a user interface provided by a process editor 222. In some embodiments, the process editor 222 allows a user to define the structure of a business process graphically, e.g., by dragging node symbols onto a drawing canvas and drawing connections therebetween to create a tree structure. Alternatively or additionally, the process editor 222 may provide text input fields for defining the nodes and associated data. In some embodiments, the business process structure is subject to certain constraints and limitations, such as a maximum number of hierarchy levels. These constraints may be stored in the form of a process model 224 and enforced by the process editor 222. The version manager 220 may also reconstruct a specified (e.g., user-selected) version of the business process based on the data structure(s) 210; the reconstruction process is explained in detail further below. The reconstructed process may be visualized by the process editor 222, e.g., in the form of a tree structure. The process editor 222 may display two or more versions of the business process side by side, thereby facilitating convenient comparisons between versions by the user.
The system 200 may also include an execution module 226 that can execute any version of the business process, e.g., the current productive version or, for test purposes, a development version. Execution of a business process version may involve traversing the process structure and accessing resources, such as data 230 or software applications 232, 234 associated with the nodes of the structure. The execution module 226 may communicate with the version manager 220 to receive information about the reconstructed process structure for the particular version. Further, the system 200 may include a deployment module 228 that manages the activation of a modified business process version. The deployment module 228 may be responsible for resolving any conflicts (e.g., arising from the at least partially parallel modification of the current modified version and a previously deployed modified version), as well as for updating the data structure 210, directly or via the version manager 220, to turn the modified version into the new productive version. The functionality of the system 200 will be more readily understood from the following illustration and description of various embodiments.
In some embodiments, different versions of a process structure are stored in the form of “branches” that contain only changes relative to the respective parent branch, rather than copies of the entire process tree structure.
In some embodiments, a branch, including the root branch, can exist in two different contexts: active and inactive. These contexts arise when a branch (e.g., root branch 302) is enabled for inactive handling, which means that the active version (i.e., the currently deployed version; e.g., root branch 302) is locked and cannot be changed directly, while the inactive version (e.g., branch 304) provides the changeable working version. The inactive version (e.g., branch 304) is an implicit child branch of the active version (e.g., root branch 302), and it is possible to treat inactive versions just like any other branch version. In some application scenarios, however, it is beneficial to distinguish branches that reflect changes expected to be deployed in the short term from branches that are used for long-term development. For example, when a business process is originally implemented, errors and deficiencies may be revealed that should be corrected as soon as possible; changes designed to fix these errors and deficiencies may be stored in the inactive version of the branch. At the same time, the business process may already be undergoing development directed towards long-term improvements and extensions. Changes related to such long-term development may be stored in regular child branches (such as branches 306, 308). The expectation is that the inactive version of a parent branch will be deployed before any of the child branches. Rules may specify how the child branches are to be updated following deployment (or activation) of the inactive parent version, i.e., the merging of the changes of the inactive parent version into the active parent version.
In general, a change made in a child branch is not immediately visible in its parent branch. Whether a change made in a parent branch is immediately visible in its child branch, on the other hand, may depend on the usage scenario. In some use cases, e.g., if a correction has been made to a parent branch, it may be beneficial to render the change immediately visible in the child branch. In other use cases, e.g., if a child branch represents a separately installed productive version, it may be preferable to hide the changes made to the parent branch in the child branch. Branches may be classified based on the rules according to which changes made in the parent branch are propagated to the child branch (e.g., rules specifying which changes are immediately visible in the child branch and which support is available to merge any conflicting changes). In some embodiments, three “isolation levels” are defined:
-
- In level 0 (the “dirty” isolation level), changes of the parent branch and the child branches are uncontrolled, meaning that any non-conflicting changes made to the parent branch are immediately visible in the child branch and that any conflicting changes made to the parent branch are handled using a two-way compare-and-adjust process (explained further below).
- In level 1 (the “conflicts” isolation level), non-conflicting changes made to the parent branch are immediately visible in the child branch, whereas conflicting changes are isolated and may be handled using a three-way compare-and-adjust process (also explained further below).
- In level 2 (the “strict” isolation level), the child branch is completely isolated from its parent branch, which means that none of the changes made to the parent branch are immediately visible in the child branch. Conflicting changes in the parent branch may be handled (at a later time) using a three-way compare-and-adjust process.
In the example branch tree of
With renewed reference to the example business-process structure depicted in
The data associated with the above-described business-process structure in its four versions—active trunk 302, inactive trunk (i.e., branch 304), branch B1 306, and branch B2 308—may be stored in a single database; the table depicted in
From a database such as, for instance, that depicted in
A modified version of a process structure may, at some point, be deployed, or “merged” into the active version. For example, the inactive context of a branch may serve as a working environment in which short-term corrections can be made initially without touching the productive version, i.e., the active context, but to implement the corrections in the real world, the changes made in the inactive context are eventually brought back to the active context—in other words, the inactive version is “activated.” Since the active context is frozen and no conflicts can arise, this can be accomplished simply by turning the previously inactive version into the active version; for the example inactive version shown in
In situations where changes to a process structure are made in parallel in multiple branches (including inactive versions of a branch) that are, thereafter, deployed sequentially, such deployment is generally more complex, as changes made in a later-deployed branch may have been recorded relative to an outdated parent version, i.e., the parent version as it existed prior to activation of an earlier-deployed modified branch. To avoid inconsistencies between multiple modified versions at the time of deployment, changes made in the active parent branch context, e.g., by virtue of the activation of an inactive context, may be propagated to the child branches. The manner in which this propagation is effected depends generally on the isolation level of the child branch, and is illustrated in
The parent branch base versions that are stored in child branches at the time a change is made to the parent may be used to resolve all isolated conflicts when the child branch is eventually deployed, i.e., merged with the parent. In preparation for deployment of a child branch, all nodes with conflicting changes may be identified. The IDs of conflicting nodes may be determined simply by selecting all IDs for which a parent branch base version exists in the branch. Since this process does not involve any content comparisons, it may execute very fast. In the above-illustrated example of branch B1, the only conflicting node is the one with ID 103.
Once a conflicting node has been identified, the conflict may be resolved by a comparison between the different, conflicting versions for that node and the adjustment of the node based thereon. The conflicting versions may include the parent branch version (i.e., the effective version of the parent branch), the parent branch base version (i.e., the version stored in the child branch with key (node ID, branch ID, B)), and the effective branch version (i.e., the version stored in the child branch with key (node ID, branch ID, A or I). For example, as illustrated in
In some embodiments, the compare-and-adjust process involves manual input, i.e., a human-made decision as to the preferable node version. In alternative embodiments, conflict resolution for nodes may be accomplished automatically, e.g., based on a set of rules implemented by a rules engine. For example, a selection may be made based on the date on which a change was made (e.g., such that a change made in a child branch trumps a change made in the parent if and only if the change in the child branch was made after the change in the parent took effect, i.e., after the parent branch base version was stored in the child branch), the privilege level of the user who made the change, the priority level of a project associated with the branch, other criteria, and/or combinations thereof.
As explained previously, in strictly isolated branches (e.g., branch B2), all changes made to the parent (not only the conflicting ones) are “hidden,” i.e., stored as parent branch base versions in the child branch. The deployment of a strictly isolated branch may, therefore, involve a compare-and-adjust process for all of the nodes for which parent branch base versions exist. Conflicts may be resolved by a three-way compare-and-adjust process as described above with respect to
Certain embodiments are described herein as including logic or a number of components, modules, or mechanisms. Modules may constitute either software modules (e.g., code embodied on a machine-readable medium or in a transmission signal) or hardware modules. A “hardware module” is a tangible unit capable of performing certain operations and may be configured or arranged in a certain physical manner. In various example embodiments, one or more computer systems (e.g., a standalone computer system, a client computer system, or a server computer system) or one or more hardware modules of a computer system (e.g., a processor or a group of processors) may be configured by software (e.g., an application or application portion) as a hardware module that operates to perform certain operations as described herein.
In some embodiments, a hardware module may be implemented mechanically, electronically, or with any suitable combination thereof. For example, a hardware module may include dedicated circuitry or logic that is permanently configured to perform certain operations. For example, a hardware module may be a special-purpose processor, such as a field-programmable gate array (FPGA) or an Application Specific Integrated Circuit (ASIC). A hardware module may also include programmable logic or circuitry that is temporarily configured by software to perform certain operations. For example, a hardware module may include software encompassed within a general-purpose processor or other programmable processor. It will be appreciated that the decision to implement a hardware module mechanically, in dedicated and permanently configured circuitry, or in temporarily configured circuitry (e.g., configured by software) may be driven by cost and time considerations.
Accordingly, the phrase “hardware module” should be understood to encompass a tangible entity, be that an entity that is physically constructed, permanently configured (e.g., hardwired), or temporarily configured (e.g., programmed) to operate in a certain manner or to perform certain operations described herein. As used herein, “hardware-implemented module” refers to a hardware module. Considering embodiments in which hardware modules are temporarily configured (e.g., programmed), each of the hardware modules need not be configured or instantiated at any one instance in time. For example, where a hardware module comprises a general-purpose processor configured by software to become a special-purpose processor, the general-purpose processor may be configured as respectively different special-purpose processors (e.g., comprising different hardware modules) at different times. Software may accordingly configure a particular processor or processors, for example, to constitute a particular hardware module at one instance of time and to constitute a different hardware module at a different instance of time.
Hardware modules can provide information to, and receive information from, other hardware modules. Accordingly, the described hardware modules may be regarded as being communicatively coupled. Where multiple hardware modules exist contemporaneously, communications may be achieved through signal transmission (e.g., over appropriate circuits and buses) between or among two or more of the hardware modules. In embodiments in which multiple hardware modules are configured or instantiated at different times, communications between such hardware modules may be achieved, for example, through the storage and retrieval of information in memory structures to which the multiple hardware modules have access. For example, one hardware module may perform an operation and store the output of that operation in a memory device to which it is communicatively coupled. A further hardware module may then, at a later time, access the memory device to retrieve and process the stored output. Hardware modules may also initiate communications with input or output devices, and can operate on a resource (e.g., a collection of information).
The various operations of example methods described herein may be performed, at least partially, by one or more processors that are temporarily configured (e.g., by software) or permanently configured to perform the relevant operations. Whether temporarily or permanently configured, such processors may constitute processor-implemented modules that operate to perform one or more operations or functions described herein. As used herein, “processor-implemented module” refers to a hardware module implemented using one or more processors.
Similarly, the methods described herein may be at least partially processor-implemented, with a particular processor or processors being an example of hardware. For example, at least some of the operations of a method may be performed by one or more processors or processor-implemented modules. Moreover, the one or more processors may also operate to support performance of the relevant operations in a “cloud computing” environment or as a “software as a service” (SaaS). For example, at least some of the operations may be performed by a group of computers (as examples of machines including processors), with these operations being accessible via a network (e.g., the Internet) and via one or more appropriate interfaces (e.g., an application program interface (API)).
The performance of certain of the operations may be distributed among the processors, not only residing within a single machine, but deployed across a number of machines. In some example embodiments, the processors or processor-implemented modules may be located in a single geographic location (e.g., within a home environment, an office environment, or a server farm). In other example embodiments, the processors or processor-implemented modules may be distributed across a number of geographic locations.
Software ArchitectureThe operating system 1402 may manage hardware resources and provide common services. The operating system 1402 may include, for example, a kernel 1420, services 1422, and drivers 1424. The kernel 1420 may act as an abstraction layer between the hardware and the other software layers. For example, the kernel 1420 may be responsible for memory management, processor management (e.g., scheduling), component management, networking, security settings, and so on. The services 1422 may provide other common services for the other software layers. The drivers 1424 may be responsible for controlling and/or interfacing with the underlying hardware. For instance, the drivers 1424 may include display drivers, camera drivers, Bluetooth® drivers, flash memory drivers, serial communication drivers (e.g., Universal Serial Bus (USB) drivers), Wi-Fi® drivers, audio drivers, power management drivers, and so forth.
The libraries 1404 may provide a low-level common infrastructure that may be utilized by the applications 1408. The libraries 1404 may include system libraries 1430 (e.g., C standard library) that may provide functions such as memory allocation functions, string manipulation functions, mathematic functions, and the like. In addition, the libraries 1404 may include API libraries 1432 such as media libraries (e.g., libraries to support presentation and manipulation of various media format such as MPEG4, H.264, MP3, AAC, AMR, JPG, PNG), graphics libraries (e.g., an OpenGL framework that may be used to render 2D and 3D graphic content on a display), database libraries (e.g., SQLite that may provide various relational database functions), web libraries (e.g., WebKit that may provide web browsing functionality), and the like. The libraries 1404 may also include a wide variety of other libraries 1434 to provide many other APIs to the applications 1408.
The frameworks 1406 may provide a high-level common infrastructure that may be utilized by the applications 1408. For example, the frameworks 1406 may provide various graphic user interface (GUI) functions, high-level resource management, high-level location services, and so forth. The frameworks 1406 may provide a broad spectrum of other APIs that may be utilized by the applications 1408, some of which may be specific to a particular operating system or platform.
The applications 1408 may include a home application 1450, a contacts application 1452, a browser application 1454, a book reader application 1456, a location application 1458, a media application 1460, a messaging application 1462, a game application 1464, and a broad assortment of other applications such as a third-party application 1466. In a specific example, the third-party application 1466 (e.g., an application developed using the Android™ or iOS™ software development kit (SDK) by an entity other than the vendor of the particular platform) may be mobile software running on a mobile operating system such as iOS™, Android™, Windows® Phone, or other mobile operating systems. In this example, the third-party application 1466 may invoke the API calls 1410 provided by the operating system to facilitate functionality described herein.
Example Machine Architecture and Machine-Readable MediumThe machine 1500 may include processors 1510, memory 1530, and I/O components 1550, which may be configured to communicate with each other via a bus 1505. In an example embodiment, the processors 1510 (e.g., a Central Processing Unit (CPU), a Reduced Instruction Set Computing (RISC) processor, a Complex Instruction Set Computing (CISC) processor, a Graphics Processing Unit (GPU), a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Radio-Frequency Integrated Circuit (RFIC), another processor, or any suitable combination thereof) may include, for example, a processor 1515 and a processor 1520 that may execute the instructions 1525. The term “processor” is intended to include multi-core processor that may comprise two or more independent processors (also referred to as “cores”) that may execute instructions contemporaneously. Although
The memory 1530 may include a main memory 1535, a static memory 1540, and a storage unit 1545 accessible to the processors 1510 via the bus 1505. The storage unit 1545 may include a machine-readable medium 1547 on which are stored the instructions 1525 embodying any one or more of the methodologies or functions described herein. The instructions 1525 may also reside, completely or at least partially, within the main memory 1535, within the static memory 1540, within at least one of the processors 1510 (e.g., within a processor's cache memory), or any suitable combination thereof, during execution thereof by the machine 1500. Accordingly, the main memory 1535, the static memory 1540, and the processors 1510 may be considered machine-readable media 1547.
As used herein, the term “memory” refers to a machine-readable medium 1547 able to store data temporarily or permanently, and may be taken to include, but not be limited to, random-access memory (RAM), read-only memory (ROM), buffer memory, flash memory, and cache memory. While the machine-readable medium 1547 is shown in an example embodiment to be a single medium, the term “machine-readable medium” should be taken to include a single medium or multiple media (e.g., a centralized or distributed database, or associated caches and servers) able to store the instructions 1525. The term “machine-readable medium” shall also be taken to include any medium, or combination of multiple media, that is capable of storing instructions (e.g., instructions 1525) for execution by a machine (e.g., machine 1500), such that the instructions, when executed by one or more processors of the machine 1500 (e.g., processors 1510), cause the machine 1500 to perform any one or more of the methodologies described herein. Accordingly, a “machine-readable medium” refers to a single storage apparatus or device, as well as “cloud-based” storage systems or storage networks that include multiple storage apparatus or devices. The term “machine-readable medium” shall accordingly be taken to include, but not be limited to, one or more data repositories in the form of a solid-state memory (e.g., flash memory), an optical medium, a magnetic medium, other non-volatile memory (e.g., Erasable Programmable Read-Only Memory (EPROM)), or any suitable combination thereof. The term “machine-readable medium” specifically excludes non-statutory signals per se.
The I/O components 1550 may include a wide variety of components to receive input, provide and/or produce output, transmit information, exchange information, capture measurements, and so on. It will be appreciated that the I/O components 1550 may include many other components that are not shown in
In further example embodiments, the I/O components 1550 may include biometric components 1556, motion components 1558, environmental components 1560, and/or position components 1562 among a wide array of other components. For example, the biometric components 1556 may include components to detect expressions (e.g., hand expressions, facial expressions, vocal expressions, body gestures, or eye tracking), measure biosignals (e.g., blood pressure, heart rate, body temperature, perspiration, or brain waves), identify a person (e.g., voice identification, retinal identification, facial identification, fingerprint identification, or electroencephalogram-based identification), and the like. The motion components 1558 may include acceleration sensor components (e.g., accelerometer), gravitation sensor components, rotation sensor components (e.g., gyroscope), and so forth. The environmental components 1560 may include, for example, illumination sensor components (e.g., photometer), temperature sensor components (e.g., one or more thermometers that detect ambient temperature), humidity sensor components, pressure sensor components (e.g., barometer), acoustic sensor components (e.g., one or more microphones that detect background noise), proximity sensor components (e.g., infrared sensors that detect nearby objects), and/or other components that may provide indications, measurements, and/or signals corresponding to a surrounding physical environment. The position components 1562 may include location sensor components (e.g., a Global Position System (GPS) receiver component), altitude sensor components (e.g., altimeters and/or barometers that detect air pressure from which altitude may be derived), orientation sensor components (e.g., magnetometers), and the like.
Communication may be implemented using a wide variety of technologies. The I/O components 1550 may include communication components 1564 operable to couple the machine 1500 to a network 1580 and/or devices 1570 via coupling 1582 and coupling 1572 respectively. For example, the communication components 1564 may include a network interface component or other suitable device to interface with the network 1580. In further examples, communication components 1564 may include wired communication components, wireless communication components, cellular communication components, Near Field Communication (NFC) components, Bluetooth® components (e.g., Bluetooth® Low Energy), Wi-Fi® components, and other communication components to provide communication via other modalities. The devices 1570 may be another machine and/or any of a wide variety of peripheral devices (e.g., a peripheral device coupled via a Universal Serial Bus (USB)).
Moreover, the communication components 1564 may detect identifiers and/or include components operable to detect identifiers. For example, the communication components 1564 may include Radio Frequency Identification (RFID) tag reader components, NFC smart tag detection components, optical reader components (e.g., an optical sensor to detect one-dimensional bar codes such as Universal Product Code (UPC) bar codes, multi-dimensional bar codes such as Quick Response (QR) codes, Aztec codes, Data Matrix, Dataglyph, MaxiCode, PDF417, Ultra Code, UCC RSS-2D bar codes, and other optical codes), acoustic detection components (e.g., microphones to identify tagged audio signals), and so on. In additional, a variety of information may be derived via the communication components 1564, such as location via Internet Protocol (IP) geo-location, location via Wi-Fi® signal triangulation, location via detecting an NFC beacon signal that may indicate a particular location, and so forth.
Transmission MediumIn various example embodiments, one or more portions of the network 1580 may be an ad hoc network, an intranet, an extranet, a virtual private network (VPN), a local area network (LAN), a wireless LAN (WLAN), a wide area network (WAN), a wireless WAN (WWAN), a metropolitan area network (MAN), the Internet, a portion of the Internet, a portion of the Public Switched Telephone Network (PSTN), a plain old telephone service (POTS) network, a cellular telephone network, a wireless network, a Wi-Fi® network, another type of network, or a combination of two or more such networks. For example, the network 1580 or a portion of the network 1580 may include a wireless or cellular network and the coupling 1582 may be a Code Division Multiple Access (CDMA) connection, a Global System for Mobile communications (GSM) connection, or another type of cellular or wireless coupling. In this example, the coupling 1582 may implement any of a variety of types of data transfer technology, such as Single Carrier Radio Transmission Technology (1×RTT), Evolution-Data Optimized (EVDO) technology, General Packet Radio Service (GPRS) technology, Enhanced Data rates for GSM Evolution (EDGE) technology, third Generation Partnership Project (3GPP) including 3G, fourth generation wireless (4G) networks, Universal Mobile Telecommunications System (UMTS), High Speed Packet Access (HSPA), Worldwide Interoperability for Microwave Access (WiMAX), Long Term Evolution (LTE) standard, others defined by various standard-setting organizations, other long range protocols, or other data transfer technology.
The instructions 1525 may be transmitted and/or received over the network 1580 using a transmission medium via a network interface device (e.g., a network interface component included in the communication components 1564) and utilizing any one of a number of well-known transfer protocols (e.g., hypertext transfer protocol (HTTP)). Similarly, the instructions 1525 may be transmitted and/or received using a transmission medium via the coupling 1572 (e.g., a peer-to-peer coupling) to the devices 1570. The term “transmission medium” shall be taken to include any intangible medium that is capable of storing, encoding, or carrying instructions 1525 for execution by the machine 1500, and includes digital or analog communications signals or other intangible media to facilitate communication of such software.
Furthermore, the machine-readable medium 1547 is non-transitory (in other words, not having any transitory signals) in that it does not embody a propagating signal. However, labeling the machine-readable medium 1547 “non-transitory” should not be construed to mean that the medium is incapable of movement; the medium should be considered as being transportable from one physical location to another. Additionally, since the machine-readable medium 1547 is tangible, the medium may be considered to be a machine-readable device.
Term UsageThroughout this specification, plural instances may implement components, operations, or structures described as a single instance. Although individual operations of one or more methods are illustrated and described as separate operations, one or more of the individual operations may be performed concurrently, and nothing requires that the operations be performed in the order illustrated. Structures and functionality presented as separate components in example configurations may be implemented as a combined structure or component. Similarly, structures and functionality presented as a single component may be implemented as separate components. These and other variations, modifications, additions, and improvements fall within the scope of the subject matter herein.
Although an overview of the inventive subject matter has been described with reference to specific example embodiments, various modifications and changes may be made to these embodiments without departing from the broader scope of embodiments of the present disclosure. Such embodiments of the inventive subject matter may be referred to herein, individually or collectively, by the term “invention” merely for convenience and without intending to voluntarily limit the scope of this application to any single disclosure or inventive concept if more than one is, in fact, disclosed.
The embodiments illustrated herein are described in sufficient detail to enable those skilled in the art to practice the teachings disclosed. Other embodiments may be used and derived therefrom, such that structural and logical substitutions and changes may be made without departing from the scope of this disclosure. The Detailed Description, therefore, is not to be taken in a limiting sense, and the scope of various embodiments is defined only by the appended claims, along with the full range of equivalents to which such claims are entitled.
As used herein, the term “or” may be construed in either an inclusive or exclusive sense. Moreover, plural instances may be provided for resources, operations, or structures described herein as a single instance. Additionally, boundaries between various resources, operations, modules, engines, and data stores are somewhat arbitrary, and particular operations are illustrated in a context of specific illustrative configurations. Other allocations of functionality are envisioned and may fall within a scope of various embodiments of the present disclosure. In general, structures and functionality presented as separate resources in the example configurations may be implemented as a combined structure or resource. Similarly, structures and functionality presented as a single resource may be implemented as separate resources. These and other variations, modifications, additions, and improvements fall within the scope of embodiments of the present disclosure as represented by the appended claims. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.
Claims
1. A system comprising:
- a memory storing a database including one or more entries for each node of a business process structure, the one or more entries for each node comprising a trunk entry and, for each branch version in which the node is modified, a branch entry, each trunk entry and each branch entry comprising a key and at least one attribute, the key comprising at least a node identifier and a branch identifier; and
- one or more modules, forming part of one or more hardware processor arrangements, configured to update the database: to reflect modifications to nodes made in one or more branch versions, to resolve conflicts between a branch version and a parent branch version thereof, and to reflect merging of the branch version into its parent branch version.
2. The system of claim 1, wherein the one or more modules are further configured to provide a user interface for receiving user input about relationships between the nodes of the business process structure and the attributes associated therewith.
3. The system of claim 1, wherein the one or more modules are further configured to reconstruct the business process structure for a given branch context based on the database.
4. The system of claim 1, wherein the one or more modules are further configured to execute the business process structure by sequentially accessing resources associated with the nodes in accordance with the business process structure.
5. The system of claim 4, wherein the resources comprise at least one of application programs or data identified in the attributes of the nodes.
6. The system of claim 1, wherein the key for each entry further comprises an indicator of a branch type, the branch type being one of an active, inactive, or parent base type.
7. The system of claim 1, wherein the database comprises, within each branch version, one or more entries only for those nodes that are modified in the branch version relative to the parent branch version thereof.
8. A method comprising:
- defining, in a computer memory, a business process structure comprising a plurality of nodes and hierarchical relations between the nodes;
- storing in the computer memory, for each node of the business process structure, a trunk entry comprising a key and at least one attribute associated with the node, the key comprising a node identifier;
- modifying the business process structure in one or more branch versions by storing in the computer memory, for each of the one or more branch versions, a branch entry for each node modified within the branch version, the branch entry comprising a key and at least one modified attribute associated with the node, the key comprising the node identifier for the modified node and a branch identifier associated with the branch version; and
- using a processor in communication with the computer memory, reconstructing a selected branch version of the business process structure based on the trunk entries and the branch entries for the selected branch version.
9. The method of claim 8, wherein reconstructing the selected branch version of the business process structure comprises identifying, for the selected branch version, an effective version of each node based on the keys of the trunk entries and the branch entries.
10. The method of claim 8, wherein reconstructing the selected branch version of the business process structure comprises executing the selected branch version.
11. The method of claim 8, wherein reconstructing the selected branch version of the business process structure comprises displaying the selected branch version of the business process structure.
12. The method of claim 8, further comprising merging a branch version of the business process structure into a parent version thereof.
13. The method of claim 8, wherein the one or more branch versions comprise first and second child branch versions derived from a parent branch version thereof, the method further comprising merging the first child branch version into the parent branch version, and propagating modifications of the parent branch version resulting from the merging to the second child branch version.
14. The method of claim 13, wherein the parent branch version is a trunk version defined by the trunk entries.
15. The method of claim 13, wherein propagating the modifications comprises storing in the second child branch version, for at least each node modified in both the parent branch version and the second child branch version, a parent base entry reflecting the at least one attribute of the node in the parent branch version prior to the merging.
16. The method of claim 15, wherein propagating the modifications comprises storing in the second child branch version, for each node modified in the parent branch version, a parent base entry reflecting the at least one attribute of the node in the parent branch version prior to the merging.
17. The method of claim 15, further comprising, following merging of the first child branch version into the parent branch version, merging the second child branch version into the parent branch version.
18. The method of claim 17, wherein merging the second child branch version into the parent branch version comprises comparing, for each node modified in both the parent branch version and the second child branch version, an entry in the parent branch version, the branch entry in the second child branch version, and the parent base entry stored in the second child branch version, and adjusting a node attribute based on the comparison.
19. The method of claim 8, wherein modifying the business process structure comprises at least one of adding a node, deleting a node, or modifying an attribute of a node.
20. A non-transitory machine-readable medium storing processor-executable instructions which, when executed by a processor, cause the processor to:
- store, in a memory, one or more entries for each node of a business process structure, the one or more entries for each node comprising a trunk entry and, for each branch version in which the node is modified, a branch entry, each trunk entry and each branch entry comprising a key and at least one attribute, the key comprising at least a node identifier and a branch identifier;
- update the stored entries to reflect modifications to nodes made in one or more branch versions; and
- update the stored entries to reflect merging of a selected branch version into its parent branch version.
Type: Application
Filed: Sep 12, 2014
Publication Date: Mar 17, 2016
Inventor: Wolfgang Herzog (Reilingen)
Application Number: 14/484,579