Search

Agile methods and software product line engineering (SPLE) are widely recognized as practical approaches for delivering high-quality software, adapting to evolving stakeholder needs, and tackling complex problems. This study proposes a hybrid agile software development and reuse approach called SPLE-Scrum based on the activities of software product line engineering and Scrum. Within the SPLE process, we incorporate requirement engineering and design practices to create a reference architecture with reusable components called core assets by introducing a product management meeting. The core assets are reused to build a series of applications with various product lines. The product increments are delivered in each Sprint with the review and retrospective meetings based on Scrum lifecycle and practices. We present a case study involving a blockchain online store to demonstrate the practical application of SPLE-Scrum, highlighting the benefits of integrating Scrum and software product line engineering. The research hypotheses of the proposed approach were validated through a study of structured interviews with 5 experts and 44 software practitioners, showing that the key factors of product management, project requirements, and product architecture in the SPLE-Scrum approach have a beneficial impact on project success. The SPLE-Scrum approach provides valuable insights and practical guidance for organizations seeking to optimize their software engineering practices while incorporating agile development and software reuse capabilities. [ABSTRACT FROM AUTHOR]

Metrics are key elements that can give us valuable information about the effectiveness of agile software development processes, particularly considering the Scrum environment. This study aims to learn about the metrics adopted to assess agile development processes and explore the impact of how the role performed by each member in Scrum contributed to increasing/reducing the perception of the importance of these metrics. The impact of years of experience in Scrum on this perception was also explored. To this end, a quantitative study was conducted with 191 Scrum professionals in companies based in Portugal. The results show that the Scrum role is not a determining factor, while individuals with more years of experience have a higher perception of the importance of metrics related to team performance. The same conclusion is observed for the business value metric of the product backlog and the percentage of test automation in the testing phase. The findings allow for extending the knowledge about Scrum project management processes and their teams, in addition to offering important insights into the implementation of metrics for software engineering companies that adopt Scrum. [ABSTRACT FROM AUTHOR]

This paper shows the necessary steps, which should be taken in order to get the most out of agile software development in interdisciplinary settings involving scientific experts. If applied properly, Agile delivers increased productivity, higher quality and, last but not least, higher customer satisfaction. The task of developing high quality software is already difficult. Developing software for a new IT-enabled service in an interdisciplinary team however, is even more challenging. In interdisciplinary projects scientific experts from different fields need to work together with computer scientists, developers, testers, business analysts and domain experts. Software engineering is very time-consuming and scientific experts who have never been involved in a software project, often find it hard to understand why progress sometimes seems so slow. Therefore, it is important that they understand what it takes to write high-quality code, i.e. code that is clean, tested, documented and extendable at the right points. The best way to achieve this goal is to expand the software team, make the scientific experts an integral part of it and thus profit from their know-how. [ABSTRACT FROM AUTHOR]

This study compares the reliability of estimation, productivity, and defect rate metrics for sprints driven by a specific instance of the agile approach (i.e., scrum) and an agile model-Bbased software engineering (MBSE) approach called the integrated Scrum Model-Based System Architecture Process (sMBSAP) when developing a software system. The quasi-experimental study conducted ten sprints using each approach. The approaches were then evaluated based on their effectiveness in helping the product development team estimate the backlog items that they could build during a time-boxed sprint and deliver more product backlog items (PBI) with fewer defects. The commitment reliability ( C R ) was calculated to compare the reliability of estimation with a measured average scrum-driven value of 0.81 versus a statistically different average sMBSAP-driven value of 0.94. Similarly, the average sprint velocity ( S V ) for the scrum-driven sprints was 26.8 versus 31.8 for the MBSAP-driven sprints. The average defect density ( D D ) for the scrum-driven sprints was 0.91, while that of the sMBSAP-driven sprints was 0.63. The average defect leakage ( D L ) for the scrum-driven sprints was 0.20, while that of the sMBSAP-driven sprints was 0.15. The t-test analysis concluded that the sMBSAP-driven sprints were associated with a statistically significant larger mean C R , S V , D D , and D L than that of the scrum-driven sprints. The overall results demonstrate formal quantitative benefits of an agile MBSE approach compared to an agile alone, thereby strengthening the case for considering agile MBSE methods within the software development community. Future work might include comparing agile and agile MBSE methods using alternative research designs and further software development objectives, techniques, and metrics. [ABSTRACT FROM AUTHOR]

