In this poster, we develop an evolutionary document summarization system for discovering the changes and differences in each phase of a disaster evolution. Given a collection of document streams describing an event, our system generates a short summary delivering the main development theme of the event by extracting the most representative and discriminative sentences at each phase. Experimental results on the collection of press releases for Hurricane Wilma in 2005 demonstrate the efficacy of our proposal.

Multimedia communication services today are conceived, designed, and developed in isolation, following a stovepipe approach. This has resulted in a fragmented and incompatible set of technologies and products. Building new communication services requires a lengthy and costly development cycle, which severely limits the pace of innovation. In this paper, we address the fundamental problem of automating the development of multimedia communication services. We propose a new paradigm for creating such services through declarative specification and generation, rather than through traditional design and development. Further, the proposed paradigm pays special attention to how the end-user specifies his/her communication needs, an important requirement largely ignored in existing approaches.

The development of collaborative multimedia applications today follows a vertical development approach, which is a major inhibitor that drives up the cost of development and slows down the pace of innovation of new generations of collaborative applications. In this paper, we propose a network communication broker (NCB) that provides a unified higher-level abstraction that encapsulates the complexity of network-level communication control and media delivery for the class of multimedia collaborative applications. NCB expedites the development of next-generation applications with diverse communication logics. Furthermore, NCB-based applications can be easily ported to new network environments. In addition, the self-managing design of NCB supports dynamic adaptation in response to changes in network conditions and user requirements

The convergence of data, voice and multimedia communication over digital networks, coupled with continuous improvement in network capacity and reliability has significantly enriched the ways we communicate. However, the stovepipe approach used to develop today's communication applications and tools results in rigid technology, limited utility, lengthy and costly development cycle, difficulty in integration, and hinders innovation. In this paper, we present a fundamentally different approach, which we call communication virtual machine (CVM) to address these problems. CVM provides a user-centric, model-driven approach for conceiving, synthesizing and delivering communication solutions across application domains. We argue that CVM represents a far more effective paradigm for engineering communication solutions. The concept, architecture, modeling language, prototypical design and implementation of CVM are discussed

System assembly is one of the major issues in engineering complex component-based systems. This is especially true when heterogeneous, COTS and GOTS distributed systems, typical in industrial applications, are involved. The goal of system assembly is not only to make constituent components work together, but also to ensure that the components as a whole behave consistently and guarantee certain end-to-end properties. Despite recent advances, there is a lack of understanding about software composability, as well as theory and techniques for checking and verifying component-based systems. A theory of software system constraints about components, their environment and about system as a whole is the necessary foundation toward solid understanding of the composability of component-based systems. In this paper, we present a systematic approach for constraint specification and constraint propagation in concert with design refinement with a novel technique to ensure consistency between system-wide and component constraints in a design composition process of component-based systems. The consistent constraint propagation is used in our approach to drive progressive verification of the design. It allows us to verify overall design composition without interference of internal details of component designs. Verification is done separately at architectural and component levels without having to compose results of component analyses. A component can be safely replaced with alternative design without re-verifying the overall system composition so long as the replacement conforms to the corresponding interface and component constraint(s).

To real-time system designers, end-to-end time delay between external inputs and outputs is among the most important constraints. To ensure these system-wide constraints are satisfied, each of the constituent components is subject to a set of derived intermediate constraints. Since the system-wide constraints allow many possibilities for the intermediate constraints based on design tradeoffs, an important issue is how to guarantee the consistency between system-wide constraints and intermediate component constraints. In this paper, we present a systematic method for the verification of consistency between a system's global timing constraints and intermediate component constraints. The essence of this technique is to construct a timing model for each component, based on component constraints. This model treats a component as a black box. When replacing each component with its timing model, we obtain a complete time Petri net model for system architecture, which allows us to verify the consistency between global and component constraints. The key contribution is twofold. First, our technique of verification is efficient by supporting incremental analysis and suppressing internal state space of components. Second, much of the verification process presented in this paper can be automated. We illustrate the consistency verification process through a flexible manufacturing system example.

