Large Software Development Projects Research Articles

Stepwise migration of a monolith to a microservice architecture: Performance and migration effort evaluation

Due to scalability requirements and the split of large software development projects into small agile teams, there is a current trend toward the migration of monolith systems to the microservice architecture. However, the split of the monolith into microservices, its encapsulation through well-defined interfaces, and the introduction of inter-microservice communication add a cost in terms of performance. In this paper, we describe a case study of the migration of a monolith to a microservice architecture, where a modular monolith architecture is used as an intermediate step. The impact on migration effort and performance is measured for both steps. Current state-of-the-art analyses the migration of monolith systems to a microservice architecture, but we observed that migration effort and performance issues are already significant in the migration to a modular monolith. Therefore, a clear distinction is established for each of the steps, which may inform software architects on the planning of the migration of monolith systems. In particular, we consider the trade-offs of doing all the migration process or just migrating to a modular monolith.

Agile software development projects–Unveiling the human-related critical success factors

ContextInvestment in information technology is associated with better business performance when its implementation is successful, but it has high costs in case of failure, especially for large software development projects, which typically have the highest failure rates. Agile methodologies emerged with the expectation of reducing the risk of software development project failure. ObjectiveThis research aims to answer the following question: What are the human-related critical success factors for agile software development projects to succeed? The research model comprises four explanatory variables (team capability, customer involvement, psychological safety, and team autonomy) and one dependent variable (success of agile software development projects). MethodA questionnaire-based survey was carried out, resulting in 177 valid responses. A Partial Least Squares (PLS) analysis was performed to test the theoretical model. ResultsThe findings indicate that team capability and customer involvement have the strongest effects on the success of agile software development projects. The results also show that psychological safety is a significant indirect success factor and that team autonomy appears to have a competing dynamic with psychological safety on the other two factors. ConclusionTo the best of our knowledge, this is the first study to examine the direct impact of psychological safety and its indirect effect, mediated by team capability and customer involvement, on the success of agile software development projects. The mediation, moderation, and direct effects are studied, offering theoretical and practical insights.

Composition of UML Class Diagrams Using Category Theory and External Constraints

In large software development projects, there is always a need for refactoring and optimization of the design. Usually software designs are represented using UML diagrams (e.g., class diagrams). A software engineering team may create multiple versions of class diagrams satisfying some external constraints. In some cases, subdiagrams of the developed diagrams can be selected and combined into one diagram. It is difficult to perform this task manually since the manual process is very time consuming, is prone to human errors, and is not manageable for large projects. In this paper, we present algorithmic support for automating the generation of composing diagrams, where the composed diagram satisfies a given collection of external constraints and is optimal with respect to a given objective function. The composition of diagrams is based on the colimit operation from category theory. The developed approach was verified experimentally by generating random external constraints (expressed in SPARQL and OWL), generating random class diagrams using these external constraints, generating composed diagrams that satisfy these external constraints and computing class diagram metrics for each composed diagram.

Githru: Visual Analytics for Understanding Software Development History Through Git Metadata Analysis.

Git metadata contains rich information for developers to understand the overall context of a large software development project. Thus it can help new developers, managers, and testers understand the history of development without needing to dig into a large pile of unfamiliar source code. However, the current tools for Git visualization are not adequate to analyze and explore the metadata: They focus mainly on improving the usability of Git commands instead of on helping users understand the development history. Furthermore, they do not scale for large and complex Git commit graphs, which can play an important role in understanding the overall development history. In this paper, we present Githru, an interactive visual analytics system that enables developers to effectively understand the context of development history through the interactive exploration of Git metadata. We design an interactive visual encoding idiom to represent a large Git graph in a scalable manner while preserving the topological structures in the Git graph. To enable scalable exploration of a large Git commit graph, we propose novel techniques (graph reconstruction, clustering, and Context-Preserving Squash Merge (CSM) methods) to abstract a large-scale Git commit graph. Based on these Git commit graph abstraction techniques, Githru provides an interactive summary view to help users gain an overview of the development history and a comparison view in which users can compare different clusters of commits. The efficacy of Githru has been demonstrated by case studies with domain experts using real-world, in-house datasets from a large software development team at a major international IT company. A controlled user study with 12 developers comparing Githru to previous tools also confirms the effectiveness of Githru in terms of task completion time.

Implementing Agility in Large Software Development Projects

