Showing papers in "Information & Software Technology in 2008"
TL;DR: A systematic review of empirical studies of agile software development up to and including 2005 was conducted and provides a map of findings, according to topic, that can be compared for relevance to their own settings and situations.
Abstract: Agile software development represents a major departure from traditional, plan-based approaches to software engineering. A systematic review of empirical studies of agile software development up to and including 2005 was conducted. The search strategy identified 1996 studies, of which 36 were identified as empirical studies. The studies were grouped into four themes: introduction and adoption, human and social factors, perceptions on agile methods, and comparative studies. The review investigates what is currently known about the benefits and limitations of, and the strength of evidence for, agile methods. Implications for research and practice are presented. The main implication for research is a need for more and better empirical studies of agile software development within a common research agenda. For the industrial readership, the review provides a map of findings, according to topic, that can be compared for relevance to their own settings and situations.
2,399 citations
TL;DR: In this article, the authors propose a mapping from BPMN to Petri nets, for which efficient analysis techniques are available, and implement a tool that, in conjunction with existing Petri net-based tools, enables the static analysis of BPMNs models.
Abstract: The Business Process Modelling Notation (BPMN) is a standard for capturing business processes in the early phases of systems development. The mix of constructs found in BPMN makes it possible to create models with semantic errors. Such errors are especially serious, because errors in the early phases of systems development are among the most costly and hardest to correct. The ability to statically check the semantic correctness of models is thus a desirable feature for modelling tools based on BPMN. Accordingly, this paper proposes a mapping from BPMN to a formal language, namely Petri nets, for which efficient analysis techniques are available. The proposed mapping has been implemented as a tool that, in conjunction with existing Petri net-based tools, enables the static analysis of BPMN models. The formalisation also led to the identification of deficiencies in the BPMN standard specification.
654 citations
TL;DR: The landscape of current reported knowledge in terms of what motivates developers, what de-motivates them and how existing models address motivation is plotted to indicate that there is no clear understanding of the Software Engineers' job, how they are motivated, or the outcome and benefits of motivating Software Engineers.
Abstract: Objective: In this paper, we present a systematic literature review of motivation in Software Engineering. The objective of this review is to plot the landscape of current reported knowledge in terms of what motivates developers, what de-motivates them and how existing models address motivation. Methods: We perform a systematic literature review of peer reviewed published studies that focus on motivation in Software Engineering. Systematic reviews are well established in medical research and are used to systematically analyse the literature addressing specific research questions. Results: We found 92 papers related to motivation in Software Engineering. Fifty-six percent of the studies reported that Software Engineers are distinguishable from other occupational groups. Our findings suggest that Software Engineers are likely to be motivated according to three related factors: their 'characteristics' (for example, their need for variety); internal 'controls' (for example, their personality) and external 'moderators' (for example, their career stage). The literature indicates that de-motivated engineers may leave the organisation or take more sick-leave, while motivated engineers will increase their productivity and remain longer in the organisation. Aspects of the job that motivate Software Engineers include problem solving, working to benefit others and technical challenge. Our key finding is that the published models of motivation in Software Engineering are disparate and do not reflect the complex needs of Software Engineers in their career stages, cultural and environmental settings. Conclusions: The literature on motivation in Software Engineering presents a conflicting and partial picture of the area. It is clear that motivation is context dependent and varies from one engineer to another. The most commonly cited motivator is the job itself, yet we found very little work on what it is about that job that Software Engineers find motivating. Furthermore, surveys are often aimed at how Software Engineers feel about 'the organisation', rather than 'the profession'. Although models of motivation in Software Engineering are reported in the literature, they do not account for the changing roles and environment in which Software Engineers operate. Overall, our findings indicate that there is no clear understanding of the Software Engineers' job, what motivates Software Engineers, how they are motivated, or the outcome and benefits of motivating Software Engineers.
500 citations
TL;DR: This systematic review identifies empirical studies of knowledge management initiatives in software engineering, and discusses the concepts studied, the major findings, and the research methods used.
Abstract: Software engineering is knowledge-intensive work, and how to manage software engineering knowledge has received much attention. This systematic review identifies empirical studies of knowledge management initiatives in software engineering, and discusses the concepts studied, the major findings, and the research methods used. Seven hundred and sixty-two articles were identified, of which 68 were studies in an industry context. Of these, 29 were empirical studies and 39 reports of lessons learned. More than half of the empirical studies were case studies. The majority of empirical studies relate to technocratic and behavioural aspects of knowledge management, while there are few studies relating to economic, spatial and cartographic approaches. A finding reported across multiple papers was the need to not focus exclusively on explicit knowledge, but also consider tacit knowledge. We also describe implications for research and for practice.
355 citations
TL;DR: JADE is a very mature product, used by a heterogeneous community of users both in research activities and in industrial applications and a discussion of the possible reasons for its success and lessons learned from the somewhat detached perspective possible nine years after its inception is presented.
Abstract: Since a number of years agent technology is considered one of the most innovative technologies for the development of distributed software systems. While not yet a mainstream approach in software engineering at large, a lot of work on agent technology has been done, many research results and applications have been presented, and some software products exists which have moved from the research community to the industrial community. One of these is JADE, a software framework that facilitates development of interoperable intelligent multi-agent systems and that is distributed under an Open Source License. JADE is a very mature product, used by a heterogeneous community of users both in research activities and in industrial applications. This paper presents JADE and its technological components together with a discussion of the possible reasons for its success and lessons learned from the somewhat detached perspective possible nine years after its inception.
323 citations
TL;DR: An analytical framework, called 4-DAT, is developed and applied to six well-known agile methods and, for comparison, two traditional methods, indicating the degree of agility to be found in each method, from which a judgement can be made as to whether the appellation of ''agile'' to that method is appropriate.
Abstract: While agile methods are in use in industry, little research has been undertaken into what is meant by agility and how a supposed agile method can be evaluated with regard to its veracity to belong to this category of software development methodological approaches. Here, an analytical framework, called 4-DAT, is developed and applied to six well-known agile methods and, for comparison, two traditional methods. The results indicate the degree of agility to be found in each method, from which a judgement can be made as to whether the appellation of ''agile'' to that method is appropriate. This information is shown to be useful, for example, when constructing a methodology from method fragments (method engineering) and when comparing agile and traditional methods.
274 citations
TL;DR: A data model for traceability and a set of suitable patterns to encode generic traceability semantics are introduced and a practical implementation of a traceability system is shown through a real world experience on food supply chains.
Abstract: Industrial traceability systems are designed to operate over complex supply chains, with a large and dynamic group of participants. These systems need to agree on processing and marketing of goods, information management, responsibility, and identification. In addition, they should guarantee context independence, scalability, and interoperability. In this paper, we first discuss the main issues emerging at different abstraction levels in developing traceability systems. Second, we introduce a data model for traceability and a set of suitable patterns to encode generic traceability semantics. Then, we discuss suitable technological standards to define, register, and enable business collaborations. Finally, we show a practical implementation of a traceability system through a real world experience on food supply chains.
226 citations
TL;DR: One of the main findings showed that software developers believe in the usefulness of knowledge sharing; however, their ability to utilise some of the KM systems was limited, and the tools, techniques and methodologies currently employed for software development were inadequate to address effective management of knowledge in these organisations.
Abstract: This study, using both quantitative and qualitative methods, investigates current practice of Knowledge Management (KM) in Software Engineering (SE) processes in two Australian companies on the basis that they both claimed to apply KM practices in their software development work. It also describes the KM activities and KM process used in SE practice, and examines the enablers of KM process for SE in terms of leadership, technology, culture, process and measurement. One of the main findings showed that software developers believe in the usefulness of knowledge sharing; however, their ability to utilise some of the KM systems was limited. The most commonly used systems included personal networks, informal networks, groupware and third-party knowledge. There is a need to formalise knowledge sharing of practices, while also supporting informal and ad-hoc knowledge sharing. While KM was considered to be important, the tools, techniques and methodologies currently employed for software development were inadequate to address effective management of knowledge in these organisations. In both organisations, a uniform model of the KM process did not exist. Among the four KM enablers, leadership was considered to be the most significant as top-down KM strategies were seemingly being pursued by management. Technology was also considered to be an obvious mechanism for KM, despite some of their current KM systems either being unsuitable or inaccessible. In addition, the crucial role that personal networks played in accessing tacit and implicit knowledge was seen as a key reason to foster a culture that encourages participants to share their knowledge with others.
189 citations
TL;DR: Despite its origins in helping to address customer-related issues for the USAF, CMM-based SPI has mostly been adopted to help organizations improve project performance and product quality issues, which reinforces a view that the goal of SPI is not to improve process per se, but instead to provide business benefits.
Abstract: Background: Software Process Improvement (SPI) is intended to improve software engineering, but can only be effective if used. To improve SPI's uptake, we should understand why organizations adopt SPI. CMM-based SPI approaches are widely known and studied. Objective: We investigated why organizations adopt CMM-based SPI approaches, and how these motivations relate to organizations' size. Method: We performed a systematic review, examining reasons reported in more than forty primary studies. Results: Reasons usually related to product quality and project performance, and less commonly, to process. Organizations reported customer reasons infrequently and employee reasons very rarely. We could not show that reasons related to size. Conclusion: Despite its origins in helping to address customer-related issues for the USAF, CMM-based SPI has mostly been adopted to help organizations improve project performance and product quality issues. This reinforces a view that the goal of SPI is not to improve process per se, but instead to provide business benefits.
156 citations
TL;DR: Empirical results are provided on end-user productivity, which is measured as the lines of code needed to express a domain-specific program, similarity to the original notation, and how error-reporting and debugging are supported in a given implementation.
Abstract: Various implementation approaches for developing a domain-specific language are available in literature. There are certain common beliefs about the advantages/disadvantages of these approaches. However, it is hard to be objective and speak in favor of a particular one, since these implementation approaches are normally compared over diverse application domains. The purpose of this paper is to provide empirical results from ten diverse implementation approaches for domain-specific languages, but conducted using the same representative language. Comparison shows that these discussed approaches differ in terms of the effort need to implement them, however, the effort needed by a programmer to implement a domain-specific language should not be the only factor taken into consideration. Another important factor is the effort needed by an end-user to rapidly write correct programs using the produced domain-specific language. Therefore, this paper also provides empirical results on end-user productivity, which is measured as the lines of code needed to express a domain-specific program, similarity to the original notation, and how error-reporting and debugging are supported in a given implementation.
146 citations
TL;DR: A mapping from Workflow Nets (WF-nets) to BPEL is provided, which builds on the rich theory of Petri nets and can also be used to map other languages onto BPEL.
Abstract: The Business Process Execution Language for Web Services (BPEL) has emerged as the de facto standard for implementing processes. Although intended as a language for connecting web services, its application is not limited to cross-organizational processes. It is expected that in the near future a wide variety of process-aware information systems will be realized using BPEL. While being a powerful language, BPEL is difficult to use. Its XML representation is very verbose and only readable for the trained eye. It offers many constructs and typically things can be implemented in many ways, e.g., using links and the flow construct or using sequences and switches. As a result only experienced users are able to select the right construct. Several vendors offer a graphical interface that generates BPEL code. However, the graphical representations are a direct reflection of the BPEL code and not easy to use by end-users. Therefore, we provide a mapping from Workflow Nets (WF-nets) to BPEL. This mapping builds on the rich theory of Petri nets and can also be used to map other languages (e.g., UML, EPC, BPMN, etc.) onto BPEL. In addition to this we have implemented the algorithm in a tool called WorkflowNet2BPEL4WS.
TL;DR: A mathematical formalization of release planning with a corresponding optimization tool that supports product and project managers during release planning and enables what-if analysis in the optimization environment is presented.
Abstract: We present a mathematical formalization of release planning with a corresponding optimization tool that supports product and project managers during release planning. The tool is based on integer linear programming and assumes that an optimal set of requirements is the set with maximal projected revenue against available resources. The input for the optimization is twofold. The first type of input data concerns the list of candidate requirements, estimated revenues, and resources needed. Second, managerial steering mechanisms enable what-if analysis in the optimization environment. Experiments based on real-life data made a sound case for the applicability of our approach.
TL;DR: A new, richer model that is capable of more realistically simulating real-world situations is described along with a new GA that produces optimal or near-optimal schedules, and results show that this new model enhances the ability of GA-based approaches, while providing decision support under more realistic conditions.
Abstract: Effective management of complex software projects depends on the ability to solve complex, subtle optimization problems. Most studies on software project management do not pay enough attention to difficult problems such as employee-to-task assignments, which require optimal schedules and careful use of resources. Commercial tools, such as Microsoft Project, assume that managers as users are capable of assigning tasks to employees to achieve the efficiency of resource utilization, while the project continually evolves. Our earlier work applied genetic algorithms (GAs) to these problems. This paper extends that work, introducing a new, richer model that is capable of more realistically simulating real-world situations. The new model is described along with a new GA that produces optimal or near-optimal schedules. Simulation results show that this new model enhances the ability of GA-based approaches, while providing decision support under more realistic conditions.
TL;DR: A group of university students, 68 undergraduate students and 60 master's degree graduate students, each of whom had been personality type profiled using the Myers-Briggs Type Indicator (MBTI) model, was split into three sub-groups, which showed that the sub-group of subjects who were diverse in MBTI type exhibited higher productivity than both alike and opposite groups.
Abstract: With the recent advent of agile software process methods, a number of seldom used and unorthodox practices have come to the forefront in the field of computer programming. One such practice is that of pair programming, which is characterized by two programmers sharing the same computer for collaborative programming purposes. The very nature of pair programming implies a psychological and social interaction between the participating programmers and thus brings into play a unique element that we do not see with the conventional individual programming model. This paper focuses on the effects that one of these psychosocial factors, a programmer's personality type, may have on the pair programming environment. In this study, a group of university students, 68 undergraduate students and 60 master's degree graduate students, each of whom had been personality type profiled using the Myers-Briggs Type Indicator (MBTI) model, was split into three sub-groups. One group consisted of subjects who were alike in MBTI type. Another group consisted of subjects who were opposite to each other in MBTI type, and the last group was comprised of subjects who were diverse - partially alike and partially opposite - in MBTI type. Through two pair programming sessions, the pairs in each group were assessed for their output, in code productivity. The result showed that the sub-group of subjects who were diverse in MBTI type exhibited higher productivity than both alike and opposite groups. In a comparison between alike and opposite groups, the productivity of the opposite group was greater than that of the alike group.
TL;DR: This paper presents an ontology-based methodology, MOBMAS, for the analysis and design of multi-agent systems and identifies and implements the various ways in which ontologies can be used in the MAS development process and integrated into the MAS model definitions.
Abstract: Ontologies offer significant benefits to multi-agent systems: interoperability, reusability, support for multi-agent system (MAS) development activities (such as system analysis and agent knowledge modeling) and support for MAS operation (such as agent communication and reasoning). This paper presents an ontology-based methodology, MOBMAS, for the analysis and design of multi-agent systems. MOBMAS is the first methodology that explicitly identifies and implements the various ways in which ontologies can be used in the MAS development process and integrated into the MAS model definitions. In this paper, we present comprehensive documentation and validation of MOBMAS.
TL;DR: A framework of dependent variables is presented that serves as a full range for requirements engineering quality assessment and includes whether or not the company was successful and whether there was a positive or negative impact on society as a whole.
Abstract: When software development teams modify their requirements engineering process as an independent variable, they often examine the implications of these process changes by assessing the quality of the products of the requirements engineering process, e.g., a software requirements specification (SRS). Using the quality of the SRS as the dependent variable is flawed. As an alternative, this paper presents a framework of dependent variables that serves as a full range for requirements engineering quality assessment. In this framework, the quality of the SRS itself is just the first level. Other higher, and more significant levels, include whether the project was successful and whether the resulting product was successful. And still higher levels include whether or not the company was successful and whether there was a positive or negative impact on society as a whole.
TL;DR: A new experimental study of the four typical test suite reduction techniques, including Harrold et al.'s heuristic and three other recently proposed techniques such as Chen and Lau's GRE heuristic, Mansour and El-Fakin's genetic algorithm-based approach, and Black et al.'s ILP- based approach are presented.
Abstract: In software development, developers often rely on testing to reveal bugs. Typically, a test suite should be prepared before initial testing, and new test cases may be added to the test suite during the whole testing process. This may usually cause the test suite to contain more or less redundancy. In other words, a subset of the test suite (called the representative set) may still satisfy all the test objectives. As the redundancy can increase the cost of executing the test suite, quite a few test suite reduction techniques have been brought out in spite of the NP-completeness of the general problem of finding the optimal representative set of a test suite. In the literature, there have been some experimental studies of test suite reduction techniques, but the limitations of the these experimental studies are quite obvious. Recently proposed techniques are not experimentally compared against each other, and reported experiments are mainly based on small programs or even simulation data. This paper presents a new experimental study of the four typical test suite reduction techniques, including Harrold et al.'s heuristic, and three other recently proposed techniques such as Chen and Lau's GRE heuristic, Mansour and El-Fakin's genetic algorithm-based approach, and Black et al.'s ILP-based approach. Based on the results of this experimental study, we also provide a guideline for choosing the appropriate test suite reduction technique and some insights into why the techniques vary in effectiveness and efficiency.
TL;DR: A conceptual framework is presented which has been developed for the systematic evaluation of interoperability standards and the use of these models are illustrated with practical experience and examples.
Abstract: There is a wide range of standards available for the integration and interoperability of applications and information systems, both on domain-specific and domain-neutral levels. The evaluation and selection of interoperability standards are necessary in the application development and integration projects, when there is a need to assess the usefulness of existing models or to find open solutions. In addition, standards have to be evaluated when recommendations are made for a given domain or when their quality is examined. The evaluation of the scope and other aspects of interoperability standards is usually performed against project-specific requirements, but generic frameworks can be used for supporting the evaluation. In this article, we present a conceptual framework which has been developed for the systematic evaluation of interoperability standards. We also present an overview of a process for the evaluation of interoperability standards. We illustrate the use of these models with practical experience and examples.
TL;DR: A method is proposed to support this reengineering process that analyses the strengths and weaknesses of the current process; considers the strategic needs of the organization; provides guidelines for the prescriptive construction of i^* models; and drives the systematic generation and evaluation of alternative technological and organizational solutions for the new system.
Abstract: Information system development can often be addressed as a business process reengineering practice, either because it automates some human-based processes or because it replaces an existing legacy system. Therefore, observing and analysing current processes can enable analysts to converge on the specification of the new system, generating and evaluating new system alternatives throughout. In this paper, we propose a method to support this reengineering process that analyses the strengths and weaknesses of the current process; considers the strategic needs of the organization; provides guidelines for the prescriptive construction of i^* models; and drives the systematic generation and evaluation of alternative technological and organizational solutions for the new system.
TL;DR: A number of challenges that ISVs face in handling extensions and modifications to OSS components are identified and several strategies ISVs can follow in maintaining these modifications are described.
Abstract: Open Source Software (OSS) has already been adopted by a large number of organizations. An important - but sometimes neglected - group of OSS users are Independent Software Vendors (ISVs). ISVs often develop their applications on top of OSS platform software. Frequently, this requires making several extensions and modifications to these OSS components. We identify a number of challenges that ISVs face in handling these extensions and modifications. Next, we describe several strategies ISVs can follow in maintaining these modifications. Finally, we suggest an opportunity for a closer collaboration between OSS projects and ISVs which could be mutually beneficial.
TL;DR: This case study shows how Alcatel-Lucent over time achieved effective interaction of engineering processes, tools and people on the basis of a knowledge-centric product life-cycle management (PLM).
Abstract: Improving project management, product development and engineering processes is for many companies crucial to survive in a fast changing environment. However, these activities are rarely integrated well due to the diversity of stakeholders with individual knowledge about projects, products and processes. This case study shows how Alcatel-Lucent over time achieved effective interaction of engineering processes, tools and people on the basis of a knowledge-centric product life-cycle management (PLM). Starting from identifying project, product and process knowledge, we show how they can be effectively integrated for best possible usage across the enterprise. The case study provides insight into how to best embark on PLM and how to effectively integrate product development with supportive tools. It describes how the concepts can be transferred to software engineering teams and IT departments in other companies. Concrete results from several product lines, such as efficiency improvement and better global development underline the business value.
TL;DR: A gradual methodology to initiate software process improvement in VSE through three steps approach is presented and the first and most original step is based on a light evaluation achieved by means of a dedicated Micro-Evaluation approach.
Abstract: The paper concerns software process improvement in Very Small Enterprises (VSEs). It presents briefly a gradual methodology to initiate software process improvement in VSE through three steps approach and develops the first and most original step. This first step is based on a light evaluation achieved by means of a dedicated Micro-Evaluation approach. It has been experimented during 7 years in 86 organizations from three countries. The experience with that utilization tends to show that such a light approach is practicable and promising, at least for the targeted enterprises.
TL;DR: An analytic tool to predict the likelihood of a software project being outsourced by Japanese IT managers is developed and novel insights are provided into the drivers of Japanese software outsourcing decisions.
Abstract: Although Japan represents the single largest Asian market and 10% of the global software outsourcing market, little is understood about how Japanese companies make software project outsourcing decisions Tried-and-tested outsourcing models consistently fail to predict the outsourcing decisions of Japanese companies, leaving global software development companies with little usable guidance in the Japanese outsourcing market Analyses of 396 software project outsourcing decisions made by 33 IT managers in Toshiba, Hitachi, Fujitsu, IBM-Japan, and Mitsubishi provides novel insights into the drivers of Japanese software outsourcing decisions The objective of this paper is to develop an analytic tool to predict the likelihood of a software project being outsourced by Japanese IT managers
TL;DR: MARS is described, a semi-automatic grammar-centric system that leverages grammar inference techniques to solve the metamodel recovery problem and contains an applicative case study, as well as experimental results from the recovery of several metamodes in diverse domains.
Abstract: Domain-specific modeling (DSM) assists subject matter experts in describing the essential characteristics of a problem in their domain When a metamodel is lost, repositories of domain models can become orphaned from their defining metamodel Within the purview of model-driven engineering, the ability to recover the design knowledge in a repository of legacy models is needed In this paper we describe MARS, a semi-automatic grammar-centric system that leverages grammar inference techniques to solve the metamodel recovery problem The paper also contains an applicative case study, as well as experimental results from the recovery of several metamodels in diverse domains
TL;DR: The software quality principle of flexibility as a mediator variable is employed to determine if certain design aspects play a key role in achieving the benefits to the project of process standardization.
Abstract: It has been assumed for years that process standardization in the development of software will improve the efficiency of the development project by the virtues of applying a learned procedure and tight controls. Past research, however, is inconclusive in the elements that must be in place to achieve the benefits. In this study, we employ the software quality principle of flexibility as a mediator variable to determine if certain design aspects play a key role in achieving the benefits to the project of process standardization. A survey of computer professionals indicates that software flexibility is a positive influence. System designers should apply standard processes but with an eye toward quality design principles.
TL;DR: This paper proposes a heuristics-based approach to infeasible path detection for dynamic test data generation based on the observation that many inf Easible program paths exhibit some common properties.
Abstract: Automated test data generation plays an important part in reducing the cost and increasing the reliability of software testing. However, a challenging problem in path-oriented test data generation is the existence of infeasible program paths, where considerable effort may be wasted in trying to generate input data to traverse the paths. In this paper, we propose a heuristics-based approach to infeasible path detection for dynamic test data generation. Our approach is based on the observation that many infeasible program paths exhibit some common properties. Through realizing these properties in execution traces collected during the test data generation process, infeasible paths can be detected early with high accuracy. Our experiments show that the proposed approach efficiently detects most of the infeasible paths with an average precision of 96.02% and a recall of 100% of all the cases.
TL;DR: The relation of EbA method to the nearest neighbor non-parametric regression in order to suggest a resampling procedure, known as iterated bagging, for reducing the prediction error.
Abstract: Estimation by analogy (EbA) is a well-known technique for software cost estimation. The popularity of the method is due to its straightforwardness and its intuitively appealing interpretation. However, in spite of the simplicity in application, the theoretical study of EbA is quite complicated. In this paper, we exploit the relation of EbA method to the nearest neighbor non-parametric regression in order to suggest a resampling procedure, known as iterated bagging, for reducing the prediction error. The improving effect of iterated bagging on EbA is validated using both artificial and real datasets from the literature, obtaining very promising results.
TL;DR: A methodology called TAD is used, which consists of six phases, which presents a new unique way for business process identification, modelling, and improvement.
Abstract: This paper aims at discussing business process modelling and improvement as an essential work to create a successful and competitive enterprise. To achieve this goal, we use a methodology called TAD, which consists of six phases. The first three deal with business process identification, modelling and improvement. The methodology presents a new unique way for business process identification, modelling, and improvement. The last three phases continue with the implementation of the improved business process(es) by developing its information system. The business process ''Surgery'' is used as an example to show the implementation of the methodology.
TL;DR: An extensive and substantial case study on pair programming is presented, which was carried out in courses for software development at the University of Dortmund, Germany, and found the code produced by the paired teams was easier to read and to understand.
Abstract: We present the results of an extensive and substantial case study on pair programming, which was carried out in courses for software development at the University of Dortmund, Germany. Thirteen software development teams with about 100 students took part in the experiments. The groups were divided into two sets with different working conditions. In one set, the group members worked on their projects in pairs. Even though the paired teams could only use half of the workstations the teams of individual workers could use, the paired teams produced nearly as much code as the teams of individual workers at the same time. In addition, the code produced by the paired teams was easier to read and to understand. This facilitates finding errors and maintenance.
TL;DR: Six aspects of scenarios having inherent structure on which automated support may be based, and the results of using such support are discussed, resulting in higher-quality scenarios for better system requirements.
Abstract: Scenarios are widely used as requirements, and the quality of requirements is an important factor in the efficiency and success of a development project. The informal nature of scenarios requires that analysts do much manual work with them, and much tedious and detailed effort is needed to make a collection of scenarios well-defined, relatively complete, minimal, and coherent. We discuss six aspects of scenarios having inherent structure on which automated support may be based, and the results of using such support. This automated support frees analysts to concentrate on tasks requiring human intelligence, resulting in higher-quality scenarios for better system requirements. Two studies validating the work are presented.