Scott Henninger

An evolutionary approach to constructing effective software reuse repositories

Repositories for software reuse are faced with two interrelated problems: (1) acquiring the knowledge to initially construct the repository and (2) modifying the repository to meet the evolving and dynamic needs of software development organizations. Current software repository methods rely heavily on classification, which exacerbates acquistition and evolution problems by requiring costly classification and domain analysis efforts before a repository can be used effectively, This article outlines an approach that avoids these problems by choosing a retrieval method that utilizes minimal repository structure to effectively support the process of finding software conponents. The approach is demonstrated through a pair of proof-of-concept prototypes: PEEL, a tool to semiautomatically identify reusable components, and CodeFinder, a retrieval system that compensates for the lack of explicit knowledge structures through a spreading activation retrieval process. CodeFinder also allows component representations to be modified while users are searching for information. This mechanism adapts to the changing nature of the information in the repository and incrementally improves the repository while people use it. The combination of these techniques holds potential for designing software repositories that minimize up-front costs, effectively support the search process, and evolve with an organizations changing needs.

Supporting the construction and evolution of component repositories

Repositories must be designed to meet the evolving and dynamic needs of software development organizations. Current software repository methods rely heavily on classification, which exacerbates acquisition and evolution problems by requiring costly classification and domain analysis efforts before a repository can be used effectively. This paper outlines an approach in which minimal initial structure is used to effectively find relevant software components while methods are employed to incrementally improve repository structures. The approach is demonstrated through PEEL, a tool to semi-automatically identify reusable components, and CodeFinder, a retrieval system that compensates for the lack of explicit knowledge structures through spreading activation retrieval and allows component representations to be incrementally improved while users are searching for information. The combination of these techniques yields a flexible software repository that minimizes up-front costs and improves its retrieval effectiveness as developers use it to find reusable software artifacts.

Software pattern communities: current practices and challenges

Software pattern designers and users have few resources available to support pattern-based development practices. Patterns are currently disseminated in disjoint collections in various publishing mediums with little or no technology support. As the number of patterns and diversity of pattern types continue to proliferate, pattern users and developers are faced with difficulties of understanding what patterns already exist and when, where, and how to use or reference them properly. This defeats the very purpose of patterns as a medium to encapsulate and disseminate recurring design experiences. In this paper, an initial study among a set of pattern collections is performed to better understand the difficulties related to improve pattern-based support for software development activities. Based on the empirical survey, challenges are identified that define impediments to the federation of software patterns into an interconnected body of knowledge. A Semantic Web ontology is presented as an initial attempt at solving some of these issues through the use of Web-based ontologies.

Case-Based Knowledge Management Tools for Software Development

Modern software development is a knowledge-intensive activity. The proliferation of development tools, rapidly changing technology, and increasing complexity and diversity of application domains all increase the cognitive burden placed on software developers. General purpose programming languages and CASE tools offer little relief from these problems. Knowledge management tools are needed that can effectively capture and disseminate software development knowledge that applies to the domain-specific needs of an organization. This knowledge is not static, but evolves with technology and the changing needs of the organization‘s development practices, customer base, and business milieu. This paper presents an infrastructure that supports evolving knowledge through case-based techniques and domain analysis methods that capture emerging knowledge and synthesize it into generally applicable forms. The approach is less concerned with the veracity of knowledge in its repository than evolving the knowledge toward answers to problems that fit the organization‘s technical and business context. Implications of this approach go beyond supporting software development to other knowledge-intensive professions where knowledge management tools can be used to support an organizational memory.

A methodology and tools for applying context-specific usability guidelines to interface design

Abstract This paper presents a methodology and an associated technology to create context-specific usability guidelines. The objective is to transform usability guidelines into a proactive resource that software developers can employ early and often in the development process. The methodology ensures conformance with established guidelines, but has the flexibility to use design experiences to adapt the guidelines to meet the emergent and diverse requirements of modern user interface design. Case-based and organizational learning technology is used to support the methodology and provide valuable resources for software developers.

A framework for developing experience-based usability guidelines

