Search

The agile methodology stands out as a prevalent model for efficient software development, particularly favored for its adaptability and suitability in small-scale projects across various software industries. Nevertheless, its widespread adoption has brought to light certain communication challenges, particularly when applied to large-scale distributed teams. Agile, it appears, may not be the optimal choice for extensive teams engaged in global software development efforts. This study delves into the intricacies of issues faced by teams employing agile in the context of large-scale distributed development, particularly focusing on communication-related challenges and their repercussions. Our approach involved in-depth interviews with diverse developers and teams hailing from various sectors within the software industry. Moreover, we conducted an extensive quantitative analysis, surveying 50 developers representing different distributed teams. The outcomes of our investigation unearthed several communication-related deficiencies that significantly impact the development process. To arrive at these insights, we employed two robust statistical analysis methods: descriptive analysis and regression analysis. The implications of our findings have led us to propose innovative software solutions, bearing distinctive features engineered to mitigate the communication issues often encountered in large-scale software development. These solutions have the potential to enhance the efficiency and effectiveness of agile practices when applied in extensive and globally dispersed development endeavors. [ABSTRACT FROM AUTHOR]

Abstract Risk management is often overlooked in the software industry, especially in agile methodology-based projects, which can have negative impacts on the schedule, budget, and quality of a project, eventually leading to customer dissatisfaction. Hence, it is essential to identify the risks and prioritize them based on their level of importance. This study has utilized the Analytic Hierarchy Process (AHP) methodology for prioritizing the software risk factors identified during our previously executed risk identification phase experimental study in small and medium software enterprises that follow agile and traditional methodologies for software development. Among the 16 risk factors categorized under four different risk natures named 'difficulties', 'changes', 'mistakes', and 'challenges', the 'challenges' risk nature category is found to be the most significant one by the research findings, followed by 'difficulties', 'mistakes', and 'changes' risk natures. The results also highlight that 'proper utilization of funds', 'complicated tasks', and 'convincing the customer with alternative technologies' are the most significant risk factors. The study gives an insight into the possible risk factors in a software environment, along with their significance. [ABSTRACT FROM AUTHOR]

Ontology building can greatly influence the development cycle of an information system and enhance interoperability among its constituent elements. Throughout the projects we have been developing we have detected, by studying the current literature, a need to develop an agile method to conceive and mapping ontologies, which allows a quick and effective response to R&D projects. Designing a method for building an ontology, which is integrated and aligned with a systematic development approach, represents a crucial challenge in new approaches to system design and exploitation. Extant proposed methods for building an ontology, especially following agile approaches, have achieved interesting results but lack integration and alignment with a wider-view development framework. Thus, we have defined the first version of a semantic model allowing the alignment with the previously defined information model. Following the best practices for ontology building and based on our previous work on software system development, we now propose a method for designing an ontology, the 4SRS Method for Ontological Design based on the V-Model 4SRS, aligning it with a proven development method. We further demonstrate this approach by applying the proposed method in a real case, to develop an ontology for a choen restricted scope within the domain problem. [ABSTRACT FROM AUTHOR]

Effort estimation is fundamental for the development of software projects and critical to their success. The objective of this paper is to understand how Colombian agile practitioners perform effort estimates and to identify opportunities for improvement based on these results. For this purpose, we conducted an exploratory survey study using as instrument an on-line questionnaire answered by agile practitioners with experience in effort estimation. Data was collected from 60 agile practitioners and the main findings are: (1) Agile practitioners prefer non-algorithmic estimation techniques, mainly those based on Expert Judgment. (2) Most of the respondents perceive that their estimates have a medium accuracy level; however, in most cases, no formal analysis of the accuracy level is carried out. (3) The determining effort predictors/cost drivers are characteristics of the project team (size, experience, and skills) and attributes of the software to be built (complexity, type, and domain). (4) The use of datasets for estimation is not common; proprietary datasets predominate and are used for productivity comparisons within the company. (5) Most of the results of related studies are comparable with ours; however, there are significant differences in terms of the roles involved and the techniques used in the effort estimation process. Based on the results and findings of the survey, we identified key opportunities to improve estimation accuracy through (1) software measurement standardization, (2) use of effort datasets, (3) implementation of techniques for measuring accuracy levels, and (4) knowledge management in effort estimation. [ABSTRACT FROM AUTHOR]

Effort estimation based on user stories plays a pivotal role in agile software development, where accurate predictions of project efforts are vital for success. While various supervised ML tools attempt to estimate effort, the prevalence of estimation errors presents significant challenges, as evidenced by the CHAOS report by the Standish Group, which highlights incorrect estimations contributing to a substantial percentage of failed agile projects. This research delves into the domain of user story-based effort estimation in agile software development, aiming to explore the issues arising from inaccurate estimations. The primary goal is to uncover these issues comprehensively and propose potential solutions, thus enhancing the efficacy of the user story-based estimation method. To achieve the research objectives, a systematic literature review (SLR) is conducted, surveying a wide range of sources to gather insights into issues surrounding user story-based effort estimation. The review encompasses diverse estimation methods, user story attributes, and the array of challenges that can result from inaccurate estimations. The SLR reveals a spectrum of issues undermining the accuracy of user story-based effort estimation. It identifies internal factors like communication, team expertise, and composition as crucial determinants of estimation reliability. Consistency in user stories, technical complexities, and task engineering practices also emerge as significant contributors to estimation inaccuracies. The study underscores the interconnectedness of these issues, emphasizing the need for a standardized protocol to minimize inaccuracies and enhance estimation precision. In light of the findings, it becomes evident that addressing the multi-dimensional factors influencing user story-based effort estimation is imperative for successful agile software development. The study underscores the interplay of various aspects, such as team dynamics, task complexity, and requirement engineering, in achieving accurate estimations. By recognizing these challenges and implementing recommended solutions, software development processes can avoid failures and enhance their prospects of success in the agile paradigm. [ABSTRACT FROM AUTHOR]

Project management has long been a challenge for Information Technology (IT) organizations to learn how to manage projects effectively and efficiently while balancing the iron triangle: cost, time and scope without sacrificing quality. Agile project management (APM) and traditional project management (TPM) are two different approaches related to software development, the core tenet of TPM is that projects are relatively simple, predictable, and linear with well-defined boundaries, whereas APM has emerged as a new methodology for managing high-risk, time-sensitive and scope flexible projects. While it is undeniable that the use of agile project management is increasing, the traditional opposite side continues to exist. The agile approach has an impact on all phases of software development, and they must adapt to this new way of thinking. Software testing is also impacted as a fundamental link in the software development life cycle that ensures quality. Software testing is a vital component of software Quality Assurance (QA) since it serves as the final review of the specification, design, and code. Has software testing evolved along with the evolution of project management? Is there a difference between a traditional and an agile software testing? This paper answers these questions by comparing software testing in the two approaches. [ABSTRACT FROM AUTHOR]

Software systems evolve continuously and must be developed quickly to fit user requirements and new advances in technology. This has led the software engineering to propose several methods and approaches to overcome the development and maintenance of these software systems. In this regard, Agile Methodologies and Model-Driven Engineering (MDE) are two main approaches that have emerged in recent years and suggest a solution to some of the issues associated with Software systems developments. MDE focuses on software reuse through models and on generative approaches based on separation of concerns whereas Agile Methods promote the use of simpler models and best practices for programming to achieve quick feedback from clients within a development process. However, these two approaches have evolved separately and there are only a few works related to their combination. This paper presents a customized V development life cycle based on models which combines the two MDE variants: The MDA approach in the V left branch with the MBT approach to generate tests of the V right branch. In addition, we integrate this customized V life cycle in the agile Scrum methodology to facilitate the management of each Scrum sprint. [ABSTRACT FROM AUTHOR]

The growing trend in agile approach to software development today shows a tendency towards combining practices from different approaches and methodologies. This trend can be explained by the difficulties in managing agile processes. A potential solution to these challenges could be a multi-agent model of software development process of supporting management in the cycle of continuous product quality improvement. The AGent-Object MOdel (AGOMO) was constructed to investigate this idea and an experiment was carried out in which a typical medium-sized project developed using hybrid methodology was reproduced. This article describes the first phase of research, in which replicative adequacy of this model was demonstrated, thus opening avenues for further research related to project management support. [ABSTRACT FROM AUTHOR]

Requirements Engineering (RE) is a critical process in the development of any software. It requires intensive communication among many stakeholders in order to identify software requirements accurately. As RE activities require intensive communication, cultural influences might need to be considered to improve these activities and to avoid issues that might affect the software project outcomes. In our work, we explored the influence of national culture on RE activities. We conducted an empirical study in two countries that have different cultural profiles: Saudi Arabia and Australia. To explore this issue, we conducted 41 face-to-face interviews. To consolidate the collected data, we conducted also 30 follow-up interviews with the same practitioners. The aim of our study was to empirically identify the set of cultural influences affecting RE activities, and analyse their implication on RE activities. This paper reports the results of the analysis of participants' responses with respect to their industrial profiles, in terms of three factors: the type of software methodology applied by the participants (Traditional vs. Agile), the size of their company/organisation (small, medium, and large), and its type (private vs. government). The results showed a number of significant differences in the cultural influences that determine the type of software development methodology, i.e., Traditional or Agile, being applied within the corresponding company. In this paper, we discuss the identified differences and the factors that determine them. This in-depth analysis provides a broader examination of the influence of culture on RE activities, which might assist RE practitioners to select the most suitable RE practices/methodology to overcome any negative effects of these influences. [ABSTRACT FROM AUTHOR]

The Internet of Things or the Internet of Everything is a new and a potentially disruptive technology paradigm. It describes several technologies such as RFID, short range wireless communications, and research disciplines that can connect physical objects from the real world to the internet. To implement IoT solutions, they exist software development approaches like Scrum and Kanban, also, others are adapted viz; Large-Scale Scrum, Scaled Agile Framework and so on., and many methods have proposed such as Ignite | IoT Methodology and IoT Methodology. Most of them have taken agile thinking as a strategy. However, they are monolithic, which are not easy to adopt. Then, a new method is needed to handle the real nature of IoT, particularity, to handle distributed, mobile and human out-of-the-loop concerns, and that can grow as new product evolve and new problems emerge. This research studies and analyses some of the existing IOT methodologies. Particularly, it focuses on these methodologies Scrum, Kanban, Scaled Agile Framework, Ignite | IoT Methodology and IoT Methodology. Our study evaluates their capabilities and compares their main characteristics and behaviors in terms of various methodologies of IoT. The comparison presented in this paper would benefit in selecting an appropriate methodology for the IoT projects. In addition, it identifies their advantages and limits in order to suggest a new approved IoT methodology. [ABSTRACT FROM AUTHOR]

Model-Driven Architecture (MDA) is a framework for software development processes that allows an automatic transformation from a business process model to the code model. In MDA there are two transformation kinds: Transformation from the Computation independent model (CIM) to platform-independent model (PIM), and transformation from PIM to platform-specific model (PSM). In this paper, we based on CIM to PIM transformation. This transformation is done by developing a platform that generates a class diagram, presented in XMI file, from specifications that are presented in user stories, which are written in natural language (English). We used a natural language processing (NLP) tool named "Stanford CoreNLP" for extracting of the object-oriented design elements. Applying our approach to several case studies has given good results. [ABSTRACT FROM AUTHOR]

Software development projects are becoming increasingly important to achieve successful results in the global digitalization trend that has spread throughout the world at the time of the pandemic. The main software development methodologies (SDM) are waterfall and agile. This study investigates the achievement of success methodology through the evaluation of software development projects, personnel under the scope of SDM's. Software projects require strong human resources to be successful in terms of on-time completion and success. For software projects that include the human component, it is important to make project team SDM assignments more meaningful and accurate. The power of linguistic variables and the use of expert ratings in such assignments have been the focus of this paper. The reason for the strong representativeness is the conversion of linguistic variables to mathematical fuzzification, Interval Valued Neutrosophic Z-Numbers (NZN) are used to determine which SDM should be used first in projects. The results of the NZN are then incorporated into the NZN-Area model. This replaces the distance measurement equation used to rank alternatives with an area calculation. The NZN-Area Model is the new proposed form of the model. The NZN-Area model produced 22% better results in terms of defect numbers and 25% better results in terms of defect resolution time compared to the NZN method. Additionally, a sensitivity analysis was performed by comparing the NZN method and NZN-Area method with real data. The proposed NZN-Area method was found to be more consistent under variable conditions. [ABSTRACT FROM AUTHOR]

