[Previous Article]
[Next Article]
[In this Issue]
Rome Laboratory has been conducting a research and development program in requirements engineering since 1985. One result has been the evolutionary development of the Requirements Engineering Environment (REE). The REE is an integrated set of tools which allows system analysts to rapidly build functional and user interface prototypes. The REE is currently comprised of two tools: Proto and RIP.
Proto
Proto supports the prototyping of functional requirements. A functional prototype can model and execute the target system's operational capabilities to check the completeness and correctness of information as it flows through the system. This type of prototyping is typically performed on critical or complex applications. Proto supports the functional prototyping of requirements which are targeted to both sequential and parallel architecture environments. When performing functional prototyping the requirements analyst first obtains functional specifications for the application or the subset of the application to be prototyped. Such functional specifications represent precise descriptions of what the system does.
The analyst uses Proto to graphically construct a software model (logical model) which captures the functional specifications of the application. During this process the analyst creates multiple diagrams to identify the various functions in the specifications and their corresponding relationships. Such diagrams can be based on dataflow or object-based paradigms. The analyst uses a graphical editor to create all of the data objects required by the application. The details of the various specification functions are captured in a high level language which was explicitly developed for the tool. C functions and/or binary executables can also be used to describe function activities. In addition, a reusable library of functions is available to expedite model development. Collectively, the various diagrams, data objects, language statements and library functions make up a Proto software model.
If the software is targeted for a parallel architecture environment or the analyst wishes to identify and validate potential parallelism in the application being prototyped then a hardware model (physical model) can be graphically created and associated with the software model. The analyst uses a graphical approach to create a hardware model which consists of processors, buses and memories. In addition, Proto provides configurations for two multiple-instruction, multiple data (MIMD) parallel processing hardware architectures: a shared memory architecture and a distributed memory architecture. A template for automatic creation of mesh interconnection topologies is also provided. Once the hardware model is defined, the logical software functions can be associated with the physical hardware components. More than one such software-to-hardware mapping can be associated with a given hardware model. Moreover, more than one hardware model can be associated with a given functional prototype. Such capabilities support the effective analysis of various software to hardware mappings and hardware architecture trade-offs.
The analyst then executes the functional prototype using the Proto interpreter facility. Functions which are currently executing in the software model are highlighted. More importantly, the analyst can set breakpoints and view various data values. Performance statistics are available after an interpretation session. Once the application has been debugged, it is executed for the end users to verify its completeness and correctness. Comments provided by the end users are incorporated into the requirements specifications and the functional prototype. The prototype is once again executed for the end users. The procedure of executing the prototype for the end users and incorporating comments into the requirements specifications and prototype continues until the functional requirements are validated. The REE provides the capability to generate Ada and C code from the functional specifications. Such code can serve as the starting point for further design work.
Rapid Interface Prototyping (RIP)
RIP provides a graphical toolset to prototype human-machine interfaces. Such interfaces can model the system's screen layout as well as execute its associated functions. One of the strengths of RIP is that its users need not be computer scientists or programmers. RIP employs an Apple Macintosh "McDraw-like" graphics editor to create the objects required for the prototype and menus to specify the activities which will occur during the prototype execution. There is also a world database facility which allows geographical areas to be extracted out of a database and incorporated into the prototype.
The requirements analyst and end-user work together to define and capture the user interface requirements. Once requirements are defined, the analyst identifies relevant graphic objects and constructs a set of static and dynamic displays to be used in the prototype. The graphic objects represent the real-world objects as the user would see them on the display. Using menus, the analyst then links these displays in a logical sequence to create event sets and scenarios which represent operational system requirements. Examples of functionality which can occur during the scenario are displaying objects, ringing alarms, flashing objects, and prompting the user for inputs. RIP also supports the creation of simulated real-time dynamic displays and object motion which are based on events occurring over time. Once completed, the analyst working with the user, can execute the RIP prototype by selecting predetermined "hot-buttoned" objects on the display. Typical comments that users might provide are the need to change the color of an object, relocate an object on the screen or build additional functionality into the human-machine interface.
Proto and RIP Integration
The REE provides data sharing between the Proto and RIP tools. The RIP and Proto tools are integrated such that there is two way data sharing between them. First, a Proto model can be used to drive a RIP user interface prototype. The Proto tool provides a set of predefined functions which facilitate the manipulation of RIP objects. Such manipulations include removing and displaying objects, changing the color of objects, setting data values and moving objects to new locations. No programming is required to connect a Proto model with a RIP user interface. The second type of data sharing between Proto and RIP allows data values specified in RIP to be read and manipulated by a Proto model. Consequently, the data required for a Proto model can be interactively entered using custom made, user friendly interfaces. Once again, non-programming techniques are used to specify the connection between the two tools.
Utility & Usability
Proto is particularly useful for constructing system topological structures, logic control of software/system behavior and general modeling of the system's information/data flow triggered by events or external stimuli. RIP is useful for conceptualizing and designing user interfaces consisting of menus, windows and screens. In addition, its flexible graphical editing capabilities and other tools (such as map generation and scenario generation) make it a valuable resource in any organization performing software/system development activities. The integration capability provides the mechanism to execute the entire target system prototype very easily. Prototypes can be developed in a timely fashion and presented to key players of the lifecycle (end users, analysts, designers, developers) during appropriate system development milestones and reviews. REE prototype products can be thought of as low cost "mediums of communication" in which all system development players can observe prototype products and reconcile assumptions, tendencies, preferences and perspectives about requirements and high level design issues. At these reviews, feedback is then elicited and incorporated into the prototype and then reevaluated as necessary until all players are at a proper orientation point in which to proceed with more traditional development activities.
Operational Requirements
REE currently resides on a Sun platform (4/65 or better) with a minimum of 32 MB RAM, minimum of 100 MB of swap space and high resolution (color preferred) graphics monitor. Required software includes Sun OS 4.1.2 or 4.1.3 (porting to Solaris is currently underway), Ontologic's ONTOS 2.2 object-oriented database management system, Sun C compiler, Sun C++ 2.1 or 3.0.1 (if compiling generated C++ code) and Sun Ada (if compiling generated Ada code).
Rome Laboratory is actively transitioning REE technology to the general technical community. All inquiries can be directed to: