Mobile edge computing (MEC) has become a key paradigm for supporting latency-sensitive and bandwidth-intensive applications. However, existing server recommendation methods rely on static heuristics and lack adaptability to dynamic environments with incomplete quality of service (QoS) data. This study aims to address these limitations by enabling adaptive and context-aware server recommendations that effectively manage user mobility and missing QoS information in real time. We propose an intelligent MEC server recommendation framework built on a multi-agent architecture spanning mobile, edge, and cloud layers. The mobility layer predicts user movement, the edge layer performs LLM-based decision-making, and the cloud layer imputes QoS through multi-source data fusion. Lightweight gRPC and WebSocket protocols ensure scalability across multi-user environments. Experiments demonstrate that the proposed system outperforms the baseline, achieving 85% Top-1 accuracy and confirming its effectiveness and scalability for real-world MEC applications.

In mobile edge computing (MEC), frequent server handovers due to user mobility increase latency and degrade quality of service (QoS). This study enhances MEC service stability by predicting user mobility for efficient server transitions. The proposed spacio-temporal (ST)-Mamba model combines Mamba (state-space encoder) and a gated recurrent unit (GRU) in parallel to capture both long-term and short-term dependencies, while Fourier feature embedding enriches spatial-temporal representation. Experiments show that ST-Mamba achieves about 9–10% lower root mean square error (RMSE) and mean absolute error (MAE) than long short-term memory (LSTM), GRU, and Transformer baselines, with statistically significant improvements confirmed by Welch’s t-test. These results demonstrate that hybrid state space model (SSM)–RNN architectures are promising for mobility-aware QoS optimization in MEC, with future work extending to real-world and multi-user settings.

Edge-cloud systems, which bring computing, storage, and networking resources closer to end-users, offer significant advantages in reducing latency and enabling real-time data processing. These systems are increasingly deployed across diverse domains, such as smart manufacturing, autonomous vehicles, and large-scale IoT networks, to support big data-driven services that require continuous analytics and rapid response. Ensuring software reliability in these environments is critical, which has led to growing attention on just-in-time (JIT) defect prediction as an effective technique for prioritizing testing efforts by identifying code changes likely to introduce defects. However, existing techniques struggle to perform accurately on new or low-data projects due to insufficient training data. In this paper, we propose PROPER-SDP, a prompt-based approach that leverages large language models. By incorporating project evolution data directly into prompts, our approach enables LLMs to effectively capture the contextual information essential for accurate JIT defect prediction. By doing so, we effectively address the cold-start problem, allowing accurate JIT defect prediction even in the absence of project-specific training data. Evaluation results demonstrate that our method significantly improves prediction performance, surpassing baseline methods by an average of 19.7% in F1-score. Our approach enables reliable JIT defect prediction even in rapidly evolving, resource-constrained edge-cloud systems.

The prevalence of software vulnerabilities necessitates accurate and scalable detection techniques. While Pre-trained Language Models (PLMs) have shown strong potential in vulnerability analysis, most existing methods provide no explicit guidance on which parts of the input code are more likely to be vulnerable. As a result, the model must infer token-level relevance without any indication of which parts are important, making it harder to learn the characteristics of vulnerable code during training. We address this by proposing LOSVER (Line-level mOdifiability Signal-guided VulnERability analyzer), a novel two-stage framework that enhances PLM-based vulnerability analysis using line-level modifiability signals. LOSVER first localizes modifiable lines, which are code segments likely to be changed in the future and often associated with vulnerabilities, and then assigns them greater importance, allowing the PLM to focus on potentially vulnerable regions during both training and inference. We evaluated LOSVER across three benchmark datasets (Devign, Big-Vul, and PrimeVul) for vulnerability detection, classification, and patch-pair analysis. Experimental results demonstrate that LOSVER consistently improves performance, increasing detection accuracy by 4 percentage points and the weighted F1-score for classification by over 2 points when applied on top of UniXcoder. These results demonstrate that integrating line-level modifiability signals significantly enhances the effectiveness of PLM-based software vulnerability analysis across both detection and classification tasks.

