Software Engineering

UNIT I

Evolution of software ,Characteristics of software, Software

application domains, Components of software, Legacy
software, Software Engineering-layers, Practices-essence of
practice and software myths.(9Hrs)
 SOFTWARE ENGINEERING

Software is considered to be collection of executable

programming code, associated libraries and documentations.
Engineering on the other hand, is all about developing products,
using well-defined, scientific principles and methods.
Software Engineering is a part of computer science in which
several kind of method, thoughts and techniques used for getting
the high quality software and computer programs.
 NEED OF STUDYING SOFTWARE
ENGINEERING

Software engineering is important because specific software is

needed in almost every industry, in every business, and for every
function.
THE ROLE OF SOFTWARE ENGINEER
 SOFTWARE PRODUCT
The final software that is delivered to the customer is called the software
product. It is the outcome of the entire software development process.
It may include
• source code,
• data,
• user guides,
• reference manuals,
• installation manuals,
• specification documentation etc.
 SOFTWARE PROCESS
The software process is the entire way in which we produce the software.
It is the entire journey from the idea of the Software to the final release of
it. It includes all the activities that are performed to the form the final
Software product, like
• the requirement analysis,
• designing of the software
• coding
• testing
• documentation
• Maintenance, etc.
 FUNDAMENTAL ACTIVITIES IN
SOFTWARE PROCESS
• Software Specification
-defining specification of software product.
• Software Development
-designing and programming of the software.
• Software Validation
-the software is checked to make sure it satisfies the user needs.
• Software Evolution
-the software is modified to meet the changing requirement of the
user
 Software Evolution

Software Evolution is a term that refers to the process of

developing software initially, and then timely updating it for
various reasons, i.e., to add new features or to remove obsolete
functionalities, etc.
Evolution processes
Software evolution processes depend on:
● The type of software being maintained;
● The development processes used;
● The skills and experience of the people involved.
Change implementation
Design: Plan how to make the change.
Implementation: Write the code for the change.
Testing: Ensure the change works correctly and doesn’t introduce
new issues.
Program Understanding: If the original developers are not making
the changes, understand how the program works before modifying it.
Effect Analysis: Evaluate how the proposed change will impact the
existing system.
 Necessity of Software Evolution

• Change in requirement with time

• Environment change
• Errors and bugs
• Security risks
• For having new functionality and features
 Characteristics Of Software
A software product can be judged by what it offers and how well it can be used.
This software must satisfy on the following grounds:

● Maintainability
● Dependability
● Efficiency
● Usability
Maintainability refers to the ease with which software can be modified to
correct faults, improve performance, or adapt to a changed environment. It is a
critical characteristic that ensures the longevity and adaptability of software
systems.

Attributes:
- Modularity: Software components are divided into distinct modules, each
handling a specific function, making it easier to understand and modify.
-Readability: Clear, well-documented code that is easy for developers to read
and understand.
-Testability: The ease with which software can be tested to ensure it is
functioning correctly after modifications.
-Extensibility: The ability to add new features or enhance existing ones with
minimal effort
Dependability
Dependability encompasses various attributes that ensure the software
performs reliably and correctly. It includes aspects like availability, reliability,
safety, and security.

Attributes:
- Reliability: The ability of software to perform its required functions under
stated conditions for a specified period.
- Availability: The degree to which the software is operational and accessible
when required for use.
- Safety: The software's ability to operate without causing unacceptable risk
or harm.
- Security: Protection against unauthorized access, modification, and
ensuring data integrity and confidentiality.
Efficiency
Efficiency in software engineering refers to the optimal use of system resources,
such as CPU time, memory, bandwidth, and other computing resources. Efficient
software performs its functions without wasting resources.
Attributes:
○ Performance: The speed and responsiveness with which the software
executes tasks.
○ Resource Utilization: The effective management of system resources,
ensuring minimal wastage and maximal productivity.
○ Scalability: The ability to handle increased load or expand resources
without degradation in performance.
Usability
Usability is the ease with which end-users can learn to operate, prepare inputs for,
and interpret outputs of a system or component. It focuses on the user experience
and interaction.
Attributes:
- Learnability: How quickly and easily a new user can become proficient with the
software.
- Efficiency: How quickly a user can perform tasks once they have learned the
software.
- Memorability: How easily users can remember how to use the software after not
using it for a period.
- Error Handling: The ability to prevent errors and assist users in recovering
from them.
- Satisfaction: The degree to which users are happy with the software and find it
pleasant to use.
Software application domains
• Web Applications:
Examples: E-commerce sites, social media platforms, online banking
systems.
Focus: User interfaces for browsers, web servers, and internet-based
services.
• Mobile Applications:
Examples: Smartphone apps like Instagram, Uber, and fitness trackers.
Focus: Development for mobile operating systems (iOS, Android).
• Desktop Applications:
Examples: Microsoft Office Suite, Adobe Photoshop, local database
applications.
Focus: Software designed to run on personal computers with graphical user
interfaces.
● Embedded Systems:
Examples: Firmware in medical devices, automotive control systems, smart
home devices.

Focus: Software that operates on hardware with specific functionalities,

often with real-time constraints.

● Enterprise Applications:
Examples: Enterprise Resource Planning (ERP) systems, Customer
Relationship Management (CRM) systems.

Focus: Large-scale applications that manage and integrate business

