Software Engineering Lecture note

Software is the set of programs, procedures, algorithms and documentation that enable computers
to perform specific tasks. It acts as the bridge between the user and hardware, controlling computer
operations and facilitating meaningful use of the system.

Characteristics of Software
 Software cannot be touched or physically measured.
 Software is developed through design and logic rather than physical assembly.
 Software does not deteriorate like hardware; however, it may become obsolete due to changes
in user needs or technology.
 Software can be tailored to meet specific requirements.
 Software are often more complex than hardware systems due to logical interdependencies.

Components of Software
1. Programs: A set of instructions that perform specific tasks.
2. Data: Information processed by programs.
3. Documentation: Manuals, help files, and instructions that describe how to use or maintain
the software.
4. Configuration files: Parameters that control software behavior.

Software Engineering
Software Engineering is the systematic, disciplined, and quantifiable approach to the design,
development, operation, and maintenance of software.
It applies engineering principles to software creation with the goal of producing reliable, efficient, cost-
effective, and maintainable software.
Definition (IEEE Standard):
Software engineering is the application of a systematic, disciplined, quantifiable approach to the
development, operation, and maintenance of software.

The Software Crisis

The Software Crisis refers to the difficulties encountered in the early years of software development
when software projects began to fail frequently due to:
 Cost overruns and late delivery.
 Poor quality and unreliability.
 Difficulty in maintenance.
 Mismatch between user requirements and delivered product.
Causes of the Software Crisis
1. Rapid growth in computer power and demand for complex systems.
2. Lack of systematic methods for development.
3. Poor project management and documentation.
4. Inadequate testing and quality assurance.
5. Insufficient understanding of user requirements.
Solutions to the Software Crisis
 Adoption of software engineering principles.
 Introduction of structured and object-oriented programming.
 Development of software process models (e.g., Waterfall, Agile, Spiral).

1
  Emphasis on quality assurance, testing, and maintenance.
 Training and certification of software engineers.

Broadly, software is classified into two major categories:

 System Software
 Application Software
These two categories work together to deliver complete functionality to the user. System software
provides the platform and infrastructure, while application software performs user-oriented tasks.

Layered View of Hardware and Software

The above illustrates a layered view of hardware and software components, showing their
interdependence:
 Hardware Layer: Includes the physical components of the computer such as CPU, memory,
storage, and networking equipment. Hardware performs no useful function without software.
 System Software Layer: Sits directly above the hardware. It controls, manages, and
coordinates hardware components. The most essential example is the Operating System (OS),
which acts as an interface between hardware and application programs.
 Application Software Layer: The topmost layer, which interacts directly with the user. It
depends on system software to access hardware resources and provides tools or functionalities
to perform user-specific tasks such as word processing, education, entertainment, and
management.
This layered relationship ensures smooth operation and integration of all components in a computing
environment.

Categories of Software
A. System Software
System software is a collection of programs designed to manage and control hardware resources and
provide a platform for running application software.
Purpose
It facilitates the communication between hardware and user applications, ensuring efficient operation
of the entire computer system.
Examples
 Operating Systems (Windows, Linux, macOS)
 Device Drivers
 Utility Programs
2
  Firmware
 Network Management Systems
Functions of System Software
 Manages memory, processes, and storage.
 Controls input/output operations.
 Provides user interfaces (CLI or GUI).
 Facilitates networking and file management.
 Enhances performance through optimization and diagnostics.

B. Application Software
Application software refers to programs developed to help users perform specific tasks or solve
domain-related problems using the computer system.
It operates on top of system software and is user-oriented rather than hardware-oriented.
Main Categories of Application Software
1. Games and Entertainment Software
o Designed for leisure and recreation.
o Includes computer games, video simulations, and multimedia entertainment.
o Examples: FIFA, Chess Titans, Candy Crush, PlayStation applications.
2. Intelligent Applications
o Utilize artificial intelligence (AI) techniques to automate reasoning and learning.
o Include expert systems, neural networks, business decision systems, and robotic vision
software.
o Examples: Chatbots, machine learning tools, medical diagnosis systems.
3. Modeling and Simulation Applications
o Used for scientific, educational, military, and training simulations.
o Provide virtual environments to analyze behavior without real-world risk.
o Examples: Flight simulators, financial modeling software, physics simulation packages.
4. Real-Time Applications
o Designed to process data instantly and provide immediate responses.
o Common in control systems, telecommunications, and industrial monitoring.
o Examples: Air traffic control systems, missile control, and embedded systems.
5. Productivity Applications
o Support office, business, and personal productivity tasks.
o Include word processors, spreadsheets, and project management software.
o Examples: Microsoft Office Suite, Google Workspace, Trello.
6. Web-Based Applications
o Operate through web browsers and require internet connectivity.
o Support e-commerce, communication, and content management.
o Examples: Gmail, YouTube, Facebook, Amazon, WordPress.
7. Educational Applications
o Facilitate teaching, learning, and training.
o Include school management systems, e-learning platforms, and educational games.
o Examples: Google Classroom, Moodle, Duolingo, Khan Academy.
8. Domain-Specific Applications
o Developed for specialized fields or industries.
o Examples include banking, hospital management, or airline reservation systems.
3
 o Examples: Core Banking Systems, SAP ERP, Airline Ticketing Software.

Comparison Between System Software and Application Software

Feature System Software Application Software
Purpose Manages hardware and system operations Solves specific user problems
User Direct; interacts with end
Indirect; operates in the background
Interaction users
Dependency Independent of applications Depends on system software
Examples Operating Systems, Utilities, Compilers MS Word, AutoCAD, SPSS
Runs continuously during system
Execution Runs when initiated by users
operation

Importance of Understanding Software Types

 Enables effective system configuration and software management.
 Helps in selecting the appropriate tools for specific applications.
 Provides foundational understanding for software engineering practices.
 Supports integration between hardware and software for optimal performance.

Stages in Software Development

Software development follows a systematic sequence of stages aimed at producing high-quality
software efficiently and within budget.
These stages are often referred to as the Software Development Life Cycle (SDLC) representing the
phases of software from conception (identifying user requirements) to deployment and maintenance

The Software Development Life Cycle (SDLC) is the framework that describes the stages involved in
the creation of software from identifying user requirements to deployment and maintenance.