Ensuring the reliability of infrastructure as code (IaC) scripts, like those written in Ansible, is vital for maintaining the performance and security of edge-cloud systems. However, the scale and complexity of these scripts make exhaustive testing impractical. To address this, we propose a large language model (LLM)-based software defect prediction (SDP) approach that uses code-smell-guided prompting (CSP). In some cases, CSP enhances LLM performance in defect prediction by embedding specific code smell indicators directly into the prompts. We explore various prompting strategies, including zero-shot, one-shot, and chain of thought CSP (CoT-CSP), to evaluate how code smell information can improve defect detection. Unlike traditional prompting, CSP uniquely leverages code context to guide LLMs in identifying defect-prone code segments. Experimental results reveal that while zero-shot prompting achieves high baseline performance, CSP variants provide nuanced insights into the role of code smells in improving SDP. This study represents exploration of LLMs for defect prediction in Ansible scripts, offering a new perspective on enhancing software quality in edge-cloud deployments.

It requires historical datasets from diverse environments to build accurate and robust software reliability growth models. However, it is very difficult to collect such datasets, particularly in the industrial domain, due to confidentiality and security considerations. To solve this issue, we conducted a thorough investigation of historical datasets for software reliability growth modeling. We searched IEEE Xplore, a prominent digital library, using the keyword “Software Reliability Growth Model” for publications up to 2022 and gathered 127 non-redundant historical datasets. In this paper, we present a comprehensive analysis of these datasets, which helps advance software reliability growth modeling. We applied seven representative software reliability growth models and found that the Generalized Goel model, which has a concave curve, was the most frequently chosen optimal model for Failure-Count type datasets. However, It is notable that S-shaped curve models remained preferred for the majority of datasets. Categorizing datasets by collection phases, application types, source types, and data flow trends resulted in varied optimal model selections across classifications. These insights contribute to the advancement of software reliability growth modeling, fostering informed decision-making in software development and maintenance.

Traditional Software Reliability Growth Models (SRGMs) depend on unrealistic assumptions, which makes it difficult to capture the complexities of modern software development. Recent advancements in artificial intelligence have introduced new modeling techniques, but these methods are complex and require careful algorithm selection and hyperparameter tuning. Automated Machine Learning (AutoML) has emerged as a promising solution to streamline this process. However, its application in the field of software reliability growth modeling remains unexplored. In this study, we explore the effectiveness of AutoML in enhancing software reliability growth modeling and compare its performance with traditional SRGMs. We employ two prominent AutoML packages, Auto-sklearn and H2O AutoML, and leverage twelve project datasets to answer three research questions: (1) the impact of various AutoML package options on software reliability growth modeling, (2) the identification of the optimal AutoML approach for modeling software reliability growth, and (3) the overall effectiveness of AutoML in software reliability growth modeling. We found that using ensemble options enhanced predictive performance across multiple projects. Auto-sklearn with the ensemble option emerged as the most effective approach when evaluated based on End-point Prediction values, while H2O AutoML with the ensemble option demonstrated superior performance based on Mean Squared Error values. Additionally, AutoML packages with ensemble options demonstrated more accurate predictive performance compared to traditional SRGMs across the majority of datasets. Our study highlights the potential of AutoML to enhance software reliability growth modeling and provides insights for future research and practical applications in software engineering.

Edge computing is applied to various applications and is typically applied to autonomous driving software. As the self-driving system becomes complicated and the proportion of software increases, accidents caused by software defects increase. Just-in-time (JIT) defect prediction is a technique that identifies defects during the software development phase, which helps developers prioritize code inspection. Many researchers have proposed various JIT models, but it is difficult to find a case in which JIT defect prediction was performed on edge computing applications. In particular, due to the characteristic of self-driving software, which is frequently updated, there is a high risk of inducing defects into the update process. In this work, we propose a JIT defect prediction model via deep learning for edge computing applications called JIT4EA. Our research goal is to develop an effective model to predict defects in edge computing applications. To do this, we perform defect prediction on self-driving software, a representative edge computing application. We use pre-trained unified cross-modal pre-training for code representation (UniXCoder) to embed commit messages and code changes. We use bidirectional-LSTM(Bi-LSTM) for context and semantic learning. As a result of the experiment, it was confirmed that the proposed JIT4EA performed better than state-of-the-art methods and could reduce the code inspection effort.

