T.C. Hartrum’s research while affiliated with Wright State University and other places

State transition models are frequently used in the specification and design of complex systems. The unified modeling language (UML) includes state transition models in the form of statecharts. State models have been around a long time and are used in many design paradigms from low-level hardware sequential circuit design to more complex finite state automata. The formalisms of state transition models are well known. However, formal techniques for transforming system-level state models into executable code, especially object-oriented code, are not as well developed, and as with most manual techniques are prone to errors. This paper describes an approach to automating this process.

The research looks at collaboration in general and planning in particular. Our project goal was to investigate agent-based frameworks for distributed collaborative planning using a goal-centered approach. One major thrust of the project was to examine intelligent agent and multiagent system architectures to model distributed planning (i.e., teamwork). In a second thrust we looked at mixed-initiative systems in which a symbiosis between human and machine planners is the main objective. To demonstrate the problems and solutions we have tackled, we have built a number of prototypes that solve basic collaborative problems in both a small air campaign scenario and in a small business logistics scenario. Many of these programs are available on the Web.

This paper addresses the effect of mixed-initiative systems on multiagent systems design. A mixed-initiative system is one in which humans interact directly with software agents in a collaborative approach to problem solving. There are two main levels at which multiagent systems are designed: the domain level and the individual agent level. At the domain level, there are few unique challenges to mixedinitiative system design. However, at the individual agent level, the agent itself must be designed to interact with the human and the agent system, integrating the two into a single system.

Although techniques for using formal specifications have been progressing, methods for developing formal specifications themselves have improved little. To alleviate this problem, we propose a parallel refinement approach to specification acquisition wherethe designer uses an object-orientedspecification representation while an underlying specification composition system manipulates an equivalent theory-basedspecification. This paper presents the key to such a system --atheory-based object model. Our theory-based object model formally defines object-orientedconcepts in terms of algebraic theories and category theory operations. The theory-based object model provides the basis for the translation of the specification from a semi-formal, object-orientedrepresentation to a formal theory-based specification suitable for input to semi-automated software synthesis systems. 1

This work proposes a methodology that can be used to integrate formal models representing software components. The integration ensures that the correctness of each input model is maintained while adding the desired functionality to the integrated model. Further, because of the inherent knowledge captured in the formal models, automated tool support can be developed to assist the application engineer in this process. This allows needed middleware for connecting the components to be synthesized from the formal specifications developed

Formal software specification has long been touted as a way to increase the quality and reliability of software; however, it remains an intricate, manually intensive activity. An alternative to using formal specifications directly is to translate graphically based, semiformal specifications into formal specifications. However, before this translation can take place, a formal definition of basic object oriented concepts must be found. The paper presents an algebraic model of object orientation that defines how object oriented concepts can be represented algebraically using an object oriented algebraic specification language O-SLANG. O-SLANG combines basic algebraic specification constructs with category theory operations to capture internal object class structure, as well as relationships between classes

Over the past several years, the Air Force Institute of Technology (AFIT) has been developing a formal-based software synthesis system, the AFIT Wide Spectrum Object Modeling Environment (AWSOME), along with a specification language AWL (AFIT Wide-spectrum Language). Several tools have been developed, including a parser for the AWL syntax, an interactive object editor, a Java code generator, and a generator for database schemas and SQL queries. The paper describes the formal object-oriented meta-model, the AWL specification language, and transformations from specification to code, along with current and future tools and applications

The Unified Modeling Language (UML) has been incorporated into the CASE tool, Rational Rose98, offering the user the capability of specifying systems using UML notation, Booch notation, or Rumbaugh notation. Through this research effort, Rose98 has been extended to allow formal notation to be entered in the class diagram text fields. Rose scripts were developed to transform the resulting extended Rose model into Z (zed) specifications in LATEX format. Z specifications are developed for the object model, dynamic model, and functional model based on information gathered from the class diagram and state transition diagram of the Rose model. These specifications can then be parsed into a tool supporting formal methods and Ada code can be automatically generated

The current abstract view of the detailed architecture of a software program simply focuses on a set of modules that interact with each other. The pictorial view of the architecture of modules abstracts to a directed, connected, acyclic graph whose nodes are modules and whose arcs reveal the reference dependency relationship. No distinction exists among the modules. This paper provides a decided distinction. This paper introduces a new, formal, objective classification scheme of ten classes for modules. The process of fashioning the classification scheme applies the software principle of information hiding to three internal structural components of a module. These components are the variable, the data structure, and the subprogram. Two conceptual constructs enable information hiding. One is the encapsulation of a data structure (object). The other is the inaccessible section of a module which is the section that no external module can reference. Each module belongs to exactly one class. The assignment of a module to a class is objective, not subjective. The scheme opens up the opportunity for a deeper study into each class. The classes of the scheme are subjectively ranked into four categories, ranging from best to worst. The paper lists five benefits of this classification scheme, and relates these benefits to three application areas.

This paper presents a methodology for extracting objects from legacy imperative code. The parameter-based object identification (PBOI) methodology is based on the thesis that object attributes manifest themselves as data items passed from subprogram to subprogram in the imperative paradigm. A taxonomy of imperative subprograms is presented and the PBOI methodology is defined. Several examples are provided