Product Focused Software Process Improvement

Advances have been made in the development of software process improvement (SPI) standards and models, i.e. Capability Maturity Model (CMM), more recently CMMI, and ISO’s SPICE. However, these advances have not been matched by equal advances in the adoption of these standards and models in software development which has resulted in limited success for many SPI efforts. The current problem with SPI is not a lack of a standard or model, but rather a lack of an effective strategy to successfully implement these standards or models. In the literature, much attention has been paid to “what activities to implement” rather than “how to implement” these activities. We believe that identification of only “what activities to implement” is not sufficient and that knowledge of “how to implement” is also required for successful implementation of SPI programmes.The aim of this research paper is to empirically explore the viewpoints and experiences of practitioners regarding SPI implementation and based on the findings to develop a model in order to guide practitioners in effectively implementing SPI programmes. This SPI implementation model has six phases and provides a very practical structure within which to implement SPI programmes in organizations.

Objective. To investigate how the use of incremental and evolutionary development models affects the accuracy and bias of effort and schedule estimates of software projects. Rationale. Advocates of incremental and evolutionary development models often claim that use of these models results in improved estimation accuracy. Design of study. We conducted an in-depth survey, where information was collected through structured interviews with 22 software project managers in 10 different companies. We collected and analyzed information about estimation approach, effort estimation accuracy and bias, schedule estimation accuracy and bias, completeness of delivered functionality and other estimation related information. Results. We found no impact from the development model on the estimation approach. However, we found that incremental and evolutionary projects were less prone to effort overruns. The degree of delivered functionality and schedule estimation accuracy, on the other hand, were seemingly independent of development model. Conclusion. The use of incremental and evolutionary development models may reduce the chance of effort overruns.

Measurement based software process improvement is nowadays a mandatory activity. This implies continuous process monitoring in order to predict its behavior, highlight its performance variations and, if necessary, quickly react to them. Process variations are due to common causes or assignable ones. The former are part of the process itself while the latter are due to exceptional events that result in an unstable process behavior and thus in less predictability. Statistical Process Control (SPC) is a statistical based approach able to determine whether a process is stable or not by discriminating between the presence of common cause variation and assignable cause variation. It is a well-established technique, which has shown to be effective in manufacturing processes but not yet in software process contexts. Here experience in using SPC is not mature yet. Therefore a clear understanding of the SPC outcomes still lacks. Although many authors have used it in software, they have not considered the primary differences between manufacturing and software process characteristics. Due to such differences the authors sustain that SPC cannot be adopted “as is” but must be tailored. In this sense, we propose an SPC-based approach that reinterprets SPC, and applies it from a Software Process point of view. The paper validates the approach on industrial project data and shows how it can be successfully used as a decision support tool in software process improvement.

Though more and more researchers have realized the importance of creativity in software development, there are few empirical studies reported on this topic. In this paper, we present an exploratory empirical research in which several issues on creativity in software development are studied, that is, which development phases are perceived to include more creative work, whether or not UML-based documentation can make developers perceive more time is devoted to creative work, whether or not more creative work can accelerate the software development speed, and whether developers more prefer to do the creative work. Based on result analyses, we proposed four hypotheses to direct the future research in this field and discussed the challenge that ‘since developers do not like to participate in those improving activities (quality assuring activities), how can we keep and improve software quality effectively and efficiently?’

Process improvement activities in small and medium size enterprises (SME) are challenging due to small number of personnel and projects, people have to perform in a variety of roles. Assigning process improvement activities to the overburdened personnel may be seen as a threat to ongoing projects. Both management and staff should become convinced of the benefits of the improvement actions before taking the first step of the process. Even in this situation the software inspection provides a tempting starting point for process improvement. It is a focused and well defined subprocess and enables high return on investment benefits even in short period use. Our experiment in a small software company confirms that software inspection provides the justified starting point for process improvement. By means of the inspection maturity model the company recognises the weak points in their review practice and inspection patterns help in discovery of improvement actions.

