1.Software process management metrics.
Software process management metrics play a crucial role in assessing and improving the various aspects of the software development process. These metrics are quantitative measurements that provide valuable insights into the efficiency, quality, and effectiveness of software development activities. By tracking and analyzing these metrics,
organizations can identify bottlenecks, optimize processes, and make data-driven decisions to enhance their software development practices.
Let's explore some common software process management metrics in detail:
Schedule Variance (SV): Schedule Variance measures the variance between the planned and actual schedule for completing project activities. It provides visibility into whether the project is on track or behind schedule. A positive SV indicates that the project is ahead of schedule, while a negative value suggests that it is falling behind. By monitoring SV, project managers can take timely corrective actions, such as adjusting resources or priorities, to ensure the project stays on schedule.
Cost Variance (CV): Cost Variance measures the variance between the planned and actual project costs. It helps organizations monitor their budget adherence and financial performance. A positive CV indicates that the project is under budget, while a negative value indicates that it is over budget. By analyzing CV, project managers can identify cost overruns, evaluate resource utilization, and make informed decisions to optimize project costs.
Effort Variance (EV): Effort Variance measures the variance between the planned and actual effort required to complete project activities. It provides insights into resource utilization and efficiency. By comparing EV with the planned effort, project managers can identify deviations and assess the impact on project timelines and costs. This metric helps in managing resources effectively and ensuring that the project is staffed
appropriately.
Defect Density: Defect Density is a quality metric that measures the number of defects or bugs discovered in the software per unit of code size. It provides an indication of the software's reliability and robustness. By tracking defect density, organizations can identify areas of the codebase that are prone to defects and prioritize efforts to improve
their quality. Decreasing defect density over time demonstrates the effectiveness of quality assurance processes and the overall maturity of the development team.
Test Coverage: Test Coverage measures the extent to which the software code is
exercised by test cases. It helps evaluate the adequacy of the testing process and identifies areas with inadequate coverage. Higher test coverage indicates a lower probability of undiscovered defects. By analyzing test coverage metrics, organizations can identify areas that require additional testing and improve the overall effectiveness of their quality assurance efforts.
Cycle Time: Cycle Time is the time taken to complete a specific task or process from start to finish. In software development, it can measure the time it takes to complete a user story, fix a bug, or deliver a software feature. Monitoring cycle time helps identify bottlenecks and optimize workflow efficiency. By reducing cycle time, organizations can improve their time-to-market and responsiveness to customer needs.
Lead Time: Lead Time is the total time it takes from the initiation of a development request (e.g., a feature request or bug report) to its completion and delivery. It provides insights into the overall responsiveness and efficiency of the development process. By measuring lead time, organizations can identify areas of delay or inefficiency and implement measures to streamline the development pipeline. Shorter lead times lead to faster delivery, increased customer satisfaction, and a competitive advantage in the market.
Code Churn: Code Churn measures the amount of code that is modified or replaced during development. High code churn may indicate instability or inadequate planning, potentially leading to increased defects and rework. By monitoring code churn,
organizations can identify areas where code stability is lacking and take steps to improve the development process. Reducing code churn can result in better code quality,
improved maintainability, and increased development efficiency.
Customer Satisfaction: Customer Satisfaction metrics, such as Net Promoter Score (NPS) or customer feedback ratings, gauge the level of satisfaction with the software product or service. They provide organizations with valuable insights into customer perception and help identify areas for improvement. By tracking customer satisfaction metrics,
organizations can understand customer needs, enhance the user experience, and drive customer loyalty and retention.
Employee Satisfaction: Employee Satisfaction metrics, such as surveys or engagement scores, measure the satisfaction and morale of the software development team. High employee satisfaction is crucial for productivity, collaboration, and retention. By regularly assessing employee satisfaction, organizations can identify issues affecting team morale, address concerns, and create a positive work environment. Satisfied
employees are more likely to be motivated, innovative, and committed to delivering high- quality software.
It is important to note that while these metrics provide valuable insights, they should not be viewed in isolation. They should be used in combination with qualitative analysis, industry benchmarks, and organizational goals. Additionally, organizations should avoid focusing on a large number of metrics and instead prioritize those that align with their specific objectives and contribute to continuous improvement. Regularly reviewing and analyzing software process management metrics enables organizations to optimize their development processes, enhance quality, and deliver successful software projects.
The management of software processes is largely recognized as a key factor for improving both the productivity of an organization and the quality of the software delivered (Fuggetta, 2000). Process Modelling is an important activity of software process management and it is the starting point for analyzing, improving, and enacting processes (Florac and Carleton, 1999).
A software process model (SPM) is an abstraction of a real-world software process expressed in a suitable process modelling language (PML). SPMs applications range from comprehension to enactment; Curtis et al. (1992) identify five main applications of process modelling:
To facilitate human understanding and communication.
To support process improvement.
To support process management.
To automate guidance in performing process.
To automate execution support.
SPMs can be grouped into two main categories: descriptive models and active models (Curtis et al., 1992, Dowson and Fernstrửm, 1994). Descriptive models are aimed at describing processes and organizational behaviour in terms of entities—activities, roles, tools, and artifacts- and the relationships among them. Active models are intended for building executable systems that support the enactment of processes.
Descriptive SPMs, which are the focus of this paper, have proven useful for guiding process execution and as a basis for measurement in the context of software process improvement (Becker-Kornstaedt, 2000). They are a prerequisite for active modelling.
The current competitive marketplace forces software organizations to continuously improve their processes. Improving software processes effectively requires their maintenance: maintenance of the software process deserves the same attention as any other kind of software (Curtis, 1992). As a consequence, process models must be continuously maintained based on gained experience, new requirements and changed policies (Jaccheri and Conradi, 1993). This suggests the need for descriptive software process models with high maintainability.1 In particular, means are needed to evaluate the maintainability of software processes in the early stages of their development, primarily during process modelling. This would provide organizations with a basis for
choosing, among semantically equivalent SPMs, the model which can be more easily maintained and adapted to new and emerging needs.
In this context, this paper addresses two main issues:
To quantify descriptive SPMs by means of the definition of a set of suitable metrics.
To demonstrate which metrics can be used as maintainability indicators by carrying out an empirical study.
This paper is organized as follows. Section 2 provides an overview of related work and Section 3 introduces the metrics for SPMs and presents an example of computation.
Section 4 provides an overview of the family of experiments carried out in order to empirically validate the metrics. Sections 5 Subjective experiments, 6 Objective
experiments describe the individual experiments and Section 7 presents a global analysis of the results. Finally, conclusions and future works are outlined in Section 8.
Section snippets Related works
Software process research has gained a great importance due to the growing interest of software companies in the improvement of the productivity and quality of delivered products. To support software process evaluation and improvement, a wide variety of initiatives have proposed reference frameworks. Notable examples are the CMM (SEI, 1995), the CMMI (SEI, 2002), the ISO 15504 standard (ISO/IEC, 1998). Process improvement has also been considered in the new family of ISO 9000:2000 standards ( Metrics for software process models
A representative set of metrics for software process models has been defined in order to evaluate SPMs maintainability (Table 1).
The metrics have been defined following the SPEM (Software Process Engineering Metamodel) terminology (OMG, 2002), but they can be easily applied to other PMLs.
Fig. 1 shows an example of a software process model represented with the SPEM; in particular, it consists of a UML Activity Diagram with stereotypes which represent the SPEM constructors.
Table 2 shows the
Overview of the family of experiments
A family of experiments contains multiple similar empirical studies pursuing the same goal. As Basili et al. (1999) remark, a family of experiments permits the accumulation of the knowledge needed to extract significant conclusions that can be applied in practice.
We planned and performed a family of experiments based on the methodology of Ciolkowski et al. (2002). A five steps process was exploited:
1.
Experiment preparation. The general goal of the experiments was to demonstrate the suitability
Subjective experiments
In this section we describe the subjective experiments. We followed the suggestions provided by Wohlin et al. (2000), Kitchenham et al. (2002), Perry et al. (2000) and Briand et al. (1999) on how to perform controlled experiments. To describe the experiment we use (with only minor changes) the format proposed by Wohlin et al.
(2000) comprising the following main tasks: definition, planning, operation, analysis and interpretation, validity evaluation and presentation and package.
Objective experiments
Even though the results of the subjective experiments were encouraging, we were aware that the way of measuring the dependent variables was subjective and relied solely on the judgement of the users, which may have biased the results. For this reason in the family of experiments objective experiments were planned which are described in the following subsections.
Family data analysis
Once the individual experiments were carried out we performed a global analysis of the results in the context of the family of experiments to determine if the general goal of the empirical validation has been achieved. In Table 10 a general summary of the results obtained in the individual experiments is provided. Five experiments grouped in two subjective and three objective ones were performed in which 224 subjects participated, belonging to the following groups: students, researchers,
Conclusions and future works
Maintenance and evolution of software processes and their models is acquiring a growing importance in the software process community. As happens with software products, software processes evolve and consequent changes should be properly managed by organizations, in the context of effective software processes improvement programs.
The SPMs constitute the starting point in process management, and it is according to these models that processes are enacted and improved. From such a perspective, Acknowledgments
This research is supported by the MAS project partially supported by the “Dirección General de Investigación of the Ministerio de Ciencia y Tecnología” (TIC 2003-02737- C02-02). We would also like to thank the professors, professionals of Cronos Iberica S.A and the students of Spain and Italy who participated in the experiments.
Gerardo Canfora is a full professor of computer science at the Faculty of Engineering and the Director of the Research Centre on Software Technology (RCOST) of the University of Sannio in Benevento, Italy. He serves on the program committees of a number of
international conferences. He was a program co-chair of the 1997 International Workshop on Program Comprehension, of the 2001 International Conference on Software
Maintenance, and of the 2004 European Conference on Software Maintenance and…
2.Current issues in software process management: A critical review of legal &
methodological issues
Software process management involves various methodological and legal aspects that need careful consideration to ensure effective implementation. Here, we will provide a critical review of the methodological and legal issues related to software process management.
Methodological Issues:
Process Definition and Standardization: One of the key challenges in software process management is defining and standardizing processes across an organization. This requires capturing best practices, documenting procedures, and establishing guidelines that align with industry standards. However, this task can be complex and time-consuming, especially in large organizations with diverse project teams and development
methodologies. Balancing flexibility and standardization is crucial to avoid overly rigid processes that hinder innovation or overly flexible processes that result in inconsistencies.
Process Tailoring and Adaptation: Software development projects often differ in scope, size, and complexity. Therefore, it is essential to tailor and adapt processes to suit specific project requirements. However, striking the right balance between
standardization and customization can be challenging. Overly customized processes may lead to inconsistency, while adhering strictly to standardized processes may result in inefficiencies. It requires a thorough understanding of project needs, continuous evaluation, and feedback loops to optimize the process tailoring approach.
Process Measurement and Metrics: Defining meaningful metrics to assess software development processes is critical. However, selecting appropriate metrics that align with project goals and effectively measure process performance can be challenging. In some cases, organizations may focus on easily measurable metrics without considering their relevance or impact on overall process improvement. It is important to select metrics that provide actionable insights and drive continuous improvement, rather than merely
creating a numerical representation of progress.
Process Integration and Tooling: Software development involves a range of tools and technologies. Integrating these tools to support the software process management lifecycle can be complex. Issues may arise due to incompatible tools, lack of
interoperability, or difficulties in data sharing and synchronization. Seamless integration and tool support are crucial for effective process management, ensuring that development teams can efficiently collaborate, track progress, and analyze data.
Legal Issues:
Intellectual Property Protection: Software development involves the creation of intellectual property (IP). Organizations need to address legal issues related to IP
protection, including copyrights, trademarks, and patents. Clear ownership and licensing agreements must be established to protect the organization's interests and prevent
unauthorized use or infringement of IP rights.
Compliance with Regulations: Various regulations and industry standards govern software development practices, such as data privacy (e.g., GDPR), security (e.g., ISO 27001), or industry-specific regulations (e.g., medical device regulations). Ensuring compliance with these regulations is essential to avoid legal and financial consequences.
Organizations need to incorporate regulatory requirements into their software process management practices, including documentation, risk assessment, and quality assurance.
Contractual Agreements: Software development projects often involve contracts and agreements with clients, vendors, or subcontractors. These agreements define project scope, deliverables, timelines, and legal responsibilities. Legal issues may arise due to ambiguous or inadequate contract terms, scope creep, or disputes over deliverables. Clear and well-defined contractual agreements, reviewed by legal experts, are essential to mitigate legal risks and establish a solid foundation for successful project execution.
Data Protection and Privacy: Software development involves handling sensitive data, including user information, financial data, or personal identifiable information (PII).
Organizations must comply with data protection and privacy laws to safeguard this data.
This includes implementing appropriate security measures, obtaining user consent, and ensuring secure storage and transmission of data. Failure to address these legal
requirements can lead to data breaches, legal liabilities, and reputational damage.
In conclusion, software process management faces methodological challenges related to process definition, standardization, tailoring, and measurement. Balancing flexibility and standardization, selecting meaningful metrics, and integrating tools are critical for effective process management. On the legal front, issues related to intellectual property protection, regulatory compliance, contractual agreements, and data protection must be carefully addressed. By addressing these methodological and legal challenges,
organizations can enhance their software development processes, mitigate risks, and ensure legal compliance.
3.The power of software process management.
The power of software process management is rooted in its ability to address and overcome various challenges and problems commonly faced in software development.
By effectively managing these challenges, organizations can harness the full potential of software process management. Let's delve into the problems that software process management helps tackle:
Lack of Standardization: In many software development environments, there is a lack of standardized processes and practices. This leads to inconsistencies, inefficiencies, and difficulties in collaboration. Software process management promotes the establishment of
standardized processes that define clear guidelines, roles, and responsibilities. By implementing standardized practices, organizations can improve efficiency, reduce errors, and enhance collaboration across teams.
Inefficient Resource Allocation: Without proper process management, resource allocation can be ad hoc and inefficient. Teams may be overloaded, leading to burnout and
suboptimal performance. Conversely, resources may be underutilized, resulting in wasted time and budget. Software process management provides the tools and methodologies to assess resource requirements accurately, allocate resources effectively, and optimize resource utilization. This ensures that the right resources are assigned to the right tasks at the right time.
Lack of Visibility and Control: Without proper process management, organizations may struggle to have clear visibility into the progress of software development projects. It becomes challenging to track project status, identify bottlenecks, and take timely corrective actions. Software process management emphasizes the use of metrics, measurements, and reporting mechanisms to provide visibility and control over the development process. This enables project managers to monitor progress, identify risks, and make data-driven decisions to ensure successful project outcomes.
Poor Quality Assurance: Quality assurance is a critical aspect of software development, but it can be challenging to ensure consistent and reliable quality without proper process management. Without standardized processes, organizations may lack a systematic approach to testing, reviewing, and validating software deliverables. Software process management incorporates quality assurance practices throughout the development lifecycle. It emphasizes the use of metrics, testing methodologies, and quality gates to ensure that software meets the required quality standards.
Ineffective Communication and Collaboration: Communication and collaboration are essential for successful software development. However, without proper process management, communication can be fragmented, leading to misunderstandings and delays. Collaboration may suffer due to a lack of clarity regarding roles, responsibilities, and expectations. Software process management promotes effective communication channels, establishes clear roles and responsibilities, and fosters collaboration among team members. By facilitating better communication and collaboration, software process management improves coordination, reduces rework, and enhances productivity.
Lack of Continuous Improvement: Without a process management framework, organizations may struggle to drive continuous improvement in their software development practices. There may be a lack of mechanisms to identify process
bottlenecks, analyze performance metrics, and implement corrective actions. Software process management encourages a culture of continuous improvement by systematically evaluating process performance, identifying areas for enhancement, and implementing iterative changes. This enables organizations to adapt to changing requirements, adopt best practices, and continuously enhance their software development processes.