The competition in the software market demands that the time required for any software product to reach the market be reduced if the product is to survive competition from other developers. The pursuit of this goal has led to the adoption of agile software development methodologies. While other agile methodologies provide guidelines as to the software engineering (SE) practices to be used during the development lifecycle, Scrum does not. The purpose of this study is twofold: first, to identify the usage and level of importance of software engineering practices in the Scrum development environment; and second, to investigate how Scrum teams adopt an appropriate set of SE techniques and whether a hybrid Scrum/Extreme Programming (XP) methodology is an appropriate approach to take. This research was conducted by examining sample data from five organizations using the Scrum methodology. The sample included a range of industries including communications and embedded systems, financial asset management, software development houses and consulting firms in South Africa. The study employed a mixed method approach. A key finding was that, regardless of the fact that Scrum does not explicitly recommend engineering practices, there was extensive use of these practices by all of the participating organizations. The study also found that the lack of software engineering practices in Scrum does not constitute a barrier to a successful adoption of Scrum, provided the 'inspect and adapt' principle inherent in Scrum is properly followed. The study discusses the findings, explains the implications and suggests future research. [ABSTRACT FROM AUTHOR]

In this paper, an undergraduate capstone course in software engineering is described that not only exposes students to agile software development, but also makes it possible to observe the behavior of developers using Scrum for the first time. The course requires students to work as Scrum Teams, responsible for the implementation of a set of user stories defined by a project domain expert playing the role of the Product Owner. During the course, data on project management activities are collected in order to analyze the amount of work completed, compliance with the release and iteration plans, productivity, ability in effort estimation, and the like. The paper discusses the achievement of teaching goals and provides empirical evaluation of students' progress in estimation and planning skills. A summary of lessons learned and recommendations is given, reflecting the issues to be considered when teaching courses in agile software development. Surveys of students have shown that they were overwhelmingly positive about the course, indicating that the course fully met or even exceeded their expectations. [ABSTRACT FROM PUBLISHER]

This paper describes the authors' experience of teaching agile software development to students of computer science, software engineering, and other related disciplines, and comments on the implications of this and the lessons learned. It is based on the authors' eight years of experience in teaching agile software methodologies to various groups of students at different universities, in different cultural settings, and in a number of courses and seminars. It specifically discusses three different courses on agile software development, given in different teaching settings and at different levels, and briefly surveys variations to these courses given elsewhere. Based on the experience acquired, analyses and evaluations conducted, and current pedagogical trends at relevant university departments, the authors provide recommendations on how to overcome potential problems in teaching agile software development and make their adoption more effective. [ABSTRACT FROM AUTHOR]

Despite the profusion of research about knowledge management within larger organizations, fewer studies tried to analyze knowledge management in small and medium enterprises. The study contributes to research by providing a more nuanced classification of knowledge management approaches and guides managers about the types of knowledge management approaches that should be adopted based on the size, geographical dispersion, and task nature of the organization. A purposive sample of 34 companies was selected for this study along with a survey that focused on the objective of investigating awareness and implementing strategies of knowledge management. The various phases and processes of knowledge management were accounted for. Organizations were bifurcated on the criteria like the core area of the company, the size of the company, the type of company, etc. Knowledge management implementation was judged through each dimension. Different statistical tests were carried out to test a set hypothesis. Having established that wide variation in overall adoption of knowledge management practices exists across the software engineering organizations, the different characteristics associated with knowledge management adoption were tested: organization size in terms of employee strength, the domain of the software engineering, team distribution, and type of organization. To a surprise, most of the organizational characteristics are not found in the significantly associated with knowledge management adoption except knowledge management adoption level in full and partial agile organizations and the relationship between the organization KM level and the number of software developers in organization for only product development companies is found significant. Opposite to the claims of many researchers, this study does not find any significant difference between knowledge management adoptions between distributed and co-located agile teams. [ABSTRACT FROM AUTHOR]

