METKIT: training in how to use measurement as a software management tool

A Science is as mature as its measurement tools. Louis PasteurThe main purpose of this paper is to present the results of the ESPRIT project METKIT, a three-year collaborative technology transfer project in the field of software engineering measurement. METKIT was concerned with developing a set of integrated training courses that show how to implement process improvement programmes and use measurement as a powerful management tool. METKIT can be used by an organization to enable them to provide in-house training to their managers and software developers to enable them to understand control and then improve software development.     

Explaining software developer acceptance of methodologies: a comparison of five theoretical models

Many organizations attempt to deploy methodologies intended to improve software development processes. However, resistance by individual software developers against using such methodologies often obstructs their successful deployment. To better explain why individual developers accept or resist methodologies, five theoretical models of individual intentions to accept information technology tools were examined. In a field study of 128 developers in a large organization that implemented a methodology, each model explained significant variance in developers' intentions to use the methodology. Similar to findings from the tool adoption context, we found that, if a methodology is not regarded as useful by developers, its prospects for successful deployment may be severely undermined. In contrast to the typical pattern of findings in a tool context, however, we found that methodology adoption intentions are driven by: 1) the presence of an organizational mandate to use the methodology, 2) the compatibility of the methodology with how developers perform their work, and 3) the opinions of developers' coworkers and supervisors toward using the methodology. Collectively, these results provide surprising new insights into why software developers accept or resist methodologies and suggest what software engineering managers might do to overcome developer resistance.     

Measurement as an alternative to bureaucracy for the achievement of software quality

In this paper we discuss the two dominant modes of thought on the problem of software quality: the bureaucratic approach and the technical approach. The aim of the paper is to pursue the issues of how these approaches affect people, in our case software developers, and how we can assess the effectiveness of each approach in actually achieving quality software. An outline of the main aspects of the organizational approach — process modelling and software standards — is given. In order to address the effects of each of these modes of thought on people we take a psychological perspective. The implications for software engineering, in terms of formalism and mechanization, are discussed. The paper argues that overzealous structure, control and automation can negatively affect the creative process of developing software. A perspective on each of the components of the technical approach in terms of their effectiveness in achieving quality objectives is provided. From recent work we find that process modelling and many software standards do not provide an adequate assessment of the benefits derived from their application. The paper argues that measurement goes some way to addressing these problems. Measurement should form the core of the software development process, especially with respect to product quality assessment. The main conclusion is that by focusing on measurable objectives and results we can best achieve quality software products and highlight the processes which are likely to create them in a repeatable and manageable fashion. Additionally, by adopting measurement in practice we should expect to increase the freedom and creativity of software developers.     

Connecting architecture reconstruction frameworks

A number of standalone tools are designed to help developers understand software systems. These tools operate at different levels of abstraction, from low level source code to software architectures. Although recent proposals have suggested how code-level frameworks can share information, little attention has been given to the problem of connecting software architecture level frameworks. In this paper, we describe the TA Exchange Format (TAXForm) exchange format for frameworks at the software architecture level. By defining mappings between TAXForm and formats that are used within existing frameworks, we show how TAXForm can be used as a “binding glue” to achieve interoperability between these frameworks without having to modify their internal structure.     

Understanding developer and manager perceptions of function points and source lines of code

Although function points (FP) are considered superior to source lines of code (SLOC) for estimating software size and monitoring developer productivity, practitioners still commonly use SLOC. One reason for this is that individuals who fill different roles on a development team, such as managers and developers, may perceive the benefits of FP differently. We conducted a survey to determine whether a perception gap exists between managers and developers for FP and SLOC across several desirable properties of software measures. Results suggest managers and developers perceive the benefits of FP differently and indicate that developers better understand the benefits of using FP than managers.     

The importance of branching models in SCM

To improve software quality, you must first understand your software. If you do not understand your code base, your odds of updating it without breaking something are poor. Often, a fundamental misunderstanding of software configuration management (SCM) as it applies to real-world application development is at fault. Branching is integral to version management, software build correctness, and release management. Good decisions about when and why to branch can make it much easier for developers and release engineers to coordinate software product changes. The right branching strategy makes it easier to deliver the right code, re-create past releases, and-if necessary roll back to a previous release. The authors consider how adopting the right SCM branching model facilitates rapid development, increases overall product quality and process efficiency, reduces the incidence of software failures, and improves organizational performance.     

开源许可证的选择:挑战和影响因素

开发者通常会为其开源代码选择不同的开源许可证来约束其使用条件,以期能有效地保护知识产权和维持软件的长远发展.然而,现有的开源许可证种类繁杂,开发者难以了解不同开源许可证间的差异,并且难以通过现有的开源许可证选择工具做出合适的选择——其使用要求开发者了解开源许可证相关条款并明确自己的业务需求.学术界虽然对开源许可证已有研...     

Tool Support for Continuous Quality Control

Over time, software systems suffer gradual quality decay and therefore costs can rise if organizations fail to take proactive countermeasures. Quality control is the first step to avoiding this cost trap. Continuous quality assessments help users identify quality problems early, when their removal is still inexpensive; they also aid decision making by providing an integrated view of a software system's current status. As a side effect, continuous and timely feedback helps developers and maintenance personnel improve their skills and thereby decreases the likelihood of future quality defects. To make regular quality control feasible, it must be highly automated, and assessment results must be presented in an aggregated manner to avoid overwhelming users with data. This article offers an overview of tools that aim to address these issues. The authors also discuss their own flexible, open-source toolkit, which supports the creation of dashboards for quality control.     

A methodology to infer and refactor an object‐oriented model from C applications

When analyzing legacy code, generating a high‐level model of an application during the reverse engineering process helps the developers understand how the application is structured and how the dependencies relate the different software entities. Within the context of procedural programming languages (such as C), the existing approaches to get a model of the code require documentation and/or implicit knowledge that stakeholders acquire during the software building. These approaches use the code itself to build a syntactic model where we see the different software artifacts, such as variables, functions, and modules. However, there is no supporting methodology to detect and analyze if there are relationships/dependencies between those artifacts, such as which variable in a module is declared using an abstract data type described in another one, or which are the functions that are using parameters typed with an abstract data type; or any design decision taken by original developers, such as how the developer has implemented functions in different modules. On the other hand, current developers use object‐oriented (OO) paradigm to implement not only business applications but also useful methodologies/tools that allow semiautomatic analysis of any application. We must remark the legacy procedural code still has worth and is working in several industries, and as any evolving code, the developers have to be able to perform maintenance tasks minimizing the limitations offered by the language. Based on useful properties that the OO paradigm (and their supporting analysis tools) provide, such as UML models, we propose M2K as a methodology to generate a high‐level model from legacy procedural code, mainly written in Ansi C. To understand how C‐based applications were implemented is not a new problem in software reengineering. However, our contribution is based on building an OO model and suggesting different refactorings that help the developer to improve it and to eventually guide a new implementation of the target application. Specifically, the methodology builds cohesive software entities mapped from procedural code and makes the coupling between C entities explicit in the high‐level model. The result of our methodology is a set of refactored class candidates: a structure that groups a set of variables and a set of functions obtained from the C applications. Based on the class candidate model, we propose refactorings based on OO design principles to improve the design of the application. The most relevant design improvements were obtained with algorithm abstraction by applying the strategy pattern, attributes/methods relocalization, variables types generalization, and removing/renaming methods/attributes. Besides a methodology and the supporting tool, we provide 14 case studies based on real projects implemented in C, and we showed how the results validate our proposal.     

How to win an evolutionary arms race

To keep up with malware writers, software producers in both the commercial and open-source software worlds have adopted various automatic software update mechanisms. Some of these mechanisms distribute updates after requesting a user's permission; others install updates automatically. Although such systems provide some short-term relief, they will likely soon become ineffective, and further, they will also become extremely dangerous once they are inevitably co-opted by attackers. If we want the Internet to remain a viable way to communicate and collaborate, we must adopt another, perhaps radically different, model for securing our computers. To better understand this conclusion, we should first re-examine why developers and users are embracing automated update systems.     

Perceptions of software quality: a pilot study