Software Process Improvement (SPI) methods have been used for years as means to try to solve the problems in software development. Number of SPI life cycle models exists, and some of them take a wider look to the problems. However, little information exists about how the SPI models apply to global level SPI programs in a multi-site environment. This article takes a historical look into one such case and compares how well IDEAL and ISO 15504-7 models match the actual activities. The results are naturally only indicative, but suggest that the literature models do not readily scale up and that a separate model may be needed to support setting up and guiding the execution of a multi-site SPI program.

For an organization that has just begun the SPI initiatives, making developers understand the benefits of SPI and gain active participation are critical success factors. Meanwhile, within the CMM® level 2 KPAs, the SCM KPA has a broad range of directly involved stakeholders. Therefore, as an SEPG, the authors have decided to implement the SCM process firsthand to such an organization developing a series of embedded software systems. The following activities are keys for successful SCM implementation: a) Creating an SCM deployment plan from easy, single project implementation to complex, multiple projects implementation. b) Establishing systematically the SCM Web where all stakeholders share plans, processes, and FAQs. c) Administering questionnaires to stakeholders, analyzing responses and improving SCM quickly and frequently. As a result, the developers conformed to the processes and no SCM related problems were found throughout testing.

Evaluating the characteristics of ubiquitous applications is still in its infancy although this area is rapidly gaining importance as such applications are becoming common. We present a framework for evaluating the degree of calmness in ubiquitous applications. Calmness is a characteristic of the system that is experienced by the user in the usage situation, hence our evaluation framework is targeted at evaluating the technology in real usage context. We first identify the characteristics of calmness from the user’s perspective and then use them to define the dimensions for our evaluation framework. As the framework is subjective in nature, calmness is not presented as numerical values but as graphics. The suggested presentation gives an overall understanding of the application characteristics at a glance. Further, it facilitates understanding the effects of different design and implementation choices and comparing different applications. We illustrate the framework by evaluating an application being currently constructed. This application will be evaluated in real usage context at the beginning of year 2004. We also compare related work with ours.

The paper deals with quality attributes for mobile web applications. It describes typical challenges when developing mobile web applications and relates the challenges to the ISO 9126 quality attributes. The quality attributes are summarized to an ISO model that is focusing on the most important quality attributes for the quality assurance of mobile web applications. Finally, the paper proposes that applying formal quality assurance methods during the development of mobile web applications may solve some of the challenges in mobile web application development.

The institutionalization of a Quality System improves the levels of technical and managerial efficiency of Enterprises. Moreover, the market itself solicits the acquisition of a Quality Certification for getting a steady confirmation of Enterprise’s capabilities. The introduction of a Quality System in Small and Medium Enterprises can entail prohibitive costs for them and affect their agility and flexibility. The paper proposes a lightweight approach as a solution to either avoid or reduce such drawbacks; it consists of a method for re-designing processes and a software system to control and monitoring processes’ execution. Consequently, a research question arises: is the approach suitable for establishing a Quality System effectively in a Small Medium Enterprise? In order to have a preliminary evaluation of the proposed approach, a case study has been carried out in an Italian Enterprise, aiming at owning VISION 2000 Certification.

Software companies are becoming more and more concerned about software process improvement, when they are promoting the improvement of the final products. One of the main reason of the growing interest in software metrics has been the perception that software metrics are necessary for software process improvement. Measurement is essential for understanding, defining, managing and controlling the software development and maintenance processes and it is not possible to characterize the various aspects of development in a quantitative way without having a deep understanding of software development activities and their relationships. In this paper a representative set of metrics for software process models is presented in order to evaluate the influence of the software process models complexity in their quality. These metrics are focused on the main elements included in a model of software processes, and may provide the quantitative base necessary to evaluate the changes in the software processes in companies with high maturity levels. To demonstrate the practical utility of the metrics proposed at model level, an experiment has been achieved which has allowed us to obtain some conclusions about the influence of the metrics proposed on two sub-characteristics of the maintainability: understandability and modifiability, which besides confirm the results of a subjective experiment previously performed.