Security system architecture governs the composition of components in security systems and interactions between them. It plays a central role in the design of software security systems that ensure secure access to distributed resources in networked environment. In particular, the composition of the systems must consistently assure security policies that it is supposed to enforce. However, there is currently no rigorous and systematic way to predict and assure such critical properties in security system design. A systematic approach is introduced to address the problem. We present a methodology for modeling security system architecture and for verifying whether required security constraints are assured by the composition of the components. We introduce the concept of security constraint patterns, which formally specify the generic form of security policies that all implementations of the system architecture must enforce. The analysis of the architecture is driven by the propagation of the global security constraints onto the components in an incremental process. We show that our methodology is both flexible and scalable. It is argued that such a methodology not only ensures the integrity of critical early design decisions, but also provides a framework to guide correct implementations of the design. We demonstrate the methodology through a case study in which we model and analyze the architecture of the Resource Access Decision (RAD) Facility, an OMG standard for application-level authorization service.

The process of agent migration is the major difference between logical code mobility of software agents and physical mobility of mobile nodes in ad hoc networks. Without considering agent transfer, it would make little sense to mention the modeling of strong code mobility, which aims to make a migrated agent restarted exactly from the state when it was stopped before migration. From the perspective of system's architecture, this paper proposes a two-layer approach for the formal modeling of logical agent mobility (LAM) using predicate/transition (PrT) nets. We view a mobile agent system as a set of agent spaces and agents could migrate from one space to another. Each agent space is explicitly abstracted to be a component, consisting of an environmental part and an internal connector dynamically binding agents with their environment. We use a system net, agent nets, and a connector net to model the environment, agents, and the connector, respectively. In particular, agent nets are packed up as parts of tokens in system nets, so that agent transfer and location change are naturally captured by transition firing (token game) in Petri nets. Agent nets themselves are active only at specific places and disabled at all the other places in a system net. The semantics of such a two-layer LAM model is defined by transforming it into a PrT net. This facilitates the analysis of several properties about location, state, and connection. In addition, this paper also presents a case study of modeling and analyzing an information retrieval system with mobile agents.

The software architecture model (SAM) is a general software architecture model based on a dual formalism combining Petri nets and temporal logic. A SAM model contains a hierarchical set of compositions, each of which consists of a set of components, a set of connectors, and a set of constraints. This paper proposes a formal method for analyzing SAM models in both element (either component or connector) level and composition level. The basic idea is to simulate Petri net behaviors in terms of fair transition systems. The properties of individual components and connectors are verified either by deductive reasoning or model checking. The properties of the entire system is inferred from the properties of its constituents. A detailed case study of an electronic commerce system shows our approach to formally modeling, refining and analyzing software architecture models.

In the past decade, software architecture research has mainly focused on the concept formulation and the development of various architecture description languages. This field has matured enough and thus requires more emphasis on validation techniques. Symbolic model checking has been a highly successful automatic validation technique for hardware systems. We are interested in whether symbolic model checking can be effectively applied to software architecture validation. In this paper, we present our approach to apply the symbolic model checking technique to verify software architecture specifications written in SAM.

In the past decade, software architecture research has mainly focused on the concept formulation and the development of various architecture description languages. This field has now matured enough and thus requires more emphasis on techniques for developing and analyzing software architecture specifications. SAM is a general software architecture model for developing and analyzing software architectures. In this paper, we show how to integrate high-level Petri nets and first-order temporal logic as the foundation of SAM to establish a unified framework for specifying and analyzing all aspects of a software architecture. We provide a set of heuristics, which are supported by well-defined existing methods and techniques developed by other researchers as well as our own, for software architecture development and analysis. We demonstrate the application of this framework and the heuristics with an example.

We present an approach for analysis of security system architecture. Constraint patterns are introduced to formally specify the generic form of security policies that all implementations of the system architecture must enforce. The analysis is driven by incrementally decomposing a system-wide constraint pattern into a set of constraint patterns of constituent components. Since there are potentially many ways to partition a security system, a key element of the analysis is to verify that the component constraint patterns are collectively consistent with the global constraint pattern under the given architecture. A "consistent" component constraint is then used as the basis for analyzing possible designs of the component. We show that our approach is both flexible and scalable, which not only ensures the consistency of critical early design decisions, but also provides a framework to guide correct implementations of the design.

