Patricia Dockhorn Costa

An Introduction to Agile Methods

Abstract Agile Methods are creating a buzz in the software development community, drawing their fair share of advocates and opponents. While some people consider agile methods the best thing that has happened to software development in recent years, other people view them as a backlash to software engineering and compare them to hacking. The aim of this chapter is to introduce the reader to agile methods allowing him/her to judge whether or not agile methods could be useful in modern software development. The chapter discusses the history behind agile methods as well as the agile manifesto, a statement from the leaders of the agile movement. It looks at what it means to be agile, discusses the role of management, describes and compares some of the more popular agile methods, provides a guide for deciding where an agile approach is applicable, and lists common criticisms. It summarizes empirical studies, anecdotal reports, and lessons learned from applying agile methods and concludes with an analysis of various agile methods. The target audiences for this chapter include practitioners, who will be interested in the discussion of the different methods and their applications, researchers who may want to focus on the empirical studies and lessons learned, and educators looking to teach and learn more about agile methods.

Evaluating Software Architectures

Abstract As software systems become increasingly complex, the need to investigate and evaluate them at high levels of abstraction becomes more important. When systems are very complex, evaluating the system from an architectural level is necessary in order to understand the structure and interrelationships among the components of the system. There are several existing approaches available for software architecture evaluation. Some of these techniques, pre-implementation software architectural evaluations, are performed before the system is implemented. Others, implementation-oriented software architectural evaluations, are performed after a version of the system has been implemented. This chapter briefly describes the concepts of software architecture and software architectural evaluations, describes a new process for software architectural evaluation, provides results from two case studies where this process was applied, and presents areas for future work.

Empirical Findings in Agile Methods

In recent years, the use of, interest in, and controversy about Agile methodologies have realized dramatic growth. Anecdotal evidence is rising regarding the effectiveness of agile methodologies in certain environments and for specified projects. However, collection and analysis of empirical evidence of this effectiveness and classification of appropriate environments for Agile projects has not been conducted. Researchers from four institutions organized an eWorkshop to synchronously and virtually discuss and gather experiences and knowledge from eighteen Agile experts spread across the globe. These experts characterized Agile Methods and communicated experiences using these methods on small to very large teams. They discussed the importance of staffing Agile teams with highly skilled developers. They shared common success factors and identified warning signs of problems in Agile projects. These and other findings and heuristics gathered through this valuable exchange can be useful to researchers and to practitioners as they establish an experience base for better decision making.

Context-Aware, Ontology-Based Service Discovery

Service discovery is a process of locating, or discovering, one or more documents, that describe a particular service. Most of the current service discovery approaches perform syntactic matching, that is, they retrieve services descriptions that contain particular keywords from the user’s query. This often leads to poor discovery results, because the keywords in the query can be semantically similar but syntactically different, or syntactically similar but semantically different from the terms in a service description. Another drawback of the existing service discovery mechanisms is that the query-service matching score is calculated taking into account only the keywords from the user’s query and the terms in the service descriptions. Thus, regardless of the context of the service user and the context of the services providers, the same list of results is returned in response to a particular query. This paper presents a novel approach for service discovery that uses ontologies to capture the semantics of the user’s query, of the services and of the contextual information that is considered relevant in the matching process.

An Empirically-Based Process for Software Architecture Evaluation

Software systems undergo constant change causing the architecture of the system to degenerate over time. Reversing system degeneration takes extra effort and delays the release of the next version. Improved architecture is intangible and does not translate into visible user features that can be marketed. Due to a lack of representative metrics, technical staff has problems arguing that stopping degeneration is indeed necessary and that the effort will result in an improved architecture that will pay off. We believe that architectural metrics would give technical staff better tools to demonstrate that the architecture has improved. This paper defines and uses a set of architectural metrics and outlines a process for analyzing architecture to support such an argument. The paper reports on a case study from a project where we restructured the architecture of an existing client-server system written in Java while adding new functionality. The modules of the existing version of the system were “library-oriented” and had a disorganized communication structure. The new architecture is based on components and utilizes the mediator design pattern. The goal of the study is to evaluate the new architecture from a maintainability perspective. The paper describes our evaluation process, the metrics used, and provides some preliminary results. The architectural evaluation shows that the components of the system are only loosely coupled to each other and that an architectural improvement has occurred from a maintenance perspective. The process used to evaluate the architecture is general and can be reused in other contexts.

Situations in Conceptual Modeling of Context

In previous work, we have defined conceptual foundations that can be beneficially used in context modeling. These conceptual foundations include the separation of entity and context, and the characterization of context as either Intrinsic or Relational. This paper aims at extending this approach by introducing the ontological concept of Situation as means of composing the elements of our ontology (entities, intrinsic and relational contexts) to model particular states of affairs of interest. Our concepts have been inspired by and aligned with conceptual theories from the fields of philosophy and cognitive sciences.

Lessons Learned about Structuring and Describing Experience for Three Experience Bases

The Experience Factory approach defines a framework for experience management. It has been successfully applied to software development at NASA for more than 25 years and has now been applied to other organizations outside the software development community. The Experience Management System (EMS) developed at Fraunhofer Center Maryland (FC-MD) is a set of tools implemented to support the Experience Factory approach. The Visual Query Interface (VQI), a component of EMS, is used in conjunction with a methodology to help organizations capture, synthesize and reuse experience. To easily add new experience as well as find previous experience packages, the captured experience must be structured and stored in an experience base. This paper describes how we organize and structure experience into packages that can be stored in the experience base. We describe some of the lessons learned from applying EMS to three different organizations.

Designing a configurable services platform for mobile context‐aware applications

Context-aware services platforms aim at supporting the handling of contextual information in order to provide better user-tailored services. This paper proposes a novel services platform architecture to support mobile context-aware applications, giving emphasis to the configurability of the platform’s generic functionality. The paper introduces concepts and a language to cope with configurability aspects. The paper also reports on the implementation of a prototype, which implements a Web services-based context-aware services platform that runs on top of 3G networks

Does the code match the design? A process for architecture evaluation

Constant changes cause software architectures to degenerate. In organizations where developers are involved in the maintenance and evolution, system degeneration is even more likely to occur. We have experimented with a process for detecting deviations from the intended design. The process is a quick and inexpensive process that helps to keep the system architecture from veering off course from the planned design. It is expected to improve maintainability over time. The paper describes our evaluation process, the metrics used and presents results of applying the process in a case study. The case study illustrates the difficulty involved in detecting deviations without a systematic approach. The process used to evaluate the architecture is general and straightforward. We believe the process can be reused in other contexts.

Situation specification and realization in rule-based context-aware applications

Context-aware applications use and manipulate context information to detect high-level situations, which are used to adapt application behavior. This paper discusses the specification of situations in context-aware applications and introduces a rule-based approach to detect situations. Situations are specified using a combination of UML class diagrams and OCL constraints. We support a wide range of situations, which can be composed of more elementary kinds of context. We discuss how to cope with distribution and to exploit it beneficially for context manipulation and situation detection. We employ a generic rule-based platform (DJess [2]) to support the derivation of situations in a distributed fashion.