Reflecting the growing consensus that principles and methods for developing effective interfaces are beginning to mature, usability design guidelines have begun to proliferate. But current approaches to guidelines tend to either be technology-centric, focusing on platform-specific interface widgets, or abstract and general-purpose. At best, these general guidelines provide weak support that is insufficient to support developers faced with specific interface design problems targeted for specific user populations. If the potential of usability guidelines as an interface design technique is to be fully realized, they need to be augmented with context-specific guidelines and examples that synthesize isolated guidelines into domain-specific solutions to design problems. In this paper, we present a method in which software development organizations can develop and evolve domain-specific guidelines based on the kinds of applications they develop. The method facilitates the process of determining when and how guidelines should be applied by tying guidelines to specific design cases and providing the means to match customer requirements to specific interface techniques that have proven effective for similar users and application domains. The concrete cases help designers interpret the guidelines, making them easier to comprehend and apply to the current design problem. We demonstrate these issues through Mimir, a case-based system that supports the refinement and location of relevant guidelines and cases.

An organizational learning approach to domain analysis

As the application of computer technology continues to proliferate and diversify, the identification and understanding of application domains is becoming increasingly important to software development methodologies. Domain analysis techniques have been developed to accumulate and formalize the knowledge necessary for successful software reuse. These techniques have been shown to be useful, but suffer from defining the domain too restrictively, burying important relationships deep in domain taxonomies, and prohibiting flexible identification of domains with common issues. Techniques are needed that dynamically detect recurring patterns of activities in development projects, This paper presents a method for developing and refining the knowledge and experience accumulated by a development organization so it can learn from previous efforts. A case-based repository of project experiences supports the re-use and refinement of domain knowledge to reduce duplicate effort, build on successful efforts, and avoid repeating mistakes in the process of building quality software systems.

A Case-Based Approach to Tailoring Software Processes

Software development is a knowledge-intensive activity involving the integration of diverse knowledge sources that undergo constant change. The volatility of knowledge in software development demands approaches that retrieve episodic knowledge and support the continuous knowledge acquisition process. To address these issues, case-based technology is used in combination with an organizational learning process to create an approach that turns Standard Development Methodologies (SDM) into living documents that capture project experiences and emerging requirements as they are encountered in an organization. A rule-based system is used to tailor the SDM to meet the characteristics of individual projects and provide relevant development knowledge throughout the development lifecycle.

Information access tools for software reuse

Software reuse has long been touted as an effective means to develop software products. But reuse technologies for software have not lived up to expectations. Among the barriers are high costs of building software repositories and the need for effective tools to help designers locate reusable software. Although many design-for-reuse and software classification efforts have been proposed, these methods are cost-intensive and cannot effectively take advantage of large stores of design artifacts that many development organizations have accumulated. Methods are needed that take advantage of these valuable resources in a cost-effective manner. This article describes an approach to the design of tools to help software designers build repositories of software components and locate potentially reusable software in those repositories. The approach is investigated with a retrieval tool, named CodeFinder, which supports the process of retrieving software components when information needs are ill-defined and users are not familiar with vocabulary used in the repository. CodeFinder uses an innovative integration of tools for the incremental refinement of queries and a retrieval mechanism that finds information associatively related to a query. Empirical evaluation of CodeFinder has demonstrated the effectiveness of the approach.

Interface issues and interaction strategies for information retrieval systems

The need for effective information retrieval systems becomes increasingly important as computer-based information repositories grow larger and more diverse. In this tutorial, we will present the key issues involved in the use and design of effective interfaces to information retrieval systems. The process of satisfying information needs is analyzed as a problem solving activity in which users learn and refine their needs as they interact with a repository. Current systems are analyzed in terms of key interface and interaction techniques such as querying, browsing, and relevance feedback, We will discuss the impact of information seeking strategies on the search process and what is needed to more effectively support the search process. Retrieval system evaluation techniques will be discussed in terms of their implications for users. We close by outlining some user-centered design strategies for retrieval systems. INFORMATION RETRIEVAL AS A PROBLEM SOLVING PROCESS The field of information retrieval can be divided along the lines of its system-based and user-based concerns. While the system-based view is concerned with efficient search techniques to match query and document representations, the user-based view must account for the cognitive state of the searcher and the problem solving context. People are drawn to an information retrieval system because they perceive that they lack some knowledge to solve a problem or perform a task. This creates an “anomalous state of knowledge” [1] or “situation of irresolution” [6] in which information seekers must find something they know little or nothing about. Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of ACM. To copy otherwise, or to republish, requires a fee and/or specific permission. CHI’ Companion 95, Denver, Colorado, USA Q 1995 ACM 0-89791 -755-3/95/0005...