Stages of Software Development

Stages or phases in software development include:

Requirements phase: This is the first and most crucial phase in software development. It involves
identifying, gathering, and documenting the needs and expectations of users and stakeholders.
Activities in this phase are
Conducting feasibility studies.
Gathering requirements through interviews, questionnaires, and observation.
Preparing a Software Requirements Specification (SRS) document.

System and Software Design Phase: At this stage, the system’s overall structure is defined. It
transforms the “what” from the requirement phase into the “how” of implementation.
Activities in this phase are Architectural design (high-level design), Detailed design (low-level design).
Database and interface design.

4
Implementation (Coding) Phase: This is where actual programming takes place according to the
design specifications.
Activities in this phase are
Writing code in appropriate programming languages (e.g., Java, Python, C++).
Following coding standards and conventions.
Performing unit testing on individual modules.

Testing Phase: Testing is performed to verify and validate that the software works as intended and
meets user requirements.
Types of Testing
Unit Testing: Testing individual modules.
Integration Testing: Testing combined modules.
System Testing: Testing the entire software system.
Acceptance Testing: Testing by end-users before final delivery.

Deployment (Installation) Phase: After successful testing, the software is installed and made
operational in the user’s environment.
Activities in this phase are
Installing the system on user hardware.
Configuring the system for operation.
Conducting user training.
Performing initial performance monitoring.

Maintenance Phase: Maintenance is the longest phase of the software life cycle, involving corrections,
updates, and enhancements after deployment.
Types of Maintenance
 Corrective: Fixing bugs or defects found after delivery.
 Adaptive: Modifying the software to adapt to new environments.
 Perfective: Improving performance or adding new features.
 Preventive: Anticipating and preventing future problems.

Importance of the SDLC

 Provides a structured approach to software creation.
 Ensures project predictability and control.
 Improves product quality.
 Facilitates communication among team members.
 Reduces project risk and cost.

Models of Software Development

Different process models implement these stages in varied ways, including:
Waterfall Model
Incremental Model
Spiral Model
Agile Development Model
Prototype Model

5
Each model selects or rearranges stages depending on project type and complexity.

Waterfall Model: Development Phases, Activities, and Deliverables

The Waterfall Model is a sequential software development life cycle (SDLC) approach where progress
flows downward through clearly defined stages. Each phase depends on the deliverables of the
previous one, ensuring a structured and disciplined approach to software development. It is most
suitable for projects with well-defined requirements, stable objectives, and limited scope for change.
Phases of the Waterfall Model
The model consists of six main development phases: Analysis, Design, Coding, Testing, Installation,
and Maintenance supported by several umbrella activities such as project management,
documentation, quality assurance, and configuration management.

1. Analysis Phase
Activities:
•Collect and analyze system requirements from stakeholders.
•Define functional and non-functional requirements.
•Prepare feasibility and cost-benefit analyses.
• Document user needs and expectations.
Deliverables:
• Software Requirements Specification (SRS) document.
• Feasibility report and initial project plan.
• Requirement validation report.
2. Design Phase
Activities:
• Transform requirements into a detailed system design.
• Develop architectural design (overall system structure).

6
• Create detailed design for each module, data flow, and interface.
• Review and validate design consistency and feasibility.
Deliverables:
• System Design Document (SDD) or Design Specification.
• Data models, UML diagrams, and interface designs.
• Prototypes (if applicable) for critical modules.

3. Coding (Implementation) Phase

Activities:
• Convert design documents into actual code using appropriate programming languages.
• Perform unit testing for each module to ensure functionality.
• Integrate code according to design specifications.
• Maintain version control and configuration records.
Deliverables:
• Source code modules and compiled executables.
• Unit test reports.
• Version-controlled repository.

4. Testing Phase
Activities:
• Integrate all modules into a complete system.
• Conduct integration testing, system testing, and acceptance testing.
• Verify that the software meets all specified requirements.
• Detect and correct defects through iterative feedback.
Deliverables:
• Test plan and test cases.
• Bug/defect reports and test results summary.
• Verified and validated system ready for deployment.

5. Installation Phase
Activities:
• Deploy the tested system in the production environment.
• Configure the software to match user and hardware requirements.
• Conduct user training and prepare operation manuals.
• Obtain user acceptance and handover documentation.
Deliverables:
• Deployed software system.
• User manuals and training materials.
• System acceptance report.

6. Maintenance Phase
Activities:
• Monitor software performance in the user environment.
• Fix post-deployment bugs or performance issues.

7
• Implement updates, patches, and enhancements.
• Provide ongoing technical support and user assistance.
Deliverables:
• Updated software versions.
• Maintenance logs and issue tracking reports.
• Performance improvement documentation.

Ongoing Umbrella Activities

Across all phases, several supportive (umbrella) activities ensure quality and coordination:
• Project Management and Metrics – Planning, scheduling, and progress tracking.
• Quality Assurance – Verification and validation of each deliverable.
• Documentation – Maintaining design, code, and test records.
• Configuration Management – Version control and change tracking.
• Technical Support and Training – Preparing users and staff for deployment.
• Operations and Support – Managing the system post-deployment.

Characteristics
• Linear and sequential flow.
• Each phase has specific entry and exit criteria.
• Emphasizes documentation and milestone tracking.
• Ideal for predictable, low-risk projects.

Prototype Model: Development Phases and Activities

Prototype Model is a software development approach that emphasizes the creation of a working
model (prototype) of the system early in the development process. The prototype serves as an
experimental version of the product that helps stakeholders visualize requirements, validate
functionality, and refine system specifications before full-scale development begins.
This model reduces the risk of misunderstandings, improves requirement accuracy, and ensures
that the final system aligns closely with user expectations.

In the diagram, prototyping is embedded within the Waterfall framework, allowing feedback loops
between requirements, specifications, and design stages.

8
Phases and Key Activities
1. Prototype Requirements Phase: involves gather preliminary requirements and identify the core
functionalities to be represented in the prototype.
Activities:
 Conduct initial user interviews and feasibility studies to define basic needs.
 Identify ambiguous, high-risk, or complex requirements suitable for prototyping.
 Prepare an outline of system objectives, data inputs, processing needs, and expected outputs.
 Define the scope and goals of the prototype—whether it will demonstrate user interfaces, system