Edge-Cloud system requires massive infrastructures located in closer to the user to minimize latencies in handling Big data. Ansible is one of the most popular Infrastructure as Code (IaC) tools crucial for deploying these infrastructures of the Edge-cloud system. However, Ansible also consists of code, and its code quality is critical in ensuring the delivery of high-quality services within the Edge-Cloud system. On the other hand, the Large Langue Model (LLM) has performed remarkably on various Software Engineering (SE) tasks in recent years. One such task is Automated Program Repairing (APR), where LLMs assist developers in proposing code fixes for identified bugs. Nevertheless, prior studies in LLM-based APR have predominantly concentrated on widely used programming languages (PL), such as Java and C, and there has yet to be an attempt to apply it to Ansible. Hence, we explore the applicability of LLM-based APR on Ansible. We assess LLMs’ performance (ChatGPT and Bard) on 58 Ansible script revision cases from Open Source Software (OSS). Our findings reveal promising prospects, with LLMs generating helpful responses in 70% of the sampled cases. Nonetheless, further research is necessary to harness this approach’s potential fully.

Edge-cloud computing is a distributed computing infrastructure that brings computation and data storage with low latency closer to clients. As interest in edge-cloud systems grows, research on testing the systems has also been actively studied. However, as with traditional systems, the amount of resources for testing is always limited. Thus, we suggest a function-level just-in-time (JIT) software defect prediction (SDP) model based on a pre-trained model to address the limitation by prioritizing the limited testing resources for the defect-prone functions. The pre-trained model is a transformer-based deep learning model trained on a large corpus of code snippets, and the fine-tuned pre-trained model can provide the defect proneness for the changed functions at a commit level. We evaluate the performance of the three popular pre-trained models (i.e., CodeBERT, GraphCodeBERT, UniXCoder) on edge-cloud systems in within-project and cross-project environments. To the best of our knowledge, it is the first attempt to analyse the performance of the three pre-trained model-based SDP models for edge-cloud systems. As a result, we can confirm that UniXCoder showed the best performance among the three in the WPDP environment. However, we also confirm that additional research is necessary to apply the SDP models to the CPDP environment.

With recent increases in the number of network-connected devices, the number of edge computing services that provide similar functions has increased. Therefore, it is important to recommend an optimal edge computing service, based on quality-of-service (QoS). However, in the real world, there is a cold-start problem in QoS data: highly sparse invocation. Therefore, it is difficult to recommend a suitable service to the user. Deep learning techniques were applied to address this problem, or context information was used to extract deep features between users and services. However, edge computing environment has not been considered in previous studies. Our goal is to predict the QoS values in real edge computing environments with improved accuracy. To this end, we propose a GAIN-QoS technique. It clusters services based on their location information, calculates the distance between services and users in each cluster, and brings the QoS values of users within a certain distance. We apply a Generative Adversarial Imputation Nets (GAIN) model and perform QoS prediction based on this reconstructed user service invocation matrix. When the density is low, GAIN-QoS shows superior performance to other techniques. In addition, the distance between the service and user slightly affects performance. Thus, compared to other methods, the proposed method can significantly improve the accuracy of QoS prediction for edge computing, which suffers from cold-start problem.

Abstract Fault localization techniques are used to deduce the exact source of a failure from a set of failure indications while debugging software and play a crucial role in improving software quality. Mutation‐based fault localization (MBFL) techniques are proposed to localize faults at a finer granularity and with higher accuracy than traditional fault localization techniques. Despite the technique's effectiveness, the immense cost of mutation analysis hinders MBFL's practical application in the industry. Various mutation alternative strategies are utilized to lower the cost of MBFL, but they sacrifice the accuracy of localization results. Higher‐order mutation testing was proposed to search for valuable mutants that drive testing harder and reduce the overall test effort. However, higher‐order mutants (HOMs) never have been used to address the cost problem of MBFL to the extent of our knowledge. This paper proposes a novel, cost‐effective MBFL technique called HOTFUZ, Higher‐Order muTation‐based FaUlt localiZation, that employs HOMs to reduce the cost while minimizing the accuracy degradation. HOTFUZ combines mutants of a program under test into HOMs to decrease the number of mutants by more than half, depending on the order of HOMs. An experimental study is conducted using 65 real‐world faults of CoREBench to assess the proposed approach's cost‐effectiveness. The experimental results show that HOTFUZ outperforms the extant mutation alternative strategies by localizing faults more accurately using the same number of mutants executed. HOTFUZ has three main benefits over existing mutant reduction techniques for MBFL: (a) It keeps the advantage of using the whole set of mutation operators; (b) it does not discard generated mutants randomly for the sake of efficiency; and, finally, (c) it significantly decreases the proportion of equivalent mutants.

