Unit-5

Computer-aided software engineering (CASE):

Computer-aided software engineering (CASE) is the implementation of computer-facilitated

tools and methods in software development. CASE is used to ensure high-quality and defect-free
software. CASE ensures a check-pointed and disciplined approach and helps designers,
developers, testers, managers, and others to see the project milestones during development.

CASE Tools:

The essential idea of CASE tools is that in-built programs can help to analyze developing
systems in order to enhance quality and provide better outcomes. Throughout the 1990, CASE
tool became part of the software lexicon, and big companies like IBM were using these kinds of
tools to help create software.

Various tools are incorporated in CASE and are called CASE tools, which are used to support
different stages and milestones in a software development life cycle.

Categories of CASE Tools:

Sometimes CASE tools are classified in to following categories due to their activities:

 UPPER CASE Tools: They support the analysis and the design phase. They include
tools for analysis modeling, reports and forms generation.
 LOWER CASE Tools: They support the coding phase, configuration management,
etc.
 INTEGRATED CASE Tools: It is known as I-CASE and also supports analysis,
design and coding phases.

Types of CASE Tools:

 Diagram tools : These tools are used to represent system components, data and
control flow among various software components and system structure in a graphical
form. For example, Flow Chart Maker tool for creating state-of-the-art flowcharts.
 Process Modeling Tools : Process modeling is method to create software process
model, which is used to develop the software. Process modeling tools help the
managers to choose a process model or modify it as per the requirement of software
product. For example, EPF Composer
 Project Management Tools : These tools are used for project planning, cost and
effort estimation, project scheduling and resource planning. Managers have to strictly
comply project execution with every mentioned step in software project management.
Project management tools help in storing and sharing project information in real-time
throughout the organization. For example, Creative Pro Office, Trac Project,
Basecamp.
 Documentation Tools : Documentation in a software project starts prior to the
software process, goes throughout all phases of SDLC and after the completion of the
project. Documentation tools generate documents for technical users and end users.
Technical users are mostly in-house professionals of the development team who refer
 to system manual, reference manual, training manual, installation manuals etc. The end
user documents describe the functioning and how-to of the system such as user
manual. For example, Doxygen, DrExplain, Adobe RoboHelp for documentation.
 Analysis Tools : These tools help to gather requirements, automatically check for any
inconsistency, inaccuracy in the diagrams, data redundancies or erroneous omissions.
For example, Accept 360, Accompa, CaseComplete for requirement analysis, Visible
Analyst for total analysis.
 Design Tools : These tools help software designers to design the block structure of the
software, which may further be broken down in smaller modules using refinement
techniques. These tools provides detailing of each module and interconnections among
modules. For example, Animated Software Design
 Configuration Management Tools : An instance of software is released under one
version. Configuration Management tools deal with –
o Version and revision management
o Baseline configuration management
o Change control management
CASE tools help in this by automatic tracking, version management and release
management. For example, Fossil, Git, Accu REV.
 Change Control Tools : These tools are considered as a part of configuration
management tools. They deal with changes made to the software after its baseline is
fixed or when the software is first released. CASE tools automate change tracking, file
management, code management and more. It also helps in enforcing change policy of
the organization.
 Programming Tools : These tools consist of programming environments like IDE
(Integrated Development Environment), in-built modules library and simulation tools.
These tools provide comprehensive aid in building software product and include
features for simulation and testing. For example, Cscope to search code in C, Eclipse.
 Prototyping Tools : Software prototype is simulated version of the intended software
product. Prototype provides initial look and feel of the product and simulates few
aspect of actual product. Prototyping CASE tools essentially come with graphical
libraries. They can create hardware independent user interfaces and design. These tools
help us to build rapid prototypes based on existing information. In addition, they
provide simulation of software prototype. For example, Serena prototype composer,
Mockup Builder.
 Web Development Tools : These tools assist in designing web pages with all allied
elements like forms, text, script, graphic and so on. Web tools also provide live
preview of what is being developed and how will it look after completion. For
example, Fontello, Adobe Edge Inspect, Foundation 3, Brackets.
 Quality Assurance Tools : Quality assurance in a software organization is monitoring
the engineering process and methods adopted to develop the software product in order
to ensure conformance of quality as per organization standards. QA tools consist of
configuration and change control tools and software testing tools. For example,
SoapTest, AppsWatch, JMeter.
 Maintenance Tools : Software maintenance includes modifications in the software