performance, or critical functions.
Deliverables:
 Preliminary requirements document
 Prototype plan outlining key features and scope
2. Specification Phase involves translate user requirements into detailed system specifications
through iterative prototype feedback.
Activities:
 Develop an initial prototype representing core functionalities or user interface elements.
 Present the prototype to users for evaluation and feedback.
 Modify and refine requirements based on user input until the desired clarity and
functionality are achieved.
 Finalize Software Requirement Specifications (SRS) based on validated user needs.
Deliverables:
 Revised prototype versions
 Validated Software Requirement Specification (SRS)
 User feedback documentation

3. Design Phase: involves create a system design that reflects the validated requirements from the
prototype.
Activities:
 Transform approved requirements into system and software architecture designs.

9
  Develop data models, interface designs, and workflow diagrams.
 Reuse insights from the prototype (e.g., user interface layouts, process logic).
 Review design for consistency and feasibility.
Deliverables:
 System Design Document (SDD)
 Data flow and architecture diagrams
 Interface specifications

4. Coding (Implementation) Phase: involves convert the design specifications into executable code.
Activities:
 Implement system modules using suitable programming languages.
 Integrate prototype components where applicable.
 Conduct unit testing for each module to ensure correctness.
 Perform internal code reviews for optimization and standard compliance.
Deliverables:
 Source code files
 Unit test reports
 Integrated build of the software system

5. Testing Phase involves validate the complete system against the specified requirements.
Activities:
 Conduct integration, system, and user acceptance testing (UAT).
 Verify that functionalities match those refined during the prototype stage.
 Identify and correct defects or performance issues.
 Ensure all user requirements are met satisfactorily before release.
Deliverables:
 Test plan and test case documentation
 Bug and defect reports
 Verified and validated software product

6. Operations Phase involves deploy the finalized system into the operational environment and
provide ongoing support.
Activities:
 Install the software on target systems.
 Conduct user training sessions and deliver user manuals.
 Provide post-deployment maintenance, updates, and enhancements.
 Monitor system performance and address user feedback for improvement.
Deliverables:
 Deployed system
 User and training manuals
 Maintenance and support reports

Feedback and Iteration Mechanism: The dotted feedback arrows in the diagram represent the
iterative nature of the prototype model within the Waterfall framework.
 Feedback flows back from Design, Coding, and Testing to earlier stages (Specifications and
Requirements).

10
  This ensures that errors, ambiguities, or missing requirements discovered later are corrected
promptly.
 The prototype thus acts as a communication bridge between developers and users,
promoting a shared understanding of the system’s behavior before final implementation.

Advantages of the Prototype Model

 Enhances understanding of user requirements through visualization.
 Reduces risk of requirement misunderstanding and rework.
 Improves user involvement and satisfaction.
 Facilitates early detection of design and logic flaws.
 Allows flexibility to incorporate changes at early stages.

Limitations
 Frequent prototype revisions may increase development time and cost.
 Users may mistake the prototype for the final product.
 Poorly managed prototypes can lead to scope creep.
 Inappropriate for projects with well-defined, stable requirements.

Incremental and Iterative Model in Software Development

The Incremental and Iterative Model is a hybrid software development approach that combines
elements of both incremental development (building software in parts or releases) and iterative
refinement (revisiting and improving existing components). Instead of delivering the entire system at
once, the product is developed and delivered in multiple increments, where each increment adds new
features or improves existing functionality based on feedback.
This model ensures progressive enhancement, early delivery of working software, and continuous
user engagement throughout the development cycle.
 Incremental Development: The system is built in small, manageable portions (increments), each
delivering a functional product.
 Iterative Development: Each increment is refined and improved through multiple iterations
based on user feedback, testing, and performance evaluation.
 Prioritization: Requirements are prioritized and implemented in stages—high-priority features
are developed first, followed by medium and low-priority ones.

Phases of the Incremental and Iterative Model

1. Requirements Analysis and Prioritization
In this phase, all system requirements are identified, analyzed, and prioritized according to their
importance and dependency. Critical and high-value features are scheduled for early increments,
while less critical ones are postponed to later releases.
Activities:
 Gather functional and non-functional requirements.
 Analyze dependencies among requirements.
 Prioritize based on business value and user needs.
 Prepare a roadmap for multiple releases.
Deliverables:
 Requirements Specification Document.

11
  Prioritized Requirements List.
 Incremental Development Plan.

2. Incremental Design
Each increment is designed to integrate seamlessly with previous releases while maintaining system
scalability and modularity.
Activities:
 Design the architecture to support modular expansion.
 Define the design for each release (UI, database, and system logic).
 Review design consistency with previous increments.
Deliverables:
 Incremental Design Document.
 Updated Architectural Blueprint.
 Interface and Data Flow Diagrams.

3. Implementation (Development)
Development occurs in iterations, where each increment builds upon the previous one. Each
iteration produces a working system with new or improved functionality.
Activities:
 Develop and code modules defined for the current increment.
 Integrate with previously developed components.
 Conduct unit and integration testing.
 Record feedback for the next iteration.
Deliverables:
 Executable Increment (partial product).
 Source Code Repository.
 Integration and Unit Test Reports.

4. Testing and Integration

Each increment undergoes thorough testing to ensure that new functionality works correctly and that
previous components are not affected (regression testing).
Activities:
 Conduct system and acceptance testing.
 Verify integration with earlier increments.
 Fix defects and refine components.
 Validate user requirements for the current release.
Deliverables:
 Test Reports and Bug Logs.
 Updated System Documentation.
 Verified Increment.

5. Deployment (Release)
After testing, each increment is deployed for user evaluation and real-world use. This enables early
feedback and continuous improvement.

12
Activities:
 Deploy the increment to the production or pilot environment.
 Provide user training and operational support.
 Collect user feedback for future iterations.
Deliverables:
 Deployed System Increment.
 User Manuals and Release Notes.
 Feedback and Performance Reports.

6. Maintenance and Iteration

Maintenance ensures continuous enhancement of the software after each release. Issues, user
feedback, and performance data are used to plan and refine subsequent increments.
Activities:
 Monitor software performance.
 Fix post-deployment issues.
 Implement updates and feature enhancements.
 Plan next iteration based on user feedback.
Deliverables:
 Updated Software Version.
 Maintenance Reports.
 Refined Requirement List for Next Iteration.

