[go: up one dir, main page]
Scribd
Upload
79 views2 pages

Maintainability: Operability: Making Life Easy For Operations

The document discusses three principles for designing maintainable software systems: operability, simplicity, and evolvability. Operability focuses on making it easy for operations teams to keep systems running smoothly through good monitoring, automation, and predictable behavior. Simplicity aims to reduce complexity through loose coupling, consistent naming, and removing unnecessary complexity. Evolvability is about designing systems that can easily be changed and adapted to new requirements over time. Maintaining software is often more costly than initial development, so these principles can help minimize costs by making software easier to maintain.

Uploaded by

Reena Verma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
79 views2 pages

Maintainability: Operability: Making Life Easy For Operations

The document discusses three principles for designing maintainable software systems: operability, simplicity, and evolvability. Operability focuses on making it easy for operations teams to keep systems running smoothly through good monitoring, automation, and predictable behavior. Simplicity aims to reduce complexity through loose coupling, consistent naming, and removing unnecessary complexity. Evolvability is about designing systems that can easily be changed and adapted to new requirements over time. Maintaining software is often more costly than initial development, so these principles can help minimize costs by making software easier to maintain.

Uploaded by

Reena Verma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 2

Maintainability

The majority of the cost of software is not in its initial development, but in its ongoing maintenance:

 Fixing bugs
 Keeping systems operational
 Investigating failures
 Adapting it to new platforms
 Modifying it for new use cases
 Repaying technical debt
 Adding new features

Unfortunately, many people working on software systems dislike maintenance of so-called legacy


systems, which perhaps involves fixing other people's mistakes, or working with platforms that are
now outdated, or systems that were forced to do things they were never intended for. Every legacy
system is unpleasant in its own way, and so it is difficult to give general recommendations for
dealing with them.
However, we can and should design software that will hopefully minimize pain during maintenance,
and thus avoid creating legacy software ourselves. To this end, we will pay particular attention to
three design principles for software systems:

 Operability. Make it easy for operations teams to keep the system running smoothly.
 Simplicity. Make it easy for new engineers to understand the system, by removing as much
complexity as possible from the system. (Note this is not the same as simplicity of the user
interface.)
 Evolvability. Make it easy for engineers in future to make changes to the system, adapting it
for unanticipated use cases as requirements change. Also known
as extensibility, modifiability or plasticity.

Operability: making life easy for operations


It has been suggested that:

Good operations can often work around the limitations of bad (or incomplete)
software, but good software cannot run reliably with bad operations.
While some aspects of operations can and should be automated, it is still up to humans to set up that
automation in the first place, and to make sure it's working correctly.
Operations teams are vital to keeping a software system running smoothly. A good operations team
typically does the following:

 Monitoring the health of the system, and quickly restoring service if it goes into a bad state;
 Tracking down the cause of problems, such as system failures or degraded performance;
 Keeping software and platforms up-to-date, including security patches;
 Keeping tabs on how different systems affect each other, so that a problematic change can be
avoided before it causes damage;
 Anticipating future problems and solving them before they occur, e.g. capacity planning;
 Establishing good practices and tools for deployment, configuration managementand more;
 Performing complex maintenance tasks, such as moving an application from one platform to
another;
 Maintaining security of the system as configuration changes are made;
 Defining processes that make operations predictable and help keep the production
environment stable;
 Preserving the organization's knowledge about the system, even as individual people come
and go;

Good operability means making routine tasks easy, allowing the operations team to focus their effort
on high-value activities. Data systems can do various things to make routine tasks easy, including:

 Provide visibility into the runtime behavior and internals of the system, with good
monitoring;
 Good support for automation and integration with standard tools;
 Avoid dependency on individual machines (allowing machines to be taken down for
maintenance while the system as a whole continues running uninterrupted);
 Good documentation and an easy-to-understand operational model ("if I do X, Y will
happen");
 Good default behavior, but also giving administrators the freedom to override defaults when
needed;
 Self-healing where appropriate, but also giving administrators manual control over the
system state when needed;
 Predictable behavior, minimizing surprises.

Simplicity: Managing Complexity


Small software projects can have delightfully simple and expressive code, but as projects get larger,
they often become very complex and difficult to understand. This complexity slows down everyone
who needs to work on the system, which further increases the cost of maintenance. A software
project mired in complexity is sometimes described as a big ball of mud.
There are various possible symptoms of complexity:

 Explosion of the state space


 Tight coupling of modules
 Tangled dependencies
 Inconsistent naming and terminology
 Hacks aimed at solving performance problems
 Special-casing to work around issues elsewhere

You might also like