US20070003347A1 - State machine-driven interactive system and associated methods - Google Patents

State machine-driven interactive system and associated methods Download PDF

Info

Publication number
US20070003347A1
US20070003347A1 US11411997 US41199706A US2007003347A1 US 20070003347 A1 US20070003347 A1 US 20070003347A1 US 11411997 US11411997 US 11411997 US 41199706 A US41199706 A US 41199706A US 2007003347 A1 US2007003347 A1 US 2007003347A1
Authority
US
Grant status
Application
Patent type
Prior art keywords
state
state machine
event
processing
machine controller
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
US11411997
Other versions
US8458336B2 (en )
Inventor
Raphael Manfredi
Pierre Fouche
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
EntIT Software LLC
Original Assignee
Hewlett-Packard Development Co LP
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46Multiprogramming arrangements
    • G06F9/54Interprogram communication
    • G06F9/542Event management; Broadcasting; Multicasting; Notifications
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/451Execution arrangements for user interfaces
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F2209/00Indexing scheme relating to G06F9/00
    • G06F2209/54Indexing scheme relating to G06F9/54
    • G06F2209/545Gui

Abstract

An interactive system, such as a webserver, is described of the type wherein responses to a user are associated with states of a state machine, the responses being generated as a result of a transition into a state associated with the response, the system comprising a state machine controller arranged to change states of the state machine according to the processing of user-initiated events. To provide for handling of concurrent events, the state machine controller is arranged, during processing of a current event, to determine whether the current event was initiated at an earlier time than another event and, if so, (i) restore the state machine to a condition consistent with that immediately prior to processing of the current event, and then (ii) carry out a state transition according the other event.

