1

Chapter 1: Introduction to Software Engineering

 Definition and scope of software engineering

 Software development life cycle models
 Roles and responsibilities of software engineers
 Ethical and professional considerations in software engineering

Chapter 2: Software Requirements Engineering

 Gathering and analyzing requirements

 Specification and documentation of requirements
 Requirements validation and verification
 Managing requirements changes

Chapter 3: Software Design and Construction

 Principles of software design

 Architectural design
 Object-oriented design
 Coding standards and best practices
 Unit testing and test-driven development

Chapter 4: Software Testing, Maintenance, and Project Management

 Fundamentals of software testing

 Test planning and test case design
 Software maintenance activities and challenges
 Version control systems and configuration management
 Project planning and estimation
 Agile methodologies
 Software quality assurance and process improvement

Prepared by: Mr Dawit B.

 2

CHAPTER 1: INTRODUCTION TO SOFTWARE

ENGINEERING

Definition and scope of software engineering:

Software engineering is a discipline that applies engineering principles to the design,

development, testing, and maintenance of software systems. It involves systematic approaches
and methodologies to create reliable, scalable, and high-quality software.

The scope of software engineering encompasses the entire software development life cycle,
including requirements gathering, system design, coding, testing, deployment, and maintenance.
It also involves managing software projects, ensuring software quality, and continuous process
improvement.
Software development life cycle models:

Software development life cycle (SDLC) models provide a framework for managing the different
stages and activities involved in software development. These models help organize and
streamline the development process. Some commonly used SDLC models include:

Waterfall model: This model follows a sequential approach, where each phase is completed
before moving to the next. It is suitable for projects with well-defined and stable requirements.
Agile model: The agile model emphasizes iterative and incremental development, with
continuous collaboration and flexibility. It is ideal for projects with evolving requirements and
dynamic environments.
Spiral model: This model combines elements of the waterfall model and prototyping. It involves
iterative cycles, allowing for risk management and early user feedback.
V-shaped model: The V-shaped model emphasizes the verification and validation activities
aligned with each phase of development. It ensures that each phase's deliverables meet
predefined criteria.

Prepared by: Mr Dawit B.

 3

Each SDLC model has its strengths and weaknesses, and the choice of model depends on factors
such as project requirements, resources, and organizational culture.
Roles and responsibilities of software engineers:

Software engineers assume various roles throughout the software development life cycle. These
roles include:
Software developer/programmer: Responsible for writing code to implement software
functionalities based on design specifications and requirements.
Systems analyst: Analyzes user requirements, identifies system needs, and helps translate them
into system specifications.
Software architect: Designs the overall structure and components of the software system,
ensuring scalability, modularity, and performance.
Quality assurance engineer: Conducts testing activities to ensure the software meets quality
standards and requirements.
Project manager: Plans, coordinates, and monitors software development projects, ensuring
timely delivery and resource management.
Software engineers are responsible for requirements gathering, design, coding, testing,
documentation, and maintenance of software systems. They collaborate with stakeholders,
follow coding standards and best practices, and continuously improve their skills.
Ethical and professional considerations in software engineering:

Software engineers have ethical responsibilities to ensure the ethical and responsible use of
software. Some key ethical considerations include:
Privacy and data protection: Respecting user privacy and protecting sensitive data from
unauthorized access or misuse.
Intellectual property: Respecting copyrights, patents, and intellectual property rights of others,
and avoiding plagiarism.
Software piracy: Avoiding the unauthorized use, distribution, or replication of software without
proper licensing or permissions.
Professional conduct: Adhering to professional codes of ethics, maintaining integrity, and
avoiding conflicts of interest.
Professional considerations include:

Prepared by: Mr Dawit B.

 4

Continuous learning: Keeping up with advancements in software engineering, acquiring new

skills, and staying updated with industry trends.
Collaboration and teamwork: Engaging in effective communication, teamwork, and
collaboration with colleagues, clients, and stakeholders.
Professional development: Pursuing professional certifications, attending conferences, and
participating in training programs to enhance skills.
Legal and regulatory compliance: Adhering to laws and regulations related to software
development, intellectual property, privacy, and cybersecurity.
By understanding the definition and scope of software engineering, different SDLC models, roles
and responsibilities of software engineers, and ethical and professional considerations, students
gain a comprehensive overview of the field. These concepts provide a solid foundation for their
software engineering journey and help them develop a sense of responsibility, professionalism,
and ethical conduct in their future software development endeavors.

CHAPTER 2: SOFTWARE REQUIREMENTS ENGINEERING

Gathering and analyzing requirements:

Gathering and analyzing requirements is the initial phase of software requirements engineering.
It involves understanding and documenting the needs, expectations, and constraints of
stakeholders to establish a clear understanding of the software system's purpose and
functionalities.

Eliciting requirements: Techniques such as interviews, surveys, document analysis,

brainstorming sessions, and observations are used to gather requirements from stakeholders.
These techniques aim to identify user needs, business objectives, environmental factors, and
system constraints that shape the requirements.

Analyzing requirements: Once requirements are gathered, they need to be analyzed to ensure
they are clear, consistent, complete, and feasible. This involves techniques such as requirements
prioritization, requirements validation, requirements negotiation, and requirements traceability.

Prepared by: Mr Dawit B.

 5

Requirements analysis helps identify potential conflicts, ambiguities, or missing details in the
requirements.

Specification and documentation of requirements:

Specification and documentation of requirements involve translating the gathered requirements
into a formal and structured format that can be easily understood by stakeholders and used by the
development team. Clear and well-documented requirements serve as the foundation for the
entire software development process.

Use cases and user stories: Use cases and user stories are techniques used to describe system
functionalities from the perspective of end-users. Use cases provide detailed descriptions of
interactions between users and the system, while user stories capture short, simple descriptions
of desired system functionalities.

Requirements specification documents: Detailed requirement specification documents provide a

comprehensive description of functional and non-functional requirements. These documents
include information about system behavior, user interfaces, data specifications, performance
requirements, security requirements, and any other relevant details.

Prototypes: Prototyping involves creating interactive mockups or prototypes of the software

system to visualize and validate requirements with stakeholders. Prototypes help stakeholders
better understand the system's look and feel and provide valuable feedback early in the
development process.

Requirements validation and verification:

Requirements validation and verification activities ensure that the documented requirements are
correct, complete, consistent, and meet stakeholders' needs. These activities focus on minimizing
the risk of developing a system that does not fulfill its intended purpose.

Requirements validation: Requirements validation involves assessing the requirements to ensure

they align with stakeholders' needs and expectations. Validation techniques include reviews,

Prepared by: Mr Dawit B.

 6

walkthroughs, and inspections, where requirements are evaluated by stakeholders, subject matter
experts, and the development team to identify potential issues, inconsistencies, or omissions.

Requirements verification: Requirements verification involves checking that the documented

requirements are complete, consistent, unambiguous, and testable. Verification techniques
include inspections, reviews, and testing activities. Verification ensures that the requirements are
well-defined and can be used as a basis for system design and implementation.

Managing requirements changes:

Requirements are subject to change throughout the software development life cycle due to
evolving business needs, technological advancements, or stakeholder feedback. Effectively
managing requirements changes is crucial to ensure that the software system continues to meet
stakeholders' expectations.

Change control process: A change control process establishes a formal mechanism for
evaluating, approving, and tracking changes to requirements. It involves assessing the impact of
proposed changes on the system's functionality, cost, schedule, and other project constraints.

Impact analysis: Impact analysis is performed to evaluate the potential effects of proposed
changes on the software system. It involves assessing how changes to requirements may impact
other system components, such as design, implementation, and testing. Impact analysis helps in
making informed decisions about incorporating or rejecting changes.

Requirements versioning: Requirements versioning involves maintaining a version history of

requirements to track changes over time. Versioning allows for traceability and provides a
reference point to understand the evolution of requirements throughout the software development
process.

Requirements communication: Effective communication with stakeholders is crucial when

managing requirements changes. Clear and timely communication helps stakeholders understand
the reasons for changes, the impact on the system, and any trade-offs involved. It also helps in
maintaining stakeholder engagement and minimizing misunderstandings.

Prepared by: Mr Dawit B.

 7

By emphasizing the gathering and analysis of requirements, the specification and documentation
of requirements, requirements validation and verification, and the management of requirements
changes, software engineering practitioners ensure a solid foundation for successful software
development. These activities help to establish a common understanding among stakeholders,
provide a basis for system design and implementation, and enable effective project management
throughout the software development life cycle.

CHAPTER 3: SOFTWARE DESIGN AND CONSTRUCTION

Principles of software design:

a. SOLID principles:

Single Responsibility Principle (SRP): A class or module should have only one reason to change,
meaning it should have a single responsibility or purpose.
Open-Closed Principle (OCP): Software entities (classes, modules, functions) should be open for
extension but closed for modification. New functionality should be added through extension
rather than modifying existing code.
Liskov Substitution Principle (LSP): Subtypes must be substitutable for their base types,
meaning objects of a superclass should be replaceable with objects of its subclasses without
affecting the correctness of the program.
Interface Segregation Principle (ISP): Clients should not be forced to depend on interfaces they
do not use. It promotes the creation of smaller, focused interfaces instead of large, monolithic
ones.
Dependency Inversion Principle (DIP): High-level modules should not depend on low-level
modules; both should depend on abstractions. It promotes loose coupling between modules and
facilitates easier maintenance and testing.

Prepared by: Mr Dawit B.

 8

b. DRY principle: The Don't Repeat Yourself (DRY) principle states that duplication in code
should be avoided. Instead, code should be organized in a way that promotes reusability and
modularity, reducing redundancy and making it easier to maintain and update.

c. KISS principle: The Keep It Simple, Stupid (KISS) principle suggests that software design
should prioritize simplicity over complexity. It advocates for straightforward solutions that are
easy to understand, debug, and maintain. Complex designs should be avoided unless absolutely
necessary.

d. YAGNI principle: The You Ain't Gonna Need It (YAGNI) principle advises against adding
functionality or code that is not currently required. Developers should focus on implementing
only the features that are necessary to meet the immediate requirements. This avoids unnecessary
complexity and reduces the risk of over-engineering.

Architectural design:
a. Architectural patterns: Architectural patterns provide reusable solutions to common design
problems at the system level. Examples include:

Layered architecture: Divides the system into logical layers (e.g., presentation, business logic,
data access) with defined dependencies between them, promoting separation of concerns.
Client-server architecture: Separates the system into clients (requesters) and servers (providers)
that communicate over a network.
Microservices architecture: Decomposes the system into small, independent services that can
be developed, deployed, and scaled independently.
Model-View-Controller (MVC) architecture: Separates the presentation, business logic, and data
layers, facilitating modularity and maintainability.
b. Design patterns: Design patterns provide proven solutions to recurring design problems at a
lower level than architectural patterns. They address issues such as object creation, structuring
relationships between objects, and managing object behavior. Examples include:

Factory pattern: Encapsulates object creation and provides a centralized method for creating
instances of classes.

Prepared by: Mr Dawit B.

 9

Singleton pattern: Ensures that only one instance of a class exists throughout the application.
Observer pattern: Defines a one-to-many dependency between objects, allowing them to notify
and update each other.
Strategy pattern: Defines a family of interchangeable algorithms and encapsulates each one,
enabling runtime selection of algorithms.
c. Component-based design: Component-based design involves breaking the system into
modular components, each responsible for a specific functionality or service. Components can be
developed independently, tested in isolation, and easily replaced or updated without affecting the
entire system. This promotes reusability, maintainability, and scalability.

d. Deployment and scalability considerations: Architectural design should take into account
factors such as hardware requirements, network topology, and scalability needs. It should allow
for easy deployment across different environments and provide mechanisms to handle increased
load and accommodate future growth.

Object-oriented design:
a. Classes and objects: Object-oriented design organizes code into classes, which are blueprints
for creating objects. Classes encapsulate data (attributes) and behavior (methods) related to a
specific concept or entity. Objects are instances of classes and interact with each other by
invoking methods.

b. Inheritance and polymorphism: Inheritance allows the creation of new classes (derived or
child classes) based on existing classes (base or parent classes), inheriting their attributes and
behaviors. Polymorphism enables objects of different classes to be treated interchangeably
through common interfaces or base classes, promoting code reuse and flexibility.

c. Encapsulation and information hiding: Encapsulation bundles data and associated behaviors
into objects, hiding the internal implementation details. It protects the integrity of the data by
controlling access through methods, and provides a clear interface for interacting with the object.

d. Abstraction and modularity: Abstraction involves identifying essential characteristics of

objects while ignoring irrelevant details. It allows developers to create simplified models of

Prepared by: Mr Dawit B.

 10

complex systems, focusing on what is important. Modularity breaks down a system into smaller,
self-contained modules that can be developed and tested independently, promoting reusability
and maintainability.

Coding standards and best practices:

a. Naming conventions: Consistent and meaningful naming of variables, functions, classes, and
other code elements improves code readability. Naming conventions should follow a consistent
style, such as camel case or snake case, and convey the purpose or intent of the element.

b. Code formatting: Consistent code formatting improves code readability and maintainability.
Adopting a coding style guide, such as the popular ones like Google Style Guide or PEP 8 for
Python, helps ensure consistent code formatting across the project. It covers aspects such as
indentation, line length, spacing, and use of comments.