The need for systematic evaluation of process quality and of the resulting products has always been an issue of primary importance within the software engineering community. In the past few years many factors have determined changes in the software process scenario that inevitably impact on software quality. To this end, goal oriented measurement models, such as Goal Question Metrics (GQM), have become essential for assessing desired quality and for enacting software process improvement (SPI). Although the importance of measurement is a shared issue, many software organizations encounter difficulties and strive to define and adopt measurement plans successfully. Causes are most likely attributable to critical issues such as measurement plan dimensions, complexity, dependencies among goals. Often the industrial projects are characterized by GQM plans with numerous quality factors and, consequently, numerous goals. This makes both measurement and interpretation procedures quite onerous. Furthermore, managing a measurement plan turns out to be quite costly and requires numerous investments. To this end, this work proposes a GQM-based approach (Multiview Framework) that provides support in designing a structured measurement plan in order to overcome the common problems mentioned previously, and manage large industrial measurement plans. The proposed approach has been validated through a post mortem analysis, consisting in a legacy data study, carried out on industrial project data.

Previous studies show that software development projects strongly underestimate the uncertainty of their effort estimates. This overconfidence in estimation accuracy may lead to poor project planning and execution. In this paper, we investigate whether the use of estimation error information from previous projects improves the realism of uncertainty assessments. As far as we know, there have been no empirical software studies on this topic before. Nineteen realistically composed estimation teams provided minimum-maximum effort intervals for the same software project. Ten of the teams (Group A) received no instructions about how to complete the uncertainty assessment process. The remaining nine teams (Group B) were instructed to apply a history-based uncertainty assessment process. The main results is that software professionals seem to willing to consider the error of previous effort estimates as relevant information when assessing the minimum effort of a new project, but not so much when assessing the maximum effort!

This paper discusses about the results of using OO (Object-Oriented) measures for the small-sized programs in C++. The metric values for the class level Object-Oriented properties: inheritance, coupling and cohesion are computed and compared with the existing study results for medium sized programs. Among the three properties, inheritance is used widely in the programs. The effective use of the three properties for the proper abstraction of the class design is investigated using six hypotheses proposed. The result of the investigation shows that inheritance and cohesion are used well for the design of attribute level abstraction in the classes.

Software inspection is often seen as a technique to produce quality software. It has been claimed that expertise is a key determinant in inspection performance particularly in individual detection and group meetings [33]. Uncertainty, among reviewers during the group meetings due to lack of expertise is seen as a weakness in inspection performance. One aspect of achieving expertise is through education or formal training. Recent theoretical frameworks in software inspection also support the idea of possible effects of training on inspection performance [33]. A laboratory experiment was conducted to test the effects of training by examples on requirements inspection. Our findings show that the trained group performs significantly better than the group which received no training. However, the ‘experienced’ reviewers did not outperform those with no experience. The results have implications the use of a repository of defect examples for training reviewers.

Software maintenance is the most expensive activity in software development. Many software companies spent a large amount of cost to maintain the existing software systems. In perfective maintenance, refactoring has often been applied to the software to improve the understandability and complexity. One of the targets of refactoring is code clone. A code clone is a code fragment in a source code that is identical or similar to another. In an actual software development process, code clones are introduced because of various reasons such as reusing code by ‘copy-and-paste’ and so on. Code clones are one of the factors that make software maintenance difficult. In this paper, we propose a method which removes code clones from object oriented software by using existing refactoring patterns, especially “Extract Method” and “Pull Up Method”. Then, we have implemented a refactoring supporting tool based on the proposed method. Finally, we have applied the tool to an open source program and actually perform refactoring.

The area of tool support for software inspection has been under active research since the early 1990’s. Although numerous implementations exist and development is still taking place, no tool has achieved a break-through. The main reason is that one tool usually demonstrates only one new idea, neglecting other features. A different approach must be taken, and software inspection tools should be seen as integral parts of the development environment. This paper categorises the existing tools into four generations based on the transition from traditional meeting support to asynchronous distributed inspections implemented with web technologies. Based on the analysis of 16 tools and our experiences, we summarize the most important features and add two new aspects to be notified when implementing the next generation of inspection tools for use in modern software development, flexibility and integration. The major focus is on comprehension, and we have taken the first steps at achieving this.

