SEPM-1

11 October 2024 17:28

What is Software Engineering?

Software Engineering is the process of designing, developing, and maintaining software using
engineering principles. It's more than just writing code; it involves planning, analysis, design, testing,
and maintenance. The goal is to produce reliable, efficient, and maintainable software products.
Attributes of a Good Software
1. Correctness: The software must do what it is intended to do.
2. Reliability: It should perform consistently under expected conditions.
3. Efficiency: The software should use resources (like memory and CPU) wisely.
4. Maintainability: It should be easy to update or fix problems in the future.
5. Usability: The software should be easy to use for its intended audience.
6. Portability: It should be adaptable to different environments or platforms.
7. Security: It must protect data and operations from unauthorized access.
Key Challenges in Software Engineering
1. Complexity: Software systems can be highly complex, especially when serving different
platforms, users, or tasks.
2. Changeability: Requirements change over time as users or businesses evolve. Handling these
changes without breaking the software is difficult.
3. Scalability: As the number of users or data grows, ensuring the software remains fast and
functional becomes a challenge.
4. Quality Assurance: Ensuring software works correctly requires extensive testing, and bugs can
be hard to detect.
5. Security: As software is connected to the internet or handles sensitive data, protecting it from
malicious attacks is a constant challenge.
6. Resource Constraints: Developing software within a fixed time and budget is challenging,
especially with complex requirements.

……………

Software Process:
A process in software engineering is a set of activities, actions, and tasks aimed at creating a
software product.
1. Activity: A large task aimed at a general objective, like communicating with customers.
2. Action: A more focused set of tasks that lead to a major outcome, like creating an
architectural design.
3. Task: A small, specific job with a clear result, such as testing a piece of code.
Software Process Framework:
A framework is a structure that outlines the core activities involved in any software project. It
applies to all kinds of software development, no matter the project's size or complexity.
The 5 Key Framework Activities:
1. Communication: Talking with the customer to understand what they want, and

SEPM Page 1
 1. Communication: Talking with the customer to understand what they want, and
gathering all necessary requirements.
2. Planning: Creating a roadmap for the project that includes tasks, risks, resources,
deliverables, and timelines.
3. Modeling: Building models that represent how the software will work, making it easier
to understand for both developers and customers.
4. Construction: Writing the code and testing it to make sure it works correctly.
5. Deployment: Delivering the final product to the customer and collecting feedback for
improvements.

• Activity:
• Example: Communicating with the client to gather requirements for a new mobile app.
• This is a broad objective aimed at ensuring the client’s needs are well understood.
• Action:
• Example: Organizing a meeting with the client and creating a list of features the app
should include, such as push notifications, user login, and profile management.
• This is a more focused step within the communication activity that produces a major
outcome: gathering specific requirements.
• Task:
• Example: Sending a follow-up email to confirm the client’s preferences for the app’s
notification settings.
• This is a small, specific action aimed at completing a well-defined objective that directly
contributes to the communication action.

• Communication:
• Example: A company wants an e-commerce website. The development team
meets with the client to understand features like product categories, payment
gateways, and a shopping cart. They also gather specific needs, such as
international shipping and real-time stock updates.
• Planning:
• Example: The team creates a project plan after gathering requirements. The plan
includes tasks like designing the homepage, building the product catalog,
integrating payment systems, and testing. They also consider potential risks like
delays in third-party API integration and set deadlines for each phase.
• Modeling:
• Example: The team builds a wireframe showing the website layout, including
product images and "Add to Cart" buttons. They also create a flowchart that
outlines the steps a user will take from browsing products to completing a
purchase, including the checkout process.
• Construction:
• Example: Developers code the product catalog and shopping cart features. They
then test the "Add to Cart" and "Checkout" functions to ensure users can select
products, place them in the cart, and complete their purchases smoothly.
• Deployment:
• Example: After testing and fixing bugs, the e-commerce site is launched.
Customers start using the site, and the development team gathers feedback from
the client and users. They make adjustments, like improving the search function or
simplifying the checkout process based on this feedback.

How It Works:
• Communication: Requirements gathering and project initiation.
• Planning: Estimating time, cost, and resources, scheduling tasks.
• Modeling: Analyzing and designing the system.
• Construction: Writing the code and performing tests.
• Deployment: Delivering the software to the customer and providing support.

Prescriptive process models are structured approaches to software development that define
clear steps, phases, and activities. They bring order and discipline to software engineering,
especially when the requirements are well understood. These models provide a set of rules, or
a “prescription,” for how software projects should be carried out.
Here are the most commonly used prescriptive models:
1. Waterfall Model
2. Incremental Model
3. Evolutionary Model
1. Waterfall Model
The Waterfall model is one of the oldest and most traditional models. It follows a linear
sequence where each phase must be completed before moving on to the next.