Heterogeneous defect prediction (HDP) predicts defect-prone modules when the source and target data have heterogeneous metric sets. Although several researchers have tried to improve the performance of HDP, many of them did not suggest selection guidelines of source projects nor handle the class imbalance problem. In this paper, we propose a novel approach to improve the performance further by selecting proper source projects for the given target project and considering imbalanced data, called CorrelAtion-based selection of Multiple source projects and Ensemble Learning (CAMEL) for HDP. Specifically, CAMEL first matches metrics through the Kolmogorov-Smirnov test. Second, it calculates fitness scores based on correlation analysis and selects multiple projects. Third, it predicts target labels using each selected source project and integrates the results with ensemble learning. The experiments show that CAMEL produces better results against existing methods. Consequently, CAMEL enhances reliability in the early development phase by providing proper source selection guidelines.

Cross-project Defect Prediction (CPDP) aims to build a defect prediction model to recognize target project's defective modules by utilizing other source project's historical data. In addition, Transfer Learning (TL) has been widely applied at CPDP to improve prediction performance by alleviating the data distribution discrepancy between the source and the target project. However, existing TL-based CPDP techniques are not applicable at the unit testing phase since they require the entire historical target project data for TL. As a result, they lose a chance of increasing the product's reliability in the unit testing phase by applying the prediction results to identify defects. Thus, the objective of this paper is to apply prediction results at the unit testing phase. To this end, we propose an early CPDP model (eCPDP) which is TL-based CPDP technique using Singular Value Decomposition applicable at the unit testing phase. We compare the performance of eCPDP with state-of-the-art TL-based CPDP techniques on effort-unaware and effort-aware performance metrics over 17 project datasets. Experimental result demonstrates that eCPDP executed during the unit testing stage is one of the best techniques compared to baselines executed after the unit testing stage on both types of metrics. Thus, we show that eCPDP is an applicable CPDP model at the unit testing phase, and it can help practitioners find and fix defects in an earlier phase than other TL-based CPDP techniques.

Abstract Background The importance of software in maritime transportation is rapidly increasing as the industry seeks to develop and utilize innovative future ships, which can be realized using software technology. Due to the safety‐critical nature of ships, software quality assurance (SQA) has become an essential prerequisite for such development. Objective Based on the unique characteristics of the maritime domain, the purpose of this study was to achieve effective SQA resource allocation to reduce post‐release quality costs. Method Software defect prediction (SDP) is employed to predict defects in newly developed software based on models trained with past software defects and to update information using machine learning. This study demonstrated that just‐in‐time SDP is applicable to maritime domain practice and can reduce post‐release quality costs via combination with an estimation model, qCOPLIMO. Results Using real‐world datasets collected from the maritime industry, performance and cost‐benefit analyses of SDP were performed. A successful model was obtained that meets the performance criterion of 0.75 in within‐project defect prediction (WPDP) but not cross‐project defect prediction (CPDP). In addition, the cost‐benefit analysis results showed that 20% effort enables the detection of 56% of defects on average and that the post‐release quality cost can be reduced by 37.3% in the maritime domain. Conclusion SDP can be successfully applied to the maritime domain. Further, it is desirable to utilize WPDP instead of CPDP once minimum high‐quality commits are available that can be identified as defective or not. Finally, SDP can help reduce review effort and post‐release quality costs.