Scrum is a widely-used framework in industry, so many schools apply it to their software engineering courses, particularly capstone courses. Due to the differences between students and industrial professionals, changing Scrum is necessary to fit capstone projects. In this paper, we suggest a decision-making process to assist instructors in developing a strategy to adapt Scrum for their course. This framework considers critical differences, such as student’s workloads and course schedules, and keeps the Agile principles and Scrum events. To evaluate the adapted Scrum, we investigated student’s learning experiences, satisfaction, and performance by quantitatively analyzing user story points and source codes and qualitatively studying instructor’s evaluations, student’s feedback, and Sprint Retrospective notes. Our two case studies about adapted Scrum showed that having daily stand-up meetings in every class was not helpful, student’s satisfaction positively correlated to the difficulty of the task they tackled, and the project provided good learning experiences.

We present a solution based on blockchain technology and smart contracts for agile project management in light of the continuing transition in the software development industry. Due to the fact that these technologies are self-executing, customized, and impervious to tampering, they are considered to be crucial for the transition to a more efficient, transparent, and transactive payment gateway between major stakeholders. These major stakeholders will be able to communicate through smart contracts, which will act as a bridge between them. As part of their responsibility, they will make sure that all of the terms of the contract are met and acknowledged by all members of the team. As a result of our research, we propose a model in which payouts could be automatically enabled and penalties or grants could be introduced based on performance. If any changes were to be made to the contract in the future, all parties involved would be automatically notified. To maintain the development cycle, they should accept these changes as soon as possible. Because of this, the product owner and client are able to concentrate their resources on more profitable and productive tasks, without the need to monitor this aspect of agile project management. Our proposed model brings together different partners with the objective of successfully developing different IT projects by leveraging software engineering solutions such as smart contracts. [ABSTRACT FROM AUTHOR]

We live at an exciting time where software has become a dominant aspect of our everyday life. Although software provides opportunities for improving various aspects of our society, it also presents many challenges. One of them is development, deployment, and sustaining of high quality software on a broad scale. While agile methods (Scrum being one of the most prominent examples) ease the process, their popularity deteriorates the clarity and simplicity they were once meant to bring into software development. This article explores the synergy of Scrum and Essence, a domain model of software engineering processes, intending to become a common ground for software development methods, bringing clarity into the composition of methods from individual practices. This short communication motivates the interplay of Scrum and Essence, being accompanied with a set of videotutorials and 21 Scrum Essential cards to further guide more effective team's way of working. [ABSTRACT FROM AUTHOR]

The world of software engineering is constantly discovering new ways that lead to an increase in team performance in the production of software products and, at the same time, brings the customer's further satisfaction. With the advent of agile methodologies in software development, these objectives have been considered more seriously by software teams and companies. Due to their very nature, agile methodologies have the potential to be integrated with other methodologies or specific managerial approaches defined in line with agility objectives. One of the cases is Six Sigma, which is used in organizations by focusing on organizational change and process improvement. In the present study, attempts were made to present the hybrid software development approach, including Scrum, as the most common agile and Six Sigma methodology. This approach was practically used in a case study, and the obtained results were analyzed. The results of this evaluation showed that this hybrid method could lead to the increased team performance and customer satisfaction. However, besides these two achievements, an increase in the number of re-works, number of defects discovered, and the duration of the project implementation were also observed. These cases are in line with the main objectives of Scrum and Six Sigma and are justifiable and acceptable due to achieving those objectives. [ABSTRACT FROM AUTHOR]

Software engineering companies have progressively incorporated agile project management methodologies. Initially, this migration occurred mostly in the context of startups, but in recent years it has also sparked interest from other companies with larger and more geographically dispersed teams. One of the frameworks used for large-scale agile implementation is the LeSS framework. This study seeks to explore how Management 3.0 principles can be applied in the context of the ten practices proposed in the LeSS framework. To this end, a qualitative research methodology based on four case studies is used to identify and explore the role of Management 3.0 in software management and development processes that adopt this agile paradigm. The findings show that the principles of Management 3.0 are relevant to the implementation of the LeSS framework practices, especially in fostering team values and personal values; however, distinct principles between the two paradigms are also identified, namely the greater rigidity of processes advocated in the LeSS framework and a greater focus on process automation. [ABSTRACT FROM AUTHOR]