One of the most prominent issues involved in incremental software development is to decide upon the most appropriate software release plans taking into account all explicit and implicit objectives and constraints. Such decisions have become even more complicated in the presence of large number of stakeholders such as different groups of users, managers, or developers. However, early involvement of customers and understanding of their real needs is one of the core success factors of software business [16].This paper introduces a six step process model for release planning. It is inspired by the Quality Improvement Paradigm [2], as release planning is a learning and improvement process as well. Emphasis is on proposing the tool support implementing this process. The use of the intelligent decision support tool ReleasePlannerTM is presented by comparing a baseline scenario reflecting current state-of-the practice of release planning with a supposed improvement scenario obtained after usage of the tool. Initial experience from a real-world environment at iGrafx Corel Inc. is used to validate the improvement scenario.

Since software development projects often fall into runaway situations, detecting signs of runaway status in early stage of development has become important. In this paper, we propose a new scheme for the prediction of runaway projects based on an empirical questionnaire. We first design a questionnaire from five viewpoints within the projects: requirements, estimations, planning, team organization, and project management activities. Each of these viewpoints consists of questions in which experience and knowledge of software risks are included. Secondly, we classify projects into “runaway” and “success” using resultant metrics data. We then analyze the relationship between responses to the questionnaire and the runaway status of projects by the Bayesian classification. The experimental result using actual project data shows that 33 out of 40 projects were predicted correctly. As a result, we confirm that the prediction of runaway projects is successful.

Effort estimation methods are one of the important tools for project managers in controlling human resources of ongoing or future software projects. The estimations require historical project data including process and product metrics that characterize past projects. Practically, in using the estimation methods, it is a problem that the historical project data frequently contain substantial missing values. In this paper, we propose an effort estimation method based on Collaborative Filtering for solving the problem. Collaborative Filtering has been developed in information retrieval researchers, as one of the estimation techniques using defective data, i.e. data having substantial missing values. The proposed method first evaluates similarity between a target (ongoing) project and each past project, using vector based similarity computation equation. Then it predicts the effort of the target project with the weighted sum of the efforts of past similar projects. We conducted an experimental case study to evaluate the estimation performance of the proposed method. The proposed method showed better performance than the conventional regression method when the data had substantial missing values.

It is an undeniable fact that software project managers need reliable techniques and robust tool support to be able to exercise a fine control over the development process so that products can be delivered in time and within budget. Therefore, managers need to be trained so that they could learn and use new techniques and be aware of their possible impacts. In this context, effective learning is an issue. A small number of empirical studies have been carried out to study the impact of software engineering education. One such study is by Pfahl et al [11] in which they have performed a controlled experiment to evaluate the learning effectiveness of using a process simulation model for educating computer science students in software project management. The experimental group applied a Systems Dynamics simulation model while the control group used the COCOMO model as a predictive tool for project planning. The results indicated that students using the simulation model gain a better understanding about typical behaviour patterns of software development projects. Experiments need to be externally replicated to both verify and generalise original results. In this paper, we will discuss an externally replicated experiment in which we keep the design and the goal of the above experiment intact. We then analyse our results in relation to the original experiment and another externally replicated experiment, discussed in [12].

In this paper a new Experimental and Explorative Research (EER) research strategy is proposed. It combines experimental software engineering with exploratory research of new technologies. EER is based on several years experience of using and developing the approach in research of future mobile applications. In large international projects explorative application research includes quite often both industrial software developers and experienced researchers. This kind of an experimental research environment resolves the subject problem found in student experiments. It also does not have the difficulties found in experimental design and control of industrial projects that are constrained by strict commercial conditions. EER strategy provides benefits for both worlds: (1) experimental software engineering research benefits from almost industry level projects that can be used as experimentation environments, and (2) future mobile telecom application research benefits from better control and understanding of the characteristics of the applications and their development methods and processes.