Description

    BACKGROUND OF THE INVENTION
  • The HTML, or other, code that makes up each web page on the World Wide Web is commonly dynamically generated by an event-driven program that is running on server hardware. This type of program is known as a web application. In the following, the terms “web server” will be used to refer to the logical entity that provides a web page in response to an http request and “web application” to the set of components that provide this function using general-purpose computing platforms within general-purpose operating environments such as are provided by the Microsoft Windows, Linux or HP-UX operating systems and their related programming libraries and tools.
  • Web applications are generally event-driven interactive systems which react to HTTP requests from the client, the http request being directed to a web address (a URL). The web application will generate and return a web page to the browser. The difference between this type of arrangement and a simple “static” site is that each action the user takes can have some semantics associated with it. In other words, the resulting web page can differ according to the user, the current time or other factors prevailing in the system.
  • When the web application receives an event, it is arranged to evaluate the received event and decide how to respond to the client. This evaluation process may involve interaction with business logic of some kind. The interaction with the business logic can take place independently of the screen design or user interface and often involves transactions with back-end systems, such as remote databases.
  • Web servers typically provide for user sessions which enable session data relating to a series of http requests from a single user to be retained on the server. A modern production web server would normally be arranged to conduct a relatively large number of user sessions in parallel.
  • Since multiple http requests can be received at the same time by a web server, the processing of requests by a web server is inherently multi-threaded and, in most modem web servers, each request is normally processed by a separate thread or process, depending on the design.
  • A state machine may be used for controlling a web application. Where a state machine is used to control the web application, each user session will normally have a single state machine instance that will only be affected by http requests pertaining to that session. However some protection of the state machine data for each session must be put in place to avoid concurrency problems due to access by multiple threads processing separate events from the same session, corresponding, for instance, to multiple mouse clicks from a single user. The simplest approach to this is would be to place a lock on the state contexts at the time the state machine starts processing an event. Using this approach, further event processing would then be disabled until processing of the event is complete.
  • However, it is possible in such systems that a state transition and the generation of a new web page to display may take a significant amount of time and that during that time further events may be deliberately generated by the user. For instance, before a new page can be generated, the user may change their mind as to what they want to do, or may simply lose patience. If the processing of events were to be isolated by holding a coarse-grained lock on event reception until the event is fully processed, there would be no way for a user to change their mind when they click to perform an action that takes a long time to complete: the lock would not allow a new event to be processed until the previous action has run to completion.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • An embodiment of the invention will now be described by way of example only, with reference to the following figures, wherein:
  • FIG. 1 is a schematic diagram showing a web application in an embodiment of the invention;
  • FIG. 2 is a state diagram showing the screen flow of a simple web application in one example;
  • FIG. 3 is a simplified flow diagram showing the processing of a state transition;
  • FIGS. 4 a and 4 b are a simplified flow diagrams showing the processing of calls to a state machine controller.
  • DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT
  • In the embodiments to be described below, a web server is described as an example of an interactive system that can be driven by a state machine. More specifically, in the embodiments described, the JavaServer Pages (JSP) technology is employed in the web server as a means to dynamically generate web pages, although it will be appreciated that any other suitable dynamic Web scripting/programming arrangement may equally be used for this. As is well known, the JSP technology uses XML-like tags to encapsulate the logic that generates the content for a web page. The application logic can reside in server-based resources (such as JavaBeans) that the page accesses via these tags.
  • The described embodiments make use of object-oriented programming techniques that, as will be understood by those skilled in the art, involve the definition, creation, use and destruction of objects. These objects are software entities comprising data elements and routines, or methods, which manipulate the data elements. The data and related methods are treated by the software as an entity and can be created, used and deleted as if they were a single item. Together, the data and methods enable objects to model entities in terms of their characteristics, which can be represented by the data elements, and its behavior, which can be represented by its methods. In this way, objects can model things like web pages, events, people or computers.
  • Objects are defined by creating “classes” which are not objects themselves, but which act as templates that instruct the compiler how to construct instances of the actual object. A class may, for example, specify the number and type of data variables and the steps involved in the methods which manipulate the data. An object is instantiated in the program by means of a special method called a constructor which uses the corresponding class definition and additional information, such as arguments provided during object instantiation, to construct the object. The Java runtime environment, for instance, deletes objects when it determines that they are no longer being used. This process is referred to as garbage collection. Objects may be used by using their data and invoking their methods.
  • FIG. 1 illustrates a web application architecture in which a controller component is provided with a state machine. The operation of such a web application is as follows. First an incoming http request is received by a controller servlet 100 which manages application flow and logic in a manner to be described in more detail below. Event-Type mapper 110 translates the HTTP messages sent to the application server into event objects that are meaningful for the application. Then, the events are passed to a state machine controller 120 which consumes the event according to a state machine definition 130. A session manager and session controller (not shown) would also normally be present to manage user authorization in generally known manner.
  • The architecture also comprises one or more JSP pages 150 and one or more JavaBeans in JavaBean manager 140 that may be used for accessing external data resources illustrated at 160.
  • As is well known, servlets are server-side software modules that fit into a web server framework and can be used to extend its capabilities. A JavaBean is simply a building block component that can be combined with other components in the same or other computers in a distributed network to form an application. Such components can be deployed on different servers in a network and communicate with each other for needed services. The general operation of such a system will be generally well understood by those skilled in the art.
  • In such architectures, there is not normally any processing logic within the JSP pages themselves; they are simply static templates that are arranged to be populated by retrieving any objects or beans that may have been previously created, and extracting the dynamic content from them.
  • State machine definition 130 defines the flow and logic of the web application. States represent views and transitions between states represent actions. Web application developers define the states and transitions which handle request parameters, use business objects to handle business logic, and populate page beans given to a bean manager 140 to display information on pages.
  • The state machine used in this embodiment can contain nested states. In the state machine definition 130 each atomic state, that is each state that does not itself have sub-states, represents a screen that the user will see, with transitions among the various states representing the navigation flow between the screens. Superstates are used to encapsulate and provide transitions that are common to all of their substates and to provide boundary functions for various functional zones.
  • To illustrate the operation of the state machine controller, FIG. 2 is a hierarchical state diagram showing a set of different application screens and how a user can go from one to another by doing which action. The diagram comprises a “Home” state 210, a “Sport” state 220 and a “Latest News” state contained within a further state 240.
  • Within each superstate, one substate illustrated in bold is selected as the default substate that is entered by default on entry to the superstate. This default substrate can be either configured to always be the same state, or can be dynamically computed on entry to the superstate. For example, on entry to the site, the home state 210 is selected as the default state within super state 200. Thus on first entry to the site, it is the web page associated with home state 210 that is generated and displayed. Similarly, on entry to superstate 240, it is the page 230 that is generated and displayed.
  • It will be understood that, since the state machine is hierarchical, transitions that are illustrated as being available from a superstate are available from each of the substates within the superstate. So, for instance the “Home” event is available from each of the three atomic substates 210, 220, and 230.
  • When the State Machine Controller 120 receives an event, it computes the next application state based on the combination of several factors: the current state, the event received, the environment context and the set of configured transitions from the current state. Actions can be attached to the state transition that will take place, to carry out the desired business logic.
  • After event handling and a new application state has been determined, display of the page associated with that new state is triggered. The controller servlet 100 forwards control to JSP view generator 150 to generate an HTML web page that will be sent the client browser. JSP view generator 150 typically makes use of Javaserver pages Standard Tag Library (JSTL) to help produce the HTML. These tag libraries in turn use information stored in the page beans.
  • Once the page is generated, provided to the browser in an HTTP response and displayed, it presents options to the user for another interaction, and the cycle repeats itself.
  • Thus, in systems of the above described type, the hierarchical state machine formally describes the set of states that the application can be in, and is the main support for controlling the operations that can happen.
  • The operations performed between receipt of an http request and generation of a response each take some time to carry out which in some systems can result in a perceptible latency in the generation of a response.
  • Each state of the state machine is associated with a state context object that is equipped with callbacks that are triggered by the state machine controller when a state is entered or left. The state context object attached to a particular state is created once, the first time the state is entered, and then remains in existence throughout the session: this allows the data pertaining to the state to be stored there. The state context objects are thus normally persistent, to be able to hold contextual information across the various invocations during a session.
  • When a transition is made from one state to another state, several nested states may be left and then several nested states entered. As each state boundary is crossed, the corresponding leave and enter callbacks are called by the state machine controller on the associated state objects in the order described, which is defined by the actual state boundaries that are crossed during the transition. For example, in FIG. 2 if a user is in state 230 “Latest news” and then clicks on a displayed “sport” link the transition illustrated at 250 would be provoked. This transition would involve leaving states 230 and 240 and entering state 220. If in the same state 230 the user clicks on the “Home” link then the transition illustrated at 260 is provoked. This involves leaving states 230 and 240 and entering state 210.
  • To ensure the consistency of the state context objects, it is important to make sure that no concurrent access is made to them: since they hold model data and contextual information about the processing, it is not acceptable to have simultaneous method invocations on those objects from concurrent threads corresponding to different user-initiated events.
  • It will be understood that in this context, concurrent access does not normally mean two different users performing an action at the same time, since they will generally have different sessions and therefore different instantiations of the state machine. It rather means that the same user is performing concurrent actions, by opening two windows on the same application or by clicking on some link still displayed on the page after clicking on a first link and before the reply from the first action came back: the second event will be received in the middle of the processing of the first.
  • Generally, to avoid such consistency problems, critical sections can be defined. When the code is in a critical section, it holds a lock and other threads cannot acquire it until that lock is released. In effect, this guarantees that only one thread will be running the code in the critical section at one point in time.
  • The technique described here enables the size of the critical sections to be reduced, and then ensures that there will be no concurrent access to the methods held in the state contexts. As will be described in more detail below, when a concurrent request is received, the state machine is arranged to detect the concurrency by executing a small critical section and, if concurrency is detected, to then proceed by detaching the state context objects that were accessed by the earlier event—in other words breaking the link between the state and the state context object. Once the existing state contexts have been detached, the state machine controller is arranged so that entering these states will cause the creation of new associated state context objects and further operations will be carried out on those newly created context objects. The detached state context objects will be removed later by a garbage collection process.
  • In this way, it can be ensured that operations on a given state context object will only be made by a single thread of execution.
  • In addition to the above measure, when a concurrent event occurs, it is processed from the same state as the state machine was in when the earlier event was received. The state machine thus is arranged to restore that state, invoking the enter callback on the newly created contexts, as necessary, and supplying the original event context for the restored state.
  • Finally, the thread that executes the old event which was interrupted will be passively cancelled when it next tries to access to state machine controller. The thread sees that it was superseded by another event and aborts execution.
  • In alternate embodiments, it would be possible to perform active cancellation of the concurrent thread, but in the Java-based domain of this embodiment this would not be convenient, since creation and destruction of threads is beyond the control of the state machine controller.
  • The above described techniques ensure that the state contexts that can be the targets of calls during the event processing will be properly detached when a concurrent event is received. In this embodiment, the existing context of execution in all the states that were involved in the processing of the “interrupted” event will be lost, although it will be understood that in other embodiments it would be possible to back up and restore the contexts of all the visited states, if required, depending on the storage resources available.
  • Each event received by the state machine controller is assumed to be numbered sequentially or otherwise time-stamped and this data is stored and available during all processing linked with the event; the initial state of the state machine at the time the event is received is stored; Each state context that is entered or left during the processing of the event is recorded, for example, in a visited states list.
  • In this way, the complexity of the concurrency management is managed within a state machine controller, potentially freeing a programmer who may define the state contexts and the action logic associated with state transitions from having to implement it.
  • An example of a simplified algorithm that may be used by the state machine controller to carry out these steps is shown in FIG. 3. Consider a transition from statex to statey. First the full path of statex and statey are calculated. This results in lists of all states from the root state to statex and statey respectively. The current state is stored—step 300 It is then determined in step 310 whether the current state lies in the path of the target state in step 310, if not then the leave method is carried out on the current state in step 320 and the state is added to a visited state list—step 330. This process is repeated until a state is reached that does lie in the path of the target state. The enter methods of states in the target path are then repeatedly called until the target statey is reached and each state visited is added to the visited state list. The target state statey is then set as the current state.
  • FIG. 4 illustrates a second element of the method.
  • As shown in FIG. 4(a), the first time a thread processing an event makes a call on the state machine, if there exists an earlier being processed step 400, then all the state contexts visited so far during processing of the earlier event are detached—step 420.
  • The original state the state machine was in during the reception of the previous event (denoted state x in FIG. 4) is restored in step 430.
  • The new event is then processed from that state in step 440.
  • FIG. 4(b) illustrates a process that is carried out each time an event being processed by the state machine controller accesses a state context object. A lock is set in step 450, then a check is made in step 460 whether the event is the latest event received by the state machine controller. If so, then the lock is released and the state context object may be accessed normally. If not then the thread processing the event is sent an exception.
  • This has the consequence that where receipt of a later event has caused the process described in relation to steps 420 and 430 of FIG. 4(a) to be carried out, no further state contexts can be visited by the thread that is processing an earlier event.
  • It is up to the application level processing to ensure that the cancellation of the earlier event does not harm the consistency of external data handled by the application, for example in a database 160. It will be understood that the above-described techniques serve to ensure the protection of the state machine data structures (including user-supplied state data).
  • It will be appreciated that commercialised forms of the present embodiment would in practice take the form of a set of computer programs adapted to run on general-purpose computing platforms within general-purpose operating environments such as are provided by the Microsoft Windows, Linux or HP-UX operating systems and their related programming libraries and tools. These programs may be marketed in the form of suitably coded computer program products including program code elements that implement the functionality described. It will be appreciated though that the techniques described may equally be implemented as special purpose hardware or any combination of software, hardware and/or firmware. The techniques described have been primarily developed in the context of a web server where responses generated by the interactive system are web pages. However, it will be understood that the same or similar techniques may also be applied to any similar or comparable interactive system.
  • The above discussion is meant to be illustrative of the principles and various embodiments of the present invention. Numerous variations and modifications in each of the illustrated examples will become apparent to those skilled in the art once the above disclosure is fully appreciated. It is intended that the following claims be interpreted to embrace all such variations and modifications.