product after it is delivered. Automatic logging and error reporting techniques,
automatic error ticket generation and root cause Analysis are few CASE tools, which
 help software organization in maintenance phase of SDLC. For example, Bugzilla for
defect tracking, HP Quality Center.

Scope of Case Tools:

The scope of CASE tools goes throughout the SDLC.

Uses CASE tools:

Here are the ways where the CASE tools are used:

 To facilitate single design methodology: CASE tools help the organization to

standardize the development process. It also facilitates coordinated development.
Integration becomes easy as common methodology is adopted.
 Rapid Application Development: To improve the speed and quality of system
development organizations use CASE tools.
 Testing: CASE tools help in improving the testing process through automated checking
and simplified program maintenance.
 Documentation: In a traditional software development process, the quality of
documentation at various stages depends on the individual. At various stages of SDLC
CASE tools improve the quality and uniformity of documentation. It also ensures the
completeness of the documentation.
 Project Management: It improves project management activity and to some extent
automates various activities involved in project management.
 Reduce the maintenance cost: Use of CASE tools makes the software easy to maintain
and hence reduce the maintenance costs.
 Increase Productivity: Automation of various activities of system development and
management processes increases productivity of the development team.

Role of CASE tools:

CASE tools play a major role in the following activities:

 Project management
 Data dictionary
 Code generation
 User interface design
 Schema generation
 Creation of meta-data for data warehouse
 Reverse engineering
 Re-engineering
 Document generation
 Version control
 OO analysis and design
 Software testing
 Data modeling
 Project scheduling
 Cost estimation
Need of CASE tools:

Basically, the CASE tools are used to

 Reduce the cost as they automate many repetitive manual tasks.

 Reduce development time of the project as they support standardization and avoid
 repetition and reuse.
 Develop better quality complex projects as they provide greater consistency and
 coordination.
 Create good quality documentation.
 Create systems that are maintainable because of proper control of configuration item that
 support traceability requirements.

Characteristics of a successful CASE Tool:

A CASE tool must have the following characteristics in order to be used efficiently:

 A standard methodology: A CASE tool must support a standard software development

methodology and standard modeling techniques. In the present scenario most of the
CASE tools are moving towards UML.
 Flexibility: Flexibility in use of editors and other tools. The CASE tool must offer
flexibility and the choice for the user of editors' development environments.
 Strong Integration: The CASE tools should be integrated to support all the stages. This
implies that if a change is made at any stage, for example, in the model, it should get
reflected in the code documentation and all related design and other documents, thus
providing a cohesive environment for software development.
 Integration with testing software: The CASE tools must provide interfaces for
automatic testing tools that take care of regression and other kinds of testing software
under the changing requirements.
 Support for reverse engineering: A CASE tools must be able to generate complex
models from already generated code.
 On-line help: The CASE tools provide an online tutorial.

Advantages of the CASE approach:

 As the special emphasis is placed on the redesign as well as testing, the servicing cost
of a product over its expected lifetime is considerably reduced.
 The overall quality of the product is improved as an organized approach is undertaken
during the process of development.
 Chances to meet real-world requirements are more likely and easier with a computer-
aided software engineering approach.
 CASE indirectly provides an organization with a competitive advantage by helping
ensure the development of high-quality products.
 It provides better documentation.
 It improves accuracy.
 It provides intangible benefits.
 It reduces lifetime maintenance.
  It is an opportunity to non-programmers.
Disadvantages of the CASE approach:
 Cost: Using a case tool is very costly. Most firms engaged in software development on
a small scale do not invest in CASE tools because they think that the benefit of CASE
is justifiable only in the development of large systems.
 Learning Curve: In most cases, programmers’ productivity may fall in the initial
phase of implementation, because users need time to learn the technology. Many
consultants offer training and on-site services that can be important to accelerate the
learning curve and to the development and use of the CASE tools.
 Tool Mix: It is important to build an appropriate selection tool mix to urge cost
advantage CASE integration and data integration across all platforms is extremely
important.

Software Maintenance:

It refers to the process of modifying and updating a software system after it has been delivered to
the customer. This can include fixing bugs, adding new features, improving performance, or
updating the software to work with new hardware or software systems. The goal of software
maintenance is to keep the software system working correctly, efficiently, and securely, and to
ensure that it continues to meet the needs of the users.

