This article analyses the relationships between software architecture, programming languages and interactive systems. It proposes to consider that languages, like user interface tools, implement architecture styles or patterns aimed at particular stakeholders and scenarios. It lists architecture issues in interactive software that would be best resolved at the language level, in that conflicting patterns are currently proposed by languages and user interface tools, because of differences in target scenarios. Among these issues are the contra-variance of reuse and control, new scenarios of software reuse, the architecture-induced concurrency, and the multiplicity of hierarchies. The article then proposes a research agenda to address that problem, including a requirement-and scenario-oriented deconstruction of programming languages to understand which of the original requirements still hold and which are not fully adapted to interactive systems.
The design of usable interactive systems is a complex task that requires knowledge and expertise on human factors and on software development. Usability guidelines and design patterns may be one way to alleviate the lack of expertise on usability of development teams by providing guidance to solve every designer's problem when designing and developing User Interface. However, the utility of guidelines and design patterns relays on two main issues: a) the quality of the advices provided, and b) the way they are organized allowing fast access to the appropriate solutions. In this paper we discuss the organization of usability guidelines and patterns at the light of an industrial project at SmalS-MvM devoted to the development of e-Government applications in a very large scale. This paper presents not only a proposal of patterns organization but also it describes a set of analysis patterns identified for e-Government applications.
Graph theory provides a substantial resource for a diverse range of quantitative and qualitative usability measures that can be used for evaluating recovery from error, informing design tradeoffs, probing topics for user training, and so on. Graph theory is a straight-forward, practical and flexible way to implement real interactive systems. Hence, graph theory complements other approaches to formal HCI, such as theorem proving and model checking, which have a less direct relation to interaction. This paper gives concrete examples based on the analysis of a real non-trivial interactive device, a medical syringe pump, itself modelled as a graph. New ideas to HCI (such as small world graphs) are introduced, which may stimulate further research.
In this paper, we present the results of a case study conducted together with a small company that develops a workflow modeling tool. During the case study, we created a pattern collection for the domain of workflow modeling tools and evaluated a subset of these patterns. Beside the pattern description itself, the contribution of our work is a systematic process for identifying patterns. The results of the case study showed, that the identified pattern are a valuable instrument for software developers to improve the usability of their software in the given domain. Additionally this finding shows that the process of pattern identification is valuable as well. ACM Classification Keywords: H5.2. Information interfaces and presentations, Miscellaneous theory and methods, D.2.2 Software Engineering, Design Tools and Techniques.
This paper describes an approach that uses task modelling for the development of distributed and multimodal user interfaces. We propose to enrich tasks with possible interaction modalities in order to allow the user to perform these tasks using an appropriate modality. The information of the augmented task model can then be used in a generic runtime architecture we have extended to support runtime decisions for distributing the user interface among several devices based on the specified interaction modalities. The approach was tested in the implementation of several case studies. One of these will be presented in this paper to clarify the approach.
Plastic User Interfaces (UI) are able to adapt to their context of use while preserving usability. Research efforts have focused so far, on the functional aspect of UI adaptation, while neglecting the usability dimension. This paper investigates how the notion of mapping as promoted by Model Driven Engineering (MDE), can be exploited to control UI adaptation according to explicit usability criteria. In our approach, a run-time UI is a graph of models related by mappings. Each model (e.g., the task model, the Abstract UI, the Concrete UI, and the final UI) describes the UI from a specific perspective from high-level design decisions (conveyed by the task model) to low-level executable code (i.e. the final UI). A mapping between source and target models specifies the usability properties that are preserved when transforming source models into target models. This article presents a meta-model for the notion of mapping and shows how it is applied to plastic UIs.
Many systems form `chains' whereby developers use one system (or `tool') to create another system, for use by other people. For example, a web development tool is created by one development team then used by others to compose web pages for use by yet other people. Little work within Human-Computer Interaction (HCI) has considered how usability considerations propagate through such chains. In this paper, we discuss three-link chains involving people that we term Creators (commonly referred to as designers), Composers (users of the tool who compose artefacts for other users) and Consumers (end users of artefacts). We focus on usability considerations and how Creators can develop systems that are both usable themselves and also support Composers in producing further systems that Consumers can work with easily. We show how CASSM, an analytic evaluation method that focuses attention on conceptual structures for interactive systems, supports reasoning about the propagation of concepts through Creator-Composer-Consumer chains. We use as our example a knowledge representation system called Tallis, which includes specific implementations of these different perspectives. Tallis is promoting a development culture within which individuals are empowered to take on different roles in order to strengthen the `chain of comprehension' between different user types.
Taking Mathematica and xThink as representatives of the state of the art in interactive mathematics, we argue conventional mathematical user interfaces leave much to be desired, because they separate the mathematics from the context of the user interface, which remains as unmathematical as ever. We put the usability of such systems into mathematical perspective, and compare the conventional approach with a novel declarative, gesture-based approach, exemplified by TruCalc , a novel calculator we have developed.
The “Model - Display view - Picking view - Controller” model is a refinement of the MVC architecture. It introduces the “Picking View” component, which offloads the need from the controller to analytically compute the picked element. We describe how using the MPDC architecture leads to benefits in terms of modularity and descriptive ability when implementing interactive components. We report on the use of the MDPC architecture in a real application: we effectively measured gains in controller code, which is simpler and more focused.
Challenges in designing effective groupware include technical issues associated with concurrent and distributed work and social issues associated with supporting group activities. To address some of these problems, we have developed a quality-centere d architectural design framework that links requirements analysis to architectural design decisions for groupware systems. The framework supports reasoned architectural design choices that are used to tailor software architecture to the unique quality and functional requirements of the software being developed. The framework has been applied to the development of the Software Design Board, a tool for collaborative software engineering.
Software Engineering (SE) and Usability Engineering (UE) both provide a wide range of elaborated process models to create software solutions. Today, many companies have understood that a systematic and structured approach to usability is as important as the process of software development itself. However, theory and practice is still scarce how to incorporate UE methods into development processes. With respect to the quality of software solutions, usability needs to be an integral aspect of software development and therefore the integration of these two processes is a logical and needed step. One challenge is to identify integration points between the two disciplines that allow a close collaboration, with acceptable additional organizational and operational efforts. This paper addresses the questions of where these integration points between SE and UE exist, what kind of fundamental UE activities have to be integrated in existing SE processes, and how this integration can be accomplished.
Formal diagrammatic notations have been developed as alternatives to symbolic specification notations. Ostensibly to aid users in performing comprehension and reasoning tasks, restrictions called wellformedness conditions may be imposed. However, imposing too many of these conditions can have adverse effects on the utility of the notation (e.g. reducing the expressiveness). Understanding the human factors involved in the use of a notation, such as how user-preference and comprehension relate to the imposition of wellformedness conditions, will enable the notation designers to make more informed design decisions. Euler diagrams are a simple visualization of set-theoretic relationships which are the basis of more expressive constraint languages. We have performed exploratory studies with Euler diagrams which indicated that novice user preferences strongly conform to the imposition of all wellformedness conditions, but that even a limited exposure diminishes this preference.
Usability is a key quality attribute of successful software systems. Unfortunately, there is no common understanding of the factors influencing usability and their interrelations. Hence, the lack of a comprehensive basis for designing, analyzing, and improving user interfaces. This paper proposes a 2-dimensional model of usability that associates system properties with the activities carried out by the user. By separating activities and properties, sound quality criteria can be identified, thus facilitating statements concerning their interdependencies. This model is based on a tested quality meta-model that fosters preciseness and completeness. A case study demonstrates the manner by which such a model aids in revealing contradictions and omissions in existing usability standards. Furthermore, the model serves as a central and structured knowledge base for the entire quality assurance process, e.g. the automatic generation of guideline documents.
Nowadays, while the number of users of interactive software steadily increase, new applications and systems appear and provide further complexity. An example of such systems is represented by multi-device applications, where the user can interact with the system through different platforms. However, providing end-users with real capabilities to author user interfaces is still a problematic issue, which is beyond the ability of most end-users today. In this paper, we present an approach intended to enable users to modify Web interfaces easily, considering implicit user intents inferred from example interface modifications carried out by the user. We discuss the design issues involved in the implementation of such an intelligent approach, also reporting on some experimental results obtained from a user test.
This paper presents first results of a research project whose goal is to develop a pattern language that enhances business software by motivating and engaging elements. The goal of the pattern language is to turn the soft and vague term of "emotions in user interaction design" into constructive design guidance. The patterns are especially tailored for joy-of-use in business applications. The main contribution of this paper is the description of quality characteristics for this pattern language. They are illustrated by references to existing pattern descriptions and elaborating their deficiencies. This paper shows how these weaknesses were addressed in the pattern language. ACM Classification Keywords: D.2.1 Requirements/Specifications, D.2.2 Design Tools and Techniques, H.5.2 User Interfaces.
Ubiquitous environments make various types of interaction platforms available to users. There is an increasing need for automatic tools able to transform user interfaces for one platform into versions suitable for a different one. To this end, it is important to have solutions able to take user interfaces for a given platform and build the corresponding logical descriptions, which can then be manipulated to obtain versions adapted to different platforms. In this paper we present a solution to this issue that is able to reverse engineer even interfaces supporting different modalities (graphical and voice).
The last few years have seen an explosion of interaction possibilities opened up by ubiquitous computing, mobile devices, and tangible interaction. Our methods of modelling interaction, however, have not kept up. As is to be expected with such a rich situation, there are many ways in which interaction might be modelled, focussing, for example, on user tasks, physical location(s) and mobility, data flows or software elements. In this paper, we present a model and modelling technique intended to capture key aspects of user's interaction of interest to interactive system designers, at the stage of requirements capture and early design. In particular, we characterise the interaction as a physically mediated information exchange, emphasizing the physical entities involved and their relationships with the user and with one another. We apply the model to two examples in order to illustrate its expressive power.
Corporate software development faces very demanding challenges, especially concerning the design of user interfaces. Collaborative design with stakeholders demands modeling methods that everybody can understand and apply. But when using traditional, paper-based methods to gather and document requirements, an IT organization often experiences frustrating communication issues between the business and development teams. We present ways of implementing model-driven prototyping for corporate software development. Without harming agile principles and practice, detailed prototypes can be employed for collaborative design. Model-driven prototyping beats a new path towards visual specifications and the substitution of paper-based artifacts.
Most user interfaces and ubiquitous systems are built around event-based paradigms. Previous work has argued that interfaces, especially those heavily depending on context or continuous data from sensors, should also give attention to status phenomena – that is continuously available signals and state. Focusing on both status and event phenomena has advantages in terms of adequacy of description and efficiency of execution. This paper describes a collection of XML-based specification notations (called XSED) for describing, implementing and optimising systems that take account of this dual status–event nature of the real world. These notations cover individual components, system configuration, and separated temporal annotations. Our work also presents a implementation to generate Status-Event Components that can run in a stand-alone test environment. They can also be wrapped into a Java Bean to interoperate with other software infrastructure, particularly the ECT platform.
Model-based toolkit widgets have the potential for (i) increasing automation and (ii) making it easy to substitute a user-interface with another one. Current toolkits, however, have focused only on the automation benefit as they do not allow different kinds of widgets to share a common model. Inspired by programming languages, operating systems and database systems that support a single data structure, we present here an interface that can serve as a model for not only the homogeneous model-based structured-widgets identified so far – tables and trees – but also several heterogeneous structured-widgets such as forms, tabbed panes, and multi-level browsers. We identify an architecture that allows this model to be added to an existing toolkit by automatically creating adapters between it and existing widget-specific models. We present several full examples to illustrate how such a model can increase both the automation and substitutability of the toolkit. We show that our approach retains model purity and, in comparison to current toolkits, does not increase the effort to create existing model-aware widgets.