Software measurement forms a sound basis for monitoring software development process and software product quality. Implementing software measurement is, however, difficult and creates several challenges and possible pitfalls. These challenges include the establishment of measurement practices, effective metrics collection and the use of collected metrics to improve development practices or product. Automated software measurement can have a significant role when adopting software metrics for systematic use. This paper is based on the results of a measurement automation project at Nokia Mobile Phones during the years of 1999-2000. This paper describes the experiences from defining metrics for controlling new SDL based development practices. The process through which the automation was implemented is described in detail and implications of the findings are discussed.

System architectures are described in abstract terms, often using Design Patterns. Actual reuse based on such descriptions requires that each development project derive a concrete architecture from the chosen Patterns, and then implement it in code.This paper describes a case study of an industrial development project that adopted a reference application as a starting point, in order to avoid the need to design a complete architecture. Reference applications are usually made by platform or component vendors. Such applications are used to provide executable examples of best practices, for a particular platform, component set, or other technology. In this case study, the Pet Store application for the J2EE platform was chosen. Pet Store is documented by Design Patterns and is also available as source code. The development consisted of replacing the application logic, while keeping the architecture intact. The project was thus transformed from an ab initio development project into a major reuse/modification project. This development project was part of a software process improvement effort looking at processes for and with reuse.Our results indicate that this approach works well, provided that the functional and non-functional requirements of the project match those of the reference application. The development time was shortened by approximately one third relative to the original estimate, and a well-designed application was produced despite lack of experience with the platform and n-layer architectures. Surprisingly, the production deployment to a different application server was still problematic, even though the original reference application was available as a sample for that server.

In this paper, based on a proposal of a reference framework for process-oriented software development organisations, we discuss some issues related to the usage of the RUP’s disciplines as instantiations of those processes. The proposals made in this paper were consolidated based on experiences from real projects. The respective lessons learnt from two of those projects are reported.

Software process improvement seeks for better methods and techniques to develop quality products with reduced time. A prerequisite for this is to understand the current status and problems. In this paper we present a survey that gives an overall picture of the status in the development of Web-based systems. We investigated how the recognized best practice in the software community is employed in WebSys development, with respect to time-to-market and quality requirements – reliability and robustness. Data have been collected through questionnaires and interviews. Exploratory data analysis is used to discover patterns underlying data through successive iterations. Ten main findings are presented in three groups: features of the WebSys development projects, results related to time-to-market and use of engineering methods for reliability and robustness. Based on these findings, some key research areas are identified.

The relationship between agile methods and Software Engineering Institute’s CMM approach is often debated. Some authors argue that the approaches are compatible, while others have criticized the application of agile methods from the CMM perspective. Only few CMM based assessments have been performed on projects using agile approaches. This paper explores an empirical case where a project using Extreme Programming (XP) based approach was assessed using the CMMI framework. The results provide empirical evidence pointing out that it is possible to achieve maturity level 2 with approach based on XP. Yet, the results confirm that XP, as it is defined, is not sufficient. This study demonstrates that it is possible to use the CMMI for assessing and improving agile processes. However, the analysis reveals that assessing an agile organization requires more interpretations than normally would be the case. It is further concluded that the CMMI model does not always support interpretations in an agile context.

Extreme programming (XP) is a development paradigm that is becoming widespread in the field of software engineering. Very few – if any – empirically validated research results have been reported on the relationship between usability engineering and XP. To understand to which extent XP guides to development of software that is usable, a usability process assessment was conducted on a controlled XP project. The analysis reveals that XP pays almost no attention on the usability of the software, apart from some actions that can be regarded as implicit usability evaluations. The analysis shows further that in XP the team transfers the responsibility of the product’s usability to the customer. It is argued, however, that an XP team is in trouble when an enlightened customer sets value on usability requirements. These findings bear significant implications on research and practice. These implications are discussed and a promising avenue for solution is identified.