SEPM Page 2
 • Phases of the Waterfall Model:
○ Requirements: Gather requirements from stakeholders.
○ Design: Create software architecture.
○ Implementation: Write the code.
○ Testing: Test the software to find bugs.
○ Deployment: Release the software to users.
○ Maintenance: Fix issues and update the software.
Diagram of Waterfall Model:

rust
Copy code
Requirements --> Design --> Implementation --> Testing --> Deployment --> Maintenance
2. Incremental Model
In this model, the software is developed in smaller pieces called "increments." Each increment
adds new features or functionalities, and the product is gradually improved.
• Phases of the Incremental Model:
○ Develop a core product (basic features).
○ Add more features or improvements in increments.
○ Each increment builds upon the previous one.
Diagram of Incremental Model:

mathematica
Copy code
Increment 1 --> Increment 2 --> Increment 3 --> Final Product

1. Waterfall Model
The Waterfall Model follows a strict, linear approach where each phase depends on the
completion of the previous one. It’s ideal for projects with well-defined requirements that are
unlikely to change.
Example: Building a School Website
Imagine you are tasked with developing a website for a school. The school has given you all
the details upfront, like the number of pages, design layout, and required features.
Steps in the Waterfall Model:
• Requirements: Collect all details about the pages (home, admission, contact, etc.),
functionalities (online admission form, timetable), and design preferences.
• Design: Create mockups of the website, showing how each page will look and how users
will navigate through the website.
• Implementation: Develop the actual website code, setting up the pages and adding
content.
• Testing: Test the website for bugs, such as broken links or incorrect form behavior.
• Deployment: Launch the website for public access.
• Maintenance: After launch, fix bugs or update information on the website if needed.
Diagram:

Copy code
Requirements --> Design --> Implementation --> Testing --> Deployment --> Maintenance
Once you move to the next step, you don't go back to previous steps easily.

2. Incremental Model
In the Incremental Model, software is developed and delivered in small, manageable pieces
(increments). Each increment builds on the previous one, gradually adding functionality.
Example: Developing a Mobile Banking App
You are tasked with building a mobile banking app, but the project is too large to deliver all
features at once.
Steps in the Incremental Model:

SEPM Page 3
Steps in the Incremental Model:
• Increment 1: Create the core app with basic features like login, balance checking, and
viewing transaction history.
• Increment 2: Add the ability to transfer funds between accounts.
• Increment 3: Implement mobile check deposit and bill payments.
• Increment 4: Introduce notifications for low balance or large transactions.
Each increment adds more value, and users can start using the app after the first increment.
Diagram:

Increment 1 --> Increment 2 --> Increment 3 --> Final Product

2. V-Model

The V-Model (Verification and Validation Model) is an extension of the Waterfall Model,
emphasizing testing and quality assurance throughout the process. For every development
phase, there is a corresponding testing phase to ensure verification and validation.
Key Phases of the V-Model:
• Requirements Analysis: Define and analyze user requirements.
• System Design: Design the overall system architecture.
• Architecture Design: Break the system into modules and define their interactions.
• Module Design: Create detailed designs for individual modules.
• Implementation: Write code for each module.
For each design phase, there’s a corresponding testing phase:
• Unit Testing: Test individual modules.
• Integration Testing: Test interactions between modules.
• System Testing: Ensure the system functions as a whole.
• Acceptance Testing: Validate the system against user requirements

xample: Building a Mobile App for a Bank

