What is Software Engineering?

Software Engineering is the process of designing, developing, testing, and maintaining software.
It is a systematic and disciplined approach to software development that aims to create high-
quality, reliable, and maintainable software.

1. Software engineering includes a variety of techniques, tools, and methodologies,

including requirements analysis, design, testing, and maintenance.
2. It is a rapidly evolving field, and new tools and technologies are constantly being
developed to improve the software development process.
3. By following the principles of software engineering and using the appropriate tools and
methodologies, software developers can create high-quality, reliable, and maintainable
software that meets the needs of its users.
4. Software Engineering is mainly used for large projects based on software systems rather
than single programs or applications.
5. The main goal of Software Engineering is to develop software applications for improving
quality, budget, and time efficiency.
6. Software Engineering ensures that the software that has to be built should be consistent,
correct, also on budget, on time, and within the required requirements.

Key Principles of Software Engineering

1. Modularity: Breaking the software into smaller, reusable components that can be
developed and tested independently.
2. Abstraction: Hiding the implementation details of a component and exposing only the
necessary functionality to other parts of the software.
3. Encapsulation: Wrapping up the data and functions of an object into a single unit, and
protecting the internal state of an object from external modifications.
4. Reusability: Creating components that can be used in multiple projects, which can save
time and resources.
5. Maintenance: Regularly updating and improving the software to fix bugs, add new
features, and address security vulnerabilities.
6. Testing: Verifying that the software meets its requirements and is free of bugs.
7. Design Patterns: Solving recurring problems in software design by providing templates
for solving them.
8. Agile methodologies: Using iterative and incremental development processes that focus
on customer satisfaction, rapid delivery, and flexibility.
9. Continuous Integration & Deployment: Continuously integrating the code changes and
deploying them into the production environment.
 Main Attributes of Software Engineering
Software Engineering is a systematic, disciplined, quantifiable study and approach to the
design, development, operation, and maintenance of a software system. There are four
main Attributes of Software Engineering.
1. Efficiency: It provides a measure of the resource requirement of a software product
efficiently.
2. Reliability: It assures that the product will deliver the same results when used in similar
working environment.
3. Reusability: This attribute makes sure that the module can be used in multiple
applications.
4. Maintainability: It is the ability of the software to be modified, repaired, or enhanced
easily with changing requirements.

Dual Role of Software

There is a dual role of software in the industry. The first one is as a product and the other
one is as a vehicle for delivering the product. We will discuss both of them.
1. As a Product
• It delivers computing potential across networks of Hardware.
• It enables the Hardware to deliver the expected functionality.
• It acts as an information transformer because it produces, manages, acquires, modifies,
displays, or transmits information.
2. As a Vehicle for Delivering a Product
• It provides system functionality (e.g., payroll system).
• It controls other software (e.g., an operating system).
• It helps build other software (e.g., software tools).

Objectives of Software Engineering

1. Maintainability: It should be feasible for the software to evolve to meet changing

requirements.

2. Efficiency: The software should not make wasteful use of computing devices such as
memory, processor cycles, etc.

3. Correctness: A software product is correct if the different requirements specified in

the SRS Document have been correctly implemented.
 4. Reusability: A software product has good reusability if the different modules of the
product can easily be reused to develop new products.

5. Testability: Here software facilitates both the establishment of test criteria and the
evaluation of the software concerning those criteria.

6. Reliability: It is an attribute of software quality. The extent to which a program can be

expected to perform its desired function, over an arbitrary time period.

7. Portability: In this case, the software can be transferred from one computer system or
environment to another.

8. Adaptability: In this case, the software allows differing system constraints and the user
needs to be satisfied by making changes to the software.

9. Interoperability: Capability of 2 or more functional units to process data cooperatively.

Program vs Software Product

Parameters Program Software Product

Software is when a program is

made available for commercial
A program is a set of instructions business and is properly
Definition that are given to a computer in documented along with its
order to achieve a specific task. licensing.

