Involving end users in the development of interactive systems increases the likelihood those systems will be useful and usable. User involvement, however, is both time and resource intensive. Internetand World-Wide-Web-based software release models have magnified these problems. At the same time, these practices have begun to blur the distinction between development and use and, in so doing, have provided developers with unprecedented, and currently underutilized, opportunities for increasing user involvement. We propose an approach — based on expectation-driven event monitoring and expectation agents — that leverages these opportunities to support ongoing user involvement in the software development process.

The open source movement has created and uses a set of software engineering tools with features that fit the characteristics of open source development processes.To a large extent, the open source culture and methodology are conveyed to new developers via the toolset itself, and through the demonstrated usage of these tools on existing projects.The rapid and wide adoption of open source tools stands in stark contrast to the difficulties encountered in adopting traditional Computer-Aided Software Engineering (CASE) tools.This chapter explores the characteristics that make these tools adoptable and discusses how adopting them may influence software development processes.

The Unified Modeling Language (UML) is a family of design notations that is rapidly becoming a de facto standard software design language. UML provides a variety of useful capabilities to the software designer, including multiple, interrelated design views, a semiformal semantics expressed as a UML meta model, and an associated language for expressing formal logic constraints on design elements. The primary goal of this work is an assessment of UML's expressive power for modeling software architectures in the manner in which a number of existing software architecture description languages (ADLs) model architectures. This paper presents two strategies for supporting architectural concerns within UML. One strategy involves using UML "as is," while the other incorporates useful features of existing ADLs as UML extensions. We discuss the applicability, strengths, and weaknesses of the two strategies. The strategies are applied on three ADLs that, as a whole, represent a broad cross-section of present-day ADL capabilities. One conclusion of our work is that UML currently lacks support for capturing and exploiting certain architectural concerns whose importance has been demonstrated through the research and practice of software architectures. In particular, UML lacks direct support for modeling and exploiting architectural styles, explicit software connectors, and local and global architectural constraints.

The open source movement has created and used a set of software engineering tools with features that fit the characteristics of open source development processes. To a large extent, the open source culture and methodology are conveyed to new developers via the toolset itself, and through the demonstrated usage of these tools on existing projects. The rapid and wide adoption of open source tools stands in stark contrast to the difficulties encountered in adopting traditional CASE tools. This paper explores the characteristics that make these tools adoptable and how adopting them may influence software development processes.

Software design is a cognitively challenging task. Most software design tools provide support for editing, viewing, storing, and transforming designs, but lack support for the essential and difficult cognitive tasks facing designers. These cognitive tasks include decision-making, decision ordering, and task-specific design understanding.This paper describes Argo/UML, an object-oriented design tool using the unified modeling language (UML) design notation. Argo/UML supports several identified cognitive needs of software designers. This support is provided in the form of design tool features. We describe each feature in the context of Argo/UML and provide enough detail to enable other tool builders to provide similar support in their own tools. We also discuss our implementation of the UML and XMI standards, and our development approach. (C) 2000 Elsevier Science B.V. All rights reserved.

This paper discusses the use of HTML for creating early prototypes of interactive systems. The HTML prototyping technique uses an iterative approach for the creation of early prototypes. Low fidelity prototypes are iteratively refined into higher fidelity versions. The prototypes are easily accessible to project stakeholders. We evaluate the HTML prototyping technique with respect to criteria published in the CHI community.

Design diagrams play an important role in many disciplines. Many types of diagrams use spacing and alignment to communicate implicit relationships between objects within the diagram. We describe and evaluate a direct manipulation alignment tool based on a push-broom metaphor.

Software architecture descriptions are high-level models of software systems. Some researchers have proposed special-purpose architectural notations that have a great deal of expressive power but are not well integrated with common development methods. Others have used mainstream development methods that are accessible to developers, but lack semantics needed for extensive analysis. We describe an approach to combining the advantages of these two ways of modeling architectures. We present two examples of extending UML, an emerging standard design notation, for use with two architecture description languages, C2 and Wright. Our approach suggests a practical strategy for bringing architectural modeling into wider use, namely by incorporating substantial elements of architectural models into a standard design method.

Expectation-Driven Event Monitoring (EDEM) provides developers with a platform for creating software agents to collect usage data and increase user involvement in the development of interactive systems. EDEM collects information that is currently lost regarding actual usage of applications to promote improved usability and a more empirically grounded design process.