Claims (12)

  1. 1. A method for operating a state machine controller in an interactive system of the type wherein responses to a user are associated with states of a state machine, the responses being generated as a result of a transition into a state associated with the response, the state machine controller being arranged to change states of the state machine according to the processing of user-initiated events, the method comprising the state machine determining, during processing of a current event, whether the current event was initiated at an earlier time than another event and, if so, (i) restoring the state machine to a condition consistent with that immediately prior to processing of the current event, and then (ii) carrying out a state transition according to the other event.
  2. 2. A method as claimed in claim 1 wherein the events are processed by processing entities separate from the state machine controller and wherein the determination is carried out whenever a processing entity associated with the other event calls the state machine controller.
  3. 3. A method as claimed in claim 1 wherein the determination is carried out in a critical section.
  4. 4. A method as claimed in claim 1 wherein the system is a multithreaded system and the processing entities for processing the events are separate threads.
  5. 5. A method as claimed in claim 1 in a system wherein the states have associated state context objects that can only be accessed via the state machine controller and wherein each time an event tries to access a state context via the state machine controller a determination is made whether the event was initiated at an earlier time than a current event and, if so, processing of the event calling the state machine controller is terminated.
  6. 6. A method as claimed in claim 1 in a system wherein the states have associated state context objects that can only be accessed via the state machine controller, the method comprising, when the state machine controller starts processing an event, the state machine controller storing a back-up copy of the state contexts of one of more states of the state machine controller, including a current state of the state machine controller and wherein the restoration of the state machine to a condition consistent with that immediately prior to processing of the current event comprises detaching any state contexts affected by processing of the current event and restoring at least the state context of the state the state machine was in when the current event was received.
  7. 7. A method as claimed in claim 1 wherein the interactive system is a web server and the responses are web pages.
  8. 8. A web server wherein web pages sent to a user are associated with states of a state machine, the web pages being generated as a result of a transition into a state associated with the web page, the system comprising a state machine controller arranged to change states of the state machine according to the processing of user-initiated events, wherein the states have associated state context objects that can only be accessed via the state machine controller, the state machine controller comprising:
    means for storing a back-up copy of the state contexts of one of more states of the state machine controller when the state machine controller starts processing an event;
    means to determine in a critical section, during processing of a current event, whether another event was initiated at a later time than the current event;
    means to respond to such a determination by (i) restoring the state machine to a condition consistent with that immediately prior to processing of the current event by detaching any state contexts affected by processing of the current event and restoring at least the state context of the state the state machine was in when the current event was received, and then (ii) carrying out a state transition according to the other event wherein the determination is carried out when a processing entity associated with the other event calls the state machine controller; and
    means arranged so that each time an event tries to access a state context via the state machine controller a determination is made whether the event was initiated at an earlier time than a current event and, if so, processing of the event calling the state machine controller is terminated.
  9. 9. A method for operating a web server wherein responses are associated with states of a state machine, the method comprising:
    processing events initiated by a user by a processing entity associated with each event;
    under the control of a state machine control separate from the processing entities, changing states of the state machine according to the processing of the events;
    generating the responses as a result of a transition into a state associated with the response;
    determining, in a critical section during processing of a current event, whether the current event was initiated at an earlier time than another event and, if so, (i) restoring the state machine to a condition consistent with that immediately prior to processing of the current event, and then (ii) carrying out a state transition according to the other event, wherein the determination is carried out whenever the processing entity associated with the other event calls the state machine controller.
  10. 10. A method as claimed in claim 9 wherein the web server is a multithreaded system and the processing entities for processing the events are separate threads.
  11. 11. A method as claimed in claim 10 wherein the states have associated state context objects that can only be accessed via the state machine controller and wherein each time an event tries to access a state context via the state machine controller a determination is made whether the event was initiated at an earlier time than a current event and, if so, processing of the event calling the state machine controller is terminated.
  12. 12. A method as claimed in claim 11 wherein the states have associated state context objects that can only be accessed via the state machine controller, the method comprising, when the state machine controller starts processing an event, the state machine controller storing a back-up copy of the state contexts of one of more states of the state machine controller, including a current state of the state machine controller and wherein the restoration of the state machine to a condition consistent with that immediately prior to processing of the current event comprises detaching any state contexts affected by processing of the current event and restoring at least the state context of the state the state machine was in when the current event was received.