Software maintenance is a continuous process that occurs throughout the entire life cycle of the
software system. It is important to have a well-defined maintenance process in place, which
includes testing and validation, version control, and communication with stakeholders.

Several Key Aspects of Software Maintenance:

 Bug Fixing: The process of finding and fixing errors and problems in the software.
 Enhancements: The process of adding new features or improving existing features to
meet the evolving needs of the users.
 Performance Optimization: The process of improving the speed, efficiency, and
reliability of the software.
 Porting and Migration: The process of adapting the software to run on new hardware or
software platforms.
 Re-Engineering: The process of improving the design and architecture of the software to
make it more maintainable and scalable.
 Documentation: The process of creating, updating, and maintaining the documentation
for the software, including user manuals, technical specifications, and design documents.

Types of Software Maintenance:

 Perfective Maintenance: This involves improving functionality, performance, and

reliability, and restructuring the software system to improve changeability.
 Corrective Maintenance: This involves fixing errors and bugs in the software system.
 Preventive Maintenance: This involves taking measures to prevent future problems,
such as optimization, updating documentation, reviewing and testing the system, and
implementing preventive measures such as backups.
  Adaptive Maintenance: This involves modifying the software system to adapt it to
changes in the environment, such as changes in hardware or software, government
policies, and business rules.
 Patching: It is an emergency fix implemented mainly due to pressure from management.
Patching is done for corrective maintenance but it gives rise to unforeseen future errors
due to lack of proper impact analysis.

Need for Maintenance:

Software Maintenance must be performed in order to:

 Correct faults.
 Improve the design.
 Implement enhancements.
 Interface with other systems.
 Accommodate programs so that different hardware, software, system features, and
telecommunications facilities can be used.
 Migrate legacy software.
 Retire software.
 Requirement of user changes.
 Run the code fast

Challenges in Software Maintenance:

The various challenges in software maintenance are given below:

 The popular age of any software program is taken into consideration up to ten to fifteen
years. As software program renovation is open-ended and might maintain for decades
making it very expensive.
 Older software programs, which had been intended to paint on sluggish machines with
much less reminiscence and garage ability can not maintain themselves tough in
opposition to newly coming more advantageous software programs on contemporary-day
hardware.
Changes are frequently left undocumented which can also additionally reason greater
conflicts in the future.
 As the era advances, it turns into high prices to preserve vintage software programs.
 Often adjustments made can without problems harm the authentic shape of the software
program, making it difficult for any next adjustments.
 There is a lack of Code Comments.
 Lack of documentation: Poorly documented systems can make it difficult to understand
how the system works, making it difficult to identify and fix problems.
 Legacy code: Maintaining older systems with outdated technologies can be difficult, as it
may require specialized knowledge and skills.
 Complexity: Large and complex systems can be difficult to understand and modify,
making it difficult to identify and fix problems.
 Changing requirements: As user requirements change over time, the software system
may need to be modified to meet these new requirements, which can be difficult and
time-consuming.
  Interoperability issues: Systems that need to work with other systems or software can be
difficult to maintain, as changes to one system can affect the other systems.
 Lack of test coverage: Systems that have not been thoroughly tested can be difficult to
maintain as it can be hard to identify and fix problems without knowing how the system
behaves in different scenarios.
 Lack of personnel: A lack of personnel with the necessary skills and knowledge to
maintain the system can make it difficult to keep the system up-to-date and running
smoothly.
 High-Cost: The cost of maintenance can be high, especially for large and complex
systems, which can be difficult to budget for and manage.

Advantages of Software Maintenance:

 Improved Software Quality: Regular software maintenance helps to ensure that the
software is functioning correctly and efficiently and that it continues to meet the needs of
the users.
 Enhanced Security: Maintenance can include security updates and patches, helping to
ensure that the software is protected against potential threats and attacks.
 Increased User Satisfaction: Regular software maintenance helps to keep the software
up-to-date and relevant, leading to increased user satisfaction and adoption.
 Extended Software Life: Proper software maintenance can extend the life of the
software, allowing it to be used for longer periods of time and reducing the need for
costly replacements.
 Cost Savings: Regular software maintenance can help to prevent larger, more expensive
problems from occurring, reducing the overall cost of software ownership.
 Better Alignment with business goals: Regular software maintenance can help to
