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).