Software Product = Program +

Documentation + Licensing.

Software Development usually

follows a life cycle, which
Program is one of the stages involves the feasibility study of
Stages Involved involved in the development of the project, requirement
the software. gathering, development of a
prototype, system design, coding,
and testing.
Advantages of Software Engineering

There are several advantages to using a systematic and disciplined approach to software
development, such as:

1. Improved Quality: By following established software engineering principles and

techniques, the software can be developed with fewer bugs and higher reliability.

2. Increased Productivity: Using modern tools and methodologies can streamline the
development process, allowing developers to be more productive and complete projects
faster.

3. Better Maintainability: Software that is designed and developed using sound software
engineering practices is easier to maintain and update over time.

4. Reduced Costs: By identifying and addressing potential problems early in the

development process, software engineering can help to reduce the cost of fixing bugs and
adding new features later on.

5. Increased Customer Satisfaction: By involving customers in the development process

and developing software that meets their needs, software engineering can help to increase
customer satisfaction.

6. Better Team Collaboration: By using Agile methodologies and continuous integration,

software engineering allows for better collaboration among development teams.

7. Better Scalability: By designing software with scalability in mind, software engineering

can help to ensure that software can handle an increasing number of users and
transactions.

8. Better Security: By following the Software Development Life Cycle (SDLC) and
performing security testing, software engineering can help to prevent security breaches
and protect sensitive data.

Disadvantages of Software Engineering

While Software Engineering offers many advantages, there are also some potential
disadvantages to consider:

1. High upfront costs: Implementing a systematic and disciplined approach to software

development can be resource-intensive and require a significant investment in tools and
training.
2. Limited flexibility: Following established software engineering principles and
methodologies can be rigid and may limit the ability to quickly adapt to changing
requirements.

3. Bureaucratic: Software Engineering can create an environment that is bureaucratic, with

a lot of processes and paperwork, which may slow down the development process.

4. Complexity: With the increase in the number of tools and methodologies, software
engineering can be complex and difficult to navigate.

5. Limited creativity: The focus on structure and process can stifle creativity and
innovation among developers.

6. High learning curve: The development process can be complex, and it requires a lot of
learning and training, which can be challenging for new developers.

7. High dependence on tools: Software engineering heavily depends on the tools, and if the
tools are not properly configured or are not compatible with the software, it can cause
issues.

8. High maintenance: The software engineering process requires regular maintenance to

ensure that the software is running efficiently, which can be costly and time-consuming.

Conclusion:

In summary, software engineering can be expensive and time-consuming, and it may

limit flexibility and creativity. However, the benefits of improved quality, increased
productivity, and better maintainability can outweigh the costs and complexity. It’s
important to weigh the pros and cons of using software engineering and determine if it is
the right approach for a particular software project.

Attributes of Software

The international standard on software product quality suggests that software quality
comprises six main attributes:

1. Reliability: The capability to provide failure-free service.

2. Functionality: The capability to provide functions that meet stated and implied needs
when the software is used.

3. Usability: The capability to be understood, learned, and used.

4. Efficiency: The capability to provide appropriate performance relative to the amount of

resources used.
5. Maintainability: the capability to be modified for purposes of making corrections,
improvements, or adaptations.

6. Portability: The capability to be adapted for different specified environments without

applying actions or means other than those provided for this purpose in the product.

Classification of Software

The software can be classified based on various criteria, including:

1. Purpose: Software can be classified as system software (e.g., operating systems, device
drivers) or application software (e.g., word processors, games).

2. Platform: Software can be classified as native software (designed for a specific operating
system) or cross-platform software (designed to run on multiple operating systems).

3. Deployment: Software can be classified as installed software (installed on the user’s

device) or cloud-based software (hosted on remote servers and accessed via the internet).

4. License: Software can be classified as proprietary software (owned by a single entity) or

