Debugging Integrated Systems: An Ethnographic Study of Debugging Practice
Debugging Integrated Systems: An Ethnographic Study of Debugging Practice Thomas Østerlie, Alf Inge Wang Norwegian University of Science and Technology {lie, }@ Abstract This paper explores how software developers debug integrated systems, where they have little or no access to the source code of the third-party software the system is composed of. We analyze the practice of debugging integrated systems, identifying five characteristics that set it apart from existing research on debugging: it spans a variety of operating environments, it is collective, social, heterogeneous, and ongoing. We draw implications of this for software maintenance research and debugging practice. The results presented in this paper are based on observations from an ethnographic study of the Gentoo OSS community, a geographically distributed community of over 320 developers developing and maintaining a software system for distributing and integrating third-party software packages with different Unix versions. 1. Introduction Software maintenance constitutes a significant factor (between 50 and 80 percent) in the total lifecycle costs of software systems [1]. Research suggests that software developers spend much of the maintenance effort simply trying to understand the software [2]. Current research is based on the premise that source code is the primary data source for understanding the software during debugging. Models of software errors proposed in the software engineering literature are based on the premise that software failures can be traced back to faults in the source code [3]. However, with increased attention on systems integration these are problematic premises. In component-based development [4], Web services and service-oriented architecture, along with information and enterprise systems integration [5], systems integrators have limited, if any, access to the source code of the integrated software. Even when integrating with open source software (OSS) components, research suggests that few systems integrators actually access the source code [6]. As such, systems integrators face the situation of having to debug systems without the source code to build an understanding of the problem upon. We therefore ask: without the source code, how do systems integrators make sense of problems when debugging integrated systems? Debugging integrated systems is largely unexplored in the research literature. The debugging process must be understood before it can be improved upon. This motivates a shift of focus from improving the debugging process, towards exploring how software developers debug integrated systems in practice. To this end, we have explored the practice of debugging integrated systems through an ethnographic study of the Gentoo OSS community. Gentoo is a geographically distributed community of volunteer systems integrators maintaining and operating a software distribution system for distributing and integrating third-party OSS with various Unix operating systems. Similar to existing studies of community-based OSS development [7], debugging is a core activity in the Gentoo community's software development process, too. The community is therefore well suited for studying the practice of debugging integrated systems. The shift of focus towards debugging practice requires that we draw upon research on practice. In this study we therefore draw upon research on practice and problems in organization science. This research shows that in real-world practice problems do not present themselves to practitioners as given [8]. Rather, problems have to be constructed from the materials of problematic situations that are puzzling, troubling, and uncertain. The process of constructing well-defined problems out of problem situations is often called sensemaking [9]. We will use sensemaking as a theoretical lens for exploring the practice of debugging integrated systems. This paper contributes to debugging research by identifying five characteristics that sets the practice of debugging integrated systems apart from existing research on debugging: it spans a variety of operating PREPRESS PROOF FILE 1 CAUSAL PRODUCTIONS environments, it is collective, social, heterogeneous, and ongoing. The remainder of the paper is organized as follows. Section 2 presents existing work on debugging, illustrating the central role of source code as data source for debugging. The theoretical lens of sensemaking is also presented here. Section 3 describes the research methods employed and materials collected during the ethnographic fieldwork. Section 4 describes the overall debugging process in the Gentoo community. Section 5 is an analysis of debugging in Gentoo applying the theoretical lens of sensemaking. We conclude the paper by discussing the implications of our findings for software maintenance research as well as debugging practice in Section 6. 2. Related work In this section we will illustrate how debugging can be understood as a linear process from problem to its solution. Such a linear model requires that the debugging developer can trace a causal chain from the software failure to its corresponding fault. To this end, we argue, source code is critical. Without the source code, tracing such causal chains becomes harder. This motivates our use of sensemaking as theoretical lens for analyzing how software developers understand problems when debugging integrated systems. 2.1. Debugging Debugging is the process of locating and correcting the cause of an externally visible error in the program behavior [3]. Araki et al. [10] proposes a model for systematic debugging where debugging is viewed as a process of developing hypotheses about the cause of errors, expected program behavior, and how to modify the program to correct errors, and to refute or verify these hypotheses. Zeller [3] proposes a similar model. These models may be summarized as a stepwise process from a well-defined problem to its solution (as illustrated in Figure 1). Much of the existing research on debugging focuses on the process of locating the cause of errors. Broadly speaking, three approaches have been suggested [11]. The bottom-up approach to debugging involves reading program statements in the source code and chunking these into higher-level abstractions. In the top-down approach, software developers reconstruct knowledge about the problem domain and map this to the source code. A mixed model approach has also been suggested. Figure 1 Linear model of debugging Several techniques, like delta debugging [3], and tools, like Eden [10], have been proposed to support the process of locating the cause of errors in the source code. 2.2. Sensemaking The subsection above illustrates how existing research describes debugging as a linear problem solving process, progressing from a well-defined problem to its solution (illustrated by the dashed line in Figure 1). For systems integrators, however, problems do not present themselves as given. Rather, problem situations are ambiguous and open to multiple interpretations [12]. Research within organization science shows that interaction among actors increases in ambiguous situations. In a study of field service technicians repairing copying machines, Orr [13] shows that to make sense of a faulty machine the technicians engage in an ongoing dialogue about the machine with the customer. Similarly, in a study of modern professionals, Schön [8] finds that the daily work of practitioners is not about problem solving, but rather about problem setting; the kind of work professionals undertake to make a situation that is initially ambiguous, puzzling, troubling, and uncertain into something that makes sense. Confused by ambiguity people engage in sensemaking [9]. The basic premise of sensemaking is that a person or a group's collective experiences of a problem situation are progressively clarified. Rather than starting with well-defined problems, sensemaking is a framework for analyzing how practitioners make sense of a situation that initially makes little sense. In contrast to problem solving starting with well-defined problem, the question driving sensemaking is not 'which of the available means are best suited to solve the problem?' but rather 'what is going on?'. To make sense of a problem situation, people act on basis of previous experience. By actively engaging with the problem situation, understanding emerges as people make retrospective sense of what occurs by enlarging small cues from the available data and forming a 2 structure to provide meaning. Another central premise of sensemaking is therefore that action precedes understanding. 3. Methods and materials This research is based on the first author's ethnographic study of the Gentoo OSS community. This section briefly describes the research setting and the ethnographic fieldwork this study is based upon. A more detailed description of the research including a more thorough discussion on research validation can be found in [12]. 3.1. Research setting: Gentoo Gentoo is an OSS community of volunteers maintaining and operating a software distribution system for distributing and integrating third-party OSS with various Unix operating systems. In addition, the community provides a GNU/Linux distribution, Gentoo Linux, on top of the software distribution system. The community consists of 320 official developers distributed across 38 countries and 17 time zones 1 . To the best of our knowledge, none of the developers are geographically co-located. As with most OSS communities, users are an important part of the Gentoo community, contributing with problem reports as well as source code. However, it is impossible to tell how many users are active in the community at any one time. For the remainder of the paper we will use the term Gentoo about the Gentoo software distribution system, Gentoo Linux about the GNU/Linux distribution provided on top of Gentoo, and the Gentoo community when talking about the community of volunteer systems integrators. These volunteers call themselves Gentoo developers. Gentoo distributes third-party OSS packages in the form of installation scripts. The installation scripts are stored in a central repository. One script exists for every version of each of the 8486 supported packages, for a total of 23911 installation scripts. The total SLOC of installation scripts in the repository is 6719712 . The installation scripts make up 90% of the source code in the repository. The rest are mainly patches and configuration files. The installation scripts are written and maintained by the Gentoo community. While some Gentoo developers may be quite familiar and knowledgeable of the source code of the components they integrate, most treat the software being integrated 1 Unless otherwise stated, all provided figures are of March 30, 2006, the day the fieldwork was concluded 2 Data generated with SLOCCount [14] as a black box. Up to six different Unix versions may be supported by a single installation script: GNU/Linux, FreeBSD, OpenBSD, NetBSD, MacOS X, and Dragonfly. For GNU/Linux, five different processor architectures may also be supported in the script. The repository is mirrored on every Gentoo system. A Gentoo system is a computer system using Gentoo for integrating third-party OSS on the local system. The Portage package manager is the application that integrates third-party packages locally on Gentoo systems, calculating dependencies to other packages, downloading the source code, as well as configuring, compiling and integrating the package with the Gentoo system's live file system. 3.
Información del documento
- Subido en
- 26 de julio de 2024
- Número de páginas
- 10
- Escrito en
- 2023/2024
- Tipo
- Examen
- Contiene
- Preguntas y respuestas