FEDERAL UNIVERSITY OF TECHNOLOGY AKURE

SCHOOL OF COMPUTING
DEPARTMENT OF INFORMATION TECHNOLOGY

SOFTWARE ISSUES: RISKS AND LIABILITIES

PREPARED BY:
GROUP 5

SUBMITTED TO
PROF. (MRS.) O. K. BOYINBODE

AUGUST 2023

1
 GROUP MEMBERS

NAMES MATRIC NO
1. ETENG FIDELIS PROMISE IFT/16/0102
2. ADEBAYO RASHEED BABATUNDE IFT/17/2388
3. ADISA DAMILARE SAMUEL IFT/17/2404
4. AKINWOLE PELUMI EMMANUEL IFT/17/2415
5. DADA MUSA OLAMILEKAN IFT/17/2428
6. FAROTIMI ISRAEL AYPMIDE IFT/17/2438
7. OKE TOSIN EMMANUEL IFT/17/2453
8. OLUKAYODE OLUWASANMI SAMUEL IFT/17/2463
9. ADEWUNMI OLUWATOBI SAMUEL IFT/18/8615

2
 INTRODUCTION
Software is an integral part of modern life, powering everything from communication platforms
to critical infrastructure. In an era characterized by rapid technological advancement and digital
transformation, software has become the backbone of modern civilization. From managing
complex financial systems to facilitating seamless communication across continents, software
permeates every aspect of our lives. However, software is not immune to issues that can have far
reaching consequences.

Navigating the Digital Landscape

The increasing number of software ushered in a new era of unparalleled comfort and efficiency.
With a few taps and clicks, individuals can access information, connect with friends and
colleagues, and manage intricate tasks that would have been unfathomable just a few decades
ago. Businesses leverage software to streamline operations, enhance customer experiences, and
innovate in ways that redefine entire industries.

However, the digital landscape is not without its challenges. As software systems grow in
complexity and interconnectivity, the potential for issues to arise also increases. These issues
manifest in various forms, ranging from minor glitches that inconvenience users to catastrophic
failures with far-reaching consequences. The consequences of software problems transcend
beyond the realm of technology, affecting organizations, economies, and even individuals'
personal lives.

The Imperfect Nature of Software

Software, despite its remarkable capabilities, is inherently imperfect. Code, the building block of
software, is written and maintained by humans – flawed beings prone to oversight, misjudgment,
and errors. Even the most meticulous development processes cannot entirely eliminate the
possibility of software issues emerging during the lifecycle of a program. These issues may
result from coding errors, compatibility conflicts, security vulnerabilities, or unexpected
interactions between different components of a software system.

3
Understanding the Scope

The scope of software issues is broad and diverse. From bugs that disrupt user experiences to
security vulnerabilities that expose sensitive data, software issues can compromise the very
foundations of reliability and trust. As software continues to evolve and integrate into every
aspect of daily life, the risks associated with software issues also evolve, presenting new
challenges that demand careful consideration.

DEFINITIONS

Software is a set of computer programs made up of a sequence of short commands called

instructions that tell the computer what to do. Normally software is in two forms

i. built into the computer’s more permanent memory, called ROM (read-only memory)
ii. loaded on demand at runtime in less permanent but more volatile memory called RAM
(random access memory).

It encompasses the intangible components that drive hardware and provide functionality, such as
applications, operating systems, utilities, and programming languages. Software can range from
simple applications like word processors to complex systems like databases, video games, and
artificial intelligence algorithms.

A software producer, or developer, creates or develops a set of programs to meet the

specifications of a user, if there is a contract, or of a specific problem if it is a general software.

They are individuals or a team of professionals who design, create, and maintain software
applications or systems. Developers are responsible for the entire software development
lifecycle, which includes planning, coding, testing, debugging, and deploying software. They use
programming languages, frameworks, and tools to write code that instructs computers on how to
perform specific tasks. Software developers play a pivotal role in shaping the digital landscape
by translating ideas and requirements into functional and user-friendly software solutions.

Software buyers, or customers, obtain the finished software from the developer to satisfy a need,
basing their decision on developer claims.

They refer to individuals, businesses, or organizations that acquire and use software for various
purposes. These individuals or entities may obtain software through purchase, licensing, or

4
subscription agreements. Software buyers have diverse needs and expectations, ranging from
personal use applications to enterprise-level solutions that enhance productivity, improve
efficiency, or address specific challenges. As consumers of software, they interact with user
interfaces, utilize features, and rely on software to achieve their goals.

Standards

Standards in software development refer to established guidelines, principles, and criteria that
govern various aspects of the software development process. They provide a framework for
consistency, interoperability, and quality throughout the lifecycle of a software product.

Software developers must convey to buyers’ satisfaction that their products are of high quality.
The buyer, however, has little leverage in disputing the claims of the developer in these areas
because there is no single universally acceptable and agreed upon measure of software standards.
But there are universal basic standards that a software product must meet. Such standards include
the mutually agreed upon criteria and expectations of the buyer.

1. Development Testing: Development testing involves testing software during its