open-source software (available for free with the source code accessible to the public).

5. Development Model: Software can be classified as traditional software (developed using

a waterfall model) or agile software (developed using an iterative and adaptive approach).

6. Size: Software can be classified as small-scale software (designed for a single user or
small group) or enterprise software (designed for large organizations).

7. User Interface: Software can be classified as Graphical User Interface (GUI) software
or Command-Line Interface (CLI) software.

hese classifications are important for understanding the characteristics and limitations of
different types of software, and for selecting the best software for a particular need.

Software Characteristics – Software Engineering

Software is defined as a collection of computer programs, procedures, rules, and data.

Software Characteristics are classified into six major components. Software
engineering is the process of designing, developing, testing, and maintaining software.

Components of Software Characteristics

Functionality:

It refers to the degree of performance of the software against its intended purpose. Functionality
refers to the set of features and capabilities that a software program or system provides to its
users. It is one of the most important characteristics of software, as it determines the usefulness
of the software for the intended purpose. Examples of functionality in software include:

• Data storage and retrieval

• Data processing and manipulation

• User interface and navigation

• Communication and networking

• Security and access control

• Reporting and visualization

• Automation and scripting

The more functionality a software has, the more powerful and versatile it is, but also the more
complex it can be. It is important to balance the need for functionality with the need for ease of
use, maintainability, and scalability.
Required functions are:

Functionality

Reliability:

A set of attributes that bears on the capability of software to maintain its level of performance
under the given condition for a stated period of time.

Reliability is a characteristic of software that refers to its ability to perform its intended functions
correctly and consistently over time. Reliability is an important aspect of software quality, as it
helps ensure that the software will work correctly and not fail unexpectedly.

Examples of factors that can affect the reliability of software include:

1. Bugs and errors in the code

2. Lack of testing and validation

3. Poorly designed algorithms and data structures

4. Inadequate error handling and recovery

5. Incompatibilities with other software or hardware

To improve the reliability of software, various techniques, and methodologies can be used, such
as testing and validation, formal verification, and fault tolerance.

Software is considered reliable when the probability of it failing is low and it is able to recover
from the failure quickly, if any.

Required functions are

Reliability

Efficiency:

It refers to the ability of the software to use system resources in the most effective and efficient
manner. The software should make effective use of storage space and executive command as per
desired timing requirements.

Efficiency is a characteristic of software that refers to its ability to use resources such as memory,
processing power, and network bandwidth in an optimal way. High efficiency means that a
software program can perform its intended functions quickly and with minimal use of resources,
while low efficiency means that a software program may be slow or consume excessive
resources.

Examples of factors that can affect the efficiency of the software include:

1. Poorly designed algorithms and data structures

2. Inefficient use of memory and processing power

3. High network latency or bandwidth usage

4. Unnecessary processing or computation

5. Unoptimized code

To improve the efficiency of software, various techniques, and methodologies can be used, such
as performance analysis, optimization, and profiling.

Efficiency is important in software systems that are resource-constrained, high-performance, and

real-time systems. It is also important in systems that need to handle many users or transactions
simultaneously.
Required functions are:

Efficiency

Usability:

It refers to the extent to which the software can be used with ease. the amount of effort or time
required to learn how to use the software.
Required functions are:

Usability

Maintainability:

It refers to the ease with which modifications can be made in a software system to extend its
functionality, improve its performance, or correct errors.
Required functions are:

Portability:

A set of attributes that bears on the ability of software to be transferred from one environment to
another, without minimum changes.
Required functions are:

Portability

Characteristics of “Software” in Software Engineering

1. Software is developed or engineered; it is not manufactured in the classical sense:

• Although some similarities exist between software development and hardware

manufacturing, few activities are fundamentally different.

• In both activities, high quality is achieved through good design, but the
manufacturing phase for hardware can introduce quality problems than software.

2. The software doesn’t “wear out.”:

• Hardware components suffer from the growing effects of many other

environmental factors. Stated simply, the hardware begins to wear out.

• Software is not susceptible to the environmental maladies that cause hardware to

wear out.

• When a hardware component wears out, it is replaced by a spare part.

• There are no software spare parts.

• Every software failure indicates an error in design or in the process through which
the design was translated into machine-executable code. Therefore, the software
maintenance tasks that accommodate requests for change involve considerably
more complexity than hardware maintenance. However, the implication is clear—
the software doesn’t wear out. But it does deteriorate.

3. The software continues to be custom-built:

• A software part should be planned and carried out with the goal that it tends to be
reused in various projects.
 • Current reusable segments encapsulate the two pieces of information and the
preparation that is applied to the information, empowering the programmer to
make new applications from reusable parts.

• In the hardware world, component reuse is a natural part of the engineering

process.

Characteristics of the Software

• It is intangible, meaning it cannot be seen or touched.

• It is non-perishable, meaning it does not degrade over time.

• It is easy to replicate, meaning it can be copied and distributed easily.

• It can be complex, meaning it can have many interrelated parts and features.

• It can be difficult to understand and modify, especially for large and complex systems.

• It can be affected by changing requirements, meaning it may need to be updated or

modified as the needs of users change.

• It can be impacted by bugs and other issues, meaning it may need to be tested and
debugged to ensure it works as intended.

Factors of Software Quality

The modern read of high-quality associates with software many quality factors like the
following:

1. Portability: A software is claimed to be transportable, if it may be simply created to

figure in several package environments, in several machines, with alternative code
merchandise, etc.

2. Usability: A software has smart usability if completely different classes of users (i.e.
knowledgeable and novice users) will simply invoke the functions of the merchandise.
3. Reusability: A software has smart reusability if completely different modules of the
merchandise will simply be reused to develop new merchandise.

4. Correctness: Software is correct if completely different needs as laid out in the SRS
document are properly enforced.

5. Maintainability: A software is reparable, if errors may be simply corrected as and once

they show up, new functions may be simply added to the merchandise, and therefore the
functionalities of the merchandise may be simply changed, etc

6. Reliability: Software is more reliable if it has fewer failures. Since software engineers do
not deliberately plan for their software to fail, reliability depends on the number and type
of mistakes they make. Designers can improve reliability by ensuring the software is easy
to implement and change, by testing it thoroughly, and also by ensuring that if failures
occur, the system can handle them or can recover easily.

7. Efficiency. The more efficient software is, the less it uses of CPU-time, memory, disk
space, network bandwidth, and other resources. This is important to customers in order to
reduce their costs of running the software, although with today’s powerful computers,
CPU time, memory and disk usage are less of a concern than in years gone by.

Software Quality Management System

Software Quality Management System contains the methods that are used by the
authorities to develop products having the desired quality.

Some of the methods are:

• Managerial Structure: Quality System is responsible for managing the structure as a

whole. Every Organization has a managerial structure.

• Individual Responsibilities: Each individual present in the organization must have some
responsibilities that should be reviewed by the top management and each individual
present in the system must take this seriously.

• Quality System Activities: The activities which each quality system must have been

o Project Auditing.

o Review of the quality system.

o It helps in the development of methods and guidelines.

Evolution of Quality Management System

 Quality Systems are basically evolved over the past some years. The evolution of a
Quality Management System is a four-step process.

1. Inception: Product inspection task provided an instrument for quality control (QC).

2. Quality Control: The main task of quality control is to detect defective devices, and it
also helps in finding the cause that leads to the defect. It also helps in the correction of
bugs.

3. Quality Assurance: Quality Assurance helps an organization in making good quality

products. It also helps in improving the quality of the product by passing the products
through security checks.

4. Total Quality Management (TQM): Total Quality Management(TQM) checks and

assures that all the procedures must be continuously improved regularly through process
measurements.