ensure that the software remains aligned with the changing needs of the business. This
can help to improve overall business efficiency and productivity.
 Competitive Advantage: Regular software maintenance can help to keep the software
ahead of the competition by improving functionality, performance, and user experience.
 Compliance with Regulations: Software maintenance can help to ensure that the
software complies with relevant regulations and standards. This is particularly important
in industries such as healthcare, finance, and government, where compliance is critical.
 Improved Collaboration: Regular software maintenance can help to improve
collaboration between different teams, such as developers, testers, and users. This can
lead to better communication and more effective problem-solving.
 Reduced Downtime: Software maintenance can help to reduce downtime caused by
system failures or errors. This can have a positive impact on business operations and
reduce the risk of lost revenue or customers.
 Improved Scalability: Regular software maintenance can help to ensure that the
software is scalable and can handle increased user demand. This can be particularly
important for growing businesses or for software that is used by a large number of users.

Disadvantages of Software Maintenance:

 Cost: Software maintenance can be time-consuming and expensive, and may require
significant resources and expertise.
  Schedule disruptions: Maintenance can cause disruptions to the normal schedule and
operations of the software, leading to potential downtime and inconvenience.
 Complexity: Maintaining and updating complex software systems can be challenging,
requiring specialized knowledge and expertise.
 Risk of introducing new bugs: The process of fixing bugs or adding new features can
introduce new bugs or problems, making it important to thoroughly test the software after
maintenance.
 User resistance: Users may resist changes or updates to the software, leading to
decreased satisfaction and adoption.
 Compatibility issues: Maintenance can sometimes cause compatibility issues with other
software or hardware, leading to potential integration problems.
 Lack of documentation: Poor documentation or lack of documentation can make
software maintenance more difficult and time-consuming, leading to potential errors or
delays.
 Technical debt: Over time, software maintenance can lead to technical debt, where the
cost of maintaining and updating the software becomes increasingly higher than the cost
of developing a new system.
 Skill gaps: Maintaining software systems may require specialized skills or expertise that
may not be available within the organization, leading to potential outsourcing or
increased costs.
 Inadequate testing: Inadequate testing or incomplete testing after maintenance can lead
to errors, bugs, and potential security vulnerabilities.
 End-of-life: Eventually, software systems may reach their end-of-life, making
maintenance and updates no longer feasible or cost-effective. This can lead to the need
for a complete system replacement, which can be costly and time-consuming.

Cost of Maintenance:

The cost of maintenance is high. A study on estimating software maintenance found that the cost
of maintenance is as high as 67% of the cost of entire software process cycle.
On an average, the cost of software maintenance is more than 50% of all SDLC phases. There
are various factors, which trigger maintenance cost go high, such as:

Real-world factors affecting Maintenance Cost:

 The standard age of any software is considered up to 10 to 15 years.

 Older softwares, which were meant to work on slow machines with less memory and
storage capacity cannot keep themselves challenging against newly coming enhanced
softwares on modern hardware.
 As technology advances, it becomes costly to maintain old software.
 Most maintenance engineers are newbie and use trial and error method to rectify
problem.
 Often, changes made can easily hurt the original structure of the software, making it hard
for any subsequent changes.
 Changes are often left undocumented which may cause more conflicts in future.

Software-end factors affecting Maintenance Cost:

 Structure of Software Program

 Programming Language
 Dependence on external environment
 Staff reliability and availability

Maintenance Activities:

IEEE provides a framework for sequential maintenance process activities. It can be used in
iterative manner and can be extended so that customized items and processes can be included.
These activities go hand-in-hand with each of the following phase:

 Identification & Tracing - It involves activities pertaining to identification of

requirement of modification or maintenance. It is generated by user or system may itself
report via logs or error messages. Here, the maintenance type is classified also.
 Analysis - The modification is analyzed for its impact on the system including safety and
security implications. If probable impact is severe, alternative solution is looked for. A
set of required modifications is then materialized into requirement specifications. The
cost of modification/maintenance is analyzed and estimation is concluded.
 Design - New modules, which need to be replaced or modified, are designed against
requirement specifications set in the previous stage. Test cases are created for validation
and verification.
 Implementation - The new modules are coded with the help of structured design created
in the design step. Every programmer is expected to do unit testing in parallel.
 System Testing - Integration testing is done among newly created modules. Integration