Release 1: Top priority requirements

- Requirements specification
- Design
- Implementation
- Integration
- Deployment

13
Release 2: Medium priority requirements
- Requirements specification
- Design
- Implementation
- Integration
- Deployment

Release 3: Low priority requirements

- Requirements specification
- Design
- Implementation
- Integration
- Deployment
(Each release delivers a functional product that builds upon the previous release, forming a continuously
improving system.)

Advantages
 Enables early delivery of a working system.
 Supports user feedback and continuous improvement.
 Reduces project risk by identifying issues early.
 Easier to manage and test smaller increments.
 High flexibility—new features can be added in later releases.

Disadvantages
 Requires careful planning and integration management.
 Frequent iterations may increase project complexity.
 Continuous user involvement may not always be feasible.
 Overall cost may increase due to repeated testing and deployment.

Use Cases
 Web and mobile application development.
 Government, healthcare, and educational systems needing phased rollouts.
 Systems requiring early operational prototypes.

Spiral Model of Software Development

The Spiral Model is a software development process model that combines the iterative nature
of prototyping with the systematic aspects of the Waterfall model. It is a risk-driven process
model that allows for incremental releases of a system through multiple iterations (or spirals).

14
This model emphasizes risk analysis and management, making it highly suitable for large,
complex, and high-risk projects where requirements are not well understood from the
beginning.

The Spiral Model is represented as a spiral-shaped diagram where each loop represents a
development phase of the software. Each loop in the spiral corresponds to a phase in the
software process, and the spiral continues outward as the project progresses.

The model is divided into four quadrants, each representing a specific set of activities:
1. Determine objectives, alternatives, and constraints
2. Evaluate alternatives and manage risks
3. Develop and verify
4. Plan the next phase

As the development progresses through these quadrants, the software evolves through
continuous refinement and expansion.

Phases of the Spiral Model

Phase I: determine objectives, alternatives, and constraints
 This is the first quadrant of the spiral.
 The primary goal is to define the objectives of the phase, identify possible alternatives,
and list constraints (such as budget, technology, time, and resources).
 Activities include:
o Defining project goals and success criteria.
o Identifying functional and non-functional requirements.
o Exploring alternative approaches (e.g., using a new framework or technology).
o Recognizing potential limitations.

Example: During requirements planning, objectives such as performance, user interface

design, and response time are identified.
Phase II: Evaluate alternatives and manage risks
 This is the second quadrant of the spiral.
15
  The focus is on evaluating the alternatives identified in the previous phase and
performing risk analysis to minimize potential project failures.
 A prototype may be developed to better understand uncertain requirements or to
assess feasibility.
 Activities include:
o Risk identification and analysis.
o Evaluating and comparing alternative solutions.
o Building prototypes for high-risk areas.
o Performing simulations or experiments for technical feasibility.

Phase III: Develop and Verify

 This is the third quadrant of the spiral.
 The selected approach is implemented and verified through design, coding, and testing.
 Each iteration results in a partial or complete version of the software.
 Activities include:
o Detailed design and coding.
o Unit and integration testing.
o Verification of prototype and user validation.
Phase IV: Plan the Next Phase
 This is the fourth quadrant of the spiral.
 Based on the results from the previous phases, plans for the next iteration of the spiral
are prepared.
 The focus is on project management and progress review.
 Activities include:
o Reviewing performance and deliverables.
o Updating project schedules, cost estimations, and milestones.
o Planning the next cycle (next spiral loop) with improved requirements or
expanded scope.

Diagram Explanation
The attached Figure 2.4: Spiral Model for Software Development and Maintenance clearly
illustrates the cyclical nature of the process:
 The radial dimension represents increasing cost and effort.
 The angular dimension represents progress in completing each cycle.
 Each loop corresponds to one iteration in the software process.
 The risk management line shows the central role of risk analysis and prototype
evaluation throughout the process.
 The spiral expands outward as the software evolves from the conceptual stage to a fully
developed system.

Advantages of the Spiral Model

1. Risk Management: Risks are identified and mitigated early through analysis and
prototyping.
16
2. Flexibility: Incorporates user feedback and changes at any stage of development.
3. Progressive Refinement: The system evolves with each iteration, improving accuracy and
performance.
4. Customer Satisfaction: Early prototypes ensure continuous user involvement and
validation.
5. Systematic Control: Combines structured and iterative approaches effectively.

Disadvantages of the Spiral Model

1. Complexity: The model is more complex to manage compared to linear models.
2. High Cost: Requires significant expertise and resources for risk assessment.
3. Not Suitable for Small Projects: Overhead of risk analysis makes it less efficient for small-
scale projects.
4. Time-Consuming: Repeated cycles and validations can extend development time.
5. Dependence on Expertise: Success depends heavily on the skill of project managers and
risk analysts.

Applications of the Spiral Model

The Spiral Model is ideal for:
 Large, complex, and high-risk software projects.
 Projects requiring frequent changes and customer feedback.
 Research and development systems.
 Real-time systems such as aerospace, defense, and banking software where reliability
and risk management are critical.

Agile Development Model in Software Engineering

The Agile Development Model is an adaptive and collaborative software development approach that
emphasizes flexibility, customer satisfaction, iterative progress, and rapid delivery of high-quality
software.
Agile focuses on short, time-boxed development cycles called sprints or iterations, where teams
continuously plan, design, develop, test, and deliver working software.
Agile is built with the following parameters:
 Individuals and interactions over processes and tools,
 Working software over comprehensive documentation,
 Customer collaboration over contract negotiation, and
 Responding to change over following a fixed plan.

Iterative and Incremental: Software is developed in small, functional increments that evolve over
multiple iterations.
Continuous Feedback: Customer feedback is integrated at every stage of development.
Cross-Functional Teams: Developers, testers, and stakeholders work collaboratively.
Adaptability: Requirements can change even late in the project.
Time-Boxed Sprints: Each sprint (usually 2–4 weeks) results in a working product increment.

17
Phases of the Agile Development Model
1. Requirement Gathering and Planning
This phase begins with high-level requirements and user stories that define what the customer needs.
Unlike traditional methods, Agile does not freeze all requirements at the start. Instead, they are
continuously refined throughout the development process.
Activities:
 Conduct stakeholder meetings to identify user needs.
 Create Product Backlog (a prioritized list of features).
 Define Sprint Goals and select items for the current sprint.
 Formulate user stories and acceptance criteria.