The poor design of interactive systems has been attributed to insufficient communication between developers and end users. Critical forms of communications include soliciting requirements and feedback on prototype systems. Our research develops a software lifecycle emphasizing feedback from end users and communication among end users, developers, and other stakeholders in a software development project. Communication implies the transferal, storage, and review of knowledge about a software project. Three software systems —Argo, EDEM, and the Knowledge Depot —illustrate one kind of support that can be provided for the management of knowledge to improve the design of interactive software. Specifically, Argo provides support for the design of systems; EDEM provides support for collecting feedback and usage data from end users; and the Knowledge Depot provides support for reviewing feedback and other information about a system.

Software architectures are high-level design representations of software systems that focus on composition of software components and how those components interact. Software architectures abstract the details of implementation and allow the designer to focus on essential design decisions. Regardless of notation, designers are faced with the task of making good design decisions, which demands a wide range of knowledge of the problem and solution domains. Argo is a software architecture design environment that supports designers by addressing several cognitive challenges of design. In this paper we describe how Argo supports decision making by automatically supplying knowledge that is timely and relevant to decisions at hand.

Domain-oriented design environments are cooperative problem-solving systems that support designers in complex design tasks. We present the facilities and architecture of Argo, a domain-oriented design environment for software architecture. Argo's architecture is motivated by the desire to achieve reuse and extensibility of the design environment. It separates domain-neutral code from domain-oriented code, which is distributed among intelligent design materials as opposed to being centralized in the design environment. Argo's facilities are motivated by the observed cognitive needs of designers. These facilities extend previous work in design environments to support reflection-in-action, opportunistic design, and comprehension and problem-solving.

Design critiquing systems are a type of intelligent user interface used to support human designers in decision making. This paper places design critics in the larger context of intelligent user interface approaches and surveys several critiquing systems. Each approach and system is evaluated with respect to a five-phase design improvement process. This paper concludes with a summary of the state of the art in critiquing systems and recommendations for future research directions.

Architecture-based software development is an approach to designing software in which developers focus on one or more high-level models of the software system rather than program source code. Choosing which aspects to model and how to evaluate them are two decisions that frame software architecture research. Some software architecture researchers have proposed special-purpose notations that have a great deal of expressive power but are not well integrated with common development methods. Others have used general-purpose notations that are accessible to developers, but lack details needed for extensive analysis. In this paper we describe an approach to combining the advantages offered by these two different kinds of notation. In particular, we extend UML, an emerging standard notation for object-oriented design, with semantics specific to C2, an architectural style for user-interface intensive systems. Doing so suggests a practical strategy for bringing architectural modeling into the mainstream of software development and achieving partial integration of architectural models as needed.

Software architectures evolve as the result of numerous, interrelated design decisions. At any point in an architecture’s evolution, current decisions can critically affect altematives at later stages, and each decision has the potential of requiring previous decisions to be reconsidered. Analysis techniques that provide feedback only after “complete” sequences of design decisions have been made do not directly support the evolutionary nature of the architecture design process. We present a system for architectural analysis that more closely supports evolution by providing feedback as design decisions are made.

Software architectures are useful, in part, because they use the appropriate level of abstraction to support the design of complex systems. Software architecture research has quickly evolved to the degree that design environments have been implemented to support software architects in creating new designs. We report on a software architecture design environment named Argo that differs from other approaches by paying attention to the human, cognitive needs of software architects, as much as to the representation and manipulation of the architecture itself. We emphasize the primary considerations by contrasting the human cognitive design process to the systems-oriented software design process. Human-centered features in Argo focus on the application of critics for providing design feedback, design processes for supporting critics, and multiple architectural perspectives for aiding human designers.

Software architectures evolve as the result of numerous, interrelated design decisions. At any point in an architecture’s evolution, current decisions can critically affect alternatives at later stages, and each decision has the potential of requiring previous decisions to be reconsidered. Analysis techniques that provide feedback only after “complete” sequences of design decisions have been made do not directly support the evolutionary nature of the architecture design process. In this paper we present an approach to architectural analysis that more closely supports evolution by providing feedback as design decisions are made.

Fundamental to the design of visual languages are the goals of facilitating communication between people and computers, and between people and other people. The Object Block Programming Environment (OBPE) is a visual design, programming, and simulation tool which emphasizes support for both human-human and human-computer communication. OBPE provides several features to support effective communication: (1) multiple, coordinated views and aspects, (2) customizable graphics, (3) the "machines with push-buttons" metaphor and (4) the host-transient pattern. OBPE uses a diagram-based, visual object-oriented language that is intended for quickly designing and programming visual simulations of factories.