Abstract: The present invention relates to a coordination-centric framework for implementing a software system in a distributed computing environment. In a presently preferred embodiment the software system is a software design environment having authoring, synthesis, and debugging tools. The coordination-centric framework is flexible enough to interconnect tools and robust enough that tool designers can use it for all aspects of tool interconnection without requiring costly workarounds. The coordination-centric framework uses modular and reusable software elements and standardized interfaces to connect the software elements.

Abstract: An Applet Agent on a browser of a client processor communicates with a server processor exclusively through a server agent on the server processor. Via this secure network connection, the server agent retrieves Client Applets and client applet data from a server database and sends them to the Applet Agent. The Applet Agent sends the Client Applets and data to the browser of the client processor. The Applet Agent stores the Client Applets, data, and amended data in the client processor, whereby the Client Applets and their data can be retrieved without accessing the server processor. Upon conclusion of a session, the Applet Agents sends the Client Applet data to the server agent, which stores the data on the server database. A plurality of Client Applets are preferably arranged in a logical unit of work, whereby a finite set of the Client Applets accomplish multiple functions.

Abstract: A behavioral abstraction is, in an abstract sense, a generalization of an event cluster. Behavioral abstraction is a technique where a predetermined behavioral sequence is automatically recognized by the simulator in a concurrent stream of system events. A behavioral sequence is at its most basic level a partial order of events. However, the events considered in a behavioral sequence are subject to configuration-based filtering and clustering. This allows a designer to create a model for a particular behavior and then set up a tool to find instances of the particular behavior in an execution trace. Behavior models are representations of partially ordered event sequences and can include events from several components.

Abstract: Software development methods and tools are described to generate visual representations of a system's behavior over time, called “evolution diagrams,” to aid in debugging concurrent software systems. The diagrams take advantage of the exposure provided by coordination interfaces to present more complete views of system executions, explicitly showing events, message traffic between components, etc. The display is presented at a user-selectable hierarchical level of the system design, thus enabling a programmer to work at a design layer where the problem or its effect is easily recognized.

Abstract: Coordination-centric design methodology facilitates the design and the debugging of software systems. Software systems comprise the following elements: components, coordinators and coordination interfaces. Components are function blocks. Coordinators manage all control and dataflow interactions between components based on a predetermined protocol. Coordination interfaces connect components to coordinators and allow control and dataflow information to be passed between components and coordinators.

Abstract: A software system and method, using a coordination-centric approach, for debugging distributed software environments is described, wherein the distributed software environment produces event traces to be analyzed by a debugging host. Distributed software environments are connected to debugging hosts either directly or indirectly. In a direct connection, a processing element's runtime system collects event records and sends them to a primary runtime debugging architecture, where the event records are time-stamped and causality-stamped and transferred to an event queue on the debugging host. An indirect connection uses an intermediate runtime debugging architecture, which facilitates the transfer of event records from the processing element to the event queue. Event records also may be collected and stored on a flash memory for post-mortem distributed debugging.

Abstract: A data structure and method of detecting constraint conflicts in a software system, prior to execution, is described wherein the data structure and method represent the static aspects of a software system having at least two software elements with explicit control interactions between the software elements. A software system's control constraints can be graphically-represented by a static control graph (SCG). An SCG represents the static aspects of system wide control. A simple SCG includes conjunctive nodes, modes represented by disjunctive nodes, and edges that connect two nodes and represent implication between the nodes. The most important use of an SCG is in identifying constraint conflicts in which two active constraints try to force a disjunctive node in opposite directions. An SCG facilitates identification of the set of mode states that cause a control constraint conflict and adjustment of the constraint to remove the conflict.

Abstract: Static analysis can be of great benefit in debugging complex systems. Traditional runtime debugging is necessary because certain software errors cannot be detected until after they are compiled into execution errors. Static analysis can reduce the number of such errors and can aid designers by illuminating subtle design interactions. Disclosed are various systems and methods for static analysis that can be applied to coordination-centric systems, including typechecking, consistency checking, and conflict detection through automatically derived abstract views, and model checking. The static analyses presented here comprise a form of preemptive debugging for coordination-centric software systems.

Abstract: The present invention relates to a coordination-centric framework for implementing a software system in a distributed computing environment. In a presently preferred embodiment the software system is a software design environment having authoring, synthesis, and debugging tools. The coordination-centric framework is flexible enough to interconnect tools and robust enough that tool designers can use it for all aspects of tool interconnection without requiring costly workarounds. The coordination-centric framework uses modular and reusable software elements and standardized interfaces to connect the software elements.