Deliverables:
 Product Backlog.
 Sprint Backlog.
 User Stories and Acceptance Criteria.
 Initial Project Plan.

2. Design and Architecture

In Agile, design is iterative and adaptive. The focus is on creating a simple, scalable design that can
evolve as requirements change.
Activities:
 Develop a high-level architecture for the entire system.
 Create detailed design only for features planned in the current sprint.
 Use modeling tools (UML, wireframes) for visual clarity.
 Review design collaboratively with the team.
Deliverables:
 System Architecture Document.
 Sprint Design Specifications.
 Updated Backlog and Wireframes.

3. Development (Implementation)
The development phase focuses on coding the selected user stories for the sprint. Agile emphasizes
collaborative coding, pair programming, and daily communication to maintain progress and
transparency.
Activities:
 Implement user stories assigned for the sprint.
 Conduct daily stand-up meetings (Scrum meetings).
 Maintain version control and continuous integration.
 Update sprint backlog as tasks progress.
Deliverables:
 Working Increment (functional product).
 Updated Source Code Repository.
 Sprint Progress Reports.

4. Testing
Testing is integrated throughout the sprint, not delayed until the end. Agile promotes test-driven
development (TDD) and continuous testing to ensure quality.

18
Activities:
 Conduct unit, integration, and acceptance testing.
 Automate regression testing where possible.
 Collaborate between developers and testers for quick bug resolution.
 Validate each user story against acceptance criteria.
Deliverables:
 Tested Product Increment.
 Test Reports and Defect Logs.
 Updated Documentation and Test Cases.

5. Deployment and Review

At the end of each sprint, the working product increment is delivered to the customer or stakeholder
for review and feedback.
Activities:
 Conduct Sprint Review Meeting to demonstrate completed work.
 Gather user feedback and performance evaluation.
 Prepare deployment documentation if release-ready.
Deliverables:
 Deployed Sprint Increment.
 Sprint Review Report.
 Updated Product Backlog based on feedback.

6. Feedback and Retrospective

After deployment or review, the team holds a Sprint Retrospective to analyze performance, identify
bottlenecks, and plan improvements for the next sprint.
Activities:
 Review sprint performance and team collaboration.
 Identify what went well and what can be improved.
 Adjust workflow, tools, or communication strategies.
 Plan the next sprint with refined priorities.
Deliverables:
 Retrospective Report.
 Improved Agile Practices.
 Next Sprint Plan.

Illustration
Agile Development Lifecycle Diagram
(The diagram will be inserted in the Word version as a labeled graphic.)
+---------------------------------------------------------------+
| Agile Development Lifecycle (Iterative) |
+---------------------------------------------------------------+
| 1. Requirement Gathering → 2. Design → 3. Development → 4. Testing → 5. Deployment |
| ↑ ↓ |
| ←←←←←←←←←←←←←←←← 6. Feedback & Retrospective ←←←←←←←←←←←
|
+---------------------------------------------------------------+

19
Each cycle (Sprint) delivers a working software increment ready for review.

Advantages
 Delivers functional software quickly and frequently.
 Highly flexible to changing requirements.
 Promotes strong collaboration and transparency.
 Early identification of defects and risks.
 High customer satisfaction due to continuous involvement.
 Encourages continuous improvement.
Disadvantages
 Requires frequent customer involvement.
 Difficult to predict final cost and timeline.
 Documentation may be limited or less formal.
 Demands skilled, self-disciplined teams.
 Not ideal for very large or highly regulated projects without adaptation.

Use Cases
 Dynamic projects with rapidly changing requirements.
 Startups or innovation-driven product development.
 Web and mobile app development.
 Software-as-a-Service (SaaS) solutions.
 Collaborative environments requiring quick market release.

Software Errors
Software error (or bug) is any defect, fault, or mistake in a program that causes it to produce incorrect
or unexpected results, or to behave in unintended ways.
In essence, an error occurs when the software does not do what it is supposed to do according to
requirements or specifications.

Sources of Software Errors

Software errors may arise at any stage of development. Common sources include:
 Requirement Errors: Incomplete or misunderstood user requirements and conflicting
specifications.
 Design Errors: Poor system architecture and Inconsistent data flow or control flow designs.
 Coding Errors: Syntax mistakes, logic errors, or incorrect algorithms and improper variable use
or data type mismatches.
 Interface Errors: Incompatibility between software modules or between software and hardware.
 Documentation Errors: Inaccurate manuals or misleading instructions.
 Human Errors: Mistakes made by programmers, testers, or users due to carelessness or
misunderstanding.

Types of Software Errors

Error Type Description Example
Syntax Error Violation of programming Missing semicolon or
language rules. parenthesis
20
 Logic Error Incorrect reasoning or Wrong formula in computation.
algorithm design.
Runtime Error Error that occurs during Division by zero, file not found.
program execution.
Interface Error Mismatch between components Wrong data format passed
or systems. between modules.
Validation Error Occurs when input is not Accepting invalid user data.
properly checked.
Design Error Faulty architecture or Poor modularization leading to
structure. failure.

Consequences of Software Errors

 System malfunction or crash.
 Data loss or corruption.
 Financial loss to users or organizations.
 Security vulnerabilities and breaches.
 Damage to developer or company reputation.
 Increased cost of correction and maintenance.

Error Prevention and Reduction Techniques

1. Clear Requirement Specification: Ensure complete and precise documentation.
2. Use of Standards and Guidelines: Follow coding and design conventions.
3. Code Reviews and Inspections: Regular peer checks during development.
4. Automated Testing: Use testing tools to detect early bugs.
5. Version Control Systems: Track and manage software changes.
6. Proper Documentation: Accurate and updated manuals for developers and users.
7. Training and Quality Assurance: Ensure staff are competent and adopt QA processes.

Error Detection and Correction

Software testing and debugging are used to identify and correct errors.
Testing: Identifies presence of errors.
Debugging: Locates and removes the cause of errors.
Verification and Validation (V&V): Ensures software meets design and user expectations.

Relationship between Error, Fault, and Failure

These three terms are related but distinct in software quality:
Term Meaning Example