The present paper focuses on providing an in-depth understanding of the concept of agility and its uses in the software development projects. The paper also explains the key issues experienced by large companies while implementing agility practices and frameworks in the large-scale software development projects. The paper also develops key ideas about the procedure involved in implementing agility practices through extensive study of previous literature in this context. It also recommends certain methods in which the issues experienced during the implementation of agility in large scale software development projects can be minimized. The findings provide insights about the various challenges and reasons behinds such issues that are common in such large-scale software development projects drawing instances of international companies providing software development services.

The Effects of Turnover on Expert Effort Estimation

Turnover of the personnel represents a serious issue for management of software projects. The buildup of competences and phasing in of the people into the project requires both time and effort. This paper presents a case study of a large in-house agile software development project. The research goal was to determine the effects that turnover has on the expert effort estimation. In order to do this, paper examines relations across empirical data on a studied project. Study findings are the following: a) it is necessary to distinguish types of turnover, b) the general and planned turnover do not necessarily have a negative effect on estimation accuracy, and c) the unplanned turnover can have a significant negative impact on the reliability of the estimates and therefore should be treated with special attention. Results suggest that these facts should be taken into account both by the management and human resources.

A Review for Improving Software Change using Traceability Model with Test Effort Estimation

Maintaining a software system includes tasks such as fixing defects, adding new features, or modifying the software (software changes) to accommodate different environments. Then, the modified software system needs to be tested, to ensure the changes will not having any adverse effects on the previously validated code. Regression testing is one of the approaches which software tester used to test the software system. The traditional regression testing strategy was to repeat all the previous tests and retesting all the features of the program even for small modifications. For programming with thousand lines of codes (LOC), the cost of retesting the entire system is expensive if attempted after every change. This practice is becoming increasingly difficult because of the demand for testing the new functionalities and correcting errors with limited resources. Numerous techniques and tools have been proposed and developed to reduce the costs of regression testing and to aid regression testing processes, such as test suite reduction, test case prioritization, and test case done on the thresholds and weightings used in regression testing. However, there is still need to study on the software traceability model of coverage analysis in software changes during regression testing and test effort estimation on regression testing. Hence, this paper describes the proposal for improving software changes with hybrid traceability model and test effort estimation during regression testing. We will explain our proposed work including the problem background, the intended research objectives, literature review and plan for future implementation. This study is expected to contribute in developing hybrid traceability model for large software development project to support software changes during regression testing with test estimation approach and expected to reduce operational cost during the implementation on software maintenance. Also, it is hoped that an efficient and improve solution to regression testing can be realized, thus, gives the benefits to software testers and project manager manage the software maintenance task since it is a critical part in software project development.

An IT Project as a Plaything of its Organizational Environment: Long-term Challenges in Financial Services

At the end of 2015, and after 10 years, the German financial service provider FinAdvizard finally achieved the first results from the development project of its next-generation advisory application. Although this achievement can be considered as project success, the new application includes only the core of the initially intended scope because of environmental changes. First, the project team had to continuously deal with resource scarcity, stakeholder influences, regulatory requirements, and the involvement of its sales force. The team also had to adapt different management approaches and software development methods. Furthermore, the organization's focus and management attention repeatedly changed over time. Subsequently, this case retrospectively highlights information technology (IT) project management issues and challenges faced by large software development projects. Given the longitudinal analysis of the period of a decade, both positive and negative effects that are not visible in shorter IT projects become apparent. Additionally, the case sheds light and stimulates a discussion on, among others, collaboration between the business and IT departments, the importance of top IT management support, the challenge of bimodal or two-speed IT, and the influence of a strong sales force.

Software Project Management Observes: Fiasco V/S Victory

A study on successful and un-successful about 210 large software (development) projects from around the world between February 1995 and December 2017 has been presented in this review paper. All these projects involved on mass level that completed on time with their scheduled expense, and time frame estimates in development of those are getting late as defined, much expensive as decide, or were get delayed or close without its completion, major seven hurdles were noted: un sufficient project planning, un sufficient cost estimating, un sufficient measurements, un sufficient milestone tracking, un sufficient change control, and un sufficient -quality control, Poor Coronation and communication. After detail study on past reviews on these hurdles in project management, in this review paper we have presented a short overview of success and failure reasons/causes/possibilities of all those seven factor/ hurdles are noted. Maybe the clearest aspect of these major problems is linked with project management rather than technical resource. Two occupied ideas combine which are no proper excellence regulator are the huge funder for the rates, and late time and unfair plan organization have number of prospective reason of insufficient excellence actions.

The Best Software Development Teams Might be Temporary

A study of a large company's software development projects indicates that quality often suffers if team members have worked together previously. Thus, in many cases, temporary teams might be best.