development phase to identify defects early. Testing tries to assure that the program satisfies
its specifications, and it detects and prevents design and implementation faults. Types of
development testing include unit testing, integration testing, and component testing. The goal
is to catch and fix issues before they propagate to higher levels of testing.
2. Verification and Validation: The process of verification and validation (V&V) involves
static formal mathematical techniques such as proof of correctness and dynamic techniques
such as testing to show consistency between the code and the basic initial specifications.
Verification ensures that software meets specified requirements and adheres to design and
coding standards. Validation ensures that the software meets user needs and expectations and
functions as intended in its intended environment. Verification involves reviews, inspections,
and walkthroughs, while validation includes testing against user requirements. Both
processes are essential for ensuring software quality and reliability.

5
Reliability

A software product can fail to deliver expected results because of an unexpected input sequence.
Reliability of software can, therefore, be defined in relation to these input sequences.

Reliability refers to the ability of software to perform its intended functions without failure over
a specified period. Reliable software is consistent, predictable, and free from critical defects that
could cause crashes or data corruption. Achieving reliability involves rigorous testing, error
handling, and fault tolerance mechanisms. Reliability is crucial for mission-critical systems and
applications where downtime or failure could have serious consequences.

Security

Software is an integral part of a computer system, and the security of such a system depends on
its hardware but even more so on the software component. There are more security attacks on
systems through software “holes” than hardware, mainly through piracy, deletion, and alteration
of programs and data. A computer system software is secure if it protects its programs and data
—in other words, if it does not contain trapdoors through which unauthorized intruders can
access the system.

A computer system software can be protected from undetected modification through strong and
sound design principles, enforcement of proper encapsulation, separation of all privileges, and
ethical education of system developers and users about security issues.

Security focuses on protecting software and its data from unauthorized access, attacks, and
vulnerabilities. Threats include hacking, data breaches, malware, and social engineering.

Security measures include

i. encryption
ii. authentication
iii. authorization
iv. intrusion
v. detection
vi. regular security audits.

Software security is vital to safeguard sensitive information and maintain user trust.

6
Safety

Recent advances in computer technology have resulted in wider computer applications in

previously unthinkable areas such as space exploration, missile and aircraft guidance systems,
and life-sustaining systems. In these areas, the safety of software has become one of the most
prominent components of the whole security system. Such a system cannot afford an accident or
an error because of software failure without dire consequences to human life, property, and the
environment.

Safety concerns the prevention of harm to users, operators, and the environment due to software
failures.

The function of software safety in system safety is that software executes within a prescribed
context so as not to contribute to hazards or risk either by outputting faulty values and timing or
by failing to detect and respond to hardware failures that may cause a system to go into a
hazardous state.

Software safety involves hazard analysis, risk assessment, and designing for fail-safe or fail-soft
behavior. Ensuring safety requires compliance with relevant safety standards and regulations.

In the final analysis, good and safe software depends on good programming practice, which
includes control techniques, application of various types of safety analysis during the
development cycle, and evaluation of the effectiveness of these techniques. Whether these
techniques are enough depends on the chosen and acceptable risk level, which tends to vary with
the application environments

Quality

The emergence of a global software market, the establishment of powerful software development
warehouses in different countries, and the improving standards of global software have all
brought software quality to the forefront of software issues. A software product has quality if it
maintains a high degree of excellence in standards, security, safety, and dependability. Many
software vendors are starting to develop and app.

Quality in software refers to the overall excellence and fitness for purpose of a software product.
It encompasses various aspects, including functionality, performance, usability, maintainability,

7
and more. Achieving high-quality software involves adhering to best practices, rigorous testing,
and continuous improvement. Quality assurance processes include code reviews, testing, and
adherence to coding and design standards.

Many software vendors are starting to develop and apply quality improvements techniques such
as total quality management (TQM). A TQM technique that tries to improve software quality
through a software development process known as the software quality function development
(SQFD) represents a movement from the traditional techniques of TQM to the software
development environment by focusing on improving the development process through upgrades
in the requirement solicitation phase

Quality of Service

For a product, and in particular, a software product, quality of service (QoS) means providing
consistent, predictable service delivery that will satisfy customer application requirements. The
product must have some level of assurance that the customer’s service requirements can be
satisfied.

Quality of Service (QoS) in software refers to the level of performance, reliability, and user
satisfaction delivered by a software product or service. It encompasses various attributes and
measures that ensure the software meets or exceeds user expectations.

8
 CAUSES OF SOFTWARE FAILURES
Software failures in the realm of social and ethical issues in computing can arise due to a variety
of reasons. Failure or poor performance of a software product can be attributed to a variety of
causes, most notably human error, the nature of software itself, and the environment in which
software is produced and used. These failures can have significant implications for individuals,
society, and organizations.

Key Causes of Failures

Here are some key causes of software failures in social and ethical issues:

1. Bias and Discrimination: Software can perpetuate bias and discrimination if it's developed
using biased data or biased algorithms. This can lead to unfair treatment of individuals or
groups, reinforcing societal inequalities.
2. Privacy Violations: Failure to adequately protect user data and privacy can result in
breaches that expose sensitive information. Inadequate data handling practices can lead to
loss of trust and potential legal consequences.
3. Surveillance and Monitoring: Software that enables surveillance or monitoring without
proper consent or oversight can infringe on individuals' rights to privacy and create a culture
of constant surveillance.
4. Algorithmic Decision-making: Relying solely on automated decision-making algorithms
can lead to situations where important decisions (e.g., hiring, lending) are made without
human intervention, potentially leading to unjust outcomes or discrimination.
5. Lack of Transparency: When software operates as a "black box," with little to no
transparency into how decisions are made, it can be difficult to hold systems accountable for
their actions and identify potential biases or errors.
6. Inadequate Testing and Quality Assurance: Rushing software development without
thorough testing and quality assurance can result in unintended consequences and
vulnerabilities that can be exploited by malicious actors.

9
7. Unintended Consequences: Software can have unintended social, economic, and cultural
consequences that were not foreseen during its development. These consequences can disrupt
established norms and create new ethical challenges.
8. Cultural and Contextual Insensitivity: Software developed without considering cultural
norms and contexts can lead to misunderstandings, offense, or even harm to certain groups.
9. Misinformation and Disinformation: Software platforms that allow the spread of
misinformation and disinformation can contribute to the erosion of public trust, the
polarization of societies, and the undermining of democratic processes.
10. Addiction and Mental Health Concerns: Software that's designed to capture user attention
and engagement might inadvertently lead to addictive behaviors or negatively impact users'
mental health.
11. Responsibility and Accountability: Attribution of responsibility and accountability for
software failures can be complex, especially when multiple parties are involved in software
development, deployment, and maintenance.
12. Regulatory and Legal Gaps: The rapid evolution of technology can outpace the
development of regulatory frameworks, creating legal gaps that allow harmful software
practices to thrive.
13. Economic Incentives: Profit-driven motivations might lead to the development and
deployment of software that prioritizes short-term gains over long-term societal well-being.

To mitigate these causes of software failures in social and ethical issues, it's crucial to prioritize
ethical considerations throughout the software development lifecycle, involve diverse
stakeholders, and adhere to ethical guidelines and principles that ensure technology benefits
society as a whole.

Human Factors

Human factors play a significant role in software failures related to social and ethical issues in
computing. These factors encompass the psychological, social, and organizational aspects of how
people interact with technology and how their decisions and actions influence software
development, deployment, and usage. Here's an explanation of the key human factors involved:

1. Bias and Unconscious Bias: Developers, data scientists, and other stakeholders involved in
software development might inadvertently introduce their own biases into the system. These

10
 biases can stem from personal beliefs, cultural backgrounds, or societal influences and can
lead to biased algorithms, discriminatory outcomes, and unfair treatment.
2. Memory Lapses and Attentional Failures: For example, someone was supposed to have
removed or added a line of code, tested, or verified but did not because of simple
forgetfulness.
3. Rush to finish: The result of pressure, most often from management, to get the product on
the market either to cut development costs or to meet a client deadline, rushing can cause
problems.
4. Overconfidence and Use of Nonstandard or Untested Algorithms: Before algorithms are
fully tested by peers, they are put into the product line because they seem to have worked on
a few test runs.
5. Malice: Software developers, like any other professionals, have malicious people in their
ranks. Bugs, viruses, and worms have been known to be embedded and downloaded in
software as is the case with Trojan horse software, which boots itself at a timed location.
6. Complacency: When either an individual or a software producer has significant experience
in software development, it is easy to overlook certain testing and other error control
measures in those parts of software that were tested previously in a similar or related product,
forgetting that no one software product can conform to all requirements in all environments.
7. Ethical Awareness and Training: The lack of awareness about ethical implications in
technology development can result in software that doesn't consider potential social or ethical
consequences. Proper training and education are essential to ensure that professionals
understand the broader societal impact of their work.
8. Decision-Making and Accountability: Human decision-making processes can lead to
ethically questionable outcomes, such as choosing profit over social responsibility or
disregarding the potential harm caused by software. Defining clear lines of responsibility and
accountability can help prevent unethical decisions.
9. Communication and Collaboration: Effective communication and collaboration among
cross-functional teams are crucial for identifying and addressing ethical concerns during
software development. Miscommunication or siloed decision-making can lead to overlooked
ethical issues.

11
10. Cognitive Biases: Cognitive biases, such as confirmation bias and groupthink, can influence
decision-making and prevent teams from critically evaluating the ethical implications of
software. These biases can lead to the perpetuation of harmful practices.
11. User-Centered Design: Failing to consider the needs, preferences, and values of end-users
can result in software that doesn't align with users' ethical expectations. User-centered design
approaches prioritize user feedback and involvement throughout the development process.
12. Lack of Diversity and Inclusion: Homogeneous development teams can overlook the
perspectives of marginalized groups, leading to software that doesn't adequately address their
needs or potentially harms them. Diverse teams are more likely to identify ethical concerns.
13. Incentives and Goals: Human behavior is often driven by incentives and goals. If
developers or organizations are incentivized solely by financial gains or speed-to-market,
ethical considerations might be sacrificed in the process.
14. Stakeholder Engagement: Engaging a wide range of stakeholders, including ethicists,
activists, and affected communities, can help identify potential issues and guide the
development of more socially responsible software.
15. Regulatory Compliance: Compliance with ethical and legal regulations can influence
software development practices. However, merely adhering to regulations without a deeper
ethical understanding might not address all potential ethical concerns.
16. Organizational Culture: The culture within an organization can shape whether ethical
considerations are prioritized or overlooked. A culture that values ethics and promotes open
dialogue is more likely to prevent and address ethical failures.
17. Transparency and Accountability: Ensuring transparency in software development and
decision-making processes can foster accountability and make it easier to identify and rectify
ethical issues.