Error A human mistake made during Wrong logic in code.

development.
Fault (Bug) The manifestation of an error in Incorrect algorithm
code or design. implemented.
Failure The observable incorrect Program crashes or produces
behavior during execution. wrong output.

21
Software Reliability and Errors
The number and severity of errors affect software reliability defined as the probability that software
performs correctly over a specified time and environment.
To achieve high reliability: Minimize defects. Apply continuous testing. Implement preventive
maintenance.

Software Behavior, Structure, and Architecture

Software Behavior
Software behavior refers to how a software system acts or responds when it is executed under
specified conditions. It describes what the software does its functionality, performance, and reactions
to user inputs and environmental factors.

Software Behavior can be categories into four

1. Functional Behavior: Defines the operations or services that the software provides. It concerned
with the outputs produced from given inputs. Example: A payroll software computing employee
salaries accurately.
2. Non-Functional Behavior: Refers to quality attributes such as reliability, speed, usability, security,
and scalability. Example: How fast a system responds to user queries or how secure it keeps data.
3. Reactive Behavior: Behavior triggered by external events or user actions. Example: A security
system responding to motion detection.
4. Deterministic vs. Non-Deterministic Behavior:
Deterministic: Produces the same output for the same input every time (e.g., a calculator app).
Non-Deterministic: May produce different outcomes depending on timing or external factors (e.g.,
network-based software).

Factors Influencing Software Behavior

Quality of algorithms used.
Design of software architecture.
Hardware and network environment.
Input data and user interaction.
Internal system configuration.

Software Structure
Software structure refers to the organization or arrangement of components and modules within a
software system and how they interact to perform overall system functions. It is the skeleton or
framework that defines relationships among different parts of the software.

Levels of Software Structure

1. Module Level: The software is divided into modules or units, each performing a specific function.
Example: Login module, database module, user interface module.
2. Component Level: A collection of modules grouped together to provide a set of related services.
Example: Payment processing component in an e-commerce system.
3. Subsystem Level: A combination of related components forming a major functional area.
Example: Student information subsystem in a university management system.
4. System Level: The complete integrated software composed of all subsystems working together.

22
Characteristics of a Good Software Structure
 Modularity: Software is divided into independent units for easier development and maintenance.
 Cohesion: Each module performs a single, well-defined task.
 Low Coupling: Modules interact minimally, reducing dependency.
 Hierarchy: Clear organization from high-level to low-level components.
 Scalability: Ability to add or modify features without major restructuring.

Software Architecture
Software architecture is the high-level structural design of a software system that defines its
components, their interactions, and the principles guiding its construction and evolution.
It serves as the blueprint for both system design and implementation.

Elements of Software Architecture

1. Components: The independent units that encapsulate specific functionality.
2. Connectors: The interfaces or communication links between components (e.g., APIs, data buses).
3. Configuration: The overall arrangement of components and connectors in the system.
4. Design Principles: The rules and patterns that guide system organization (e.g., layered design,
client-server model).
Common Software Architectural Styles
1. Layered Architecture: System organized into layers (presentation, business logic, data access).
Example: Web applications.
2. Client-Server Architecture: Division between clients (users) and servers (providers of services).
Example: Email systems.
3. Pipe-and-Filter Architecture: Data flows through a sequence of processing units.
Example: Compilers and data transformation software.
4. Event-Driven Architecture: System components communicate via events.
Example: User interface systems and IoT applications.
5. Microservices Architecture: System broken into small, independent services that communicate
through APIs.
Example: Modern cloud-based applications (Netflix, Amazon).

Importance of Software Architecture

 Provides a clear vision and structure for developers.
 Promotes reusability and scalability.
 Enhances system performance and maintainability.
 Enables effective team coordination.
 Helps manage complexity in large projects.

Software Stakeholders
A software stakeholder is any individual, group, or organization that has an interest, influence, or
role in the software system during its development, operation, or maintenance.
Stakeholders can be internal (within the development organization) or external (outside users, clients,
or regulators).

Categories of Software Stakeholders

 End Users: People who directly interact with and use the software in daily operations.
23
 Example: Bank tellers using a banking application. It concern usability, reliability, and
performance.
 Clients or Customers: Organizations or individuals who commission and pay for the software.
Example: A company contracting developers to build an inventory system. It concern cost, delivery
time, functionality, and ROI.
 Software Developers: Programmers, engineers, and designers responsible for building the system.
It concern clear requirements, suitable tools, and maintainable code.
 Project Managers: Oversee the planning, execution, and delivery of software projects. It concern
budget, schedule, resources, and risk management.
 Testers/Quality Assurance (QA) Engineers: Validate that the software functions as intended. It
concern error detection, reliability, and performance testing.
 System Administrators: Manage software deployment, configuration, and maintenance after
release. It concern security, scalability, and operational efficiency.
 Business Analysts: Translate business needs into technical requirements. It concern requirement
accuracy and alignment with business goals.
 Regulatory Authorities: Government or industry bodies that ensure compliance with standards.
Example: Data protection agencies, ISO, IEEE. It concern safety, ethics, data privacy, and legal
compliance.
 Investors and Sponsors: Provide financial support for software projects. It concern profitability,
project success, and sustainability.
 Maintenance and Support Staff: Handle updates, user training, and bug fixes after deployment. It
concern system stability and customer satisfaction.

Roles and Responsibilities of Stakeholders

Stakeholder Responsibility Primary Concern
End Users Operate the software Ease of use, reliability
Clients Fund and approve software Cost, performance
Developers Design and implement system Code quality, efficiency
Project Manager Coordinate activities Time, cost, quality
Testers Validate software Error-free system
Administrators Maintain system Security, uptime
Regulators Ensure compliance Safety, standards
Investors Provide funding Return on investment

Importance of Identifying Stakeholders

 Ensures all needs and expectations are captured early.
 Reduces project risks and misunderstandings.
 Promotes better communication and collaboration.
 Facilitates successful project acceptance and adoption.

Software Engineering, Training, and Certification

Software engineering is a professional and technical discipline that requires formal education,
continuous training, and certification to ensure competence, ethical conduct, and adherence to global
standards.

24
As software systems become more complex and critical, well-trained and certified software engineers
are in high demand across industries.

Software Engineering Training

