Dependency Management in Large-Scale Agile: A Case Study of DevOps Teams

Managing dependencies between teams and within teams is critical when running large-scale agile projects. In large-scale software development, work is carried out simultaneously by many developers and development teams. Results are delivered frequently and iteratively, which requires management of dependencies on both the project and team level. This study explores coordination mechanisms in agile DevOps teams in a large-scale project and how the mechanisms address different types of dependencies. We conducted a case study where we observed 38 scheduled meetings and interviewed members of five DevOps teams and two teams supporting the DevOps teams. By using a dependency taxonomy, we identified 20 coordination mechanisms (eleven synchronization activities and nine synchronization artifacts). Eight of these mechanisms seem essential for coordination in large-scale projects because they addressed more than four types of dependencies. The main implication is that project management needs to combine many practices handling all the dependencies in large-scale projects

A taxonomy of dependencies in agile software development

Dependencies in a software project can contribute to unsatisfactory progress if they constrain or block the flow of work. Various studies highlight the importance of dependencies in the organisation of work; however dependencies in agile software development projects have not previously been a research focus. Drawing on three case studies of agile software projects, and the IS literature, this paper develops an initial taxonomy of agile software project dependencies. Three distinct categories of dependency are found: task, resource, and knowledge dependencies. This paper contributes to theory by providing a taxonomy of dependency types occurring in the area of agile software development. Practitioners can use this taxonomy as sensitising device to ensure they consider dependencies they might face that could hinder their projects, enabling them to take appropriate and timely mitigating action.<br /

Construction of a taxonomy for requirements engineering commercial-off-the-shelf components

This article presents a procedure for constructing a taxonomy of COTS products in the field of Requirements Engineering (RE). The taxonomy and the obtained information reach transcendental benefits to the selection of systems and tools that aid to RE-related actors to simplify and facilitate their work. This taxonomy is performed by means of a goal-oriented methodology inspired in GBRAM (Goal-Based Requirements Analysis Method), called GBTCM (Goal-Based Taxonomy Construction Method), that provides a guide to analyze sources of information and modeling requirements and domains, as well as gathering and organizing the knowledge in any segment of the COTS market. GBTCM claims to promote the use of standards and the reuse of requirements in order to support different processes of selection and integration of components.Peer ReviewedPostprint (published version

Coordination in Distributed Agile Software Development: Insights from a COTS-based Case Study

This study investigates the practices of a development team that uses an Agile system of working where some team members and stakeholders were distributed geographically and temporally. The focus of the investigation was to study the dependencies and related coordination activities as the team collaborated on their work, which was the installation and customization of a complex Commercial Off-The-Shelf (COTS) software system in this case. We collected data by interviewing eight key team members and observing three team meetings over a 2-month period. We made detailed field notes and used thematic analysis to identify the key globally distributed dependencies in the development process. We identify and discuss the coordination mechanisms and tools that address these dependencies, along with the main coordination challenges. We conclude by discussing some ideas and lessons learned by the participants which we expect to be useful for other teams in a similar context

Traceability for Model Driven, Software Product Line Engineering

Traceability is an important challenge for software organizations. This is true for traditional software development and even more so in new approaches that introduce more variety of artefacts such as Model Driven development or Software Product Lines. In this paper we look at some aspect of the interaction of Traceability, Model Driven development and Software Product Line

Towards a Modeling Method for Managing Node.js Projects and Dependencies

This paper proposes a domain-specific and technology-specific modeling method for managing Node.js projects. It addresses the challenge of managing dependencies in the NPM and REST ecosystems, while also providing a specialized workflow model type as a process-centric view on a software project. With the continuous growth of the Node.js environment, managing complex projects that use this technology can be chaotic, especially when it comes to planning dependencies and module integration. The deprecation of a module can lead to serious crisis regarding the projects where that module was used; consequently, traceability of deprecation propagation becomes a key requirements in Node.js project management. The modeling method introduced in this paper provides a diagrammatic solution to managing module and API dependencies in a Node.js project. It is deployed as a modeling tool that can also generate REST API documentation and Node.js project configuration files that can be executed to install the graphically designed dependencies