To address human factors in software failures related to social and ethical issues, organizations
must foster a culture of ethical awareness, provide ongoing training, establish clear ethical
guidelines, and encourage diverse and inclusive collaboration. Incorporating ethical
considerations as an integral part of the development process helps mitigate the risks associated
with human factors.

Nature Of Software: Complexity

12
The nature of software complexity refers to the inherent intricacy and intricacies associated with
designing, developing, testing, and maintaining software systems. Software complexity arises
from various factors that can make understanding, managing, and predicting the behavior of
software challenging. Here are some key aspects of software complexity:

1. Complexity: Unlike hardwired programming in which it is easy to exhaust the possible

outcomes of a given set of input sequences, in software programming, a similar program may
present billions of possible outcomes on the same input sequence. Therefore, in software
programming, one can never be sure of all the possibilities on any given input sequence.
2. Difficult Testing: There will never be a complete set of test programs to check software
exhaustively for all bugs for a given input sequence.
3. Ease of Programming: The fact that software programming is easy to learn encourages
many people with little formal training and education in the field to start developing
programs, but many are not knowledgeable about good programming practices or able to
check for errors.
4. Misunderstanding of Basic Design Specifications: This affects the subsequent design
phases including coding, documenting, and testing. It also results in improper and ambiguous
specifications of major components of the software and in ill-chosen and poorly defined
internal program structures.
5. Size and Scope: As software systems grow in size and complexity, they involve more
components, modules, and interactions. Managing the interdependencies between these
elements becomes increasingly intricate.
6. Interactions and Dependencies: Software components often interact with each other,
forming a network of dependencies. Changes to one component can ripple through the
system, leading to unexpected behaviors.
7. Non-Linearity: The relationship between the inputs and outputs of software components is
not always straightforward. Small changes in inputs can lead to disproportionately large
changes in outputs due to non-linear behaviors.
8. Emergent Behavior: Complex software systems can exhibit emergent behaviors—
unintended or unexpected outcomes that arise from the interactions of simple components.
These behaviors are often challenging to predict and control.

13
9. Dynamic Nature: Software is dynamic and can change over time due to updates, patches,
and user interactions. This dynamic nature can lead to evolving complexities that are difficult
to manage.
10. Concurrency and Parallelism: Modern software often handles multiple tasks
simultaneously through concurrency and parallelism. Coordinating these concurrent
processes introduces complexities related to synchronization and resource sharing.
11. State Management: Software systems have states that change based on inputs, user
interactions, and internal processes. Managing and tracking these states can become complex
as the number of possible states increases.
12. Error Handling: Complex software needs robust error handling mechanisms to handle
unexpected situations. Designing effective error handling that covers all potential scenarios
can be challenging.
13. Legacy Systems and Integration: Integrating new software with existing legacy systems
can introduce complexities due to differences in technologies, data formats, and architecture.
14. Performance Optimization: Optimizing software for performance, responsiveness, and
scalability can lead to intricate decisions about trade-offs and resource allocations.
15. Security and Privacy: Ensuring the security and privacy of software systems involves
managing access controls, encryption, and data handling practices, adding another layer of
complexity.
16. Testing and Debugging: The complexity of software can make testing and debugging a
formidable task. Identifying the root cause of a problem and ensuring that fixes don't
introduce new issues can be challenging.
17. User Interfaces: Designing user-friendly interfaces that cater to various user needs and
preferences requires addressing usability and accessibility complexities.
18. Regulatory and Compliance Factors: Depending on the domain and industry, software
must adhere to specific regulations and standards, adding compliance-related complexities.

Given the multifaceted nature of software complexity, software engineers and development
teams often employ various techniques to manage and mitigate its impact. These include
modular design, abstraction, encapsulation, automated testing, documentation, code reviews, and
adherence to best practices. Additionally, advancements in software engineering methodologies

14
and tools aim to address complexity and promote the development of more manageable and
maintainable software systems.

RISK
The first step in understanding the nature of software is to study the concept of risk, software risk
in particular. However, before we define risk, let us define hazard. Hazard is a state or set of
conditions of a system or an object that, together with other conditions in the environment of the
system, or object, will lead inevitably to an accident.

Risk can also be defined in simpler terms as the potential or possibility of suffering harm or loss
danger, in short.

Risk refers to the potential for an unwanted or adverse event to occur, leading to negative
consequences. It encompasses the uncertainty surrounding the outcome of an action, decision, or
situation, where the result may deviate from the expected or desired outcome.

Causes of Risks

1. Poor software design