Field-Programmable Gate Arrays (FPGAs) in heterogeneous computing have been attracting more and more attention. Development of acceleration systems based on FPGAs involves the cooperation of both hardware and software developers. However, although most hardware acceleration systems are motivated by software developers, software developers are difficult to participant in the system building because of the steep learning curve of the hardware concept and design tools. Moreover, due to the complexity of hardware-software integration in traditional ways, end-to-end performance is hard to evaluate before trivial engineering effort. To address these concerns, we propose an open-source Domain-Specific Language (DSL) based framework called VeriScala 1 1 https://www.github.com/VeriScala/VeriScala. to support hardware defining in a high-level language, programmatical testing, and rapid acceleration system deploying. By adopting DSL embedded in Scala language, we introduce modern software development concepts into hardware design and provide a familiar environment to software developers. And by building a stack of middle layers from hardware to software, we provide reduced hardware abstraction and communication interface to facilitate both software and hardware development and system deployment. Through the evaluation of some basic components and real-world demos, we show that VeriScala provides a practical approach to rapid prototyping of hardware acceleration systems. [ABSTRACT FROM AUTHOR]

Assembling software development freelancer comprised teams is a challenging task for a project manager. In an Agile environment, this is even more challenging because of the cross-functional character and multi-disciplinary requirements such methodology enforces. The project manager needs to identify individuals that are highly compatible from a collaborative point of view and have the skills to match project complexity. This is a lengthy endeavor which is prone to human bias as the collaborative nature of individuals that have never worked together is difficult to evaluate. The selection process also has considerable restrictions imposed by the sheer volume of information a human decision maker can process and analyze. Computerized data analysis, on the other hand, is free of bias and it can process large data sets very fast. For the current research process data was collected automatically from a freelance platform that allows free access to developers' profiles. The targeted platforms make information available about freelancer's skills, experience, background, and education. Data was validated, ensuring it's correct and relevant. Data was normalized to ensure it is easily quantifiable and can be measured using a common scale. Statistical methods were used to predict the data that was missing or incomplete. Based on the identified criteria a template was built to match the profile of the ideal team member. Machine learning techniques were used to group team members that would work together effectively from a collaborative point of view. An indicator was built to benchmark the team member's profile against the template and determine the highest ranking candidates. Conclusions were formulated regarding the topic of using profiling to assemble collaborative agile freelance software development teams. Research process limitations were enunciated and future research topics were submitted for debate. [ABSTRACT FROM AUTHOR]

Formulating developer payroll in a software development project is important for organizations to provide an equitable salary formulation that can motivate developers to work professionally. Payroll can also be used as references in planning the cost of software development projects in order to meet startup financial success. In the literature, developer payroll estimations can be obtained by multiplying the number of working hours on a project with the developer's wage. However, multiplying the number of working hours with the developer's wage is considered unfair because each developer has different competencies and performance. In addition, not much attention given to understanding how to estimate developer payroll in software development organizations by considering different competencies and performance. For those reasons, it is important to understand how to overcome the different developer's competencies and performance in developer payroll formulation. Thus, the competency and performance factors can be formulated into the developer payroll. This paper proposes a method in calculating developer payroll for a startup environment based on Agile Project Management by considering the developer's competency and performance parameters. The parameters consist of how many years developers have been working, what the type of developer role is, how many bugs developers produce and how many days developers are not able to complete the task on time. This study is expected to provide an alternative method to formulate developer payroll at startup environment. [ABSTRACT FROM AUTHOR]

Retrospective (retro) sessions are an important part of Agile/Scrum process for software development. In theory, conducting retro sessions each sprint should improve team dynamics and productivity. In praxis, retro sessions also have some disadvantages/hurdles that are hard to overcome: they are non-anonymous and time consuming. The goal of our project, conducted in collaboration between Shine Solutions and RMIT University, is to analyse the existing hurdles from industry-prospective and to provide an AI-based solution to overcome them. The two main outcomes of the project are (1) a web-based solution to support retro-sessions, and (2) a qualitative analysis of two speech recognition tools, Google Home and Amazon Alexa, to be connected with the elaborated solution to populate the retro board and help in time boxing a retro by using voice activated commands. [ABSTRACT FROM AUTHOR]

Compared with other courses, especially non-engineering ones, software development courses teaching (SDCT) has many unique characteristics, such as higher requirement to students' logical reasoning, the need for students to have comprehensive problem-solving capabilities, good communication and teamwork skills, etc. The practices of Agile Methodology can be compatible with these characteristics. Therefore, it is a matter of course to integrate Agile Methodology with SDCT. This paper analyses the problems and difficulties in the practices of applying agile teaching in SDCT. In addition, it uses an agile teaching project graph instead of linear teaching schedule to control teaching progress. Moreover, a deep generative model is used to obtain the abstract representation of students' implicit skill status so that the construction and implementation of agile teaching project graph can be carried out. Finally, a deep-learning-based agile teaching framework for SDCT is proposed, which has the potential to positively transform SDCT's future. [ABSTRACT FROM AUTHOR]

The paper proposes an ontology-based approach to support for requirements traceability in Agile development. The task of supporting the requirements traceability in a software development project is considered as a part of requirements engineering process. A brief overview of the benefits of requirements traceability usage is given. The expediency of using the ontology-based approach to support for requirements engineering, requirements traceability in particular, is shown through the analysis of scientific publications. OWL ontology is chosen to support the requirements engineering process. The ontology is implemented in the Protégé environment. The developed ontology takes into account particular qualities of working with the requirements in Agile projects, accumulates knowledge about the requirements types and requirements artefacts, enables tracing the relations between them. [ABSTRACT FROM AUTHOR]

Abstract Within the realms of software development, customers must specify the requirements of their new software before the start of the project. Today, this leads to considerable delays with respect to the start of the project. In addition, the integration of new requirements into a system already developed in parts is becoming increasingly time-consuming and cost-intensive. Yet the specifically necessitated functions of a software are often only revealed through the process of development. By means of agile programming, changes in the requirements of a software product can be handled flexibly in shorter development cycles. In the following, the framework of agile software development projects as it applies under German law is described and current legal problems of such projects – in particular, the issue of contract type and the new building contract law – are considered. The unplanned project design appears contrary to the legal approach. The article shows, however, that agile software products development provides customers with dynamic and quickly scalable products and that customers can leave the project after individual project steps. The new development of building contract law, which focuses on subunits and approvals, is also very much in line with the above-mentioned programming. [ABSTRACT FROM AUTHOR]

A Product Configuration System (PCS) is a software system that facilitates the sales and production processes of defined customizable products. PCS are specific software developments in the sense that they are knowledge-intensive so that they require models to formalize the complex knowledge inherent to product configurations also leading to dependencies between software functionalities. Scrum is a widely used agile method, but its training has been the subject of little research. Model-driven development implicitly impacts the way development is conducted especially when adopting an agile method as Scrum. This paper, as exploratory research, evaluates Scrum training for PCS projects through a qualitative case study. The goal is to identify the elements that should be focused on within Scrum background training. This research first studies and assesses the training experiences at the case company. Then, it reports on respondents' opinions about the strengths and challenges of applying Scrum in the mentioned context. The latter is based on multiple data sources: documentation, interviews, participant observations, and workshops. Issues in applicability lead to enhanced training support for learning how to (i) combine Scrum with the model-driven approach inherently required within PCS development, (ii) manage time and effort estimation on the basis of accurate artifacts and (iii) access key employees possessing domain or specific technical knowledge indispensable for pursuing the development. [ABSTRACT FROM AUTHOR]

The most profound conflict in software engineering is not between positivist and interpretivist research approaches or Agile and Heavyweight software development methods, but between the Rational and Empirical Design Paradigms . The Rational and Empirical Paradigms are disparate constellations of beliefs about how software is and should be created. The Rational Paradigm remains dominant in software engineering research, standards and curricula despite being contradicted by decades of empirical research. The Rational Paradigm views analysis, design and programming as separate activities despite empirical research showing that they are simultaneous and inextricably interconnected. The Rational Paradigm views developers as executing plans despite empirical research showing that plans are a weak resource for informing situated action. The Rational Paradigm views success in terms of the Project Triangle (scope, time, cost and quality) despite empirical researching showing that the Project Triangle omits critical dimensions of success. The Rational Paradigm assumes that analysts elicit requirements despite empirical research showing that analysts and stakeholders co-construct preferences. The Rational Paradigm views professionals as using software development methods despite empirical research showing that methods are rarely used, very rarely used as intended, and typically weak resources for informing situated action. This article therefore elucidates the Empirical Design Paradigm, an alternative view of software development more consistent with empirical evidence. Embracing the Empirical Paradigm is crucial for retaining scientific legitimacy, solving numerous practical problems and improving software engineering education. [ABSTRACT FROM AUTHOR]

Agile software development methods are mostly built as a set of managerial guidelines and development concepts on how to handle a software development but are not bounded to software development paradigms like object or agent orientation. Some methods, like eXtreme Programming and SCRUM are driven by operational requirements representation models called User Stories. These User Stories can be used as an anchoring point to agile methods; this means that we could take a User Stories set to drive a software transformation approach embedded in a particular development paradigm. This paper presents a process fragment for Multi-Agent Systems development with agile methods based on User Stories sets. The process fragment indeed takes advantage of an initial set of User Stories to build a reasoning model (called the Rationale Tree; typically several of these are built for a single project) that documents decompositions and means-end alternatives in scenarios for requirements realization. A Rationale Tree can then be aligned with a Multi-Agent design and implemented in an agent-oriented development language. In this paper the transformation is targeted to the JAVA Agent DEvelopment (JADE) framework. The process fragment (at least partially) covers the Requirements Analysis, Multi-Agent System Design and Multi-Agent System Implementation phases. Transformation from one phase to the other is overseen and illustrated on an example. [ABSTRACT FROM AUTHOR]

With the rise of agile development notion, software test automation is widely adopted by software organizations to reduce the testing time and costs during the software development process. However, it is essential to carefully implement the test automation to ensure the project's success. In the literature, several studies have indicated that decision-making is crucial for the adoption of test automation. For deciding about test automation adoption, several factors, including the skill level of testers, test tool, and development process, need to be considered since automated testing performance heavily depends on the mentioned factors and their interactions. Thus, it is of vital importance to ascertain the factors that influence test automation in the context of Agile-based Software Development (ASD). To accomplish this, we perform a systematic literature review and a questionnaire-based survey. In total, 21 factors are identified that significantly impact test automation in the ASD context. Additionally, the identified factors are categorized into five main classes. Following the identified factors' assessment, this work proposes a conceptual model that supports agile practitioners in deciding about the adoption of test automation in the context of ASD. Finally, this work validates the proposed model to assess its practical applicability. The validation of the proposed model is accomplished by using an expert-based validation approach. The attained results show that the proposed model supports agile practitioners in estimating the possibility of success when implementing test automation in the ASD context. [ABSTRACT FROM AUTHOR]

Software development organizations implement agile methods in global software development (GSD) to leverage benefits in terms of low development cost, continuous project delivery, and high-quality product. Despite the benefits, using the agile process in the GSD organizations is not a straightforward task due to inhibit additional risk factors that could lead agile projects to failure. GSD organizations are continuously improving their process management activities to improve the rate of agile project success. Project success could be improved if the project manager or organization management has preliminary information about the derailment of the project features. This work aims to investigate the most influential agile project features in determining the project outcomes and develop a cost-effective, and effort-based prediction model to improve the probability of successful completion in the globally distributed environment. To do so, a nature-inspired optimization algorithm i.e., genetic algorithm (GA), has been employed to achieve these goals. In the proposed model, GA considers the probability of success with respect to cost to determine probable project outcomes. An efficacy measure is formulated as a fitness function in GA which maximizes the success of agile project outcomes relative to cost. The optimization model has been tested with two different prediction models i.e., Naive Bayes classifier (NBC) and logistic regression (LR). We performed the experiment on data gathered through the survey administered from the globally distributed agile projects. The results demonstrate that prediction models calculate the efficacy for best solutions as 0.531 and 0.5850 for NBC and LR, respectively. Moreover, the ranking of each project feature based on their relative cost identified using NBC and LR have more similarities. The t test results are significant, i.e., t = 6.068, p = 0.001 < 0.005, which indicates that no significant differences have been observed between the ranking assigned by two different methods (NBC and LR). The results reveal that the developed prediction model based on identified eight agile project features that the GSD organization management and agile team need to focus more on to facilitate cost-effective successful implementation of agile projects. • To investigate the most significant features of agile project success in the global software development. • The significance of agile project features evaluated for agile projects success in the GSD setting. • An empirical validation of the research model using responses collected from the 103 agile and GSD software practitioners. • Developing a cost-effective agile software project success prediction model (ASPSPM) to evaluate the success probability in the GSD organizations. [ABSTRACT FROM AUTHOR]

• 'Agile cost estimation in scrum development. • Cost estimation methods in scrum and limitations. • Suggested a cost estimation model. Agile has been invented to improve and overcome the deficiencies of efficient software development. At present, the agile model is used in software development vastly due to its support to both developers and clients resourcefully. Agile methodology increases the interaction between the developer and client to make the software product defect-free. The agile model is getting to be a well-known life cycle model because of its particular features and most owing is to allow changes at any level of the project from the product owner. However, on other hand, this novel feature is a disadvantage of the agile model due to frequent change requests from the client has increased the cost and time. To overcome cost and time estimation issues different cost estimation techniques are being used in agile development but no one is pertinent for accurate estimation. Therefore, this study has proposed a cost estimation technique. The proposed estimation technique is predictions-based and has different categorizations of projects based on user stories complexities and the developer's expertise. We have applied the suggested technique to ongoing projects to find the results and effectiveness. We have used two projects with different sizes and user stories. Both projects have different modules and developers with different expertise. We have used the proposed estimation technique on projects and done a survey session with the teams. This survey session's main objective is to reveal the statistical findings of the proposed solution. We have designed the 12 hypotheses for statistical analysis. [ABSTRACT FROM AUTHOR]