Evolution of Quality Management System

What do you mean by software crisis? Explain with examples. How cansoftware crisis
can be minimized?

Software Crisis is a term used in computer science for the difficulty ofwriting useful and
efficient computer programs in the required time.software crisis was due to using same
workforce, same methods, same toolseven though rapidly increasing in software demand,
complexity of softwareand software challenges. With increase in the complexity of
software, manysoftware problems arise because existing methods were
insufficient.Causes of Software Crisis:

1. The cost of owning and maintaining software was as expensive asdeveloping the
software
2. At that time Projects was running over-time
3. At that time Software was very inefficient
4. The quality of software was low quality
5. Software often did not meet requirements
6. The average software project overshoots its schedule by half

At that time Software was never delivered Minimization of software crisis:There is no

single solution to the crisis. One possible solution of software crisis is Software
Engineering because software engineering is a systematic, disciplined and quantifiable
approach. For preventing software crisis, there are some guidelines:

a. Reduction of software over-budget

b. The quality of software must be high

c. Less time needed for software project

d. Experienced working team member on software project

e. Software must be delivered

What is traceability in software engineering? Explain requirement traceability.

Traceability in software engineering describes the extent to which documentation or code

can be traced back to its point of origin. The goal of traceability is to provide better
quality and consistency of product development. It brings the ability to verify the history,
location, and application of an item by means of documented identification. Requirements
traceability is the ability to trace a requirement forwards and backwards in the
development lifecycle. Requirements are traced forward through other development
artifacts, including test cases, test runs, and issues. Requirements are traced backward to
the source of the requirement, such as a stakeholder or a regulatory compliance mandate.
The purpose of requirements traceability is to verify that requirements are met. It also
accelerates development. That’s because it’s easier to get visibility over
your requirements. Traceability is also important for analysis. If a requirement changes,
then you can use traceability to determine the impact of change. You’ll see what the
requirement is connected to. And you’ll be able to see how changing that requirement will
impact related issues or tests.

5.

2.Communication plays a vital role in the field of software engineering.Explain.

Communication skills represent nothing but the exchange of ideas, views,and information
with others. It is a valuable and beneficial elementobligatory in every profession. Great
communication is the most importantcharacteristic for success as a software engineer. A
big part of the day-to-day job of software engineering is not spent knee-deep in code but
ratherworking with a variety of folks across the company. It turns out softwareengineers,
like other knowledge-workers, spend a ton of time collaboratingacross IM, email, reading
designs, reviewing code and going to meetings.The role of software engineering involves
working across many parts of thecompany communicating with product management,
account management,support, operations, sales, customers and of course with our peers
andmanagers. As their career develops, software engineers end up spendingmost of their
time communicating rather than actually coding.Communication skills form a backbone
in the field of software engineering.Being a software engineer, one should practice
developing theircommunication every-day. This will help in dealing with the clients
and personas working with. If both the communication skills, verbal as well asnon-verbal
are tremendous one can execute their plans with effortlessly.People believe that the world
of software engineering can be run on the basisof technical knowledge, but they are
mistaken. In this field, communicationskills are as important as technical skills are to
work in the softwareengineering field.

5.Why do we need requirements engineering in software engineering?Explain.

Requirements engineering refers to the process of defining, documenting,and maintaining
requirements in the engineering design process.Requirement engineering provides the
appropriate mechanism to understandwhat the customer desires, analyzing the need, and
assessing feasibility,negotiating a reasonable solution, specifying the solution
clearly, validatingthe specifications and managing the requirements as they are
transformedinto a working system. Thus, requirement engineering is the
disciplinedapplication of proven principles, methods, tools, and notation to describe
a proposed system's intended behavior and its associated constraints. Whendeveloping a
software, one of the most important aspects for success of anysoftware project is to get
the requirements right. The success of any software project depends on the quality of the
requirements. As the projects change

adDownload to read ad-free