GRÁFICO DE INFLUENCIA-DEPENDENCIA ENTRE ACTORES
5.7.5. MEDIOS DE COMUNICACIÓN
In this section, we describe the DynaMo-AID de- velopment process supporting the development cycle for context-aware and service-aware user interfaces in provid- ing methodologies and tool support in the design, proto- typing and deployment phase of the production of context- aware and service-aware user interfaces.
The development process is prototype-driven consisting of several iterations over a prototype until a final iteration results in a deployable user interface. The process is pre- sented in figure 1, inspired by the spiral model introduced by Boehm [1].
The process consists of four iterations which on their turn consist of four phases. Each iteration starts with the specification of an artefact, i.e. specification of models or code implementation (Artefact Construction). Subse- quently a prototype is derived from this artefact and test runs are performed with this prototype (Prototyping). Af- terwards this prototype is evaluated (Evaluation) in order to apply some changes to the basic artefact of the current iter- ation (Artefact Reconsideration). The updated artefacts are brought along to the next iteration.
The first iteration starts with the specification of mod- els defining a user interface. Firstly, abstract models are specified describing the interaction at a high level, such as user tasks (task model). Afterwards, tools assist the user
Figure 1. The User Interface Development Process
interface developer in transforming these abstract models into more concrete models (dialog and abstract presentation model) in order to make the models suitable for automated prototype generation. Next a static prototype is generated by the supporting design tool to perceive how the modelled user interface actually works. Finally, the prototype is eval- uated and possible changes to the modelled UI can be car- ried out.
The next iteration is meant to introduce context- awareness in the user interface. Because context is only relevant when it has a direct influence on the user’s task [4], we chose to attach the context model to a task model. Next a new prototype is automatically generated by the design tool. Afterwards the prototype is evaluated by the user interface developer and possible changes to the context and user in- terface models are allowed until the developer is satisfied with the resulting prototype.
In the third iteration the user interface models are linked to the functional core of the system. Furthermore the pre- sentation of the user interface is altered in order to present the data provided by the functional core of the system. Next a new prototype can be rendered. This prototype is now op- erational and can be used to test the user interface on top of a working functional core and influenced by external con- text information. The prototype is evaluated, and changes can be applied.
The final iteration includes the actual implementation of the final presentation layer of the user interface. This layer can be very thin due to the architecture’s modular character- istic and because the specified models are interpreted and used to support the communication between the different
parts of the system. In this way, more attention can be paid to the design of the presentation of the user interface in this final iteration. The resulting operational user interface can then be tested by means of a usability test with end users in order to make final adjustments to the presentation layer. Afterwards the user interface is ready for deployment.
3
Concluding Remarks
Traditional user interface development techniques did not consider external context influence. This is why we have constructed a new, prototype-based, tool supported develop- ment process in order to model and test context influence on the user interface of the system. We believe the evaluation of prototypes throughout the whole development process is necessary considering the development of ubiquitous sys- tems to create usable end user systems. In our work, we clearly focused on the development of context-aware and services-aware user interfaces which play an important role in ubiquitous systems.
Acknowledgements
The authors would like to thank Chris Vandervelpen and Kris Luyten for their contributions to the work described in this paper. Part of the research at EDM is funded by EFRD, the Flemish Government and IBBT. The CoDAMoS project IWT 030320 is directly funded by the IWT (Flemish subsidy organization).
References
[1] Barry W. Boehm. A spiral model of software develop- ment and enhancement. IEEE Computer, 21(5):61–72, 1988.
[2] Tim Clerckx, Kris Luyten, and Karin Coninx. Dynamo- aid: A design process and a runtime architecture for dynamic model-based user interface development. In Engineering for Human-Computer Interaction/DSV-IS, volume 3425 of Lecture Notes in Computer Science, pages 77–95. Springer, 2004.
[3] Tim Clerckx, Kris Luyten, and Karin Coninx. De- signing interactive systems in context: From prototype to deployment. In People and Computers XIX - The Bigger Picture, Proceedings of HCI 2005: The 19th British HCI Group Annual Conference, September 5- 9 2005, Napier University, Edinburgh, UK, pages 85– 100. Springer, 2005.
[4] Anind K. Dey. Providing Architectural Support for Building Context-Aware Applications. PhD thesis, Col- lege of Computing, Georgia Institute of Technology, December 2000.