Global software development (GSD) is gaining ever more relevance. Although communication is key in the exchange of information between team members, multi-site software development has introduced additional obstacles (different time-zones and cultures, IT infrastructure, etc.) and delays into the act of communication, which is already problematic. Communication is even more critical in the case of Agile Global Software Development (AGSD) in which communication plays a primary role. This paper reports an exploratory study of the effects of tools supporting communication in AGSD. More precisely, this paper analyses the perception of team members about communication infrastructures in AGSD. The research question to which this study responds concerns how development teams perceive the communication infrastructure while developing products using agile methodologies. Most previous studies have dealt with communication support from a highly technological media tool perspective. In this research work, instead, observations were obtained from three perspectives: communication among team members, communication of the status of the development process, and communication of the status of the progress of the product under development. It has been possible to show that team members perceive advantages to using media tools that make them feel in practice that teams are co-located, such as smartboards supported by efficient video-tools, and combining media tools with centralized repository tools, with information from the process development and product characteristics, that allow distributed teams to effectively share information about the status of the project/process/product during the development process in order to overcome some of the still existing problems in communication in AGSD. [ABSTRACT FROM AUTHOR]

• In this article, all 36 dimensional success factors are considered to estimate the required effort and cost to develop any Agile-Scrum based software project. • The work presented in the article computes the required time, effort and cost of projects mentioned in a data set on the basis of different inputs to the system. • For computation purposes, we divided the projects into three categories as Low, Medium and High level project for the unbiased estimation. • The datasets considered for computation purposes, also validated by experienced professionals from software industries. • It is found that the results obtained from the extended algorithm are cost-effective and less effort-oriented to a great extent as a compared to the existing algorithm. Effort and cost estimation is essential processes during software development. For agile methodologies as well, several approaches have been proposed so far to estimate the required effort and cost to develop any software system. Genuine assessment of software products is not an easy task as it requires the constant attention of the product owner. For effective estimation, we need to consider various success factors associated with all possible dimensions. In this article, we look at Scrum-based Agile projects that are developed over multiple sprints. We proposed an extension to the existing algorithm based on a total of 36 success factors; Which estimates the development effort and cost required to complete the project. For assessment and calculation, we have taken a data-set of a total of 30 projects categorized into three groups as low, medium, and high-level projects. This dataset is further validated by experienced professionals. We also compared our results with the existing approach and found that our results are cost-effective and require less effort even after considering more success factors. [ABSTRACT FROM AUTHOR]

Today's software development environment dictates speed, flexibility and a people-centered focus. Virtual teams represent a new organizational form that does not provide for same proximity collaboration. In this paper we propose a solution approach of a virtual team, as well as show some examples of using the Microsoft Visual Team Foundation Server 2013 tools to address these challenges. [ABSTRACT FROM AUTHOR]

Now-a-days agile software development process has become famous in industries and substituting the traditional methods of software development. However, an accurate estimation of effort in this paradigm still remains a dispute in industries. Hence, the industry must be able to estimate the effort necessary for software development using agile methodology efficiently. For this, different techniques like expert opinion, analogy, disaggregation etc. are adopted by researchers and practitioners. But no proper mathematical model exists for this. The existing techniques are ad-hoc and are thus prone to be incorrect. One popular approach of calculating effort of agile projects mathematically is the Story Point Approach (SPA). In this study, an effort has been made to enhance the prediction accuracy of agile software effort estimation process using SPA. For doing this, different types of neural networks (General Regression Neural Network (GRNN), Probabilistic Neural Network (PNN), Group Method of Data Handling (GMDH) Polynomial Neural Network and Cascade-Correlation Neural Network) are used. Finally performance of the models generated using various neural networks are compared and analyzed. [ABSTRACT FROM AUTHOR]

• Software scrum development. • Software cost estimation is still a complex task. • Effort estimation techniques in scrum still has some flaws that need to be resolve. Scrum methodology is the most useful and adopted part of the agile methodology. Many organizations are adopting Scrum for the last decade to meet their software requirements. It is facilitating the software industries to develop software applications according to the user's requirements. Scrum helps to fulfill the customer's requirements by interacting with the client and developer. Instead of this, scrum still has some challenges that influence the cost of a scrum. These challenging factors include coordination, team size, change request, complexity, and issues in daily meeting sessions. Due to these factors mostly the cost and time exceed scrum-based projects. To overcome these issues from the accurate and precise estimation in the scrum project we have developed a web-based software system to estimate the effort of a user story as well as the budget. There are some sophisticated cost estimation techniques for scrum-based projects. But all estimation techniques have some limitations that make them less useful for estimation and overcoming the effects of these factors in the scrum. We have surveyed the multiple software industries to get the static findings of the survey. We have designed the 30 hypotheses that main aim to reveal how much the proposed estimation technique is valuable for the accuracy of estimation. For the inclusion of participants, we have set the age criteria to get the opinions of the most experienced programmers. The main aim of this paper is to provide knowledge about key challenging factors in Scrum that cause exceed in cost and time, and also briefly explain why existing scrum cost estimation techniques are not pertinent for projects. In the last, we propose a framework as a solution to manage these factors and control cost and time from exceeding. We also adopted this estimation technique in different case studies in software industries for findings and results. The technique calculates the efforts autonomously. We design a software-based estimation technique that collects inputs from team/s and estimates the cost and time of a project. In outcomes, we found that our cost estimation approach reduced the issues from scrum software project development and make it more proficient for estimation of projects. Our proposed estimation technique introduced the new concept of estimation that facilitate the client, software industry, and developers as well to meet the requirements of the client, fulfill the changes during the sprints/s development and deliver the project within the time and cost. [ABSTRACT FROM AUTHOR]

Modern software systems are continuously evolving, often because systems requirements change over time. Responding to requirements changes is one of the principles of agile methodologies. In this paper we envision the seamless integration of automated verification techniques within agile methodologies, thanks to the support for incrementality. Incremental verification accommodates the changes that occur within the schedule of frequent releases of software agile processes. We propose a general approach to developing families of verifiers that can support incremental verification for different kinds of artifacts and properties. The proposed syntactic-semantic approach is rooted in operator precedence grammars and their support for incremental parsing. Incremental verification procedures are encoded as attribute grammars, whose incremental evaluation goes hand in hand with incremental parsing. [ABSTRACT FROM AUTHOR]