Analyzing defect inflow distribution and applying Bayesian inference method for software defect prediction in large software projects

Tracking and predicting quality and reliability is a major challenge in large and distributed software development projects. A number of standard distributions have been successfully used in reliability engineering theory and practice, common among these for modeling software defect inflow being exponential, Weibull, beta and Non-Homogeneous Poisson Process (NHPP). Although standard distribution models have been recognized in reliability engineering practice, their ability to fit defect data from proprietary and OSS software projects is not well understood. Lack of knowledge about underlying defect inflow distribution also leads to difficulty in applying Bayesian based inference methods for software defect prediction. In this paper we explore the defect inflow distribution of total of fourteen large software projects/release from two industrial domain and open source community. We evaluate six standard distributions for their ability to fit the defect inflow data and also assess which information criterion is practical for selecting the distribution with best fit. Our results show that beta distribution provides the best fit to the defect inflow data for all industrial projects as well as majority of OSS projects studied. In the paper we also evaluate how information about defect inflow distribution from historical projects is applied for modeling the prior beliefs/experience in Bayesian analysis which is useful for making software defect predictions early during the software project lifecycle.

A novel approach for hiding secret data in program files

All large programs and software development projects, irrespective of application, generate a large amount of associated documentation. Documentation is an important part of all types of programs and software. It tells other programmers what the program does and how it works. Documentation helps others and teammates understand your work. In this proposed work, I have designed a method which hides important and secret data into the programs and software document parts with three layers of security. The resultant stego file undoubtedly can be transmitted anywhere using any channel. Experimental results show the feasibility of the proposed methodology.

A Business Process view of Software: An effective measurement model to assess the operations readiness of software under construction

AbstractThis paper introduces the concept of a business process based measurement framework to assess completeness and correctness of an IT platform (software) for business operations readiness. Conventional software development methods do not provide the development status in a manner that reflects the business operations readiness perspective, especially when the development is outsourced. Conventional methods report in terms of the requirements developed and the number of test cases passed. In a typical operations production setup, the operations team executes the business process and hence is able to better appreciate the state of the software under construction in terms of business process. Business users validate the business process during the acceptance testing phase, but this is a post development completion activity. Consider the common scenario where a large software development project is close to its planned development end date (that is, pre user acceptance testing phase), and there is a delay as per schedule. Now, the business needs to take a call: Go Live / Not to Go Live with the business change, as planned. This decision is critical when the business change is “time‐to‐market” sensitive. To take such a call, the business needs to have a clear understanding of the level of readiness of the software from a business operations perspective; whereas the standard measures applied to report the completion status of a software development project is the number of requirements developed and the number of test cases passed. Such a report does not provide the business with a view of the operations readiness of the software. In this paper, the author has made an attempt to provide a mechanism by which the level of completion of the software can be represented using a business process view and that in turn can measure the relative business operations readiness of the software, at any given point in time. This view can further be used as a feedback mechanism to prepare and execute the revised production rollout strategy for the software.

Automated bug assignment: Ensemble-based machine learning in large scale industrial contexts

Bug report assignment is an important part of software maintenance. In particular, incorrect assignments of bug reports to development teams can be very expensive in large software development projects. Several studies propose automating bug assignment techniques using machine learning in open source software contexts, but no study exists for large-scale proprietary projects in industry. The goal of this study is to evaluate automated bug assignment techniques that are based on machine learning classification. In particular, we study the state-of-the-art ensemble learner Stacked Generalization (SG) that combines several classifiers. We collect more than 50,000 bug reports from five development projects from two companies in different domains. We implement automated bug assignment and evaluate the performance in a set of controlled experiments. We show that SG scales to large scale industrial application and that it outperforms the use of individual classifiers for bug assignment, reaching prediction accuracies from 50 % to 89 % when large training sets are used. In addition, we show how old training data can decrease the prediction accuracy of bug assignment. We advice industry to use SG for bug assignment in proprietary contexts, using at least 2,000 bug reports for training. Finally, we highlight the importance of not solely relying on results from cross-validation when evaluating automated bug assignment.

SW개발 프로젝트 관리시스템 도입 및 적용사례에 대한 연구