c. Commenting and documentation: Clear and concise comments help in understanding code
logic and intentions. Inline comments explain the purpose of code blocks or provide additional
context. Documentation, such as API documentation, README files, or code documentation
tools like Javadoc, provides a comprehensive understanding of the system's architecture, design,
and usage.

d. Error handling and exception management: Proper error handling and exception management
improve code robustness. Error messages should be informative and provide meaningful
information to aid in debugging. Exceptions should be handled appropriately, either by
gracefully degrading the system's functionality or by recovering from errors to maintain system
stability.

e. Code modularity and reusability: Breaking code into modular components promotes
reusability and maintainability. Functions and classes should have a single responsibility and be
decoupled from one another. This allows for easier testing, debugging, and code updates without
affecting the entire system.

Prepared by: Mr Dawit B.

 11

Unit testing and test-driven development:

a. Unit testing: Unit testing involves writing tests to validate the behavior of individual units or
components of a software system. Units can be functions, methods, or classes. Unit tests are
typically written using a testing framework, such as JUnit for Java or pytest for Python, and
executed automatically to verify that the code functions as expected.

b. Test-driven development (TDD): TDD is a development approach that follows a "test-first"

approach. Developers write tests before writing the actual code. Initially, the tests fail since the
code does not exist yet. Then, the code is implemented incrementally to make the tests pass.
TDD promotes writing testable and modular code, driving the design and implementation
process based on the requirements defined by the tests.

c. Test coverage: Test coverage measures the extent to which the code is exercised by tests. It
provides visibility into which parts of the code are tested and which are not. Adequate test
coverage ensures that most parts of the code are tested, reducing the risk of undiscovered bugs
and increasing code quality and reliability.

d. Regression testing: Regression testing involves re-running tests to ensure that changes or
additions to the codebase do not introduce new bugs or regressions. It helps maintain the
integrity of the software system as it evolves over time. Automated test suites are often used to
perform regression testing efficiently.

By following these principles, design patterns, coding standards, and testing practices, software
developers can create high-quality, maintainable, and scalable software systems. These practices
help ensure code readability, reusability, and testability, leading to improved productivity and
reduced maintenance efforts in the long run.

Prepared by: Mr Dawit B.

 12

CHAPTER 4: SOFTWARE TESTING, MAINTENANCE, AND

PROJECT MANAGEMENT

Fundamentals of software testing:

The fundamentals of software testing involve the process of evaluating a software system or
component to identify defects, gaps, or deviations from its expected behavior. Testing is crucial
to ensure the quality and reliability of software.

Testing objectives: The objectives of testing include identifying defects, validating the system
against requirements, verifying system behavior, and assessing system performance and
reliability.

Testing levels: Testing is typically performed at multiple levels, including unit testing,
integration testing, system testing, and acceptance testing. Each level focuses on different aspects
of the software system and aims to uncover different types of defects.

Testing techniques: Various techniques, such as black-box testing, white-box testing, and gray-
box testing, are used to design test cases and execute tests. Other techniques include equivalence
partitioning, boundary value analysis, and error guessing.

Test documentation: Test plans, test cases, and test scripts are essential documents that outline
the testing approach, test scenarios, and expected results. These documents provide a systematic
approach to testing and serve as a reference for future maintenance and regression testing.

Test planning and test case design:

Test planning involves defining the overall testing strategy, objectives, and scope for a software
project. Test case design focuses on creating specific test cases that cover different scenarios and
ensure thorough testing of the software system.

Prepared by: Mr Dawit B.

 13

Test planning: Test planning includes identifying test objectives, determining the test coverage,
allocating testing resources, and defining the test schedule. The test plan outlines the overall
approach for testing, including the testing techniques, test environments, and test deliverables.

Test case design: Test case design involves creating test cases that cover different functional and
non-functional aspects of the software system. Test cases should be designed to validate system
requirements, exercise specific software functionalities, and detect defects.

Test data preparation: Test data is the input data used during testing. Test data should be
carefully selected to cover a wide range of scenarios, including normal cases, edge cases, and
boundary conditions. Test data preparation also involves creating or modifying test databases or
files.

Software maintenance activities and challenges:

Software maintenance refers to the process of modifying, enhancing, and adapting software
systems after their initial development and deployment. Maintenance activities are essential for
ensuring the system's continued functionality, stability, and performance.

Corrective maintenance: Correcting defects or issues discovered during testing or production is

known as corrective maintenance. It involves identifying and fixing software bugs to restore the
system to its intended behavior.

Adaptive maintenance: Adaptive maintenance involves modifying the software system to