In order to analyze software systems, it is necessary to model them. Static software models are commonly imported by parsing source code and related data. Unfortunately, building custom parsers for most programming languages is a non-trivial endeavor. This poses a major bottleneck for analyzing software systems programmed in languages for which importers do not already exist. Luckily, initial software models do not require detailed parsers, so it is possible to start analysis with a coarse-grained importer, which is then gradually refined. In this paper we propose an approach to “agile modeling” that exploits island grammars to extract initial coarse-grained models, parser combinators to enable gradual refinement of model importers, and various heuristics to recognize language structure, keywords and other language artifacts. [ABSTRACT FROM AUTHOR]

Refactoring is a crucial activity in agile software development. As a consequence, automated tools are expected to support refactoring, both for reducing the developer's effort as well as for avoiding errors due to manual changes. In this context, the chosen programming language has a major impact on the level of support that an automated refactoring tool can offer. One important aspect of a programming language concerning the automation of refactoring is the type system. While a static type system, present in languages such as Java, provides information about dependencies in the program, the dynamic type system of the Smalltalk programming language offers little information that can be used by automated refactoring tools. This paper focuses on the challenges in the context of refactoring raised by the dynamic type system of Smalltalk. It highlights the problems caused by the absence of static type information and proposes the use of static code analysis for performing type inference to gather information about the dependencies in the program's source code. It explains the mechanism of the static code analysis using sample code and presents a prototype of an enhanced refactoring tool, which uses the structural information extracted through static code analysis. Empirical samples build the base for evaluating the effectiveness of the approach. [ABSTRACT FROM AUTHOR]

• In this paper, the Fuzzy TOPSIS method has been applied to identify the most suitable SDLC model for software development in the present scenario. • The work presented in the article computes the ranks and closeness coefficients of all the alternative SDLC models based on different criteria. • Six widely accepted SDLC models were compared with their core features by applying fuzzy logic and decision support systems in the form of the Multi-Criteria Decision Making method. • Five experienced decision-makers from software industries, assigned weights in linguistic terms to each alternative model against criteria. • By applying the Fuzzy TOPSIS method, it is validated that Agile Methodology is an Ideal selection for software development processes. Agile methodologies have been an emerging choice of software professionals for the past decade and a half. However, apart from this, some other SDLC models are also available for selection in front of software developers to develop any software. Usually, project managers select any of these models to develop software through their past experiences. There is no logical basis for this selection to be completely correct, as a result of which there is always a risk of software failure or over budget if an inappropriate model has opted. Keeping this problem of software industries in mind, an ideal SDLC model has been identified mathematically in this article. In this article, we applied the Fuzzy TOPSIS method that validates Agile software development as an ideal choice. We have taken a total of six software development processes that are being applied globally. Feedback from five experienced decision-makers has been taken in the form of linguistic terms and further converted into fuzzy values to perform the computation of the closeness coefficient rank of each experimented alternative software development process. [ABSTRACT FROM AUTHOR]

As many software development teams have started to adopt agile methods, a vast amount of valuable experiences have been reported on in both academic and industrial knowledge bases. This information has been used through various approaches to guide and help practitioners finding suitable practices for their software development projects. Nevertheless, not many of these approaches could gather the available experiences to make them systematically reusable and help practitioners understanding agile practices in depth. To the best of our knowledge, only one ontology has been created to solve this problem; some limitations related to its quality and usability make it nevertheless unqualified to serve the intended purpose. The aim of this paper is to build an expert system (i.e. an evidence-based tool) to ease agile practices adoption by efficiently and effectively providing information on them. Firstly, we improve the concepts and relationships in the aforementioned ontology and theoretically validate it using a large data-set of agile practices adoption experiences collected through a Systematic Literature Review (SLR). Secondly, we develop a supporting tool having a friendly Graphical User Interface (GUI) allowing to use the ontology as a concrete agile practice knowledge provider. Finally, we empirically validate the enhanced ontology and evaluate the supporting tool using a survey with agile experts. Our supporting tool can help practitioners to decide what practice to adopt, how to adopt it, how to solve practical issues, etc. The ontology and the tool materialize our contribution to the field of systematic agile practices adoption. • Successful agile practice adoption requires an in depth understanding of its content. • Existing reports on agile practice adoption experiences are essentially unexploitable. • An ontology is used as an efficient solution to recycle practices adoption experience. • A corpus-based approach and a survey are used for validating the ontology. • An expert system supports practitioners querying knowledge on practice adoption. [ABSTRACT FROM AUTHOR]

• Our approach is agnostic to programming languages, location, or development practices. • Moderate correlation was found between software and process cyclomatic complexity. • Refactoring practices were predicted with an accuracy up to 92.95%. • Using process metrics, software complexity was predicted with an accuracy of 94.36%. • Our method can be used to find non efficient software teams in generic software tasks. Context : Software comprehension and maintenance activities, such as refactoring, are said to be negatively impacted by software complexity. The methods used to measure software product and processes complexity have been thoroughly debated in the literature. However, the discernment about the possible links between these two dimensions, particularly on the benefits of using the process perspective, has a long journey ahead. Objective : To improve the understanding of the liaison of developers' activities and software complexity within a refactoring task, namely by evaluating if process metrics gathered from the IDE, using process mining methods and tools, are suitable to accurately classify different refactoring practices and the resulting software complexity. Method : We mined source code metrics from a software product after a quality improvement task was given in parallel to (117) software developers, organized in (71) teams. Simultaneously, we collected events from their IDE work sessions (320) and used process mining to model their processes and extract the correspondent metrics. Results : Most teams using a plugin for refactoring (JDeodorant) reduced software complexity more effectively and with simpler processes than the ones that performed refactoring using only Eclipse native features. We were able to find moderate correlations (≈ 43%) between software cyclomatic complexity and process cyclomatic complexity. Using only process driven metrics, we computed ≈ 30,000 models aiming to predict the type of refactoring method (automatic or manual) teams had used and the expected level of software cyclomatic complexity reduction after their work sessions. The best models found for the refactoring method and cyclomatic complexity level predictions, had an accuracy of 92.95% and 94.36% , respectively. Conclusions : We have demonstrated the feasibility of an approach that allows building cross-cutting analytical models in software projects, such as the one we used for detecting manual or automatic refactoring practices. Events from the development tools and support activities can be collected, transformed, aggregated, and analyzed with fewer privacy concerns or technical constraints than source code-driven metrics. This makes our approach agnostic to programming languages, geographic location, or development practices, making it suitable for challenging contexts, such as, in modern global software development where many projects adopt agile methodologies, and low/no code platforms. Initial findings are encouraging, and lead us to suggest practitioners may use our method in other development tasks, such as, defect analysis and unit or integration tests. [ABSTRACT FROM AUTHOR]