In this paper, we introduce PMS’s main function and main effect which implemented medium and large scale software development project site, and we propose importance and improvement nacessity of PMS implementation. PMS’s main functions are developed based on best practices which CMMI model and PMBOK. Also, each PMS has specialized unique function according to it’s target industry area or related I.T solutions which has infra dependency. The effectiveness of PMS implementation on project site is seperated two types, one is qualitative effect, the other quantitative effect. Representative qualitative effects are improvement of enterprise’s image and competency. Also representative quantitative effect is ∙제1저자 : 전형권 ∙교신저자 : 박구락 ∙투고일 : 2013. 8. 2, 심사일 : 2014. 1. 7, 게재확정일 : 2015. 5. 27. * 공주대학교 멀티미디어공학과(Dept. of Multimedia Engineering Computer Science, Kongju national University) ** 공주대학교 컴퓨터공학부(Dept. of Computer Science & Engineering, Kongju national University) *** 대전보건대학교 바이오정보과(Dept. of Bio Information, DaeJeon Health Sciences College) 92 Journal of The Korea Society of Computer and Information May 2015 reduction of project management cost as a financial effect. As far as project size is increase, PMS’s needs and necessariness will be increase, so we need to improve PMS;s function according to project management’s global trend and software customer’s requisition. ▸

Teaching at a university of applied sciences

Abstract A university of applied sciences focuses on both application and science. Before becoming a professor at a university of applied sciences, I got in touch with both worlds: the purely scientific one, doing research in the field of algorithm engineering, and the `real' one, working in large software development projects. After making these experiences, I am convinced that the approach of a university of applied sciences is a very good one.

Introducing a Method for Modeling Knowledge Bases in Expert Systems Using the Example of Large Software Development Projects

Goal of this paper is to develop a meta-model, which provides the basis for developing highly scalable artificial intelligence systems that should be able to make autonomously decisions based on different dynamic and specific influences. An artificial neural network builds the entry point for developing a multi-layered human readable model that serves as knowledge base and can be used for further investigations in deductive and inductive reasoning. A graph-theoretical consideration gives a detailed view into the model structure. In addition to it the model is introduced using the example of large software development projects. The integration of Constraints and Deductive Reasoning Element Pruning are illustrated, which are required for executing deductive reasoning efficiently.

Case study on risk management practice in large offshore‐outsourced Agile software projects

Information systems, offshoring and outsourcing have resulted in significant changes to software engineering practices. In this study, the authors explore industry practices in risk management in a large offshore-outsourced Agile Scrum software development project. The project consisted of distributed teams from two different IT vendors. Agile method is suitable for small and collocated teams, where the team members have high level of knowledge and commitment. In this study, the authors explore the challenges to Agile culture and practices posed by offshore-outsourced business model (where project ownership is shared, and business knowledge of the development team is limited), distributed project teams and large team size characteristic of offshore projects. In this study, it was further examined how these challenges were managed; and how the best practices can be used to improved performance in the context of offshore-outsourced Agile projects in general.

TESTING PROCESS OVERVIEW EXPLORATION FOR A SOFTWARE PRODUCT IN A LARGE SOFTWARE DEVELOPMENT PROJECT

Software testing is a process where you have the stated requirements, pre-requisite software that is to be installed and the configuration of the machine that need to be done as per the test data for the test case and for a specific platform which when verified works perfectly. This paper describes about Manual test case process overview in the testing life cycle for a large software development project and how you track the effort for the same. A Tester need to know about the fundamentals of testing concepts. Documentation of the testing concepts and the process overview of the testing life cycle for a software product need to be done initially so that a new tester when recruited can understand the basic flow as to how it is carried out in real time in an organization practically. Initially a tester need to execute the manual test case for few platforms and some tougher manual test cases need to be learnt from the tester who is having some experience. The tougher manual test cases need to be identified initially from the experienced tester who will be giving a session for the execution of such test cases. So when the foundation for a new tester is powerful the plan assigned for the execution of test cases is met. The effort tracking for the testing can be captured for a tester and should be matched with planned effort for the execution of test cases. Measurement of the testing effort plays a very important role as to how comfortable a new tester is and further root cause analysis is done if required when the new tester does not meet the planned effort.

Dynamic capability for trustworthy software development

SUMMARYSoftware development organizations are increasingly recognizing the need for flexibility in almost every project they execute. At the same time, development teams are under ever‐increasing pressure to deliver software products in shorter cycles and with higher levels of quality. The current software development projects face conflicting demands: improving process predictability to deliver trustworthy software products, and improving process flexibility to adapt to the dynamic context. Although the importance of process tailoring is well recognized, the current literature and industry standards fail to provide theoretically and empirically grounded guidelines on how to tailor the development process to suit the needs of developing trustworthy software in the current dynamic environment. This paper examines how software development teams achieve dynamic capabilities to pursue conflicting demands on trustworthiness and flexibility through a case study of a large military software development project. Copyright © 2010 John Wiley & Sons, Ltd.