Background: Although agile and Scrum have been important frameworks in software engineering for over a decade, little research has explored how teams use Scrum language within their sprints. Literature review: Most explorations of Scrum communication have been collected through self-reported means. These studies are inherently unable to explore how Scrum teams use Scrum-centric language in their meetings in ways that adhere or run counter to standard Scrum practice. Research questions: 1. In what ways is Scrum reflected in the language used by team members in various sprint meetings? 2. What associations exist between the job title of team members and their use of Scrum language? 3. What does a discourse analysis reveal about the ways in which this team uses language to value and discount Scrum? Research methodology: For three sprints over 10 weeks, I recorded meetings of 27 Scrum team members. I transcribed these meetings, developed a codebook for assigning Scrum language categories, conducted an interrater reliability agreement on the data, completed a correspondence analysis on how Scrum language associates with meeting types and job titles, and conducted a discourse analysis to determine in what ways these teams value and discount Scrum. Results/discussion: Scrum language was found in all recorded meetings across all three sprints, with much language found in the planning meetings. Few associations existed between Scrum language and job title, suggesting that Scrum at this engineering firm is an egalitarian process. In addition, the discourse analysis revealed that this engineering firm valued User Story and Sprint Execution language while discounting Capacity and Story Pointing language. Conclusions: Although this group broadly adheres to Scrum practices about 68% of the time, this study finds that several current standard components of Scrum are routinely discounted. This exploratory study suggests that more research into the in-situ use of Scrum language in engineering workplaces is necessary to better inform engineering professionals about the communicative expectations of Scrum and to better enable engineering communication educators to prepare future engineers for Scrum realities. [ABSTRACT FROM AUTHOR]

Software requirement engineering (SRE) is the initial stage of the software engineering process and entails several challenges relating to the identification, implementation, evolution, and management of requirements for the development of software systems that meet the desired functionality quality standards. Agile software development (ASD) is a well‐known software development process that follows a lightweight and adaptive methodology to support the incremental development of software systems. Since the ASD follows an adaptive procedure (ie, a flexible, nanostructured, and dynamic approach) of software development, it becomes challenging to perform SRE that follows a structured approach for managing software requirements throughout the life cycle of software development. The primary challenges for SRE, while pursuing an ASD, include, but are not limited to, identification of incomplete requirements, implementation of vague requirements, prioritization of secondary functional requirements, and compromise on users' involvement that negatively impacts the software system's functionality and quality. To overcome these challenges, some of the recent research efforts have focused on managing different phases of SRE during software development using the ASD. However, there is a lack of solutions that provide software engineers/practitioners with a solution. Besides, frameworks to effectively manage all the phases of SRE as per the needs of the ASD are needed. We propose a framework that unifies joint requirements document (JRD) and SCRUM to incrementally (a) identify, (b) implement, (c) evolve, and (d) manage system requirements throughout the software development cycle. We have used the action research method to qualitatively validate the proposed framework based on data and user requirements collected from a product‐focused (multinational) Norway‐based software company. The results of the validation are based on statistical analysis that reflects the usefulness of the proposed framework for SRE in ASD‐based software engineering and development. Future research is the possible application of a machine learning approach (es) in the intended context for agile requirements elicitations. [ABSTRACT FROM AUTHOR]

Copyright of Revista Facultad de Ingeniería - UPTC is the property of Universidad Pedagogica y Tecnologica de Colombia, Facultad de Ingenieria and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Education is crucial for the growth of society, and the usage of effective learning methods is key to transmit knowledge to young students. Some initiatives present Virtual Reality technologies as a promising medium to provide active, effective, and innovative teaching. In turn, the use of this technology seems to be very attractive to students, making it possible to acquire knowledge through it. On the other hand, agile methodologies have taken an essential role within information technologies and they are key in Software Engineering education. This paper combines both areas and presents prior research about Virtual Reality experiences with educational purposes and introduces a serious VR video game that aims to promote the learning of agile methodologies in Software Engineering education, specifically the Scrum methodology. This application tries to bring students closer to their first days of work within a software development team that uses the Scrum methodology. Two evaluation processes performed with university teachers and students indicate that the developed video game meets the proposed objectives and looks promising. [ABSTRACT FROM AUTHOR]

Nowadays, considerable attention is paid to agile methods as a means to improve management of software development processes. The widespread use of such methods in professional contexts has encouraged their integration into software engineering training and undergraduate courses. Although several research efforts have focused on teaching Scrum through simulating a software development project, they covered only the learning of programming practices within a Scrum team. Furthermore, few studies tackle nontechnical skills other than the development practices themselves. The work presented here introduces an original Scrum-based training model enhanced with agile coaching to maximize student performance. This was validated by a case study on a capstone project in a Scrum course. This paper summarizes the positive results of introducing agile coaching, which resulted in approximately 22% more coverage of software engineering practices. In addition, a survey data showed that, compared to students who did not receive coaching, coached students gained valuable insight into the internalization of Scrum, problem solving, and guidance by means of checkpoint meetings. [ABSTRACT FROM PUBLISHER]