Let’s say you are developing a mobile banking app. The V-Model process looks like this:
1. Requirement Gathering (Left Side - Verification):
○ Collect all the features the bank wants in the app, such as balance checking, fund
transfer, etc.
○ Example: The bank wants users to be able to check their balance instantly.
2. System Analysis:
○ Understand how the app will work and what systems (like the bank's servers) are
needed.
○ Example: The app will need to connect to the bank's database to retrieve the
balance.
3. Software Design:
○ Plan how the app will be designed, both in terms of appearance and how the code
will be organized.
○ Example: The app will have a user-friendly dashboard for viewing balance and
transactions.
4. Module Design:
○ Break the app into smaller pieces (modules). For instance, one module handles
login, another handles checking balances.
○ Example: You will have a module for secure login and another for displaying
account details.
5. Coding:
○ Write the code for the app.

The Right Side of the V-Model: Validation (Testing)

Every phase on the right side tests the corresponding phase on the left side.
1. Unit Testing:
○ Test individual modules (like login or balance checking) to make sure each works
by itself.
Example: Ensure the login feature works correctly, and balance information

SEPM Page 4
 ○ Example: Ensure the login feature works correctly, and balance information
displays without errors.
2. Integration Testing:
○ Test how the different modules work together. For example, the login and balance
modules should connect smoothly.
○ Example: After login, the app should smoothly display the correct balance.
3. System Testing:
○ Test the entire app to ensure it works on different devices and conditions.
○ Example: Make sure the app works on both Android and iOS without bugs.
4. Acceptance Testing:
○ Finally, check if the app meets all the requirements set by the bank.
○ Example: Does the app allow users to easily check their balance and transfer
funds, as the bank requested?

• Start with rough ideas of what the software should do (Initial Rough Requirements).
• Decide on the features for the first version (Specification).
• Build and test the software (Development and Validation).
• Improve it based on feedback (Intermediate Versions).
• Continue improving until you reach the final version (Final Version).

The Evolutionary Process Model is a software development approach where the project
evolves gradually through small, repeated cycles. Instead of building the entire product at
once, it is developed in increments or iterations, where each version is improved based on
user feedback and testing.
Let’s break it down with a simple example:
Example: Developing an E-commerce Website
Imagine you’re building an online shopping website. The Evolutionary Process Model helps
you develop the website step-by-step, rather than trying to complete it all at once.

1. First Version (Initial Prototype)

• Gather Initial Requirements:
○ You meet with the client to understand the basic features. They ask for a simple
product listing and a shopping cart.
○ Example: The client wants a page where customers can see a list of products and
add them to a shopping cart.
• Develop the First Version:
○ Build a basic version of the website with these two features (product listing and
shopping cart).
○ Example: You create a page that displays products, and users can add products to
a simple cart.
• Test and Gather Feedback:
○ Launch the initial version and ask the client or users to test it. They might suggest
improvements.
○ Example: Users ask for a search bar to find products easily.

2. Second Version (Improved Prototype)

• Incorporate Feedback:
○ Based on the feedback, you add the search feature and improve the shopping cart.
○ Example: You create a search bar and enhance the cart so users can see item
prices and quantities.
• Test and Gather More Feedback:
○ Let the client and users test the second version. They might now request a
payment option and a wishlist.
○ Example: Users now want to pay online and save items for later.

3. Third Version (More Features)

• Add More Features:
○ In the next iteration, you implement the payment gateway and the wishlist
feature.
Example: You build a secure payment system and allow users to save items to

SEPM Page 5
 ○ Example: You build a secure payment system and allow users to save items to
their wishlist.
• Test Again:
○ Keep testing each new version with users to identify more areas for improvement.
○ Example: Now, users suggest adding customer reviews and delivery tracking.

Repeat the Cycle:

• With each iteration, you add new features, improve the existing ones, and fix any
problems.
• The website evolves with every version, slowly becoming a full-featured e-commerce
platform.

Summary of Evolutionary Process Steps:

1. Build a simple version first (based on initial requirements).
2. Test and get feedback from users or clients.
3. Improve the software by adding features and fixing issues.
4. Repeat the process, delivering better versions with each cycle.

Web Applications (WebApps) and their Unique Nature

In the early days of the internet (around 1990–1995), websites were simple collections of
linked text files with minimal graphics. As web technologies advanced, tools like HTML, XML,
and Java allowed websites to evolve into powerful, interactive platforms called WebApps.
Unlike traditional software, WebApps offer not only information but also computing
functionality to users, integrated with databases and business systems.
WebApps have several unique characteristics:
1. Network Intensiveness: WebApps run over a network (e.g., the internet) and cater to a
large audience, often globally.
2. Concurrency: Many users can access a WebApp at the same time.
3. Unpredictable Load: The number of users can vary greatly from one day to another.
4. Performance: Users expect fast responses; delays can lead them to leave the WebApp.
5. Availability: Users expect the app to be accessible almost all the time, day or night.
6. Data-driven: WebApps often present multimedia content like text, images, and videos,
and access large databases.
7. Continuous Evolution: WebApps are updated frequently, sometimes even on a minute-
by-minute basis.
8. Immediacy: Many WebApps have a short development timeline, sometimes only taking
a few days or weeks.
9. Security: Given their open nature, WebApps must ensure data security for users.
10. Aesthetics: The look and feel of WebApps are crucial, especially when they are designed
for marketing or sales purposes.

Software Engineering as a Layered Technology

Software engineering is a way to design and create software that is reliable, efficient, and easy
to maintain.
Think of it as being built in layers, where each layer is important for the next. Here's a simple
breakdown:
1. A Quality Focus (Bottom Layer)
This is the foundation. The organization must focus on quality. Just like when building a
house, the foundation must be strong, software also needs a strong base of quality.
Continuous improvements and ensuring the software is good at every stage are key.
Example: Imagine you're building an app. You want it to work well, not just today, but
for a long time. This requires paying attention to quality in every step.
2. Process (Second Layer)
The process layer is like a plan or map that helps guide the development of software. It
ensures that everything is done in a structured way—no missing steps, deadlines are
met, and changes are handled properly.

SEPM Page 6
 met, and changes are handled properly.
Example: Think of it as baking a cake. You follow a recipe (process), step by step, so you
don't forget any ingredients or steps, ensuring the cake turns out well.
3. Methods (Third Layer)
These are the specific actions or steps used to create the software. This includes talking
to customers, understanding what they want (requirements), designing the system,
writing the code, testing it, and fixing any problems.
Example: In our cake analogy, methods would include mixing the ingredients, baking,
and decorating the cake. Each action is important to complete the whole task.
4. Tools (Top Layer)
Tools are like machines or apps that help make the process faster and easier. In software
development, tools can help with coding, testing, and project management. When all
these tools work together, they create something called a CASE (Computer-Aided
Software Engineering), which makes the whole process smoother.
Example: For baking, tools like a mixer or oven make the process easier and faster, just
like how coding tools help developers write and test software quickly.

2.1.3 Process Patterns

Process patterns are predefined solutions to common process-related problems that software
teams encounter during development. They provide reusable strategies that can be applied
across different projects, ensuring effective and efficient problem resolution.
Components of a Process Pattern:
1. Pattern Name: A descriptive name indicating the problem it addresses (e.g.,
TechnicalReviews).
2. Forces: Describes the conditions under which the problem arises, such as project
complexity or conflicting requirements.
3. Type: There are three main types of process patterns:
○ Stage Pattern: Defines a problem related to a framework activity (e.g.,
Establishing Communication).
○ Task Pattern: Defines a problem related to a specific task (e.g., Requirements
Gathering).
○ Phase Pattern: Defines a sequence of framework activities within the process,
such as Spiral Model or Prototyping.
4. Initial Context: Describes the conditions before the pattern is applied, including what
the team has already accomplished.
5. Problem: The specific problem the pattern addresses.
6. Solution: The steps to implement the pattern and resolve the problem.
7. Resulting Context: The conditions after the pattern has been applied, including new

SEPM Page 7
 7. Resulting Context: The conditions after the pattern has been applied, including new
tasks that must be completed and changes in the project state.

• Pattern Name: User Authentication

• Forces: Users need a secure way to log in to protect personal information, but the login
process must be easy to use.
• Type: Task Pattern (since it's solving a specific task within the project).
• Initial Context: The website’s layout and product catalog are ready, but there’s no login
functionality.
• Problem: How to securely allow users to log in and access personalized information.
• Solution:
1. Create a login page.
2. Set up a database to store user credentials securely.
3. Implement password encryption.
4. Validate login details and handle errors like incorrect passwords.
• Resulting Context: Users can now log in securely. Next steps might include adding extra
security measures like email verification or two-factor authentication.

1. System Software
• Helps the computer itself run.
• Includes operating systems (like Windows) and device drivers (like printer software).
• Makes sure everything on your computer works smoothly.
2. Application Software
• Programs that solve specific problems or help with tasks.
• Examples: Word processors, games, or apps for businesses.
• Helps with tasks like creating documents or processing sales.
3. Engineering/Scientific Software
• Used for calculations, simulations, and technical tasks.
• Examples: Software for designing cars or predicting the weather.
• Helps scientists and engineers in research and development.
4. Embedded Software
• Built into devices like microwaves or cars.
• Controls specific functions within these devices.
• Examples: Software that controls a washing machine or manages car braking systems.
5. Product-Line Software
• Created for a wide range of users, like Microsoft Office or video games.
• Used by both businesses and individuals for everyday tasks.
• Examples: Word processors, spreadsheets, or inventory management systems.
6. Web Applications (WebApps)
• Software that runs through a web browser.
• Examples: Email services (like Gmail) or social media platforms (like Facebook).
• Can be simple websites or complex online tools.
7. Artificial Intelligence (AI) Software
• Mimics human intelligence in machines.
• Examples: Smart assistants (like Siri) or self-driving cars.
• Helps with tasks like voice recognition and decision-making.

SEPM Page 8