Agile software development, despite its novelty, is an important domain of research within software engineering discipline. Agile proponents have put forward a great deal of anecdotal evidence to support the application of agile methods in various application domains and industry sectors. Scientifically grounded empirical evidence is, however, still very limited. Most scientific research to date has been conducted on focused practices performed in university settings. In order to generate impact on both the scientific and practical software engineering community, new approaches are needed for performing empirically validated agile software development studies. To meet these needs, this paper presents a controlled case study approach, which has been applied in a study of extreme programming methodology performed in close-to-industry settings. The approach considers the generation of both quantitative and qualitative data. Quantitative data is grounded on three data points (time, size, and defect) and qualitative data on developers’ research diaries and post-mortem sessions.

Small software development teams are much more productive than large teams. That’s been shown time after time. So how does in Nokia – with more than half of our R&D work devoted to software development – face this dilemma? The answer relies on applying the most appropriate software process to a particular business context: the good-enough software process.

We present a software process model that can be effectively applied to the agile software development context. Our approach builds an ideal agile software process model starting from the principles established by the agile community in what is known as the Agile Manifesto. The practices defined by the ideal model can be used to assess the various agile methods to determine any missing or under-emphasized practices or practices needing improvement. We compared the practices defined for two of the most popular agile methods (XP and Scrum) with the ideal model and found that these two methods do not explicitly address in an organized way all the principles in the Manifesto. While these approaches do include practices to regularly review the effectiveness of the particular method and tune the method’s behavior accordingly for a particular product being developed, they lack explicit practices to perform a retrospective focusing on the process, with the goal of adapting and improving the method itself and its future application. We propose a simple practice that could be added to these methods that would address this apparent oversight. This practice would also provide the ability to leverage what was learned from previous projects to the future projects,. We believe the proposed ideal model is complete, flexible, and can be used to assess and propose simple process improvement actions for agile methods. We also point out some open questions about the best way to share the knowledge gained from retrospectives and to do end of project reviews.

Environmental information systems (EIS) have been in professional use for quite a long time. Applications of this domain often include features of quite common location based services (LBS). This means utilization of space-, time- and content-oriented data for positioning and routing services with various maps. Firstly, new integrated technology and lower prices of related technology have made it possible for users to benefit from new mobile services with reasonable cost. Secondly, new kinds of ambient aware applications are active research and development topics. We define mobile environmental information systems (MEIS) as integrated mobile information systems used to study, monitor and exploit the nature as well as to guide users like tourists and biologists in the nature. In this paper we present our research in progress, where we have built the first MEIS prototype to be used as a basis for MEIS services that exploit LBS and ambient awareness. The main purpose of this experiment has been to explore the technologies and methods for efficient building of easily extendable mobile platforms that would support main MEIS functionalities. According to our literature survey no similar technical solution as a mobile phone service did not exist.

Over the last eight years, different approaches have been used to diagnose the performance in ABB organizations developing software. The efforts build to a large degree on methods from the Software Engineering Institute (SEI). In this paper we examine the experiences from five organizations through a description of the pathways that we have observed in the maturity development. We also propose a way to classify organizations based on two organizational characteristics, maturity and openness. Based on this classification, a simple method for the selection of how to collect performance data from the organizations is described.

Process improvement is a challenging task for software engineering. As Kuvaja [7]. has stated it: “It is difficult to find a unique way to identify a common improvement path suitable to all kinds of organizations.” The BOOTSTRAP method gives an assessor tools to evaluate processes. As a method it evaluates processes with low capability and a high effect on an organization’s goals the most important, and with high capability and a low effect on the organization the least important. It takes into account the organization’s needs and goals, capability profiles of its processes and industry as the main drivers of process improvement. Value Engineering (VE) is a systematic method to improve the value and optimize the life cycle cost of a function or a facility. VE generates cost improvements without sacrificing the capability levels needed. By combining these two processes, process improvement work can be tailored to take into consideration, not only the capabilities of software processes but also the values of the same processes. This article discusses how to enhance the BOOTSTRAP assessment method to include new value characteristics and phases. Same principles can be applied also in other capability based assessment methods (for example CMM, CMMI or SPICE).

