Software Engineering Course

CoSc3141

Course instructor : Mr. Tsega Asresa (MSc)

1 Email: [email protected]
 Module Description
This course provides an introduction to the problems of software
development and maintenance and the processes and methods
used to address them. All phases in the software development life
cycle will be introduced. The course also deals with software
project planning, cost estimation, tracking and control, staffing,
risk management, and software configuration plan. Covers O-O
concepts, tools, development life cycle, problem solving,
modeling, analysis, and design, while utilizing UML (Unified
Modeling Language) for O-O modeling. UML has become the
standard notation for modeling O-O systems and is being
embraced by major software developers like Microsoft and Oracle.

2
 Learning Objective
On completion of the course successfully, students will be able to:
Understand the basic principles of Software Engineering
Write requirements specification documents
Design a system, component, or process to meet desired needs.
Verify and validate a Software system practice with effective
communication skill.
Describe in detail the theory, concepts and methods pertaining to the
Unified Modeling Language (UML).
Create requirements using use case modeling concepts.
 Demonstrate conceptual and technical skills in the analysis, design and
implementation of a software system using Object Oriented Concepts.
Employ tools and techniques for Object Oriented Software Engineering,
Demonstrate an ability to adapt and solve problems in software
development activities from specification to testing individually and as part
3 of a team.
 Module Content
Module Chapter Topics
Content
1 Introduction
2 Unified Modeling Language(UML)

3 Requirements Elicitation

4 software Project management

Analysis
5

6 Object Oriented System Design

7 Software Quality Assurance

4
 Reference
Textbooks
1. Brahmin, Ali (1999), Object oriented System development,
McGraw Hill, USA.
References
2. Martina Seidl, Marion Scholz, Christian Huemer, Gerti Kappel.
UML @ Classroom: An Introduction to Object-Oriented Modeling.
2012. Springer International Publishing AG.
3. 2. Scott, Kendall (2004) Fast Track UML 2.0 Apress USA
4. 3. Booch, Grady Rumbaugh, James Jacobson, Ivar (2005) The
Unified Modeling Language User Guide second edition Addison
Wesley Professional USA 39

5
 Course Evaluation

Assessment  50%: (Final)

Criteria  20%: Technical Project
 30%: mid exam

6
 Software Overview

The term is made of two words, software and
engineering.

Software is more than just a program code.

A program is an executable code, which serves
some computational purpose.

Software is considered to be collection of
executable programming code, associated
libraries and documentations.

Software, when made for a specific
requirement is called software product.

Engineering on the other hand, is all about
developing products, using well defined,
scientific principles and methods.


IEEE definition of Software Engineering:

“Software engineering is an engineering
branch associated with development of
software product using well-defined
scientific principles, methods and
procedures.”

The outcome of software engineering is an
efficient and reliable software product.
 Software Evolution

It is the process of developing a software
product using software engineering
principles and methods.

includes the initial development of software
and its maintenance and updates, till
desired software product is developed,
which satisfies the expected requirements.
 Software Evolution Laws


1. Static-type (S-type) - This is a software, which
works strictly according to defined specifications
and solutions.

The solution and the method to achieve it, both are
immediately understood before coding.

The s-type software is least subjected to changes
hence this is the simplest of all.

For example, calculator program for mathematical
computation.

2. Practical-type (P-type) - This is a
software with a collection of procedures.
This is defined by exactly what procedures
can do.

In this software, the specifications can be
described but the solution is not obviously
instant.

For example, gaming software

3. Embedded-type (E-type) - This
software works closely as the requirement
of real-world environment.

This software has a high degree of
evolution as there are various changes in
laws, taxes etc. in the real world situations.

For example, Online trading software.
 E-Type software evolution

1. Continuing change - An E-type software
system must continue to adapt to the real world
changes, else it becomes progressively less
useful.

2. Increasing complexity - As an E-type software
system evolves, its complexity tends to increase
unless work is done to maintain or reduce it.

3. Conservation of familiarity - The familiarity
with the software or the knowledge about how it
was developed, why was it developed in that
particular manner etc., must be retained at any
cost, to implement the changes in the system.

4. Continuing growth- In order for an E-type
system intended to resolve some business
problem,its size of implementing the changes
grows according to the lifestyle changes of the
business.

5. Reducing quality - An E-type software
system declines in quality unless rigorously
maintained and adapted to a changing
operational environment.

6. Feedback systems- The E-type
software systems constitute multi-loop,
multi-level feedback systems and must be
treated as such to be successfully modified
or improved.

7. Self-regulation - E-type system
evolution processes are self-regulating with
the distribution of product and process
measures close to normal.
 Software Paradigms


Software paradigms refer to the methods and
steps, which are taken while designing the
software.

There are many methods proposed and are
implemented.

But, we need to see where in the software
engineering concept, these paradigms stand.

These can be combined into various categories,
though each of them is contained in one another:
 1.Software Development
Paradigm

This paradigm is known as software
engineering paradigms; where all the
engineering concepts used in the
development of software are applied.

It includes various researches and
requirement gathering which helps the
software product to build. It consists of:

Requirement gathering

Software design

Programming
 2.Software Design Paradigm


This paradigm is a part of Software
Development and includes –
 Design
 Programming
 Maintenance
 3.Programming Paradigm


This paradigm is related closely to
programming aspect of software
development. This includes:
 Coding
 Testing
 Integration
 Need of Software Engineering

The need of software engineering arises because
of higher rate of change in user requirements and
environment on which the software is working.
Following are some of the needs stated:
 Large software - It is easier to build a wall than a
house or building, likewise, as the size of the software
becomes large, engineering has to step 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 lower down the price of computer and
electronic hardware. But, cost of the software remains
high if proper process is not adapted.
 Dynamic Nature- If the nature of software is always
changing, new enhancements need to be done in the
existing one. This is where the software engineering
plays a good role.
 Quality Management- Better process of software
development provides better and quality software
product.
Characteristics of good software

A software product can be judged by what it offers and
how well it can be used.

Software must satisfy 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

Usability

Efficiency

Correctness

Functionality

Dependability

Security

Safety

Transitional

This aspect is important when the software
is moved from one platform to another:

Portability

Interoperability

Reusability

Adaptability

Maintenance

This aspect briefs about how well the
software has the capabilities to maintain
itself in the ever-changing environment:

Modularity

Maintainability

Flexibility

Scalability