The paper presents a Petri net based approach for architectural modeling of mobile agent systems. An agent template (net) is proposed to model a changing number of autonomous and communicative software agents. An agent space is explicitly abstracted as a component, consisting of mobility environment (system net), agent templates (agent nets), and internal connector (net). Agent transfer is naturally captured by transition firing. To assure the strong mobility, the agent's state is delivered during migration. Agent mobility in OMG's MASIF is also examined by formalizing the interoperable agent system architecture.

Software architecture has become one of the most active research topics in software engineering in recent years. One of the distinct features of software architecture research is to explicitly study the interconnections (connectors) among system components. In this paper, we show how to formally specify several well-known general connectors in a software architecture methodology called SAM. Related work is discussed and compared. Our results establish the basis for reusing these defined connectors and for building more sophisticated connectors from them.

A compositional modeling and performance evaluation technique for traffic control systems based on Stochastic Timed Petri Nets (STPN's) is presented. We use STPN's to specify traffic and traffic control at an intersection and use a random distribution model to model the motion of vehicles in a road segment between any two consecutive intersections. A traffic control system is thus modeled as a composition of individual intersection models and segment random distribution models. A technique is presented to incrementally evaluate the system's performance by analyzing intersections separately according to a carefully selected order. The analysis technique conforms to the accepted practice of transportation research. Compared to existing Petri net models of traffic control systems, our technique dramatically reduces the complexity of analysis.

Time Petri nets (TPNs) are a popular Petri net model for specification and verification of real-time systems. A fundamental and most widely applied method for analyzing Petri nets is reachability analysis. The existing technique for reachability analysis of TPNs, however, is not suitable for timing property verification because one cannot derive end-to-end delay in task execution, an important issue for time-critical systems, from the reachability tree constructed using the technique. In this paper, we present a new reachability based analysis technique for TPNs for timing property analysis and verification that effectively addresses the problem. Our technique is based on a concept called clock-stamped state class (CS-class). With the reachability tree generated based on CS-classes, we can directly compute the end-to-end time delay in task execution. Moreover, a CS-class can be uniquely mapped to a traditional state class based on which the conventional reachability tree is constructed. Therefore, our CS-class-based analysis technique is more general than the existing technique. We show how to apply this technique to timing property verification of the TPN model of a command and control (C2) system.

This paper introduces compositional time Petri net (CTPN) models. A CTPN is a modularized time Petri net (TPN), which is composed of components and connectors. The paper also proposes a set of component-level reduction rules for TPNs. Each of these reduction rules transforms a TPN component to a very simple one while maintaining the net's external observable timing properties. Consequently, the proposed method works at a coarse level rather than at an individual transition level. Therefore, one requires significantly fewer applications to reduce the size of the TPN under analysis than those existing ones for TPNs. The use and benefits of CTPNs and reduction rules are illustrated by modeling and analyzing the response time of a command and control system to its external arriving messages.

Decoupling authorization logic from application logic allows applications with fine-grain access control requirements to be independent of a particular access control policy and from factors that are used in authorization decisions as well as access control models, no matter how dynamic those policies and factors are. It also enables elaborate and consistent access control policies across heterogeneous systems. We present the design of a service for resource access authorization in distributed systems. The service enables one to decouple authorization logic from application functionality. Although the described service is based on CORBA technology, the design approach can be successfully used in any distributed computing environment.

We present a new modeling method to evaluate the performance indices of traffic control systems where each intersection has two or four phases. The method is based on the stochastic timed Petri net models of isolated intersections. It considers one direction of traffic along a street each time, and the interactions between traffic of different directions are partially approximated by statistical models. By so doing, it dramatically reduces the computing complexity that other Petri net-based methods suffer due to the consideration of detailed interactions among all directions of traffic. An example is presented to show the potential application of the new method.

Healthcare information systems are complex and critical enterprise systems that link together geographically distributed hospitals, clinics, physician offices and other business units with distinct business functions and mutual dependencies. In the past, these systems were built based on proprietary solutions, acquired in piecemeal fashion and tightly coupled through ad hoc means. This resulted in stovepipe systems that had many duplicated functions and that were monolithic, non-extensible and non-interoperable. How to migrate from these stovepipe systems to the next-generation open healthcare information systems that are interoperable, extensible and maintainable is increasingly a pressing problem for the healthcare industry. In this paper, we present our experience in addressing the problem using an architecture-centered approach for enterprise system development and integration based on the distributed object technology standards OMA/CORBA. Our case study is conducted from a user organization (as opposed to developer organization) point of view and is based on a large-scale effort undertaken at the Baptist Health Systems of South Florida, a large healthcare organization serving the South Florida region. Key lessons learnt from this case study include: (1) establishing a clear architectural vision is essential to successful enterprise system development; (2) adoption of a standard architecture and infrastructure is the best approach to achieve interoperable, extensible and cohesive enterprise systems; and (3) an effective development methodology and business process are key to implementing the architectural vision.

A compositional method for modeling and evaluation of performance indices of traffic control systems based on Stochastic Timed Petri Nets (STPN) is presented. We use STPN to specify traffic and traffic control at an intersection and use a random distribution model to model the motion of vehicles in a road segment between any two consecutive intersections. The traffic control system is thus modeled as a composition of individual intersection models and segment distribution models. A technique is presented to incrementally evaluate the system's performance by analyzing intersections separately, according to a carefully selected order. The analysis technique conforms to the accepted practice of transportation research. Compared to existing Petri net models of traffic control systems, our technique dramatically reduces the complexity of analysis.

The performance of a mutual exclusion algorithm is measured by the number of messages exchanged per critical section execution and the delay between successive executions of the critical section. There is a message complexity and synchronization delay trade-off in mutual exclusion algorithms. Lamport's (1978) algorithm and Ricart and Agrawal's (1981) algorithm both have a synchronization delay of T, but their message complexity is O(N). Maekawa's (1985) algorithm reduces message complexity to O(/spl radic/N); however, it increases the synchronization delay to 2T. After Maekawa's algorithm, many quorum-based mutual exclusion algorithms have been proposed to reduce message complexity or increase the resiliency to site and communication link failures. Since these algorithms are Maekawa-type algorithms, they also suffer from long synchronization delay 2T. We propose a delay-optimal quorum-based mutual exclusion algorithm which reduces the synchronization delay to T and still has the low message complexity O(K) (K is the size of the quorum, which can be as low as log N). A correctness proof and detailed performance analysis are provided.

An incremental approach for architectural modeling and analysis of real-time concurrent systems is presented. The approach integrates existing formal methods, more specifically time Petri nets and real-time computational tree logic, and leverages their complementary strengths in a way that allows us to systematically enforce that architectural design meets the system's timing requirements, and to incrementally verify the conformance. Consequently, our approach is able to provide better assurance to system design and yet reduce the complexity of analysis. The approach is based on a Real-time Architectural Specification (RAS) model, which provides a formal basis to systematically maintain a correlation between the (timing) requirements of a system and its architectural design. Based on RAS, we further present a method to verify timing properties of a system design. This method helps conquer the complexity of analysis in two dimensions. Horizontally at each design level, incremental verification is achieved by introducing TPN reduction rules that allow us to compose analysis results on individual system components. Vertically across design levels, incremental verification is achieved by propagating higher-level constraints to lower-level designs so that we can safely plug a component design into a high-level architecture without having to re-verify the entire model. A naval command and control (C2) system is used throughout the paper to demonstrate the concept and usability of our approach.

In this paper, we propose a set of component-level reduction rules for TPN. Each of these reduction rules transforms a TPN component to a constant size of simple one while maintains the net's external observable timing properties. Consequently, our method works at a coarser level than that works in individual transition level, and fewer applications of our rules are needed to reduce the size of the TPN under analysis. We illustrate the use and benefits of our reduction rules by modeling and analyzing the response time of a command and control system to its external arriving messages.

We present a new algorithm for detecting generalized deadlocks in distributed systems. Our algorithm incrementally constructs and reduces a wait-for graph (WFG) at an initiator process. This WFG is then searched for deadlock. The proposed algorithm has two primary advantages: First, it avoids sending messages along the edges of the global wait-for graph (WFG), thereby achieving a worst-case message complexity of 2n, where n is the number of processes in the WFG. Since information must be obtained from every process reachable from the initiator, this is optimal to within a constant factor. All the existing algorithms for the same problem construct a distributed snapshot of the WFG. As this involves sending messages along the edges of the WFG, the best available message complexity among these algorithms is 4e-2n+2l, which is O(n/sup 2/) in the worst case, where e and l are the number of edges and leaves in the WFG, respectively. Second, since the information about a detected deadlock is readily available at the initiator process, rather than distributed among different processes, it significantly simplifies the task of deadlock resolution, and helps to reduce system overhead associated with the resolution. The time complexity of our algorithm is also better than or equal to the existing algorithms.

This paper investigates the analysis of concurrent OO designs using a formal, executable specification technique called G-Net. After presenting an overview of the G-Net technique, we show how to use the G-Net notation to specify the concurrent OO systems. A formal transformation technique, which translates a G-Net specification to a semantically equivalent PrT-net, is presented. The resultant PrT-net can then be formally analyzed. The practical significance of this approach in fault-tolerant systems and distributed multimedia systems design is discussed.

This paper proposes a novel strategy for estimating the size of the resulting relation after an equi-join and selection using a regression model. An approximating series representing the underlying data distribution and dependency is derived from the actual data. The proposed method provides an instant and accurate size estimation by performing an evaluation of the series, with no run-time overheads in page faults and space, and with negligible CPU overhead. In contrast, the popular sampling methods incur run-time overheads in page faults (for sampling), CPU time and space. These overheads of sampling methods increase the response time of processing a query. The results of a comprehensive experimental study are also reported, which demonstrate that the estimation accuracy by the proposed method is comparable with that of the sampling methods which are believed to provide the most accurate estimation. The proposed method seems ideal for retrieval-intensive database and information systems. Since the overheads involved in deriving the approximating series are fairly moderate, we believe that this method is also an extremely competent method when moderate or periodical updates are present.

Large software systems are often aimed to deal with problems of multi-application domains or disciplines, where each class of problems has its own defining features, difficulties and emphases. No existing computation model or design paradigm is appropriate for all varieties of problems faced in software design. A unification of existing computation paradigms is thus necessary to accommodate the diverse needs in system design. In this paper, the authors propose a framework based on the notions of logical entity abstraction and instantiation (LEAI), which enables a user to select appropriate computation paradigms to design various parts (or subsystems) of a software system, and to compose the parts into a integrated system. An example is given to illustrate the application of the framework.>

The major issues in designing Distributed Information Systems (DIS) include localization of control and data, inherent concurrency, intensive interactions among computation agents, history sensitivity, dynamic configuration and continuous system change and evolution. We propose a framework, called the G-Net model, for the specification, modeling and prototyping of DIS. The G-Net model not only provides a flexible notation to represent the executable specification of DIS through G-Net instantiation, but also offers a novel style of decentralized concurrent computation, allowing flexible inter-agent communication and interaction. A prototype of the G-Net framework has been implemented on workstations connected by a local network.

The authors introduce the concept of personalized user profile for very large databases, as well as the VisualNet model as a representation for such a user profile. A user profile is a small and dynamic structure which contains the user's knowledge of the database, serves as a starting point for the user's access to the database, and supports intelligent database accesses. The basic idea is that a user usually accesses only a very small and stable region of a very large database, and therefore, the size of the user profile is much smaller than the whole database view. It is hoped that most of the user's database search can be conducted in the user profile. Techniques for automatic construction and maintenance of user profiles are discussed. A set of visual reasoning algorithms is presented to support intelligent and interactive user's queries to the database, as well as to coordinate the search between the user profile and the global database.>

The G-net model for G-type knowledge representation is introduced. It is capable of modeling both static semantic knowledge and dynamic control knowledge, combining them into a loosely coupled, mixed-type knowledge hierarchy. Four reasoning algorithms for the G-net model are proposed: inheritance reasoning and recognition reasoning for semantic knowledge, event-driven reasoning for dynamic knowledge, and control table reasoning for coordination and control in a mixed-type knowledge hierarchy. Based on the knowledge-table representation, the G-net model expresses the constraints and relationships among knowledge objects explicitly so that reasoning algorithms can be implemented efficiently. Applications to information systems prototyping are discussed.>