Many web-based software systems have been developed in the form of composite services. It is important to accurately predict the Quality of Service (QoS) value of atomic web services because the performance of such composite services depends greatly on the performance of the atomic web service adopted. In recent years, collaborative filtering based methods for predicting the web service QoS values have been proposed. However, they are mainly faced with a cold start problem that is difficult to make reliable prediction due to highly sparse historical data, newly introduced users and web services, and the existing work only deals with the case of newly introduced users. In this article, we propose a Location-based Matrix Factorization using a Preference Propagation method (LMF-PP) to address the cold start problem. LMF-PP fuses invocation and neighborhood similarity, and then the fused similarity is utilized by preference propagation. LMF-PP is compared with existing approaches on the real world dataset. Based on the experimental results, LMF-PP shows better performance than existing approaches in cold start environments as well as in warm start environments.

Pairwise testing is an effective combinatorial test case generation approach in which test cases are developed to execute all possible pairwise combinations of system inputs. It can help reduce the number of test cases and save testing time yet still effective in finding defects. However, it is very difficult for practitioners to effectively apply pairwise testing in the real world because of the lack of suitable techniques and guidelines. To redress this situation, this paper conducts a case study of applying pairwise testing to system data derived from real-valued variable inputs. In order to apply pairwise testing to this case study, this paper develops a test procedure and a novel partitioning method to test derived data as a naïve application of the conventional pairwise testing that would produce a huge number of test cases. A comparative evaluation shows that the pairwise testing of the proposed approach is more effective than the random testing with a 12–20% higher fault detection ratio. Based on our experience, guidelines for applying pairwise testing in practice are also presented. Copyright © 2014 John Wiley & Sons, Ltd.

With the popularity of service-oriented architecture, many web systems have been developed in form of composite services. Since the performance of these composite services highly depends on Quality of Service (QoS) of employed atomic web services, it is important to predict the QoS values of atomic web services with high accuracy. Although collaborative filtering based approaches have recently been proposed to predict the web service QoS values, they mostly face a cold start problem which causes unreliable prediction due to the highly sparse historical data, newly introduced users and web services. Furthermore, existing work only considers the case of newly introduced users. In this paper, we propose a Location-based Matrix Factorization technique via Preference Propagation (LMF-PP) to improve the cold start problem in web service QoS prediction domain. LMF-PP exploits the location information of entities (i.e., Users and web services) and employs the preference propagation to make the accurate QoS prediction even for the newly introduced entities and in the small amount of data (i.e., Highly sparse matrix). The performance of LMF-PP is compared with that of existing approaches on a real world dataset. The experimental results show that LMF-PP can outperform the existing approaches in not only a cold start environment but also a warm start environment.

In recent years, data-driven software reliability models have been proposed to solve the problematic issues of existing software reliability growth models (i.e., Unrealistic underlying assumptions and model selection problems). However, the previous data-driven approaches mostly focused on sample fitting or next-step prediction without adequate evaluation on their long-term predictive capability. This paper investigates three multi-step-ahead prediction strategies for data-driven software reliability models and compares their predictive performance on failure count data and time between failure data. Then, the model with the outstanding strategy on each data type is compared with conventional software reliability growth models. We found that the Recursive strategy gives better prediction for fault count data, while no strategy is superior to the others for time between failure data. Such data-driven approach with the best input domain showed performance as good as the best one among the software reliability growth models in long-term prediction. These results indicate the applicability of data-driven methods even in long-term prediction and help reliability practitioners to identify an appropriate multi-step prediction strategy for software reliability.

Various OSS(Open Source Software)s are being modified and adopted into software products with their own quality level. However, it is difficult to measure the quality of an OSS before use and to select the proper one. These difficulties come from OSS features such as a lack of bug information, unknown development schedules, and variable documentations. Conventional software reliability models are not adequate to assess the reliability of a software system in which an OSS is being adopted as a new add-on feature because the OSS can be modified while Commercial Off-The-Shelf (COTS) software cannot. This paper provides an approach to assessing the software reliability of OSS adopted software system in the early stage of a software life cycle. We identify the software factors that affect the reliability of software system using the COCOMOII modeling methodology and define the module usage as a module coupling measure. We build the fault count models using the multivariate linear regression and performed the model evaluation. Early software reliability assessment in OSS adoption helps to make an effective development and testing strategies for improving the reliability of the whole system.