2. A mismatch of hardware – software interfaces
3. Poor support and maintenance
4. Personnel shortfalls
5. Unrealistic schedules and budgets
6. Developing the wrong functions and properties
7. Developing the wrong user interface
8. Continuing stream of requirement changes
9. Shortfalls in externally furnished components
10. Shortfalls in externally performed tasks
11. Real-time performance shortfalls

15
12. Straining computer-science capabilities

Common Risks

Certainly, here are some common risks associated with software issues:

1. Security Vulnerabilities and Data Breaches: Inadequate security measures can lead to
unauthorized access, data breaches, and loss of sensitive information.
2. System Downtime and Unavailability: Software bugs, glitches, or crashes can result in
system downtime, disrupting services and causing inconvenience to users.
3. Performance Issues: Poorly optimized software can lead to slow performance, lag, and
unresponsiveness, affecting user experience.
4. Compatibility Problems: Incompatibility with different devices, operating systems, or
software versions can limit accessibility and usage.
5. Loss of Data or Data Corruption: Software failures can lead to loss of user data or
corruption of important files, causing data recovery challenges.
6. User Frustration and Loss of Trust: Repeated software issues can lead to user frustration
and erode trust in the software or the company providing it.
7. Legal and Regulatory Non-Compliance: Software that doesn't adhere to industry
regulations or legal requirements can result in legal actions, penalties, and fines.
8. Financial Losses: Software problems can lead to financial losses due to system downtime,
decreased productivity, or legal liabilities.
9. Reputation Damage: Software issues can damage a company's reputation, leading to
negative public perception and decreased customer loyalty.
10. Intellectual Property Infringement: Unauthorized use of third-party code or infringement
of intellectual property rights can lead to legal disputes.
11. Difficulty in Updates and Maintenance: Poorly designed software can be difficult to update
and maintain, leading to ongoing issues and high maintenance costs.
12. Lack of Scalability: Software that doesn't scale well can lead to performance issues as user
demand increases over time.
13. Operational Disruptions: Software failures can disrupt internal operations, causing delays
and inefficiencies in business processes.

16
14. Dependency on Third-Party Services: Reliance on third-party services or APIs can
introduce risks if those services experience outages or changes.
15. User Harm in Critical Systems: Malfunctions in software controlling critical systems (e.g.,
medical devices, autonomous vehicles) can lead to physical harm.
16. Lawsuits and Legal Actions: Software issues can result in lawsuits from users, clients, or
stakeholders seeking compensation for damages.
To mitigate these risks, software development should follow best practices including thorough
testing, security assessments, regular updates, adherence to industry standards and regulations,
and open communication with users to address issues promptly.

Risk Assessment and Management

Risk management is a process to estimate the impact of risk. It is an approach for system
managers to measure the system’s assets and vulnerabilities, assessing the threat and monitoring
security. For software, we look at risk management both during the design phase and during use.

1. Risk Identification: This involves identifying potential issues, challenges, and

vulnerabilities that could impact the quality, security, and reliability of the software. Risks
can encompass software bugs, security vulnerabilities, performance bottlenecks,
compatibility issues, and non-compliance with standards.
2. Risk Assessment: This involves identifying the software’s security vulnerabilities and may
consist of a variety of techniques including question and answer, qualitative assessment, or
methodology and calculation.
Once risks are identified, a thorough risk assessment evaluates the likelihood of each risk
occurring and the potential impact on the software project. For software issues, the
assessment considers the severity of bugs or glitches, the potential for security breaches, and
the impact of compatibility challenges on user experience.
For quality, assessment involves evaluating the potential impact of subpar user experiences,
unreliable performance, or non-compliance with industry standards.
A simple equation for calculating risk is (Risk = Assets * Threats * Vulnerabilities)
3. Prioritizing Risks: Risks are prioritized based on their potential impact and likelihood.
High-impact, high-likelihood risks require immediate attention, while lower-priority risks
may be monitored or addressed later.

17
4. Risk Mitigation: Risk mitigation strategies are developed to reduce the likelihood of risks
occurring and minimize their potential impact. This could involve implementing robust
testing procedures, code reviews, and continuous integration practices. For quality,
mitigation efforts may focus on enhancing user experience, optimizing performance, and
adhering to coding and design standards.
5. Planning: Planning involves outlining the policies for security management
6. Implementation: A good implementation may seek to match the security needs of the
system with all available security tools.
7. Monitoring: Risk management is an ongoing process that needs constant monitoring. This
helps to determine the necessary changes and new security applications to the system. The
monitoring tools must be chosen based on the nature and applications of the system being
protected.

18
 CONSUMER PROTECTION
Consumer protection involves ensuring that individuals who purchase software products are
treated fairly, receive accurate information, and have their rights upheld throughout the
purchasing process.
Important considerations for consumer protection when buying software:
1. Accurate Product Information: Sellers should provide accurate and complete information
about the software, including its features, functionality, compatibility, and system
requirements.
2. Clear Pricing and Terms: Software pricing should be transparent and clearly
communicated to the buyer
3. Trial Versions and Demos: Offering trial versions or demos of software allows consumers
to test the product before purchasing.
4. Refund and Return Policies: Sellers should have clear refund and return policies that
specify the conditions under which a buyer can return or request a refund for software that
does not meet their expectations or requirements.
5. Cancellation Rights: Buyers should have the right to cancel their purchase within a
specified period if they change their mind.
6. Security and Privacy: Sellers should prioritize the security of buyers’ personal and financial
information when processing transactions.
7. Technical Support and Updates: Buyers should have access to reliable technical support
and information about how updates will be provided to address issues and maintain software
functionality.
8. Dispute Resolution: Clear mechanisms should be in place for resolving disputes between
buyers and sellers, such as a customer support.