Software engineering training involves hands-on and practical skill development through internships,
workshops, industrial attachments, and on-the-job experiences.

Reasons for Training

 Bridge the gap between theoretical knowledge and practical application.
 Develop teamwork, leadership, and communication skills.
 Expose learners to real-world tools, environments, and methodologies.
 Keep professionals updated with emerging technologies.

Forms of Software Engineering Training

1. Industrial Training (SIWES/Internship): Practical exposure in IT industries.
2. Workshops and Bootcamps: Short-term focused skill development sessions.
3. Online Training: Remote learning via platforms like Coursera, Udemy, and edX.
4. In-House Corporate Training: Conducted by companies for their staff on specific technologies.

Software Engineering Certification

Certification is a formal recognition or credential issued by professional bodies or organizations
confirming that an individual possesses the required skills and knowledge to perform software
engineering tasks competently.

Importance of Certification
 Demonstrates professional credibility and expertise.
 Enhances employability and career advancement.
 Promotes global recognition and standardization.
 Encourages lifelong learning and specialization.
 Builds client and employer trust in the engineer’s competence.
Examples of Recognized Software Engineering Certifications
Certification Issuing Organization Focus Area
Certified Software Development IEEE Computer Society Professional software
Professional (CSDP) development skills
Certified Software Engineer Institute for Certification of General software engineering
(CSE) Computing Professionals (ICCP) competence
Microsoft Certified: Azure Microsoft Cloud-based software solutions
Developer Associate
Oracle Certified Java Oracle Corporation Java programming and
Programmer (OCJP) application development
Agile Certified Practitioner Project Management Institute Agile development
(PMI-ACP) methodologies
ISTQB Certified Tester International Software Testing Software testing and quality
Qualifications Board assurance

Software Engineering Professional Development

Software engineers must continuously update their skills due to rapid technological evolution.

25
This involves:
 Attending seminars, conferences, and workshops.
 Engaging in continuous professional development (CPD) programs.
 Reading research journals and industry publications.
 Participating in professional associations such as ACM, IEEE, and NSE.

Code of Ethics and Professional Practice

A code of ethics is a set of principles and professional standards that guide the behavior and decision-
making of individuals in a profession.
In software engineering, it defines how software engineers should conduct themselves professionally,
ensuring that their actions promote honesty, fairness, quality, and public welfare.
It establishes the moral and professional obligations of software engineers to clients, employers,
colleagues, and society.

Purpose of Code of Ethics

The purpose of having a code of ethics in software engineering is to:
1. Promote professionalism and integrity among software engineers.
2. Protect the public interest by ensuring software safety and reliability.
3. Guide decision-making in complex moral situations.
4. Ensure quality service and prevent unethical practices.
5. Build trust between software engineers, clients, and society.

The IEEE–ACM Code of Ethics

The IEEE–ACM (Institute of Electrical and Electronics Engineers / Association for Computing
Machinery) jointly developed a well-recognized Software Engineering Code of Ethics and Professional
Practice. It identifies eight key principles that software engineers should adhere to.

Eight Principles of the Software Engineering Code of Ethics

Principle Description
1. Public Software engineers shall act consistently with the public interest, ensuring that
software products are safe and beneficial to society.
2. Client and Act in the best interests of clients and employers, provided such actions are
Employer consistent with the public interest.
3. Product Ensure that products meet the highest professional standards possible,
emphasizing quality, reliability, and security.
4. Judgment Maintain integrity and independence in professional judgment, avoiding conflicts
of interest.
5. Management Promote an ethical approach to software management, development, and
maintenance.
6. Profession Advance the integrity and reputation of the software engineering profession
through ethical conduct.
7. Colleagues Be fair, supportive, and respectful toward colleagues, fostering teamwork and
knowledge sharing.

26
 8. Self Engage in lifelong learning and professional development to maintain
competence and stay current with new technologies.

Importance of Ethical Conduct in Software Engineering

 Ethical behavior ensures:
 User safety and data protection.
 Public confidence in software systems.
 Prevention of professional misconduct (e.g., plagiarism, data theft, or software piracy).
 Sustainability and fairness in project delivery.
 Professional reputation and accountability.
Examples of Unethical Practices
1. Plagiarizing software code from others.
2. Delivering low-quality software knowingly.
3. Misusing confidential client data.
4. Ignoring user safety or privacy.
5. Manipulating project budgets or timelines.

Project, Process, and People

Software Project
A software project is a planned set of activities aimed at developing or maintaining a software system
within a defined scope, time, cost, and quality.
Every software project involves resources, tools, personnel, and methods working together to achieve
a specific goal.

Characteristics of a Software Project

 Has a specific objective or deliverable.
 Operates within time and budget constraints.
 Requires team collaboration and communication.
 Involves risk management and quality assurance.

Software Project Management Includes:

1. Planning: Defining scope, objectives, and tasks.
2. Scheduling: Setting timelines and milestones.
3. Budgeting: Estimating costs and allocating resources.
4. Monitoring and Control: Tracking progress and managing risks.
5. Evaluation: Assessing deliverables and ensuring quality.

Software Process
A software process refers to the structured set of activities involved in developing a software product.
It describes how software is produced from requirements gathering to testing and maintenance.
Software Process Activities
1. Requirements Analysis: Understanding what the software should do.
2. Design: Structuring the system and components.
3. Implementation (Coding): Writing the program code.
27
4. Testing: Verifying and validating the software.
5. Deployment: Delivering the software to users.
6. Maintenance: Correcting errors and updating the system.

Examples of Software Process Models

Waterfall Model
Iterative Model
Spiral Model
Agile Development (Scrum, XP)
Prototype Model
Each process model defines a different strategy for managing project activities.

People in Software Engineering

People are the most critical factor in software development. Even with advanced tools and processes,
project success ultimately depends on human skills, teamwork, and motivation.

Roles in a Software Project

Role Responsibility
Project Manager Oversees planning, coordination, and execution of the
project.
Software Engineer / Developer Designs and writes the program code.
System Analyst Identifies user needs and translates them into technical
specifications.
Quality Assurance Engineer (Tester) Ensures that software meets standards and performs as
expected.
UI/UX Designer Designs user interfaces and ensures good user
experience.
Database Administrator (DBA) Manages data structures and database performance.
Technical Writer / Documenter Prepares user manuals and documentation.
Client or End-User Provides requirements and evaluates deliverables.