A system documentation process maturity model and assessment procedure were developed and used to assess 91 projects at 41 different companies over a seven year period. During this time the original version evolved into a total of four versions based on feedback from industry and the experience gained from the assessments. This paper reports the overall results obtained from the assessments which strongly suggest that the practice of documentation is not getting a passing grade in the software industry. The results show a clear maturity gap between documentation practices concerned with defining policy and practices concerned with adherence to those policies. The results further illustrate the need to recognize the importance of improving the documentation process, and to transform the good intentions into explicit policies and actions.

Requirements prioritization is recognized as an important activity in product development. In this paper, we describe the current state of requirements prioritization practices in two case companies and present the practical challenges involved. Our study showed that requirements prioritization is an ambiguous concept and current practices in the companies are informal. Requirements prioritization requires complex context-specific decision-making and must be performed iteratively in many phases during development work. Practitioners are seeking more systematic ways to prioritize requirements but they find it difficult to pay attention to all the relevant factors that have an effect on priorities and explicitly to draw different stakeholder views together. In addition, practitioners need more information about real customer preferences.

We developed a collaborative software development community-ware whose goal is to provide practical tasks for the students in software engineering education in a university and to provide software for education purpose. We performed a pilot experimentation for the community-ware. The results show that software requesters made software change requests for not only functional aspects but also user interface. This paper proposes a user interface oriented requirement elicitation process. The process is that software requesters present functional requests and user interface design which met the requests. Then based on the requests and the user interface, developers and software requesters decide priority for each requirement in a collaborative manner.

Important tasks in requirement engineering are resolving requirements inconsistencies between regulators and developers of safety-critical computer systems, and the validation of regulatory requirements. This paper proposes a new approach to the regulatory process, including formulating requirements and elaborating methods for their assessment. We address the differences between prescriptive and nonprescriptive regulation, and suggest a middle approach. Also introduced is the notion of a normative package as the collection of documents to be used by a regulator and provided to a developer. It is argued that the normative package should include not only regulatory requirements but also methods of their assessment. We propose the use of formal regulatory requirements as a basis for development of software assessment methods. This approach is illustrated with examples of requirements for protecting computer control systems against unauthorized access, using the Z notation as the method of formalization.

The paper describes an empirical study to investigate the state of practice and challenges concerning some key factors in reusing of in-house built components. It also studies the relationship between the companies’ reuse level and these factors. We have collected research questions and hypotheses from a literature review and designed a questionnaire. 26 developers from three Norwegian companies filled in the questionnaire based on their experience and attitudes to component reuse and component-based development. Most component-based software engineering articles deal with COTS components, while components in our study are in-house built. The results show that challenges are the same in component related requirements (re)negotiation, component documentation and quality attributes specification. The results also show that informal communications between developers are very helpful to supplement the limitation of component documentation, and therefore should be given more attention. The results confirm that component repositories are not a key factor to successful component reuse.

While the objectives of Six Sigma are to reduce variation and prevent defects, it is also a management philosophy that includes the need for fact-based decisions, customer focus, and teamwork. In attempting to build a COTS integrated system, selection of candidates typically pays attention to specify search criteria and goals to be met. Yet they often overlook some elements in the process such as fact-based decisions and teamwork, which might drive the process helping increase the probability of success. In this paper, we describe and illustrate a Six Sigma-based proposal for the process of selecting and integrating COTS components. Our approach also suggests some tools and measures to be applied during its specific phases.

In the last several years, software industry has undergone a significant transition to the use of existing component products in building systems. Nowadays, more and more solutions are built by integrating Commercial-Off-The-Shelf (COTS) products rather than building from scratch. This new approach for software development has specific features that add new factors that need to be taken into account to successfully face software development. In this paper, we present the first results of developing a dynamic simulation model to model and simulate the COTS-based software development process with the aim of helping to understand the specific features of this kind of software development, and design and evaluate software process improvements. An example of how to use these dynamic simulation models to study how the system integration starting point affects the main project variables is shown.