19
9. Digital Delivery: When software is delivered digitally, buyers should receive clear
instructions on how to access and download their purchased software.
10. Compatibility and Interoperability: Buyers should be informed about the compatibility of
the software with their devices, operating systems, and other software applications they use
Software products may not work as expected because the buyer has unrealistic expectations
about the product, the environment in which the product is supposed to work is inadequate, the
seller exaggerated the capacities of the software, or the software is simply faulty.
The following are the legal actions buyers need in order to press for their rights if nothing else
works:
A. Buyer and Provider Rights
This simply means the fundamental principles that ensure fairness, transparency, and ethical
conduct between both buyer and provider. Some of the rights include:
1. Service Level Agreements (SLA): This is an agreement between a service provider and a
customer that defines the expected level of service quality, performance, and responsibilities
for the services being provided. This also means an official commitment that prevails
between a service provider and a client. The main purpose of an SLA is to establish clear
expectations, ensure accountability, and provide a basis for measuring and managing service
performance. Layers of SLAs based on the product and the user of the product as follows:
i. Customer-based SLA: An agreement with an individual customer group, covering all
the services they use.
ii. Service-based SLA: An agreement for all customers using the services being
delivered by the service provider.
iii. Multi-Level SLA: The SLA is split into the different levels, each addressing different
sets of customers for the same services, in the same SLA.

 Corporate-level SLA: Covering all the generic service level management (often
abbreviated as SLM) issues appropriate to every customer throughout the
organization. These issues are likely to be less volatile and so updates (SLA reviews)
are less frequently required.

 Customer-level SLA: covering all SLM issues relevant to the particular customer
group, regardless of the services being used.

20
  Service-level SLA: covering all SLM issues relevant to the specific services, in
relation to this specific customer group.
Important of Service Level Agreement (SLA) includes:
i. It reduces misunderstandings and disputes
ii. It ensures that services are delivered as promised
2. Why a Service Level Agreement is Important: SLAs are important because they are the
contracts that set boundaries and expectations for the following aspects of the center service
provisioning:
i. Customer commitments: Clearly defined promises reduce the chances of disappointing a
customer. These promises also help to stay focused on customer requirements and assure that
the internal processes follow the right direction
ii. Key performance indicators for customer service: By having these indicators established, it is
easy to understand how they can be integrated into a quality improvement process, and this
increases customer satisfaction.
iii. Key performance indicators for the internal organizations: An SLA drives internal processes by
setting a clear, measurable standard of performance. Consequently, internal objectives become
clearer and easier to measure.

iv. The price of non-conformance: If the SLA has penalties, non-performance can be costly.
However, by having penalties defined, the customer understands that the service provider truly
believes in its ability to achieve the set performance levels. It makes the relationship clear and
positive.

B. A Service Provide-User Contract:

Contract is defined as a binding relationship between two or more parties. A contract need not be
in a physical form like a document; it can be oral or implied. For a relationship to be a contract, it
must satisfy several requirements including mutual consent.
Mutual consent is a meeting of the minds on issues such as the price bargained or agreed upon,
the amount paid or promised to be paid, and any agreement enforceable by law.
In contract laws, a service provider/developer can be sued for breach of contract. Contract laws
also cover express and implied warranties, third-party beneficiary contracts, and disclaimers.
Warranties are guarantees that the product or service will live up to its reasonable expectations.

21
Some warranties are not specifically written down but are implied, whereas others are merely
expressed either orally or in some other form.
Some of terms contract covers include:
1. Express Warranties: Express warranties are an affirmation of a fact, a promise, or a
description of goods, a sample, or a model made by the seller to the buyer relating to the
goods and as a basis for payment negotiations. Express warranties are entered into between
the customer and the producer when a producer agrees to supply the product to the customer.
They also involve promises made by the producer through sales representatives and written
materials on packaging attesting to the quality of the product and guidelines buyers must
follow to get detectable errors corrected by the producer. Producers usually limit their
liability on products by stipulating a time frame on warranties and contracts. But in most
cases, time limits do not apply, especially in cases of express warranties because of
advertising and description of the product capacity on or in packages
2. Implied Warranties: Implied warranties are enforced by law according to established and
accepted public policy. For example, in the nonideal world we live in, we cannot expect a
contract to contain everything the buyer and producer may want. Remember that the process
of buying and selling is a game in which there is a winner, a loser, or a draw. In this game, as
we pointed out earlier, the seller has more cards than the buyer. On the buyer’s side are quite
a number of things they do not have to negotiate because they do not know as much and need
time to learn the product. The law protects buyers, so they do not have to negotiate every
small detail of the product conditions. Implied warranties make such conditions always part
of the package agreement even if they are not specifically written down in the contract. An
implied warranty guarantees that a product is of average quality and will perform no less than
similar products and that it is fit for the intended use. For buyers to benefit from implied
warranties, proof must be given that the contract did not exclude some features and there is
no time limitation for reporting defects; some companies, however, stipulate a time frame in
which defects must be reported. Implied warranties are advantageous to buyers because they
enforce a degree of discipline on the producers and vendors to sell standard products for the
intended purposes. They are also useful to the producer and vendors because they create a
degree of confidence and trust in buyers, hence increasing sales of products. However, there
is a downside to implied warranties; they tend to make software expensive because the