Desirable Software Capabilities

Desirable software capabilities refer to the qualities, features, and characteristics that make a
software system efficient, reliable, maintainable, and user-friendly.
These capabilities determine how well the software performs its intended functions and how easily it
can be understood, modified, and used by end-users.
In software engineering, these characteristics are often referred to as “software quality attributes” or
“non-functional requirements.”

Desirable Capabilities of Software

Below are the qualities that define good software:

28
1. Correctness: The software must perform its functions accurately according to the user’s
requirements and specifications. No logical or computational errors. Produces correct and
expected results.
Example: A banking application must calculate account balances accurately.
2. Reliability: refers to the ability of software to operate without failure under specified conditions for
a specified period. It must not crash or produce inconsistent output. Critical in systems like
aviation, healthcare, or finance.
Example: Air traffic control software must operate reliably 24/7.
3. Efficiency: Software should use system resources optimally, including CPU time, memory, and
disk space. High performance with minimal resource usage. Efficiency ensures speed and
responsiveness.
Example: Mobile applications should perform well even on low-memory devices.
4. Usability: means the software is easy to learn, use, and navigate. Simple and clear interface.
Requires minimal user training.
Example: A learning management system (LMS) that teachers and students can use without much
training.
5. Maintainability: Software must be easy to modify, correct, or enhance after initial deployment.
Code should be modular, well-documented, and understandable. Reduces maintenance cost and
time.
Example: Updating a payroll system to include new tax rules.
6. Portability: is the ability of software to run on different hardware platforms or operating systems
with minimal modification.
Example: Software that runs on both Windows and Linux systems.
7. Reusability: means that parts of the software (modules, functions, or components) can be used in
other applications. Promotes productivity and reduces development cost.
Example: A login authentication module reused across multiple applications.
8. Flexibility: refers to the ease with which software can adapt to changing user needs or
environments. Software should allow configuration and extension without complete redesign.
Example: E-commerce software that can be updated to include new payment methods.
9. Security: Software must protect data and operations from unauthorized access, misuse, or
modification. Includes data encryption, authentication, and access control.
Example: Online banking systems must ensure secure transactions.
10. Testability: Software should be designed so that it can be easily tested for correctness,
performance, and reliability. Supports automated testing and debugging.
Example: Modular systems that can be tested unit by unit.
11. Scalability: is the ability of software to handle increasing workloads or users without performance
degradation.
Example: Cloud-based systems that support millions of users as demand grows.
12. Interoperability: means that software can communicate and exchange data with other systems or
applications seamlessly.
Example: A hospital management system that integrates with laboratory and pharmacy systems.

Pioneers in Software and Software Engineering

The field of software engineering has evolved through the remarkable contributions of several
scientists, mathematicians, and engineers who laid the foundations for programming, algorithms,
and software system design.

29
These pioneers helped transform computing from simple machine instructions to complex software
systems used in science, business, and society today.
Major Pioneers and Their Contributions
1. Charles Babbage (1791–1871) Known as the “Father of the Computer. Designed the Analytical
Engine, a mechanical general-purpose computer. His design introduced concepts such as control
flow, memory, and input/output — which later influenced software design.
Contribution: Laid the foundation for modern programmable computers.
2. Ada Lovelace (1815–1852) The world’s first computer programmer. Wrote the first algorithm
intended for Babbage’s Analytical Engine. Recognized that a machine could perform more than
just arithmetic.
Contribution: Introduced the idea of programming logic and symbolic computation. (The
programming language “Ada” was named in her honor.)
3. Alan Turing (1912–1954) Introduced the concept of the Turing Machine, a mathematical model
for computation. Defined the foundation of modern algorithm theory and artificial intelligence.
Played a crucial role in code-breaking during World War II.
Contribution: Established theoretical foundations of computing and algorithms.
4. John von Neumann (1903–1957) Proposed the Von Neumann Architecture, which became the
model for most modern computers. His architecture separates data and instructions and uses
stored-program concept. Contribution: Basis for the structure of modern computer systems.
5. Grace Hopper (1906–1992) Developed the first compiler that translated human-readable code into
machine code. Played a key role in developing COBOL (Common Business-Oriented Language).
Contribution: Simplified programming through high-level languages. (She is often called the
“Mother of Programming Languages.”)
6. Edsger W. Dijkstra (1930–2002) Pioneered structured programming and formal methods in
software development. Introduced the shortest path algorithm (Dijkstra’s Algorithm). Advocated
for mathematical rigor in software design.
Contribution: Improved program correctness and software reliability.
7. Frederick P. Brooks Jr. (1931–2022) Project manager for IBM’s System/360 and author of the
classic book “The Mythical Man-Month.” Emphasized that adding more people to a late project
makes it later (Brooks’ Law).
Contribution: Major influence on software project management principles.
8. Margaret Hamilton (born 1936) Director of the Software Engineering Division for NASA’s Apollo
project. Coined the term “Software Engineering.” Developed error-tolerant software that ensured
the success of Apollo 11’s lunar landing.
Contribution: Formalized software engineering as a disciplined profession.
9. Donald E. Knuth (born 1938) Author of “The Art of Computer Programming.” Created the TeX
typesetting system and developed algorithm analysis as a field.
Contribution: Advanced software algorithm efficiency and documentation standards.
10. Linus Torvalds (born 1969) Creator of the Linux operating system kernel, an open-source system
widely used globally. Promoted collaborative software development and open-source community
models.
Contribution: Revolutionized software sharing and collaborative engineering.

Summary of Pioneers
Pioneer Contribution

30
 Charles Babbage Designed the first programmable computer concept
Ada Lovelace First computer programmer
Alan Turing Concept of algorithms and Turing Machine
John von Neumann Von Neumann architecture
Grace Hopper First compiler and COBOL
Edsger Dijkstra Structured programming
Frederick Brooks Software project management
Margaret Hamilton Coined “Software Engineering”
Donald Knuth Algorithm analysis and TeX system
Linus Torvalds Linux and open-source movement

Importance of Pioneers
 Established the conceptual and theoretical foundation for computing.
 Inspired generations of engineers and researchers.
 Contributed to software reliability, structure, and development methodologies.
 Helped shape software engineering into a recognized professional discipline.

31