testing is also carried out between new modules and the system. Finally the system is
tested as a whole, following regressive testing procedures.
 Acceptance Testing - After testing the system internally, it is tested for acceptance with
the help of users. If at this state, user complaints some issues they are addressed or noted
to address in next iteration.
 Delivery - After acceptance test, the system is deployed all over the organization either
by small update package or fresh installation of the system. The final testing takes place
at client end after the software is delivered. Training facility is provided if required, in
addition to the hard copy of user manual.
 Maintenance management - Configuration management is an essential part of system
maintenance. It is aided with version control tools to control versions, semi-version or
patch management.

Software Re-engineering:
When we need to update the software to keep it to the current market, without impacting its
functionality, it is called software re-engineering. It is a thorough process where the design of
software is changed and programs are re-written.

Legacy software cannot keep tuning with the latest technology available in the market. As the
hardware become obsolete, updating of software becomes a headache. Even if software grows
old with time, its functionality does not.

For example, initially Unix was developed in assembly language. When language C came into
existence, Unix was re-engineered in C, because working in assembly language was difficult.

Other than this, sometimes programmers notice that few parts of software need more
maintenance than others and they also need re-engineering.
Re-Engineering Process:

 Decide what to re-engineer. Is it whole software or a part of it?

 Perform Reverse Engineering, in order to obtain specifications of existing software.
 Restructure Program if required. For example, changing function-oriented programs
into object-oriented programs.
 Re-structure data as required.
 Apply Forward engineering concepts in order to get re-engineered software.

Reverse Engineering:
Software Reverse Engineering is a process of recovering the design, requirement specifications,
and functions of a product from an analysis of its code. It builds a program database and
generates information from this. The purpose of reverse engineering is to facilitate the
maintenance work by improving the understandability of a system and producing the necessary
documents for a legacy system. Reverse engineering can extract design information from source
code, but the abstraction level, the completeness of the documentation, the degree to which tools
and a human analyst work together, and the directionality of the process are highly variable.

Steps of Software Reverse Engineering:

1. Collection Information: This step focuses on collecting all possible information (i.e.,
source design documents, etc.) about the software.
2. Examining the information: The information collected in step-1 is studied so as to get
familiar with the system.

3. Extracting the structure: This step concerns identifying program structure in the form
of a structure chart where each node corresponds to some routine.

4. Recording the functionality: During this step processing details of each module of the
structure, charts are recorded using structured language like decision table, etc.

5. Recording data flow: From the information extracted in step-3 and step-4, a set of data
flow diagrams is derived to show the flow of data among the processes.

6. Recording control flow: The high-level control structure of the software is recorded.

7. Review extracted design: The design document extracted is reviewed several times to
ensure consistency and correctness. It also ensures that the design represents the
program.

8. Generate documentation: Finally, in this step, the complete documentation including

SRS, design document, history, overview, etc. is recorded for future use.
Reverse Engineering Tools:
Reverse engineering if done manually would consume a lot of time and human labor and
hence must be supported by automated tools. Some of the tools are given below:
 CIAO and CIA: A graphical navigator for software and web repositories and a
collection of Reverse Engineering tools.
 Rigi: A visual software understanding tool.
 Bunch: A software clustering/modularization tool.
 GEN++: An application generator to support the development of analysis tools for the
C++ language.
 PBS: Software Bookshelf tools for extracting and visualizing the architecture of
programs.
Program Restructuring:

It is a process to re-structure and re-construct the existing software. It is all about re-arranging
the source code, either in same programming language or from one programming language to a
different one. Restructuring can have either source code-restructuring and data-restructuring or
both.

Re-structuring does not impact the functionality of the software but enhance reliability and
maintainability. Program components, which cause errors very frequently can be changed, or
updated with re-structuring. The dependability of software on obsolete hardware platform can be
removed via re-structuring.

Forward Engineering:
Forward engineering is a process of obtaining desired software from the specifications in hand
which were brought down by means of reverse engineering. It assumes that there was some
software engineering already done in the past.

Forward engineering is same as software engineering process with only one difference – it is
carried out always after reverse engineering.

Component reusability:

A component is a part of software program code, which executes an independent task in the
system. It can be a small module or sub-system itself.

Example:

The login procedures used on the web can be considered as components, printing system in
software can be seen as a component of the software.