processes and data within an organization.
● Gaming:
Examples: Video games, virtual reality experiences, simulation games.
Focus: Graphics, real-time performance, user interaction, and game mechanics.

● Scientific and Research Applications:

Examples: Data analysis tools, simulation software, research management
systems.
Focus: Handling complex computations, data processing, and domain-specific
algorithms.

● Healthcare Applications:
Examples: Electronic Health Records (EHR) systems, telemedicine platforms,
medical imaging software.
Focus: Managing patient data, supporting medical professionals, and ensuring
compliance with healthcare regulations.
●
●
● Finance and Banking:
Examples: Trading platforms, personal finance apps, banking systems.
Focus: Transaction processing, security, financial data analysis.

● Education and E-Learning:

Examples: Learning Management Systems (LMS), online courses, educational
games.
Focus: Facilitating learning and educational content delivery, tracking progress,
and interactive learning tools.
 Components of software
● A software component is a unit of software with a clear interface and defined
dependencies.
● Components can range from small reusable code blocks to entire applications.
● They help manage software complexity by breaking it into manageable parts.
● Each component hides its implementation complexity behind its interface.
● Components can be swapped like interchangeable machine parts.
● This simplifies software development, maintenance, operations, and support.
● Reusing the same code in different places becomes easier.
There are types of components
1. Off the shelf components : Existing software that can be acquired from the
third party
2. Full experience Components: Existing past projects that are similar to the
software to be built for the current project and team members have full
experience.
3. Partial Experience components: Existing past project that are related to the
software to be built for current project but needs substantial modifications.
4. New Components: Software components that must be built by the software
team specially for the needs of the current project.
 Legacy Software

The older programs which are developed decades ago that are still in use
by performing modifications in order to meet the business requirements.
The rapid increase of such systems may cause the risk to the larger
organizations as they may require outdated hardware and operating
system.

Many legacy systems remain supportive to core business functions and are
important to business.
Old Technology: Legacy software is built on older technology, programming
languages, or platforms that are no longer widely used or supported.

Critical Role: Despite being outdated, legacy software often plays a critical role
in the operations of businesses and organizations. It may handle important
functions that are difficult or expensive to replace.

Maintenance Challenges: Maintaining legacy software can be challenging due

to a lack of documentation, scarcity of skilled personnel familiar with the old
technology, and difficulty integrating with modern systems.

High Costs: Updating or replacing legacy software can be expensive and

time-consuming, leading many organizations to continue using it despite its
limitations.
The 4 Layers of Software Engineering
Layer 1 — Tools
The first layer involves choosing the semi-automated and automated tools that
will become the framework for the project. Some examples may include:

• Choosing Microsoft Publisher for web design

• Using Selenium for testing across platforms
• Using an integrated development environment (IDE) for building apps
Layer 2 — Method

The second layer establishes the methods of developing the software. This
includes any technical knowledge and resources required for development.
Some tasks include choosing methods for:

• Communication
• Analysis
• Modeling
• Program construction
• Testing and support
Layer 3 — Process
Layer three focuses on the framework that needs to be established to deliver
software effectively. This layer can be broken down into five sub-layers:
• Communication. First, communication with the client is required to
understand the needs, demands, criteria, and parameters of the project.
• Planning. This sub-layer involves making a map or blueprint to break down the
process of development and document goals, milestones, and plans.
• Modeling. For this part of the process, developers create a model so the client
can visualize the finished product.
• Construction. This sub-layer refers to the actual coding and testing of the
product.
• Deployment. This differs from modeling. Rather than just providing the client
with a model, the team delivers an actual version of the software for testing,
evaluation, and feedback.
Layer 4 — A Quality Focus

• Quality Control of Finished Product

• Testing Against Client Specifications
• Real-World Testing
• Compatibility with Existing Systems
Why Use the Layered Approach?

Laying out the tools, methods, and processes from the start of the software
engineering process and then communicating these decisions to the
development team allows clients, project managers, and team members to
periodically test the quality and usability of the end product. The layered
approach allows a team to deliver even complex software on budget and on
time.
Practices-essence of practice and software myths
 Software Engineering Practice
Essence of practice

• Understand the problem through communication.

• Plan a solution by modelling and designing.
• Carry out the plan (coding).
• Examine result for correctness (testing).
Principles of best practice
Software should provide value to users.
Keep the software design simple.
The vision of the project should be kept in mind throughout.
Keep your work products in an understandable format for others to
work with them easily.
Design in a way that can incorporate changes in future.
Build reusable components.
Think before acting or learn before starting.
Software Myths (False Belief)
Management myths
• Software practitioners follow the book of standards and procedures for
software development.
• If a delay occurs, programmers can be added at any point.
• Outsourcing helps.
Customer myths
• General requirements and not a detailed one is needed for starting
programming.
• Software is easy to change.
Practitioner’s myths (Developer’s myths)
• Software development is all about coding.
• Only a finished software can be tested.
• Software engineering has plentiful documentation and will slow down the
process.
Best Practices to Address These Myths:
● Education and Training: Provide training to developers on the full scope
of software engineering, including best practices in testing and
documentation.
● Agile Practices: Adopt Agile practices that emphasize the importance of
early testing and sufficient documentation without excessive overhead.
● Cultural Shift: Foster a culture that values all aspects of software
development, not just coding, and encourages collaboration and
continuous improvement.
● Feedback Loops: Implement regular feedback loops to continuously
improve processes and address any misconceptions or inefficiencies.