Abstract: This is a discussion of the essential features of product development traceability maps in relation to requirements, architecture, functional models, components, and tests as a set of order type hierarchies and their cross-links. This paper lays out the structure of these ideal traceability relationships that define the essence of the product under development. The importance of the trace relationships to the product is clarified and then the abandonment of traceability in the Agile approach is discussed. Following that, a way to transform between synthetic canonical narrative (story) representations that appear in the product backlog and the traditionally separate hierarchical form of the trace structure of the product will be examined. The fact that it is possible to transform back and forth between the canonic narrative and traditional hierarchical representations of trace structures, and the fact that trace structures can be produced in a ‘just in time’ fashion that evolves during product development demonstrate that these trace structures can be used in both an Agile and Lean fashion within the development process. Also, we can show that when the trace structure is produced outside the narrative representation it can have the additional benefit of helping to determine the precedent order of development so that rework can be avoided. The lack of the extrinsic external trace structure of the product that gives access to its intelligibility is, in fact, a form of technical debt. Thus, traditional trace structures using this model can be seen as an essential tool for product owners to produce sound and coherent development narratives and for structuring and prioritizing the backlog in the Agile and Lean approaches to software and systems development. [Copyright &y& Elsevier]

Abstract: The current state of the art of aircraft systems integration is similar to the traditional serial software engineering waterfall method. Agile methods transformed software engineering with a focus on incremental iterative value added design. This paper reviews selected non software agile case studies for lessons that are applicable to implementing agile methods to transform the aircraft systems integration process. [Copyright &y& Elsevier]

Abstract: Test-Driven Development (TDD) is an extreme programming development method in which a software system is developed in short iterations. In this paper we present the Test-Driven Conceptual Modeling (TDCM) method, which is an application of TDD for conceptual modeling, and we show how to develop a conceptual schema using it. In TDCM, a system''s conceptual schema is incrementally obtained by performing three kinds of tasks: (1) Write a test the system should pass; (2) Change the schema to pass the test; and (3) Refactor the schema to improve its qualities. We also describe an integration approach of TDCM into a broad set of software development methodologies, including the Unified Process development methodology, the MDD-based approaches, the storytest-driven agile methods and the goal and scenario-oriented requirements engineering methods. We deal with schemas written in UML/OCL, but the TDCM method could be adapted to the development of schemas in other languages. [Copyright &y& Elsevier]

Abstract: The notion of knowledge artifact has rapidly gained popularity in the fields of general knowledge management and more recently knowledge-based systems. The main goal on this paper is to propose and discuss a methodology for the design and implementation of knowledge-based systems founded on knowledge artifacts. We advocate that the systems built according to this methodology can be effective to convey the flow of knowledge between different communities of practice. Our methodology has been developed from the ground up, i.e. we have built some concrete systems based on the abstract notion of knowledge artifact and synthesized our methodology based on reflections upon our experiences building these systems. In this paper, we also describe the most relevant systems we have built and how they have guided us to the synthesis of our proposed methodology. [Copyright &y& Elsevier]

Abstract: With the recent emergence of agile software development technologies, the software community is awaiting sound, empirical investigation of the impacts of agile practices in a live setting. One means of conducting such research is through industrial case studies. There are a number of influencing factors that contribute to the success of such a case study. In this paper, we describe a case study performed at Sabre Airline SolutionsTM evaluating the effects of adopting Extreme Programming (XP) practices with a team that had characteristically plan-driven risk factors. We compare the team’s business-related results (productivity and quality) to two published sources of industry averages. Our case study found that the Sabre team yielded above-average post-release quality and average to above-average productivity. We discuss our experience in conducting this case study, including specifics of how data was collected, the rationale behind our process of data collection, and what obstacles were encountered during the case study. We identify four factors that potentially impact the outcome of industrial case studies: availability of data, tool support, cooperative personnel and project status. Recognizing and planning for these factors is essential to conducting industrial case studies. [Copyright &y& Elsevier]

Software project development is a dynamic process by nature, since it is common that events such as changes in the software requirements and in the development team occur during the execution of the original project plan. When such disruptive events occur, the project plan needs to be adjusted, and the activity of adjusting the original plan in order to comply with the date and costs constraints of the project is called project rescheduling. This situation is not exclusive to whole-project plan-driven approaches to software development, as it is also present when software projects are developed following agile methodologies such as Scrum. In Scrum, shorter period project plans, called release plans, are used and when disruptive events occur release plan rescheduling needs to be performed. Plan rescheduling can be modeled as a multi-objective optimization problem, however, there have been no studies that investigate the release plan rescheduling problem (RPRP) and its solution by means of multi-objective optimizers. The study presented in this paper intends to address the lack of studies of the release plan rescheduling problem and covers three fundamental topics. First, a model for the release plan rescheduling problem is proposed, which considers metrics that are particularly important to define a release plan, including story points and velocity. Second, three evolutionary multi-objective algorithms are utilized for solving a number of problem instances and an appropriate in-depth analysis of their solutions is provided. Finally, a careful examination of the solutions with respect to their practicability is performed. • Release plan rescheduling, in the context of agile software development, is modeled. • Five criteria are defined for the multi-objective optimization problem. • Three evolutionary multi-objective algorithms are applied to test instances. • Analysis of results include conflict between the objectives and algorithm performance. • Results are examined regarding the practicability of the rescheduled release plans. [ABSTRACT FROM AUTHOR]

Global Software Development (GSD) has gained great attention during the past decade or so, and it is also being adopted by most of the software development organizations. The GSD approach is practiced by the software development organizations in China and a wide range of firms have established its operations in various Chinese cities. However, GSD practices becomes more challenging for the projects based on the agile concepts. The aim of this study is to develop a taxonomy of the factors that could positively impact the scaling process of agile methods in the Chinese GSD industry. The factors are identified by exploring the available literature and conducting industrial study with the Chinese agile and GSD practitioners. The finally reported factors are categorized, prioritized and developed their taxonomy using the multi-criterion decision making (MCDM) Fuzzy AHP approach. The given taxonomy is significant and progressive for GSD industry to assess and improve the scaling process of agile methods. • Explore the factors that could positively impact the agile scaling process in Chinese global software development (GSD) industry. • Develop the conceptual mapping of the identified factors. • Conceptual mapping is empirically validated. • The fuzzy AHP approach used to priorities the identified factors and the respective categories. • Develop the recommendation taxonomy of the factors based on the fuzzy AHP findings. [ABSTRACT FROM AUTHOR]

