Complex Software Development Environment

Development of complex application software remains a difficult problem despite recent advances. The goal of this project is to support rapid software development through extensible and scalable development environment with mechanisms for specifying behavior abstraction and composition, automated verification tools and support for incremental and modular development.

We define a declarative specification language for developing complex distributed application. The language provides mechanisms for abstracting behavior of software components and composing large number of components hierarchically. This scalable approach enables software designer to build large complex software. Each component defines a limited scope in which behavior of groups of lower-level components may be independently analyzed and controlled. The language allows important properties about the behavior of the applications to be extracted and analyzed. Tools were developed for analyzing application behavior to detect synchronization problems, such as deadlock, livelock, and starvation. The runtime system dynamically manages incorporation of modification in the application. Global state consistency of the concurrent tasks is preserved automatically by the system when some task software are modified.

Several techniques have been developed for verifying specification behaviors. However, we design a uniform framework useful for specifying abstraction and composition of component behavior hierarchically that can be easily exploited in our algorithms for detecting specification and synchronization problems as well as detecting dependencies for maintaining global consistencies when modification to programs are installed at runtime. Our techniques do not require software designers to specify the properties of the problem using formalisms such as temporal logic.

We develop the uniform formalism for specifying behavior of complex systems that may describe the partial order concurrent behavior and lends itself to analysis. We also design methods for analyze the system using this formalism and develop common set of tools that use these methods. The architecture of the development environment permits large-scale complex distributed applications to be developed incrementally while they are in active use. Programming and runtime environments should allow software designers to make these changes easily and efficiently. This must be provided within the appropriate framework for modeling, analysis and correct execution that is essential for complex applications. The key to supporting reconfiguration of large-scale applications is providing efficient abstraction and composition mechanisms. By separating specification of well-defined components from the component interaction and composition behavior, we allow designers to implement easily replaceable components and changeable interaction behavior. The abstraction mechanism simplifies development of large-scale reconfigurable applications by hiding implementation details. The facility also include automatic analytical tools for checking consistency, reachability and dependency in the behavior of interacting components. These tools are essential for development and runtime support of large-scale and reconfigurable decentralized applications. The method for detecting and notifying failure was implemented. Another algorithm was developed for computing the recovery path for the failure detected.

We have designed useful and scalable mechanisms for specifying abstraction and composition of distributed programs that interact in complex ways. We have developed algorithms for checking the correctness of complex applications specifications and detecting various synchronization problems, such as deadlock, starvation and livelock. We have developed a uniform framework for preventing synchronization problem dynamically and maintaining global consistency during failure recovery and reconfiguration.