Although synthesis was considered an important and challenging approach to construction of a program or a program model in software development, most of research on synthesis has been devoted to the construction of state machine models or variations of them. Recently, as process modeling through languages like UML Activity Diagram and BPMN appears as a new paradigm of software development, the ability to synthesize models in such languages from requirements would tremendously increase the scope of automatic software development. This paper presents transformation rules for synthesis of UML Activity Diagrams from scenario-based specifications modeled as UML Sequence Diagrams. To that end, we first identify various control flow patterns of Sequence Diagrams and define rules for mapping them to corresponding parts of Activity Diagram. In order to make precise such mapping labeling rules are introduced for the patterns. Also we provide a synthesis algorithm for construction of a UML Activity Diagram from scenarios.

In this paper, we reflect upon the past five years of the KAIST-Carnegie Mellon MSE (Master of Software Engineering) collaboration, and look ahead to the ways in which we can improve in the years to come. With the understanding that the major component of the program lies in its curriculum, our insights focus mainly in the areas of curriculum improvement and evolution. As a means of achieving this goal, two surveys were conducted, one addressing reflections by the program's participating faculty and graduates, and a second investigating various reference curriculums. Based upon the results of both surveys, an improved curriculum structure is proposed, one that identifies and introduces special track options that the authors propose might better serve the needs and demands of Korean industry.

Prior coverage-based test case prioritization techniques aim to increase fault detection rates by ordering the test cases according to some coverage criteria. However, in practice, since detected faults are typically removed, test cases that already covered the previously executed areas might not perform well as expected, irrespective of their coverage. In this case, the ordering of test cases based on coverage information might not be effective. In this paper, we introduce a new test case prioritization technique that considers both coverage and historical fault information by incorporating fault localization technique. Using the historical fault detection information of test cases, our approach adjusts the priorities of fault-found test cases while maintaining test cases with high coverage in high priority. Our approach can reduce the total cost of executing entire test suite(s) and enables to detect faults earlier in a testing process by improving the testing effectiveness compared to the prior coverage-based techniques.

Software reliability has been regarded as one of the most important quality attributes for software intensive systems, especially in defense domain. As most of weapon systems complicated functionalities and controls are implemented by software which is embedded in hardware systems, it became more critical to assure high reliability for software itself. However, many software development organizations in Korea defense domain have had problems in performing reliability engineered processes for developing mission-critical and/or safety-critical weapon systems. In this paper, we propose an effective framework with which software organizations can identify and select metrics associated software reliability, analyze the collected data, appraise software reliability, and develop software reliability prediction/estimation model based on the result of data analyses.

Six Sigma has been adopted by many software development organizations to identify problems in software projects and processes, find optimal solutions for the identified problems, and quantitatively improve the development processes so as to achieve organizations' business goals. A Six Sigma framework for software process improvements is needed to provide a standard process and analysis tools for Six Sigma project executions, and also provide a platform for collaborations with other process improvement approaches, such as PSP/TSP and CMM/CMMI. However, few frameworks have been proposed to support Six Sigma project executions. Most of Six Sigma projects for software process improvements have been performed in an ad-hoc way. In this paper, we propose a framework to support Six Sigma projects for continuous process improvements for software developments. Based on this framework, we implemented a web-based tool, called SSPMT integrated with a software project management tool and a PSP supporting tool. The suggested framework and SSPMT is beneficial in initiating and executing Six Sigma projects, facilitating data collection and data analyses by Six Sigma toolkits, and standardizing the Six Sigma project execution process so as to achieve Six Sigma project goals and of organizations' business goals.

With today's increasingly competitive economy, many organizations have initiated customer relationship management (CRM) projects to improve customer satisfaction, revenue growth and employee productivity gains. However, only a few successful CRM implementations have successfully completed. In order to enhance the CRM implementation process and increase the success rate, in this paper, first we present the most significant success factors for CRM implementation identified by the results of literature reviews and a survey we conducted. Then we propose a strategy to integrate Six Sigma DMAIC methodology with the CRM implementation process addressing five critical success factors (CSF). Finally, we provide a case study to show how the proposed approach can be applied in the real CRM implementation projects. We conclude that by considering the critical success factors, the proposed approach can emphasize the critical part of implementation process and provide high possibility of CRM adoption success.