accommodate changes in the external environment, such as changes in hardware, operating
systems, or regulatory requirements.

Perfective maintenance: Perfective maintenance focuses on enhancing the software system's

functionality, performance, or usability. These enhancements are made to improve the system's
efficiency, user experience, or response times.

Prepared by: Mr Dawit B.

 14

Preventive maintenance: Preventive maintenance aims to proactively identify and address

potential issues or vulnerabilities in the software system before they cause problems. It includes
activities such as code refactoring, performance tuning, and security audits.

Version control systems and configuration management:

Version control systems (VCS) and configuration management (CM) tools are used to manage
software artifacts, track changes, and facilitate collaboration among developers working on a
software project.

Version control systems: VCS tools, such as Git, Subversion, or Mercurial, enable developers to
track changes to source code, manage different versions of the codebase, and facilitate
collaboration among team members. VCS provides features like branching, merging, and conflict
resolution.

Configuration management: CM involves managing and controlling software configurations,

including different versions, releases, and dependencies. CM tools help in managing software
artifacts, libraries, and dependencies and ensure consistent and reproducible software builds.

Change management: Change management processes and tools are used to track and manage
changes to the software system, including requirements changes, bug fixes, or feature
enhancements. Change management helps in controlling and documenting changes and their
impact on the software system.

Project planning and estimation:

Project planning and estimation involve defining project goals, scope, tasks, resources, and
schedules to ensure successful software development and delivery.

Project goals and scope: Clearly defining project goals and scope helps in setting expectations
and establishing a shared understanding among stakeholders about the project's objectives and
deliverables.

Prepared by: Mr Dawit B.

 15

Work breakdown structure: Breaking down the project into smaller, manageable tasks and
creating a work breakdown structure (WBS) helps in organizing and estimating the effort
required for each task.

Effort estimation: Effort estimation involves estimating the time, resources, and cost required to
complete each task or project phase. Estimation techniques may include expert judgment,
historical data analysis, and parametric models.

Project scheduling: Creating a project schedule involves defining task dependencies, durations,
and milestones. Techniques such as Gantt charts or critical path method (CPM) help in
visualizing and managing project timelinesand dependencies.

Agile methodologies:
Agile methodologies are iterative and incremental approaches to software development that
prioritize flexibility, collaboration, and continuous improvement. They promote adaptive
planning, self-organizing teams, and frequent delivery of working software.

Scrum: Scrum is an agile framework that divides the development process into time-boxed
iterations called sprints. It emphasizes close collaboration between the development team,
product owner, and scrum master, and promotes regular inspection and adaptation.

Kanban: Kanban is a visual management method that focuses on the flow of work. Work items
are represented as cards on a Kanban board, and teams limit work in progress (WIP) to maintain
a steady workflow.

Lean software development: Lean software development emphasizes delivering value to the
customer while minimizing waste. It focuses on eliminating non-value-adding activities,
optimizing workflow, and fostering a culture of continuous improvement.

Continuous integration and delivery: Continuous integration (CI) and continuous delivery (CD)
practices involve frequently integrating code changes, running automated tests, and deploying

Prepared by: Mr Dawit B.

 16

software in a production-like environment. This ensures early bug detection, faster feedback, and
the ability to release software at any time.

Software quality assurance and process improvement:

Software quality assurance (SQA) aims to ensure that the software development process follows
established standards, practices, and quality guidelines. Process improvement initiatives help in
identifying areas of improvement and implementing changes to enhance the quality and
efficiency of the software development process.

Quality assurance activities: SQA activities include conducting audits, reviews, and inspections
to identify and address deviations from established standards. It also involves defining and
enforcing quality metrics, conducting root cause analysis, and implementing corrective and
preventive actions.

Process improvement frameworks: Process improvement frameworks, such as the Capability

Maturity Model Integration (CMMI) and the Software Engineering Institute's (SEI) Capability
Maturity Model (CMM), provide guidelines and best practices for assessing and improving the
maturity and effectiveness of software development processes.

Continuous improvement: Continuous improvement focuses on regularly evaluating and refining

the software development process to optimize efficiency, productivity, and quality. Techniques
such as retrospectives, lessons learned sessions, and data-driven decision making help in
identifying areas of improvement and implementing changes.

By understanding the fundamentals of software testing, conducting effective test planning,

addressing software maintenance challenges, utilizing version control systems and configuration
management tools, practicing project planning and estimation, adopting agile methodologies, and
focusing on software quality assurance and process improvement, software development teams
can enhance their ability to deliver high-quality software products in a timely and efficient
manner.

Prepared by: Mr Dawit B.