Many software quality initiatives fail because they do not take account of the range of views that people have of quality. New approaches to software quality improvement will not work unless software developers believe in them, no matter how enthusiastic managers may be. This paper reports on a pilot study using the repertory grid technique that found evidence to support these assertions. The study findings justify further work and show that while the repertory grid technique is an appropriate instrument in this area it is resource intensive to apply and may not be practical in a wider study of a representative sample of the IT industry. The paper has practical recommendations for successful introduction of new software quality programmes. These recommendations stress the need for effective communication, leading to a shared understanding of quality, and for realistic goals that recognize the pressure of development schedules.     

The impacts of quality and productivity perceptions on the use of software process improvement innovations

Numerous software process improvement (SPI) innovations have been proposed to improve software development productivity and system quality; however, their diffusion in practice has been disappointing. This research investigates the adoption of the Personal Software Process on industrial software projects. Quantitative and qualitative analyses reveal that perceived increases in software quality and development productivity, project management benefits, and innovation fit to development tasks, enhance the usefulness of the innovation to developers. Results underscore the need to enrich current technology acceptance models with these constructs, and serve to encourage project managers to adopt formal SPI methods if developers perceive the methods will have positive impacts on their productivity and system quality.     

Integrating Process and Project Management for Multi-Site Software Development

Recent advances in information technology have made Internet-based collaboration much easier. It is now possible for a software team to draw on talented developers from around the world without the need to gather them together physically. However, being able to tap into a large pool of talent does not guarantee success. Software managers have to be able to manage these distributed teams. They need to define sharper processes and ensure that they are followed. They also need to better control project execution. To do so effectively, we have developed a tool that integrates features for both project and process management. Existing project management tools were originally designed for projects on a single site. Many of them do not provide the features necessary to support cooperative multi-site software projects or process management. We have developed a tool, called IPPM, which supports these features. IPPM, which integrates features for process and project management, resolves differences between existing project and process tools, and provides a number of unique features to support multi-site development. IPPM has been implemented and used by several development teams working in different regions in Hong Kong and Mainland China.     

Understanding the gap between software process practices and actual practice in very small companies

This paper reports on a grounded theory to study into software developers’ use of software development processes in actual practice in the specific context of very small companies. This study was conducted in three very small software product companies located in Ecuador. The data collection was based on semi-structured qualitative interviews with software project managers, focus group with software developers and was supplemented by the literature and document studies. We interviewed two types of participants (managers and developers), so as to ensure that we elicited a holistic perspective of how they approached the software development process in actual practice. The goal was to study what practices are actually used and their opinion and attitude toward the potential adopting of an international standard (ISO/IEC 29110) specifically designed for very small companies. With the collected data, we performed an analysis utilizing grounded theory coding techniques, as this methodology promotes the focus on uncovering the real concerns of the participants. This study highlighted three areas of concern: customer, software product and development tasks coordination and tracking. The findings in this study give an insight toward the work products as they relate to software development process practices in very small companies and the important factors that must be considered to assist project success.     

一个改善软件结构设计质量的知识系统

本文讨论我们在研制”ＭＩＳ软件工程环境“中为优化软件结构而采用的知识技术。尽管技术工程学对软件设计提出了优化软件结构的任务并给出了一些指导性原则,但由于设计者的经验和理解程度不同,因而软件结构设计质量往往因人而异。本研究旨在探索一种方法提供一种工具,以改善软件结构的质量,提高软件工程环境的智能水平。     

Effect of personality type on structured tool comprehension performance

Accurate understanding of software requirements by end users and software developers is important to ensure a high quality software product. While comprehension performance on systems analysis tools has been studied in the past, there is little research that examined the influence of personality type of an individual on his/her performance. This paper has two objectives. First, the research uncovers the relationships between personality types (introvert/extrovert, sensing/intuitive, feeling/thinking, and perceptive/judging) and comprehension performance (accuracy and speed) of users/developers using the structured tools: Decision Tables (DT), Nassi–Schneiderman Charts (NS) and Structured English (SE). Second, it examines the trade-offs between comprehension accuracy and speed for each personality type. Using laboratory experiments, we measured individual performance with the three structured tools. We found that introverts and feeling personalities comprehended more accurately with DT; thinking and intuitive personalities comprehended more accurately with NS and SE. The comprehension accuracy increased with time more for SE than for DT and NS. The results show the most suitable combinations of structured tools and personality types for high comprehension. The results also provide guidelines to managers with tight project schedules, such as structured tools that are easier/faster to understand and the matching personalities who can comprehend faster.     