22
 producer anticipates the cost of the lawsuits that might be generated and passes such costs on
to the customers.
3. Third-Party Beneficiary Contracts: If a software product injures a user other than the
buyer, under a third-party beneficiary contract, the user may sue the producer for benefits due
to injuries or loss of income resulting from the product. Third-party beneficiary contracts
suits are not common because they are rarely found valid in courts.
4. Disclaimers: Producers try to control their liability losses by putting limits on warranties via
disclaimers. Through disclaimers, producers preempt lawsuits from buyers by telling buyers
in writing on the contracts the limits of what is guaranteed. Many users see disclaimers as
way producers try to avoid responsibility. Producers see them as a way of informing the users
of the risks before they buy the product, and they also like them because they put the burden
of proof and risk taking squarely on the buyers—caveat emptor (the buyer beware), so to
speak. Whether these disclaimers are recognized in courts depends on a number of factors
including the belief that the disclaimers were made in good faith.
5. Breach of Contract: A contract entered into between two or more parties and not performed
as promised by either party can be considered breached by the party not in compliance. If the
complaint is not very serious, the breach may not cause the termination of the contract, but
the breaching party may be asked to pay some damages. However, if the breach is considered
serious by one of the parties, it may cause the termination of the contract. In this case, the
offended party may demand damages from the breaching party in the contract upon
satisfactory proof that there were indeed damages resulting from contract breaching.
C. The Tort Option
If a buyer cannot seek benefits from the producer through contracts laws, another avenue of legal
action is through tort.
A tort is a wrong committed upon a person or property in the absence of a contract. It also means
a civil wrong that result in harm or injury to someone, leading to legal liability for the person
who committed the wrongful act. Torts are a fundamental aspect of civil law and can encompass
a wide range of wrongful actions, from negligence and intentional wrongdoing to strict liability
to malpractice to misrepresentation. And torts fall into two categories: intentional and
unintentional.
Types of Torts

23
1. Negligence: Negligence can be used by the buyer to obtain benefits from the producer if
there is provable evidence that the product lacked a certain degree of care, skill, and
competence in the workmanship. Carelessness and a lack of competence may be proved from
the design stage through the testing, installation, and user training stages of the product. For
example, suppose that the buyer of a computer software product is a large hospital and the
product is life-sustaining software. If it causes injury to a patient because the hospital
personnel using the software were not adequately trained by the producer of the software,
and this can be proved beyond a reasonable doubt, then the producer can be sued for
negligence. In other words, negligence in this case is holding the software producer party
liable for the injuries he or she did not intend and even tried to avoid while making the
software. Negligence cases apply mainly to services rendered.
2. Malpractice: This refers to professional negligence or misconduct by a licensed professional
that leads to harm, injury, or damage to a client, patient, or customer. This term is commonly
used in the context of medical, legal, and other professional fields where practitioners are
expected to provide a certain standard of care and expertise. Malpractice occurs when a
professional fails to meet that standard, resulting in negative consequences for the person
they were serving.
3. Strict Liability: Strict liability is a tort involving products. Any product sold in a defective
condition that ends up endangering a person creates a case of strict liability to the seller of
such a product even if the buyer did not make a direct purchase from the seller. In strict
liability lawsuits, the burden of proof of negligence is shifted to the producer, and the costs
due to defects in the product are squarely in the hands of the producer. Under strict liability,
it is the product itself that is on trial. The product is examined, and if it is found to be
defective and dangerous, the buyer is awarded benefits. Strict liability laws are harsh. They
ignore efforts made by the producer of the product to make the product safe for the reason
that the producer was in a better position to know the risks.
4. Misrepresentation: Most computer software and other computer products are no longer sold
by their original producers and developers but by third-party sellers and vendors. Examples
of such third-party sellers are mail-order computer hardware and hundreds of software
companies and many big brand-name computer outlets. So very few original manufacturers
and software developers are selling directly to the buyer. To the buyer of a computer product,

24
 this situation may add another layer of bureaucracy and more problems. The problems are
