Artefact Consistency Management in DevOps Practice: A Survey

Artefact Consistency Management in DevOps Practice: A Survey

Dulani Meedeniya (University of Moratuwa, Sri Lanka), Iresha Rubasinghe (University of Moratuwa, Sri Lanka) and Indika Perera (University of Moratuwa, Sri Lanka)
DOI: 10.4018/978-1-7998-1863-2.ch004
OnDemand PDF Download:
No Current Special Offers


DevOps practices preserve the continuous innovation in software development. The collaborative nature and stakeholder communication are keys in DevOps that lead to highly effective and quality software outcomes with customer satisfaction. The software artefacts involved in a DevOps practice must adapt to frequent changes due to continuous stakeholder feedback. Hence, it is challenging to artefact consistency throughout the software life cycle. Although artefact traceability preserves the consistency management with theoretical support, there are practical limitations in traceability visualisation, change impact analysis, and change propagation aspects. This chapter presents an analysis of existing studies focused on software artefact traceability for the suitability in DevOps. It also identifies leading limitations and possible future research directions to resolve for the benefit of researchers and software practitioners.
Chapter Preview


Software System

Overview of a Software System

A software system is a combination of several software elements that evolves through a particular software development process model. It is an interface that connects the user with application software and computer hardware. It is a combination of a set of design decisions that lead to system architecture, which is a blueprint for any software system (Arora, & Arora, 2016). The study of theoretical concepts related to software system development, technical aspects, budgeting, management and maintenance is known as software engineering (Sommerville, 2010). With the rapid improvements in technology and resources, the importance of software systems has become vital in everyday activities. For instance, different domains such as finance, transportation, agriculture, military, academics, healthcare, business rely on software systems (Chang, 2005) (Sommerville, 2010). In practice, the aim is to maximise the use of automated software systems to minimise manual workforce and to improve quality. Thus, several well-defined software process models and technologies have been used in software system development.

Software Artefacts

Software artefacts refer to the intermediate by-products used in different phases of software development. These elements include System Requirement Specification (SRS), design diagrams, architectural documents and quality attributes or the non-functional design reports, source code, test scripts, walkthroughs, inspections, bug reports, build logs, test reports, project plans and risk assessments among many (Sommerville, 2010). Each artefact has its life cycle during software evolution. The types of artefacts in a software project may vary depending on the adapted software process model and technologies. Thus, a software system is a result of a collection of elements that goes through changes affecting each other at different levels. There are relationships and dependencies between these software artefacts, and it is essential to manage these software artefacts to maintain adequate consistency during changes. The improper management and outdated artefacts can lead to inconsistencies, synchronisation issues and lack of trust by stakeholders (Cleland-Huang, Zisman, & Gotel, 2012).

Software Development Life Cycle

Software Development Life Cycle (SDLC) denotes the overall software development related activities from the start of a software project until the completion and evolution. As shown in Figure 1, SDLC is the collection of core activities typically a software project follows regardless of project type, scale or domain (Sommerville, 2010) (Langer, 2016). The initial step is software project planning. Refinement can be applied to this phase based on the factors such as project type, stakeholder and organisational guidelines. A feasibility study is performed at this stage to identify the technical, financial, resource feasibility for the system completion. Next, the software requirements gathered from customers are further analysed, revised and prioritise, which is known as requirements engineering (Dick, Hull, & Jackson, 2017). Then, the actual software system design representing the intended software product is designed using design tools, different diagrams and mock-ups. The design is crucial, especially for implementation, where the software is coded to produce a useful product. Software developers are responsible for implementation using programming languages, supporting tools and diverse coding environments within given guidelines. Depending on the followed software process model, the application is tested incrementally or sequentially (Arora, & Arora, 2016) and transformed into a bug-free software product. Next, the software product is deployed, so that the end user can experience the system with proper user guidance. The technological, ethical, environmental circumstances and newer user requirements mainly lead to software maintenance. Thus, with the evolving needs, the deployed product is revised during the software maintenance phase.

Figure 1.

Software development life cycle


Evolution of Software Systems

At present, software systems consider as critical business assets. A software system change is inevitable and hence, must be updated continuously to maintain the assets. In such situations, software evolution is preferred over building completely new software systems due to the cost and time benefits (Rajlich, 2014). Often, software evolution occurs in a software system life cycle at a stage where it is in active operation due to new requirements. Software evolution mainly depends on the type of software being maintained and cooperated development processes, which continue the software system lifecycle. This is highly coupled with the components that are affected due to changes which allow the cost and impact of changes to be estimated (Pete, & Balasubramaniam, 2015). Alongside, user expectations increase with higher demand and hence, software systems continuously improve with advanced technical solutions. The process of creating software systems with improvements by software engineering principles and methods is called software system evolution (Sommerville, 2010) (Mens, & Demeyer, 2008). It is a continuous effort to make software systems bug-free, efficient until the end user desires are fulfilled (Chang, 2005).

The improper or outdated software artefacts and their inconsistencies result in misleading the intermediate software system development processes due to the high coupling among elements. Hence, software development and maintenance become time-consuming with many issues such as higher cost and effort. Moreover, proper artefact management is essential in integrating artefacts continuously. The changes must propagate accurately in the integrations, which are challenging to be automated. However, software artefact consistency maintenance is essential with the rapid generation of information. Well-Defined traceability management among software artefacts is required to overcome the impact of evolutions. Further, improper traceability management may lead to product failures. Thus, traceability management strengthens the software maintainability and helps for system acceptance (Cleland-Huang et al., 2012).

Key Terms in this Chapter

DevOps: Development-operations.

IDE: Integrated development environment.

Industry-Level: Commercial software development companies.

IR: Information retrieval.

Change Set: A set of artefacts that are affected due to artefact additions, modifications, or deletions.

SDLC: Software development life cycle.

CIA: Change impact analysis.

Ontology: A collection of pre-defined words and their synonyms.

CICD: A practice of continuous integration continuous delivery pipeline in a DevOps environment.

Complete Chapter List

Search this Book: