Incorporating Rapid User Interface Prototyping in Object-Oriented Analysis and Design with Genova Erik Arisholm Department of Informatics, University of Oslo, PO Box 1080 Blindern, N-0316 Oslo, Norway (e-mail:
[email protected])
Hans Christian Benestad Jon Skandsen Hege Fredhall Genera A/S, Marcus Thranes gate 2, N-0473 Oslo, Norway (e-mail: {hcb,jsk,hfr}@genera.no)
Abstract. User participation is generally believed to be beneficial in the early stages of product development to ensure that the finished software product meets customer requirements and expectations. However, most object-oriented methods prescribe the development of system models in such technical terms that user participation is difficult. In this paper, we describe an object-oriented development method with CASE tool support that enables user participation during object-oriented analysis and design. The technique used to achieve this is rapid development of model-based user interface prototypes.
1. Introduction Most object-oriented methodologists recommend that user-interface prototypes should be implemented during various phases of software development to ensure the validity of requirement specifications, analysis models and subsequent designs. In OOSE [1], user interface prototyping is prescribed as a valuable complement to the use case requirements model. In the Personal Software Process [2] prototypes are considered an important defect prevention mechanism. Common to these recommendations is that it is unclear how the prototype should be developed, and how the resulting prototype is supposed to be used as a defect prevention or validation mechanism. In [3], Mitchell noted that “prototyping has slipped into the back burner in the rush to adopt more tactile developments such as object-oriented modeling techniques and CASE”. Still, prototyping can be a valuable technique, in particular for detecting requirement defects by employing walkthroughs [12] on prototypes with the potential users. In [4], an empirical study of user participation in requirements engineering indicates that as the uncertainty of requirements increases, greater user participation alleviates the negative influence of uncertainty on the quality of the requirement analysis model. Requirement
defects are according to some studies very expensive to correct [5, 6], indicating that the cost benefits of finding defects early are significant. One particular problem is how the prototype can be rapidly developed while remaining consistent with the continuously evolving analysis and design models. In this paper, we describe the Genova method and its supporting CASE tool, the Genova tool, for rapid generation of user interface prototypes based on object models defined using the UML notation [8]. We believe that the resulting user interface prototypes can help prevent defects in analysis and design models. Some important related work exists in the field of model-based interface development environments, most notably the Mecano and Mobi-D projects at Stanford University [7]. They provide a more comprehensive treatment of the development of user interfaces in general, and on formal modeling of the dynamic aspects of the user interface in particular. Our approach differs in that we use the UML as a modeling notation, and that the Genova tool extends existing commercial object-oriented CASE tools (Rational Rose, Select Enterprise, etc.) for development of analysis and design models. Also, our target for improvement is analysis and design models whereas existing model-based interface development research focuses on improvement of the user interface. The Genova method and Genova tool are currently under development, but will soon be used in a large information system development project. During this project, we will evaluate the use of Genova. The remainder of this paper is organised as follows. Section 2 describes the Genova method and the Genova tool. Section 3 outlines a small development scenario using Genova. Finally, Section 4 concludes and describes future work.
2. Rapid User Interface Prototyping with Genova In the proposed Genova method (Figure 1), user requirements are modelled as use cases. Use cases were first proposed in the OOSE method [1] and are now supported by the UML notation. A use case describes a complete interaction between the system and the user in order to accomplish a goal [1, 8]. The sum of all use cases capture the high level functional system requirements. Each use case is elaborated by specifying a collection of related scenarios, which enumerate all the distinct interactions and outcomes of a use case. Scenarios may be textual descriptions, or more formal interaction diagrams or collaboration diagrams showing how the end-user interacts with candidate collaborations of objects in the system. Scenarios form the most important basis for the development of an initial object model. As stated in [9], the construction of formal scenarios (such as UML interaction diagrams) is based on known objects. We regard these objects as candidate objects that for instance can be found using techniques such as CRC [10] or role-modeling [11]. By examining the responsibilities and dynamic behaviour of candidate objects the object model can be developed.
The Genova method extends use case modeling, scenarios and object models with dialog flow models, dialog style guides, object selections, dialog models, dialog templates and the user interface prototypes. Scenarios form the basis for the development of a dialog flow model, showing the flow between dialogs necessary to complete the scenario in question. The dialog flow model can be specified by associating OPEN and CLOSE functionality with events in empty dialog skeletons. The transformation from an object model to a user interface prototype then proceeds as a three step process. In the first step, an associated set of objects (a collaboration) is selected from the object model using what is called an object selector. use case model
evaluates
scenarios
dialog flow model
object model
dialog style guide
dialog model
dialog template
user interface prototype FIGURE 1. The Genova method The next step, the generation of a dialog model, requires an object selection and a dialog style guide as input. The dialog style guide defines the rules for creating the dialog model from an object selection. These rules will affect:
• The generation of default window contents such as menu bars and message bars. • The generation and style of pushbuttons for triggering default database functionality such as insert, delete, update.
• The generation of tab controls related to the topology of the object selection. • The mapping of data types to user interface components. • The mechanisms used for grouping data fields. The last step, the automatic transformation from a dialog model to an actual user interface prototype, requires the specification of a predefined dialog template. The dialog template defines the layout and style for each user interface component. Layouts deter-
mine how groups of user interface components are positioned relative to each other, while styles define the font and color of each individual component. The resulting user interface prototype can be reviewed by the project team and end user participants as a means for detecting defects in the analysis and design models. Defects detected during walkthroughs[12] of the prototype trigger changes in the use case model that by re-iterating the Genova method eventually results in a new user interface prototype. The Genova tool uses the Unified Modeling Language (UML) [8] and off-the-shelf object modeling tools such as Rational Rose for specification of UML models. All activities in the method are supported by the Genova tool. Object models are specified in the off-the-shelf object modeling tool. Dialog style guides, object selections, dialog models and dialog templates are maintained by the Genova tool and stored in the Genova repository. The Genova dialog interpreter will give immediate feedback on the layout and content of dialogs, as well as the flow between dialogs. The Genova client generators produce a running version of the client part of the application, for distribution to the customer.
3. Example Development Scenario The following example explains the application of the proposed method on a very simple account management system, resulting in the generated user interface prototype. After the development of use cases and scenarios (not shown here), the initial object model is specified in Rational Rose using the UML class diagram (Figure 2).
FIGURE 2. Example object model
The next step in building a user interface prototype is to select a particular object collaboration from the object model using the object selector tool, as shown in Figure 3.
FIGURE 3. The Genova object selector tool The empty dialogs skeletons created to model the dialog flow can now be populated using object model information. The process is automatic, after an initial object selection and a dialog style guide has been specified. The resulting dialog model is depicted in Figure 4.
FIGURE 4. The Genova dialog model
Prototypes of the dialog model can be viewed immediately using the interpreter part of the Genova tool (Figure 5). Executable versions can also be generated for the most common GUI frameworks.
FIGURE 5. The resulting user interface prototype
4. Conclusion and Future Work This paper described the Genova method and the Genova tool. UML is complemented with dialog models, dialog flow models and dialog style guides, which allow rapid generation of dialogs and stand-alone user interface prototypes that graphically represent static and dynamic properties from the UML model. The Genova tool is currently under development at Genera AS, and we have already implemented key functionality for user interface prototyping based on the object selection mechanism on UML object models. Although the dialog flow model currently can be used to model the dynamic flow between dialogs, it needs a graphical modeling representation. The Genova tool also provides support for many additional development tasks such as database design and generation, and application generation for several platforms and programming languages. We believe that the resulting user interface prototypes will help prevent defects during user participated requirement capture, analysis and design. Genova will soon be used in a large information system development project. As a preparation for this project,
we are currently developing a Genova process handbook, which will provide more detailed recommendations for how Genova should be used in the development organization. During the project, we will evaluate the use of Genova, and in particular the use of user interface prototyping in object-oriented analysis and design. The design of the empirical case study is under development, and the details of the case study design will depend on the final project organization.
References [1] Jacobson I., Christerson M., Johnson P. and Øvergaard G.: Object-Oriented Software Engineering: A Use Case Driven Approach, Addison-Wesley, 1992 [2] Humphrey W.: A Discipline for Software Engineering, Addison-Wesley, 1995 [3] Mitchell I., Parrington N., Dunne P., and Moses J.: Practical Prototyping: Part 1, Object Currents, 1(5), May 1996 [4] Emam K.E., Quintin S., Madhavji N.H.: User Participation in the Requirements Engineering Process: An Empirical Study, Requirements Engineering, pg 4-26, 19961, Springer-Verlag 1996 [5] Fagan M.: Design and Code inspections to reduce errors in programs, IBM Systems Journal, 15(3) 7/1-7/26, August 1979 [6] Boehm B.W.: Software Engineering, IEEE Transactions on Computers, C-25(12): pages 1226-1241, December 1976 [7] Puerta A.: A Model-Based Interface Development Environment, IEEE Software, pages 40-47, July/August 1997 [8] Fowler M.: UML Distilled: Applying the Standard Object Modeling Language Addison-Wesley, 1997 [9] Koskimies K., Mannisto T., Systa T. and Tuomi J.: On the Role of Scenarios in Object-Oriented Software Design, Proceedings of NWPER’96, Aalborg, pages 53-69, May 29-31 [10] Beck K. and Cunningham W.: A Laboratory For Teaching Object-Oriented Thinking, Conference on Object-Oriented Programming: Systems, Languages, and Applications (OOPSLA'89), New Orleans, Louisiana, Proceedings. SIGPLAN Notices 24(10), pages 1-6, October 1-6,1989 [11] Reenskaug T., Wold P. and Lehne O.A.: Working With Objects, Manning Publication Co. 1996 [12] Freedman D.P. and Weinberg, G.M., Handbook of Walkthroughs, Inspections and Technical Reviews, 3rd edition, Dorset House, 1990