Although traceability information is vital to many software engineering activities, agile development approaches rarely use it because of the extra effort required. In this industry case study, the authors report the results of applying their lightweight semiautomated method that integrates traceability into software architecture developed with an agile process like Scrum. [ABSTRACT FROM PUBLISHER]

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]

Many smaller companies cannot afford the time and effort to change their development processes all at once. In some cases, companies are not aware of the fact that many aspects of agile development are already in place. The aim of this work was to evaluate if an evolutionary transition to agile software development is suitable for small companies. We conducted a case study with a small company to start their step‐by‐step agile transition. Initially, three agile software development practices were introduced. Based on the assessment of improvements, the transition continued with three Kanban practices. Experiences with the improvement process and the selected practices were elicited by means of qualitative interviews for data collection. Our case study reports details on the implementation of the first practices as well as the way the resulting agile transition has taken so far. The positive experiences reported by all employees during the agile transition indicate that an evolutionary transition is suitable for small companies. The experiences concerning the transition process and the positive effects of the selected practices motivate practitioners to start their own agile transition. [ABSTRACT FROM AUTHOR]

In order to develop and deliver a software project successfully, any software development organisation has to follow a well-known and recognised software engineering process for successful delivery and maintenance of the software. However, when the organisation is willing to follow a new software development process, the success rate of adopting a new software engineering process is a question mark. In the paper, we aim at studying and comparing two software engineering processes, which are based on different paradigms or models, and proposing a hybrid methodology, which integrates advantages of both compared methods. They are Microsoft Solutions Framework as a representative for an iterative methodology and SCRUM for agile software development. The comparative analysis will help a software development company to make the transition easier from Microsoft Solutions Framework to SCRUM or vice versa.

Background: The Academia-Industry partnership has been increasingly encouraged in the software development field. The main focus of the initiatives is driven by the collaborative work where the scientific research work meets the real needs of the Industry. Methods: Aiming to contribute to this effort we have proposed an approach called SoftCoDeR (Software Cooperative Design Research) that combines CMD (Cooperative Method Development), a method of Action Research, to concepts of DSR (Design Science Research). Results: We have applied the SoftCoDeR approach in a software development company to support a research and development project aiming to integrate User Experience practices into the agile software development process. Conclusions: In this paper, we present new findings about this approach that has been extended with the use of Experimental Software Engineering (ESE) practices to conduct experimental validations of artifacts before putting them in industrial practice. [ABSTRACT FROM AUTHOR]

The need of the current Software industry is changing rapidly, and the demand is ever increasing. The industry needs to provide the solution to this demand. As the software development proceeds, factors such as requirements, needs, priorities, underlying technology may change. Thus development process must be highly dynamic and a good software development methodology must adapt to these evolving and changing requirements. Traditional software development models are unable to handle such dynamic requirements. However, there are many new development models introduced in context to provide satisfactory solutions to increasing needs of the industry. Comparison between different new software development methods will help in the selection of appropriate development model in a particular scenario. [ABSTRACT FROM AUTHOR]

Agile software development methods assume that user requirements are formulated as short user stories written on paper note cards. Students often seem to be suspicious about this approach, finding user stories not precise enough to describe the desired functionality. Therefore, practical experience is needed to overcome initial doubts and impart good understanding of the potential benefits and limitations. This paper describes how user stories are taught within the scope of the software engineering capstone course at the University of Ljubljana, Slovenia, and provides an in-depth analysis of students' opinions on the basis of several surveys that have been conducted since the 2009/10 academic year. The analysis indicates that students' opinions are mostly positive and significantly improve after they gain more experience. Students successfully grasp the main concepts and understand the advantages and limitations of user stories. However, better students are more confident about potential benefits and keener to use user stories in practice. Students' satisfaction can be largely attributed to proper instruction of the course, which stimulates learning through problem solving and requires close cooperation among students, the Product Owner, and the ScrumMaster. [ABSTRACT FROM AUTHOR]