Re-use can be done at various levels:

 Application level - Where an entire application is used as sub-system of new software.

 Component level - Where sub-system of an application is used.
 Modules level - Where functional modules are re-used.

Software components provide interfaces, which can be used to establish communication among
different components.

Software Configuration Management(SCM):

SCM is a process to systematically manage, organize, and control the changes in the documents,
codes, and other entities during the Software Development Life Cycle. The primary goal is to
increase productivity with minimal mistakes. SCM is part of cross-disciplinary field of
configuration management and it can accurately determine who made which revision.

Software Configuration Management Activities :

1.Identification – (tracking multiple versions to enable efficient changes) Risk identification
involves brainstorming activities. it also involves preparation of risk list. Brainstorming is a
group discussion technique where all the stakeholders meet together. this technique produces
new ideas and promote creative thinking. Identifying the configuration items from products that
compose baselines at given points in time (a baseline is a set of mutually consistent
Configuration Items, which has been formally reviewed and agreed upon, and serves as the basis
of further development).
2.Version control – (control changes before and after release to customer). Combines
procedures and tools to manage the different versions of configuration objects created during the
software process.A variant is a different set of objects at the same revision level and coexists
with other variants Software version control (SVC), also called revision control, source control
management, and versioning control, is a management strategy to track and store changes to a
software development document or set of files that follow the development project from
beginning to end-of-life.
3.Change control – (authority to approve and prioritize changes) Change management is the
discipline that guides how we Prepare ,Equip, Support individuals to successfully adopt change.
In order to drive organizational success and outcomes. A change request (CR) is submitted and
evaluated to assess technical merit, potential side effects, overall impact on other configuration
objects and system functions, and the projected cost of the change.
4.Configuration auditing – (ensure changes made properly) A software configuration audit
complements the formal technical review of the process and product. It focuses on the technical
correctness of the configuration object that has been modified.
5.Reporting – (tell others about changes made) Providing accurate status and current
configuration data to developers, tester, end users, customers and stakeholders through admin
guides, user guides, FAQs, Release notes, Memos, Installation Guide, Configuration guide etc.

Software Version Control:

A version control system is a software that tracks changes to a file or set of files over time so
that you can recall specific versions later. It also allows you to work together with other
programmers.

The version control system is a collection of software tools that help a team to manage
changes in a source code. It uses a special kind of database to keep track of every
modification to the code.

Benefits of the Version Control System:

The Version Control System is very helpful and beneficial in software development;
developing software without using version control is unsafe. It provides backups for
uncertainty. Version control systems offer a speedy interface to developers. It also allows
software teams to preserve efficiency and agility according to the team scales to include more
developers. Some key benefits of having a version control system are as follows:

 Complete change history of the file

 Simultaneously working
 Branching and merging
 Traceability

Types of Version Control System:

 Localized version Control System

 Centralized version control systems
 Distributed version control systems
Localized Version Control Systems: The localized version control method is a common
approach because of its simplicity. But this approach leads to a higher chance of error. In this
approach, you may forget which directory you're in and accidentally write to the wrong file or
copy over files you don't want to. To deal with this issue, programmers developed local VCSs
that had a simple database. Such databases kept all the changes to files under revision control.
A local version control system keeps local copies of the files.

The major drawback of Local VCS is that it has a single point of failure.

Centralized Version Control System:

The developers needed to collaborate with other developers on other systems. The localized
version control system failed in this case. To deal with this problem, Centralized Version
Control Systems were developed. These systems have a single server that contains the
versioned files, and some clients to check out files from a central place.

Distributed Version Control System:

Centralized Version Control System uses a central server to store all the database and team
collaboration. But due to single point failure, which means the failure of the central server,
developers do not prefer it. Next, the Distributed Version Control System is developed.

In a Distributed Version Control System (such as Git, Mercurial, Bazaar or Darcs), the user
has a local copy of a repository. So, the clients don't just check out the latest snapshot of the
files even they can fully mirror the repository. The local repository contains all the files and
metadata present in the main repository.

DVCS allows automatic management branching and merging. It speeds up of most operations
except pushing and pulling. DVCS enhances the ability to work offline and does not rely on a
single location for backups. If any server stops and other systems were collaborating via it,
then any of the client repositories could be restored by that server. Every checkout is a full
backup of all the data.

These systems do not necessarily depend on a central server to store all the versions of a
project file.