Software Engineering Course Overview
Uploaded by
kernyuypatrick702Software Engineering Course Overview
Uploaded by
kernyuypatrick702INTRODUCTION TO
SOFTWARE ENGINEERING
COURSE INSTRUCTOR
MR. SEMONI
TelKEHBILA
: 653846535
Learning Guide for the Course
Module I: Introductory Concepts
Introduction & Definitions: Overview of software
engineering, its goals, and key terms.
Software Life Cycle: Steps involved in developing
software, starting from analyzing requirements and writing
specifications.
Design & Analysis:
Cohesion & Coupling: How different parts of software
connect and work together.
Data Flow Design:
Transform-Centered Design: Focus on transforming inputs
into outputs.
Transaction-Centered Design: Focus on handling different
tasks or transactions.
System Analysis: Studying systems like
inventory control or reservation systems.
Learning Guide for the Course
Module II: Object-Oriented Design
Object Modeling: Using UML (Unified
Modeling Language) to represent software
systems.
Use Case Diagrams: Visual representation of
system functions.
Class Diagrams: Show relationships between
different objects in the system.
Interaction Diagrams: Focus on how parts of
the system interact.
Activity Diagrams: Represent workflows or
processes.
Unified Development Process: A
structured way to develop object-oriented
Learning Guide for the Course
Module III: Implementation and Testing
Programming & Coding:
Understand basic programming concepts, characteristics, and different
programming languages.
Learn about efficient coding practices and styles.
Testing:
Objectives of Testing: Why testing is important in software development.
Black Box and White Box Testing: Different ways to test software.
Testing Strategies: Methods to ensure the software works as intended.
Debugging: How to find and fix errors in your code.
Maintenance, Reliability, and Availability:
Maintenance:
Key tasks and factors that influence software maintenance.
Preventive Maintenance: Steps to avoid future problems.
Re-engineering and Reverse Engineering: Improving or analyzing existing
software.
Tools and techniques for managing changes in the software.
Reliability:
Concepts like errors, faults, and repairs.
Understanding models that help ensure the software remains reliable and
available.
Recent Trends: Stay updated with the latest developments in software
COURSE OUTLINE
Module 1:
Lecture 1: Introduction to Software Engineering
Lecture 2: Software Development Life Cycle- Classical Waterfall Model
Lecture 3: Iterative Waterfall Model, Prototyping Model, Evolutionary Model
Lecture 4: Spiral Model
Lecture 5: Requirements Analysis and Specification
Lecture 6: Problems without a SRS document, Decision Tree, Decision Table
Lecture 7: Formal System Specification
Lecture 8: Software Design
Lecture 9: Software Design Strategies
Lecture 10: Software Analysis & Design Tools
Lecture 11: Structured Design
COURSE OUTLINE
Module 2:
Lecture 12: Object Modelling Using UML
Lecture 13: Use Case Diagram
Lecture 14: Class Diagrams
Lecture 15: Interaction Diagrams
Lecture 16: Activity and State Chart Diagram
COURSE OUTLINE
Module 3:
Lecture 17: Coding
Lecture 18: Testing
Lecture 19: Black-Box Testing
Lecture 20: White-Box Testing
Lecture 21: White-Box Testing (cont..)
Lecture 22: Debugging, Integration and System Testing
Lecture 23: Integration Testing
Lecture 24: Software Maintenance
Lecture 25: Software Maintenance Process Models
Lecture 26: Software Reliability and Quality Management
Lecture 27: Reliability Growth Models
MODULE 1
LECTURE 1:
INTRODUCTION TO
SOFTWARE ENGINEERING
Software engineering is made up of two key words:
software and engineering.
Software is more than just a program. A program
is a set of instructions that can be run to perform
a specific task. Software includes the program
code, along with libraries and documentation that
support it. When software is built for a specific
purpose, it’s called a software product.
Engineering, on the other hand, is the process of
creating products using established scientific
methods and principles.
So, we can define software engineering as an
engineering branch associated with the
development of software product using well-
defined scientific principles, methods and
procedures. The outcome of software
engineering is an efficient and reliable software
product.
NEED OF SOFTWARE
ENGINEERING
The need for software engineering arises because of a higher rate of change in user requirements and
the environment in which the software is working.
Large software - It is easier to build a wall than to a house or building, likewise, as the size of
software becomes large engineering has to step in to give it a scientific process.
Scalability- If the software process were not based on scientific and engineering concepts, it would
be easier to re-create new software than to scale an existing one.
Cost- As hardware industry has shown its skills and huge manufacturing has lowered the price of
computer and electronic hardware. However, the cost of software remains high if the proper process
is not adapted.
Dynamic Nature- The always-growing and adapting nature of software hugely depends upon the
environment in which the user works. If the nature of software is always changing, new
enhancements need to be done in the existing one. This is where software engineering plays a good
role.
Quality Management- Better process of software development provides better and quality software
products.
CHARACTERESTICS OF GOOD
SOFTWARE
A software product can be judged by what it offers
and how well it can be used. This software must
satisfy on the following grounds:
Operational
Transitional
Maintenance
Well-engineered and crafted software is expected to
have the following characteristics:
Operational
This tells us how well the software works in operations. It can be
measured on:
Budget: The software should have a specific amount.
Usability: The amount of effort or time required to learn how to use
the software should be less. This makes the software user-friendly
even for IT-illiterate people
Efficiency This characteristic relates to the way software uses the
available resources. The software should make effective use of the
storage space and execute commands as per desired timing
requirements
Correctness: The software that we are making should meet all the
specifications stated by the customer
Functionality The software which we are making should meet all
the specifications stated by the customer.
Reliability The software product should not have any defects. Not
only this, but it shouldn't fail while execution
Security With the increase in security threats nowadays, this factor
is gaining importance. The software shouldn't have ill effects on
data/hardware. Proper measures should be taken to keep data
Transitional
This aspect is important when the software is moved from one platform to
another:
Portability: The ability of software to perform same functions across all
environments and platforms, demonstrate its portability
Interoperability: Interoperability is the ability of software to exchange
information with other applications and make use of information transparently
Reusability: If we are able to use the software code with some modifications
for different purposes then we call software to be reusable
Adaptability: A system is adaptable to a different environment, where it can
execute its functions without any deviations.
Maintenance
This aspect briefs about how well software has the capabilities to
maintain itself in the ever-changing environment:
Modularity: Any software is said to be made of units and modules
which are independent of each other. These modules are then
integrated to make the final software. If the software is divided
into separate independent parts that can be modified, and tested
separately, it has high modularity.
Maintainability: Maintenance of the software should be easy for
any kind of user.
Flexibility: Changes in the software should be easy to make.
Scalability: It should be very easy to upgrade it for more work(or
for more number of users).
THANK YOU
FOR
YOUR ATTENTION