• An exploratory case study of agile software development within a safety critical systems engineering environment is undertaken. • Extensive interviews are undertaken with practitioners from the organization using a combination of exploratory, semi-structured and workshop formats. • Thirteen challenges are identified in the material and related to the existing literature. • Insights as to how the company are adapting agile practices to fit a safety critical context are reported. This study explores the introduction of agile software development within an avionics company engaged in safety-critical system engineering. There is increasing pressure throughout the software industry for development efforts to adopt agile software development in order to respond more rapidly to changing requirements and make more frequent deliveries of systems to customers for review and integration. This pressure is also being experienced in safety-critical industries, where release cycles on typically large and complex systems may run to several years on projects spanning decades. However, safety-critical system developments are normally highly regulated, which may constrain the adoption of agile software development or require adaptation of selected methods or practices. To investigate this potential conflict, we conducted a series of interviews with practitioners in the company, exploring their experiences of adopting agile software development and the challenges encountered. The study also explores the opportunities for altering the existing software process in the company to better fit agile software development to the constraints of software development for safety-critical systems. We conclude by identifying immediate future research directions to better align the tempo of software development for safety-critical systems and agile software development. [ABSTRACT FROM AUTHOR]

• Agile mature companies can be also conformant with ISO process reference models. • Conformance with five ISO/IEC/IEEE 12207 Technical Management processes is analysed. • Conformance with two ISO/IEC TR 29110-5-1-2 Project Management process activities is analysed. • Agile approaches propose different metrics for monitoring team performance. • Agile approaches are not faced with traditional process models. Agile approaches are well perceived in software development companies. These approaches are not faced with traditional process models. This research analyses how by defining and monitoring a set of Agile metrics, Agile mature companies can be also conformant with the best practices proposed by the targeted ISO process reference models. Conformance has been identified with five Technical Management processes of the ISO/IEC/IEEE 12207 standard and with two activities of the Project Management process of the ISO/IEC TR 29110-5-1-2 standard. The findings may be of the interest of those Agile settings that need to work according to the process model established in the company. [ABSTRACT FROM AUTHOR]

Increasingly, software development organizations are scaling agile practices in the global software development (GSD) environment in order to meet the requirements of the quickly changing and regularly developing business environment. The main objectives of this study are to investigate the key barriers and develop a prioritization-based taxonomy of the barriers for scaling agile development in the GSD environment. Total twenty-two barriers were extracted from the available literature and categorized into five categories, i.e. "human resources management", 'coordination", "technology", "project management", and "software methodology". In the next phase, the identified barriers and their categories were further validated using the questionnaire survey. In the final phase, fuzzy-AHP method, a multi-criterion decision making (MCDM) technique, was applied to prioritize and taxonomy of identified barriers and their related categories was designed. The contribution of this study is not limited to investigate the barriers, but it also provides the roadmap to tackle the issues related to the scaling agile methods in the GSD environment. • Identifying the barriers which negatively impact on the scaling programs of agile development in GSD environment. • Categorizing the identified barriers according to their types. • Validation of the identified barriers using the questionnaire survey. • Prioritizing the barriers using fuzzy AHP method by collecting responses of pair-wise comparison of factors. [ABSTRACT FROM AUTHOR]

Social media can be used to manage information flow in teams, thereby empowering knowledge management, which can be linked to innovation. This study develops a model to test the influence of social media on transactive memory system, absorptive capacities (potential and realized capacity), and team innovation performance. Partial least squares analysis on 61 software development teams indicates the positive impact of social media on transactive memory system and potential and realized absorptive capacity, which in turn can influence team innovation performance. This article presents theoretical contributions and describes implications for social media adoption in knowledge-intensive teams. • Framework to investigate role of social media for team innovation performance is defined. • Social media facilities teams to explore and exploit external knowledge to innovate. • A well-developed transactive memory system plays role to support social media to enhance absorptive capacities. • Both absorptive capacities of a team are effective in enhancing the team innovation performance. [ABSTRACT FROM AUTHOR]

The phenomena of global software development (GSD) face many challenges that are specifically associated with software process improvement (SPI). The main objective of this work is to develop the prioritization-based taxonomy of the SPI success factors using the fuzzy AHP approach. Total of twenty-one factors were extracted from the available literature that were further evaluated by conducting questionnaire survey with the SPI experts. In the second stage, multi-criterion decision making (MCDM) fuzzy AHP tool was used to prioritize and develop the taxonomy of the identified factors and their categories. The implications of fuzzy AHP approach are novel in this research area as it has been successfully used previously in different other domains e.g. electrical and electronics, supplier selection, agile software development and personnel selection. The contribution of this study is not only limited to the development of the factor's taxonomy, but also their proper prioritization by introducing the novel fuzzy AHP approach in the research field of GSD and SPI, which assist to remove the vagueness and uncertainty in the opinion of the process improvement experts. • Identifying the factors which positively affects the SPI practices in GSD environment. • Categorizing the identified factors according to their types. • Identifying the factors in the real world practices which positively affects the SPI practices in GSD environment. • Prioritizing the success factors using fuzzy AHP methods by collecting responses of pair-wise comparison of factors. [ABSTRACT FROM AUTHOR]

Virtual observatories allow the means by which an astronomer is able to discover, access, and process data seamlessly, regardless of its physical location. However, steep learning curves are often required to become proficient in the software employed to access, analyse and visualise this trove of data. It would be desirable, for both research and educational purposes, to have applications which allow users to visualise data at the click of a button. Therefore, we have developed a standalone application (written in Python) for plotting photometric Colour Magnitude Diagrams (CMDs) — one of the most widely used tools for studying and teaching about astronomical populations. The CMD Plot Tool application functions "out of the box" without the need for the user to install code interpreters, additional libraries and modules, or to modify system paths; and it is available on multiple platforms. Interacting via a graphical user interface (GUI), users can quickly and easily generate high quality plots, annotated and labelled as desired, from various data sources. This paper describes how CMD Plot Tool was developed using Object Orientated Programming and a formal software design lifecycle (SDLC). We highlight the need for the astronomical software development culture to identify appropriate programming paradigms and SDLCs. We outline the functionality and uses of CMD Plot Tool , with examples of star cluster photometry. All results plots were created using CMD Plot Tool on data readily available from various online virtual observatories, or acquired from observations and reduced with IRAF/PyRAF. [ABSTRACT FROM AUTHOR]