Toward objective software process information: experiences from a case study

A critical problem in software development is the monitoring, control and improvement in the processes of software developers. Software processes are often not explicitly modeled, and manuals to support the development work contain abstract guidelines and procedures. Consequently, there are huge differences between ‘actual’ and ‘official’ processes: “the actual process is what you do, with all its omissions, mistakes, and oversights. The official process is what the book, i.e., a quality manual, says you are supposed to do” (Humphrey in A discipline for software engineering. Addison-Wesley, New York, 1995). Software developers lack support to identify, analyze and better understand their processes. Consequently, process improvements are often not based on an in-depth understanding of the ‘actual’ processes, but on organization-wide improvement programs or ad hoc initiatives of individual developers. In this paper, we show that, based on particular data from software development projects, the underlying software development processes can be extracted and that automatically more realistic process models can be constructed. This is called software process mining (Rubin et al. in Process mining framework for software processes. Software process dynamics and agility. Springer Berlin, Heidelberg, 2007). The goal of process mining is to better understand the development processes, to compare constructed process models with the ‘official’ guidelines and procedures in quality manuals and, subsequently, to improve development processes. This paper reports on process mining case studies in a large industrial company in The Netherlands. The subject of the process mining is a particular process: the change control board (CCB) process. The results of process mining are fed back to practice in order to subsequently improve the CCB process.     

Taupe: Visualizing and analyzing eye-tracking data

Program comprehension is an essential part of any maintenance activity. It allows developers to build mental models of the program before undertaking any change. It has been studied by the research community for many years with the aim to devise models and tools to understand and ease this activity. Recently, researchers have introduced the use of eye-tracking devices to gather and analyze data about the developers’ cognitive processes during program comprehension. However, eye-tracking devices are not completely reliable and, thus, recorded data sometimes must be processed, filtered, or corrected. Moreover, the analysis software tools packaged with eye-tracking devices are not open-source and do not always provide extension points to seamlessly integrate new sophisticated analyses. Consequently, we develop the Taupe software system to help researchers visualize, analyze, and edit the data recorded by eye-tracking devices. The two main objectives of Taupe are compatibility and extensibility so that researchers can easily: (1) apply the system on any eye-tracking data and (2) extend the system with their own analyses. To meet our objectives, we base the development of Taupe: (1) on well-known good practices, such as design patterns and a plug-in architecture using reflection, (2) on a thorough documentation, validation, and verification process, and (3) on lessons learned from existing analysis software systems. This paper describes the context of development of Taupe, the architectural and design choices made during its development, and its documentation, validation and verification process. It also illustrates the application of Taupe in three experiments on the use of design patterns by developers during program comprehension.     

Results from the IPAS project: Influences of methods and tools,quality requirements and project management on the work situation of software developers

In this paper we present some results of the project IPAS¹ concerning the use and influence of methods, tools, product quality and project management issues in software development projects. The overall aim of the IPAS project is to analyze the work situation of software developers and to suggest guidelines for the improvement of their work conditions.     

An Exploratory Study of How Developers Seek, Relate, and Collect Relevant Information during Software Maintenance Tasks

Much of software developers' time is spent understanding unfamiliar code. To better understand how developers gain this understanding and how software development environments might be involved, a study was performed in which developers were given an unfamiliar program and asked to work on two debugging tasks and three enhancement tasks for 70 minutes. The study found that developers interleaved three activities. They began by searching for relevant code both manually and using search tools; however, they based their searches on limited and misrepresentative cues in the code, environment, and executing program, often leading to failed searches. When developers found relevant code, they followed its incoming and outgoing dependencies, often returning to it and navigating its other dependencies; while doing so, however, Eclipse's navigational tools caused significant overhead. Developers collected code and other information that they believed would be necessary to edit, duplicate, or otherwise refer to later by encoding it in the interactive state of Eclipse's package explorer, file tabs, and scroll bars. However, developers lost track of relevant code as these interfaces were used for other tasks, and developers were forced to find it again. These issues caused developers to spend, on average, 35 percent of their time performing the mechanics of navigation within and between source files. These observations suggest a new model of program understanding grounded in theories of information foraging and suggest ideas for tools that help developers seek, relate, and collect information in a more effective and explicit manner