US11411997 2005-04-25 2006-04-25 State machine event restoration Active 2030-11-08 US8458336B2 (en)

Priority Applications (3)

Application Number Priority Date Filing Date Title
EP20050300314 EP1717715B1 (en) 2005-04-25 2005-04-25 State machine-driven interactive system and associated methods
EP05300314.1 2005-04-25
EP05300314 2005-04-25

Publications (2)

Publication Number Publication Date
US20070003347A1 true true US20070003347A1 (en) 2007-01-04
US8458336B2 US8458336B2 (en) 2013-06-04

Family

ID=34942563

Family Applications (1)

Application Number Title Priority Date Filing Date
US11411997 Active 2030-11-08 US8458336B2 (en) 2005-04-25 2006-04-25 State machine event restoration

Country Status (2)

Country Link
US (1) US8458336B2 (en)
EP (1) EP1717715B1 (en)

Cited By (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20110078672A1 (en) * 2009-09-30 2011-03-31 Red Hat, Inc. Classloading Technique for an Application Server that Provides Dependency Enforcement
US20110078659A1 (en) * 2009-09-30 2011-03-31 Red Hat, Inc. Java-Based Application Server that Supports Multiple Component Models
US20110173568A1 (en) * 2010-01-12 2011-07-14 Crane Merchandising Systems, Inc. Mechanism for a vending machine graphical user interface utilizing xml for a versatile customer experience
US20140237487A1 (en) * 2013-02-15 2014-08-21 University Of Southern California Complex event processing for dynamic data
US9020873B1 (en) 2012-05-24 2015-04-28 The Travelers Indemnity Company Decision engine using a finite state machine for conducting randomized experiments

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101957751B (en) * 2010-06-04 2013-07-24 福建星网锐捷网络有限公司 Method and device for realizing state machine

Citations (22)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5930792A (en) * 1996-11-07 1999-07-27 Intervoice Limited Partnership Monitoring and directing flow of HTML documents for security and access
US6038596A (en) * 1997-05-23 2000-03-14 International Business Machines Corporation Method and system in a network for decreasing performance degradation triggered by multiple user redundant input events
US6098093A (en) * 1998-03-19 2000-08-01 International Business Machines Corp. Maintaining sessions in a clustered server environment
US6237035B1 (en) * 1997-12-18 2001-05-22 International Business Machines Corporation System and method for preventing duplicate transactions in an internet browser/internet server environment
US6323881B1 (en) * 1998-10-23 2001-11-27 Nortel Networks Limited Web based GUI server and method for a telecommunications node
US20020080200A1 (en) * 2000-08-25 2002-06-27 Garland Wong Method and apparatus for implementing a web application
US20020165971A1 (en) * 2001-05-04 2002-11-07 Elad Baron Method and system for terminating an authentication session upon user sign-off
US20030046291A1 (en) * 2000-03-10 2003-03-06 Fascenda Anthony C. System, method and apparatus for utilizing transaction databases in a client - server environment
US20030050813A1 (en) * 2001-09-11 2003-03-13 International Business Machines Corporation Method and apparatus for automatic transitioning between states in a state machine that manages a business process
US20030079039A1 (en) * 2001-10-16 2003-04-24 Forkner Damien R. Web server utilizing a state machine and user token
US6618851B1 (en) * 1999-08-31 2003-09-09 Autodesk, Inc. Method and apparatus for state-reversion
US20030187995A1 (en) * 2002-03-27 2003-10-02 International Business Machines Corporation Efficient server handling of multiple requests from a web browser
US6725252B1 (en) * 1999-06-03 2004-04-20 International Business Machines Corporation Method and apparatus for detecting and processing multiple additional requests from a single user at a server in a distributed data processing system
US20040111729A1 (en) * 2002-12-09 2004-06-10 International Business Machines Corporation External event interrupt for server-side programs
US6757900B1 (en) * 2000-05-18 2004-06-29 Microsoft Corporation State management of server-side control objects
US20040158549A1 (en) * 2003-02-07 2004-08-12 Vladimir Matena Method and apparatus for online transaction processing
US20040260651A1 (en) * 2003-06-17 2004-12-23 International Business Machines Corporation Multiple identity management in an electronic commerce site
US20050262098A1 (en) * 2004-05-07 2005-11-24 Raphael Manfredi Web application for supporting transaction processing
US6976259B1 (en) * 2000-09-29 2005-12-13 Microsoft Corporation Method for abstract state transitions without requiring state machine knowledge
US20070038756A1 (en) * 2003-10-14 2007-02-15 Waldorf Jerry A Mechanisms for supporting back button function of web browser as web service server in interaction with business process engine
US7376741B1 (en) * 1999-03-19 2008-05-20 Hewlett-Packard Development Corporation, L.P. System for aborting response to client request if detecting connection between client server is closed by examining local server information
US7496916B2 (en) * 2003-09-18 2009-02-24 International Business Machines Corporation Service and recovery using multi-flow redundant request processing

Family Cites Families (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
GB2355904B (en) 1999-10-05 2002-03-20 Authoriszor Ltd System and method for managing pseudo uniform resource locators in a security system

Patent Citations (23)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5930792A (en) * 1996-11-07 1999-07-27 Intervoice Limited Partnership Monitoring and directing flow of HTML documents for security and access
US6038596A (en) * 1997-05-23 2000-03-14 International Business Machines Corporation Method and system in a network for decreasing performance degradation triggered by multiple user redundant input events
US6237035B1 (en) * 1997-12-18 2001-05-22 International Business Machines Corporation System and method for preventing duplicate transactions in an internet browser/internet server environment
US6098093A (en) * 1998-03-19 2000-08-01 International Business Machines Corp. Maintaining sessions in a clustered server environment
US6323881B1 (en) * 1998-10-23 2001-11-27 Nortel Networks Limited Web based GUI server and method for a telecommunications node
US7376741B1 (en) * 1999-03-19 2008-05-20 Hewlett-Packard Development Corporation, L.P. System for aborting response to client request if detecting connection between client server is closed by examining local server information
US6725252B1 (en) * 1999-06-03 2004-04-20 International Business Machines Corporation Method and apparatus for detecting and processing multiple additional requests from a single user at a server in a distributed data processing system
US6618851B1 (en) * 1999-08-31 2003-09-09 Autodesk, Inc. Method and apparatus for state-reversion
US20030046291A1 (en) * 2000-03-10 2003-03-06 Fascenda Anthony C. System, method and apparatus for utilizing transaction databases in a client - server environment
US6757900B1 (en) * 2000-05-18 2004-06-29 Microsoft Corporation State management of server-side control objects
US20020080200A1 (en) * 2000-08-25 2002-06-27 Garland Wong Method and apparatus for implementing a web application
US6976259B1 (en) * 2000-09-29 2005-12-13 Microsoft Corporation Method for abstract state transitions without requiring state machine knowledge
US20020165971A1 (en) * 2001-05-04 2002-11-07 Elad Baron Method and system for terminating an authentication session upon user sign-off
US20030050813A1 (en) * 2001-09-11 2003-03-13 International Business Machines Corporation Method and apparatus for automatic transitioning between states in a state machine that manages a business process
US20030079039A1 (en) * 2001-10-16 2003-04-24 Forkner Damien R. Web server utilizing a state machine and user token
US20030187995A1 (en) * 2002-03-27 2003-10-02 International Business Machines Corporation Efficient server handling of multiple requests from a web browser
US7171663B2 (en) * 2002-12-09 2007-01-30 International Business Machines Corporation External event interrupt for server-side programs
US20040111729A1 (en) * 2002-12-09 2004-06-10 International Business Machines Corporation External event interrupt for server-side programs
US20040158549A1 (en) * 2003-02-07 2004-08-12 Vladimir Matena Method and apparatus for online transaction processing
US20040260651A1 (en) * 2003-06-17 2004-12-23 International Business Machines Corporation Multiple identity management in an electronic commerce site
US7496916B2 (en) * 2003-09-18 2009-02-24 International Business Machines Corporation Service and recovery using multi-flow redundant request processing
US20070038756A1 (en) * 2003-10-14 2007-02-15 Waldorf Jerry A Mechanisms for supporting back button function of web browser as web service server in interaction with business process engine
US20050262098A1 (en) * 2004-05-07 2005-11-24 Raphael Manfredi Web application for supporting transaction processing

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
David Chandler, "Controlling Page Sequencing with an Event-Driven State Machine", CodeFUsion Developer Journal, Oct. 2004 *

Cited By (8)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20110078672A1 (en) * 2009-09-30 2011-03-31 Red Hat, Inc. Classloading Technique for an Application Server that Provides Dependency Enforcement
US20110078659A1 (en) * 2009-09-30 2011-03-31 Red Hat, Inc. Java-Based Application Server that Supports Multiple Component Models
US8738589B2 (en) 2009-09-30 2014-05-27 Red Hat, Inc. Classloading technique for an application server that provides dependency enforcement
US9009667B2 (en) * 2009-09-30 2015-04-14 Red Hat, Inc. Application server that supports multiple component models
US20110173568A1 (en) * 2010-01-12 2011-07-14 Crane Merchandising Systems, Inc. Mechanism for a vending machine graphical user interface utilizing xml for a versatile customer experience
US20110173535A1 (en) * 2010-01-12 2011-07-14 Crane Merchandising Systems, Inc. Mechanism for a vending machine graphical user interface utilizing xml for on-the-fly language selection by an end user
US9020873B1 (en) 2012-05-24 2015-04-28 The Travelers Indemnity Company Decision engine using a finite state machine for conducting randomized experiments
US20140237487A1 (en) * 2013-02-15 2014-08-21 University Of Southern California Complex event processing for dynamic data

Also Published As

Publication number Publication date Type
US8458336B2 (en) 2013-06-04 grant
EP1717715A1 (en) 2006-11-02 application
EP1717715B1 (en) 2018-06-06 grant

Similar Documents

Publication Publication Date Title
Nichols et al. Pthreads programming: A POSIX standard for better multiprocessing
Haller et al. Actors that unify threads and events
US6961750B1 (en) Server-side control objects for processing client-side user interface elements
US6640255B1 (en) Method and apparatus for generation and installation of distributed objects on a distributed object system
US5475817A (en) Object oriented distributed computing system processing request to other object model with code mapping by object managers located by manager of object managers
US6567974B1 (en) Small memory footprint system and method for separating applications within a single virtual machine
US7213153B2 (en) Application program interface interception system and method
US6597366B1 (en) Transparent general purpose object isolation for multi-tier distributed object environments
US6484276B1 (en) Method and apparatus for providing extensible object-oriented fault injection
US7451434B1 (en) Programming with shared objects in a shared memory
US7293254B2 (en) Extensibility application programming interface and framework for meta-model objects
US20030070004A1 (en) Method, apparatus, and system for implementing a framework to support a web-based application
US6014666A (en) Declarative and programmatic access control of component-based server applications using roles
Dasgupta et al. The Clouds distributed operating system
US7155728B1 (en) Remoting features
US7269792B2 (en) System and method for generating high-function browser widgets with full addressability
US6078743A (en) Generic IDE interface support for scripting
US6049807A (en) Technique for maintaining object integrity during modification of a persistent store of objects
US20030023656A1 (en) Method and system for deadlock detection and avoidance
US6701368B1 (en) Providing a stream of data to a browser to update properties on a page
US20060129983A1 (en) Apparatus, system, and method for sharing and accessing data by scopes
US20060143609A1 (en) System and method for managing memory of Java session objects
US5867175A (en) Method and apparatus for scriping animation
US6263498B1 (en) Method and apparatus for enabling server side distributed object modification
US6564377B1 (en) Self-describing components within a software catalog

Legal Events

Date Code Title Description
AS Assignment

Owner name: HEWLETT-PACKARD DEVELOPMENT COMPANY, L.P., TEXAS

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:MANFREDI, RAPHAEL;FOUCHE, PIERRE;REEL/FRAME:018249/0110

Effective date: 20060821

CC Certificate of correction
AS Assignment

Owner name: HEWLETT PACKARD ENTERPRISE DEVELOPMENT LP, TEXAS

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:HEWLETT-PACKARD DEVELOPMENT COMPANY, L.P.;REEL/FRAME:037079/0001

Effective date: 20151027

FPAY Fee payment

Year of fee payment: 4

AS Assignment

Owner name: ENTIT SOFTWARE LLC, CALIFORNIA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:HEWLETT PACKARD ENTERPRISE DEVELOPMENT LP;REEL/FRAME:042746/0130

Effective date: 20170405

AS Assignment

Owner name: JPMORGAN CHASE BANK, N.A., DELAWARE

Free format text: SECURITY INTEREST;ASSIGNORS:ATTACHMATE CORPORATION;BORLAND SOFTWARE CORPORATION;NETIQ CORPORATION;AND OTHERS;REEL/FRAME:044183/0718

Effective date: 20170901

Owner name: JPMORGAN CHASE BANK, N.A., DELAWARE

Free format text: SECURITY INTEREST;ASSIGNORS:ENTIT SOFTWARE LLC;ARCSIGHT, LLC;REEL/FRAME:044183/0577

Effective date: 20170901