not one-sided, though; indirect selling also causes additional problems for the producer.
Many of the producer problems added by this layer come from misrepresentation of the
product. Misrepresentation may be intentionally done by the sales representative to induce
the buyer to buy the product, or it may be just a genuine mistake. Consider car
manufacturers, for example. Usually, they buy back faulty new cars from customers when
these cars have developed specific problems within a designated period of time. These cars
are usually repaired and sent back to the dealers to be sold, not as new but as used products.
Sometimes, however, car dealers sell these cars as new cars. Whether car manufacturers are
aware of these sales practices or not, customers always end up suing the car manufacturers.
Before you sue the producer, however, determine first whether it was an intentional
misrepresentation and fraudulent misrepresentation or not. To prove fraudulent
misrepresentation, you need to prove that the vendor was aware the facts given were not true
or that the vendor would have known the true facts but opted not to inform the buyer
accordingly. You also need to show, and be believed, that you as a buyer relied on that
information to buy the product. And finally, you need to show that the product resulted in
damage. If you can establish all these facts and be believed by the courts, then you have a
case.
Purpose of torts
1. Compensation: Torts provide a means for injured parties to seek compensation for the
harm they have suffered. This compensation can cover medical expenses, lost wages,
pain and suffering.
2. Deterrence: Torts law discourages individuals from engaging in harmful behaviour by
imposing legal consequences for wrongful actions.
3. Correction: Torts seek to correct the imbalance caused by the harm suffered by making
the responsible party provide compensation or other remedies to the injured party.
4. Prevention: The threat of legal action and potential liability encourages individuals and
businesses to act prudently and responsibly to avoid causing harm to others.

25
 IMPROVING SOFTWARE QUALITY
Improving Software Quality is a multifaceted and ongoing process that involves various
techniques, practices, and methodologies to ensure that software meets or exceeds user
expectations, is reliable, maintainable, and delivers value. High-quality software is crucial for
achieving customer satisfaction, minimizing defects, and enhancing the overall development
process. Improving software quality is an endeavor that involves meticulous planning, rigorous
testing, adherence to best practices, and a commitment to ongoing refinement. By incorporating
these strategies into the software development lifecycle, organizations can create software that
not only meets user needs but also sets a high standard for reliability, security, and performance.
Ways to Improve Software Quality
There are a lot of ways of improving software quality and some of them are listed below:
1. Requirements Analysis and Design:
Begin with a clear understanding of user requirements. Define functional and non-functional
requirements, and involve stakeholders to gather comprehensive input. Create a well-
thought-out software architecture and design that aligns with the requirements. Proper design
can prevent issues downstream.
2. Coding Standards and Guidelines:
Establish coding standards and guidelines that promote consistency, readability, and
maintainability of the codebase. Enforce code reviews to identify issues early and ensure that
code adheres to established standards.
3. Testing Practices:

26
 Adopt a comprehensive testing strategy that includes unit, integration, system, and
acceptance testing. Implement test-driven development (TDD) or behavior-driven
development (BDD) to ensure that code is thoroughly tested from the outset.
Use automated testing tools and frameworks to execute tests consistently and efficiently.
4. Continuous Integration and Continuous Deployment (CI/CD):
Integrate automated build, testing, and deployment processes into your development pipeline.
Automatically run tests whenever code changes are made, and deploy tested code to
production frequently.

5. Version Control and Collaboration:

Utilize version control systems (e.g., Git) to manage source code and track changes over
time. Encourage collaboration by using branching strategies and pull requests for code
review.
6. Static Analysis and Code Quality Tools:
Employ static analysis tools to automatically identify potential issues, such as coding errors,
security vulnerabilities, and performance bottlenecks. Use code quality tools to measure and
monitor code metrics, such as cyclomatic complexity and code duplication.
7. Documentation:
Maintain thorough documentation, including design documents, user guides, API
documentation, and code comments. Documentation ensures that developers and users have a
clear understanding of the software's functionality and usage.
8. Security Considerations:
Implement secure coding practices to prevent vulnerabilities such as SQL injection, cross-site
scripting (XSS), and other common security flaws.
Conduct regular security assessments, penetration testing, and code reviews to identify and
address potential security issues.
9. Performance Optimization:
Profile and analyze the software's performance to identify bottlenecks and areas for
optimization. Implement performance testing to ensure that the software can handle
anticipated workloads.

27
10. User Experience (UX) and Usability:
Prioritize user-centered design to create intuitive, user-friendly interfaces. Conduct usability
testing and gather user feedback to refine the software's user experience.
11. Bug Tracking and Issue Management:
Implement a robust bug tracking and issue management system to capture, prioritize, and
track defects and enhancements. Regularly review and address reported issues to maintain
software quality over time.
12. Training and Skill Development:
Invest in continuous training and skill development for development teams to stay updated
on the latest technologies, best practices, and methodologies.

13. Metrics and Monitoring:

Define and track key performance indicators (KPIs) related to software quality, such as
defect density, response times, and user satisfaction. Implement monitoring solutions to
detect and respond to issues in real-time, minimizing downtime and user impact.
14. Feedback Loops and Continuous Improvement:
Establish feedback loops with users, stakeholders, and development teams to gather insights
and continuously improve the software. Regularly assess and refine software development
processes based on lessons learned and feedback received.
15. Risk Management:
Identify potential risks that could impact software quality and develop mitigation strategies.
Regularly review and update risk assessments as the software evolves.
16. Adaptation to Change:
Embrace agile methodologies to facilitate flexibility and adaptability in response to changing
requirements and technologies. Maintain a culture of continuous improvement, where teams
are encouraged to experiment, learn, and evolve their practices.

28