The advent of software process models such as CMM/CMMI (Capability Maturity Model/Capability Maturity Model Integration) has helped software engineers understand principles and approaches of software process improvement. There, however, has been difficulty increasing productivity from applying those models since "how " is not within the scope of the CMM/CMMI. For this reason, SEI (Software Engineering Institute) introduced PSP/TSP (Personal Software Process/Team Software Process); however, they still lack statistical analysis tools and systematic process control techniques for analyzing measures collected in PSP/TSP. Six Sigma, on the other hand, provides the quantitative analysis tools necessary to identify high leverage activities, control process performance and evaluate effectiveness of process changes. Deploying PSP/TSP in conjunction with Six Sigma, therefore, can directly lead to improved project performance and continuous process improvement by analyzing data, assessing process stability, and prioritizing improvements in PSP/TSP. Continuing with this rationale, a framework that guides how and where Six Sigma tools are considered in PSP/TSP is proposed.

In this paper, we present the six sigma DMAIC approach which is used for software quality improvement. The goal was to identify and establish tactical changes that substantially increase the software quality of all software products over the next 2 years. We analyzed the data and based on the analysis expert decisions were made to determine which new technologies (tools, methods, standards, training) should be implemented and institutionalized in order to reach our goals. To measure the improvement from Six Sigma process changes we calculated our process capability baselines based on tactical changes, and we tracked and evaluated ongoing software product quality on a regular basis against these baselines to ensure that the software product quality goals were being achieved as planned.

Orthogonal Defect Classification (ODC) is an advanced software engineering technique to provide in-process feedback to developers and testers using defect data. ODC institutionalization in a large organization involves some challenging roadblocks such as the poor quality of the collected data leading to wrong analysis. In this paper, we have proposed a technique (‘Harmony Matrix’) to improve the data collection process. The ODC Harmony Matrix has useful applications. At the individual defect level, results can be used to raise alerts to practitioners at the point of data collection if a low probability combination is chosen. At the higher level, the ODC Harmony Matrix helps in monitoring the quality of the collected ODC data. The ODC Harmony Matrix complements other approaches to monitor and enhances the ODC data collection process and helps in successful ODC institutionalization, ultimately improving both the product and the process. The paper also describes precautions to take while using this approach.

CASE (computer aided software engineering) tools are believed to have played a critical role in improving software productivity and quality by assisting tasks in software development processes since the 1970s. Several parametric software cost models adopt "use of software tools" as one of the environmental factors that affects software development productivity. Several software cost models assess the productivity impacts of CASE tools based only on breadth of tool coverage without considering other productivity dimensions such as degree of integration, tool maturity, and user support. This paper provides an extended set of tool rating scales based on the completeness of tool coverage, the degree of tool integration, and tool maturity/user support. Those scales are used to refine the way in which CASE tools are effectively evaluated within COCOMO (constructive cost model) II. In order to find the best fit of weighting values for the extended set of tool rating scales in the extended research model, a Bayesian approach is adopted to combine two sources of (expert-judged and data-determined) information to increase prediction accuracy. The extended model using the three TOOL rating scales is validated by using the cross-validation methodologies, data splitting, and bootstrapping. This approach can be used to disaggregate other parameters that have significant impacts on software development productivity and to calibrate the best-fit weight values based on data-determined and expert-judged distributions. It results in an increase in the prediction accuracy in software parametric cost estimation models and an improvement in insights on software productivity investments.

The use of COTS (commercial-off-the-shelf) components for system development has been a growing trend in the software engineering community during the past decade. However, the engineering of COTS-based systems involves significant technical risks. A good indicator of the as yet unresolved difficulties in COTS-based system developments is the relatively poor understanding frequently regarding the processes associated with development of the "glue code" used to integrate COTS components into the system, as well as with the other integration activities. The main objective of the paper is to understand how the glue code development process and the COTS component integration process affect each other and how they affect development effort and schedule throughout the development life cycle, based on given parameters via software simulation that provides a method for checking the understanding of the real world process and thus help people produce better results in the future.