Software Engineering Tools and

Practices

1
 Course objectives
 This course provides an introduction to the Software
Engineering Tools and Practices.
 a look at a typical approach software engineers create
applications in practice.
 Topics include requirements analysis, high-level
design, detail-level design, UML modeling, code
generation, application building, and revision
management.

2
 Course objectives
 In order to achieve the above objectives
• create UML class, state, and sequence diagrams using
a CASE tool
• generate source code from UML design models, and
synchronize subsequent changes
• create a deployable software package using an
automated build tool
• create an installable software package using an
automated build tool
3
 Motivation
 Software engineering tools and practices have a positive
influence on the quality and cost of developed software and on
software development processes.
 There are many benefits from making these tools and practices
integral to software development and acquisition processes,
including:
• Reduced risk: programs deliver more predictably

• Improved customer satisfaction: products developed

experience fewer field defects
• Lower cost of ownership: programs experience lower
life-cycle maintenance costs when deployed operationally
4
 Prerequisites
 Proficiency in a high-level object-oriented
programming language
 Knowledge of basic object-oriented programming
concepts,
 data structures, and software design techniques.

5
 Chapter one
Introduction to software engineering tools and
practices
Contents

• Introduction
• Basic of CASE tools

6
 Definition
 Software can be defined as a set of programs and
associated documentations.
which includes
 A number of separate programs

 Configuration files

 System documentation

 User documentation

7
What is software engineering?
 Software engineering is defined as a process of
analyzing user requirements and then designing,
building, and testing software application which will
satisfy those requirements.
 IEEE, in its standard 610.12-1990, defines software
engineering as the application of a systematic,
disciplined, which is a computable approach for the
development, operation, and maintenance of
software.
8
 What is software engineering?
 Software engineering (SE) is an intellectual activity
and thus human-intensive.
 Software is built to meet a certain functional goal and
satisfy certain qualities.
 Software processes also must meet certain qualities.

9
 software engineering
Fundamental assumptions of software engineering

Good processes lead to good software

Good processes reduce risk

10
 Software Engineering Concepts:
Definitions
 Project: set of activities to develop a software
system
 Activity: a phase in which related tasks are
carried out
 Task: effort that uses resources AND produces
Work Product
 Resources: time, equipment, people (participants)
 Work Product: a model, system, or artifact

11
Basics of Software Engineering

12
 Software Engineering Activities
 Requirements Elicitation
 Analysis
 Object Design
 System Design
 Implementation
 Validation/testing

13
 Software Engineering Tools
 A software tool is a program that automates some of the labor
involved in the management, design, coding, testing,
inspection, or maintenance of other programs.
 Tools allow repetitive, well-defined actions to be automated,
thus reducing the cognitive load on the software engineer.
 The engineer is then free to concentrate on the creative aspects
of the process.
 Tools are often designed to support particular methods,
reducing any administrative load associated with applying
the method manually.

14
 CASE Tools
 CASE stands for Computer Aided Software Engineering.
 It means, development and maintenance of software projects
with help of various automated software tools.
 Computer-aided software engineering (CASE) is the
scientific application of a set of tools and methods to a
software system which is meant to result in high-quality,
defect-free, and maintainable software products.
 It also refers to methods for the development of information
systems together with automated tools that can be used in
the software development process

15
 CASE Tools…
 CASE tools are used by software project managers,
analysts and engineers to develop software system.
 There are number of CASE tools available to simplify various
stages of Software Development Life Cycle such as Analysis
tools, Design tools, Project management tools, Database
Management tools, Documentation tools are to name a few.
 Use of CASE tools accelerates the development of project to
produce desired result and helps to uncover flaws before
moving ahead with next stage in software development.

16
 CASE Tools…
 Therefore, CASE tools include design editors, data
dictionaries, compilers, debuggers, system building tools,
etc.
  CASE also refers to the methods dedicated to an
engineering discipline for the development of information
system using automated tools.
 CASE is mainly used for the development of quality
software which will perform effectively

17
 CASE Tools…
 Characteristics of CASE:
 It is a graphic oriented tool.

 It supports decomposition of process.

 Some typical CASE tools are:

 Unified Modeling Language

 Data modeling tools, and

 Source code generation tools

18
 Why CASE Tools?
 Architecture management
• Model, design and rapidly build software, systems, and
computer applications.
 Change and Release Management
• Improve software delivery and life cycle traceability, from
requirements to development.
 Software development Management
• Align projects for improved productivity and
predictability.
 Quality Management
• Ensure software functionality, reliability and performance
19
 Goals of CASE Tools
 Supply basic functionality, do routine tasks automatically.
 Enhance productivity
 Increase software quality
 Integration with other tools

20
 Importance of CASE
 CASE allows for rapid development of software.
 Produce systems with a longer effective operational life.
 Produce systems that most closely meet user needs and
requirements.
 Produce system with excellent documentation.
 Produce systems that needs less systems support.
 Produce more flexible systems.

21
 Drawbacks of CASE
 Very complex
 Expensive
 Difficult to customize
 Require training of maintenance staff
 Not easily maintainable
 Fragile(Week)

22
Components of CASE Tools

23
 CASE Tools
 There are upper CASE and Lower CASE tools.

24
 CASE Tools
 Two types of tools used by software engineers.
1. Analytical tools (CSS)
 Stepwise refinement
 Cost-benefit analysis
 Software metrics
2. CASE tools
 Diagram tools
 Process Modeling Tools
 Project Management Tools…

25
 Assignment-1
 Explain software engineering tools that exist in all generic software
development life cycle phases (Requirements, Design, Construction
(Implementation), Testing and Maintenance).

26
Symptoms of Software Development Problems

 Different software development projects fail in different ways.

 It is possible to identify a number of common symptoms that
characterize these kinds of projects:
 Inaccurate understanding of end-user needs
 Inability to deal with changing requirements
 Modules that don’t fit together
 Software that’s hard to maintain or extend
 Late discovery of serious project flaws
 Poor software quality
 Unacceptable software performance
27
 Root Causes of Software Development
Problems
 Although different projects fail in different ways, it appears that most of them
fail because of a combination of the following root causes:
 Ad hoc requirements management

 Ambiguous and imprecise communication

 Brittle architectures

 Overwhelming complexity

 Undetected inconsistencies in requirement, design, and implementations

 Insufficient testing

 Subjective project status assessment

 Failure to attack risk

 Uncontrolled change propagation

 Insufficient automation

28
Software Engineering Best Practices
 what software best practices are all about: commercially
proven approaches to software development that, when used in
combination, strike at the root causes of software development
problems.
 These best practices are as follows.
1. Develop software iteratively.
2. Manage requirements.
3. Use component-based architectures.
4. Visually model software.
5. Verify software quality.
6. Control changes to software.

29
 Software Engineering Best Practices…
1. Develop software iteratively.
 This approach is one of continuous discovery, invention, and
implementation, with each iteration forcing the development team to
drive the project’s artifacts to closure in a predictable and repeatable way.
2. Manage requirements.
 The challenge of managing the requirements of a software-intensive
system is that they are dynamic: you must expect them to change during
the life of a software project.
 Identifying a system’s true requirements—those that weigh most heavily
on the system’s economic and technical goals—is a continuous process.

30
 Software Engineering Best Practices…
3. Use component-based architectures.
 Component-based development (CBD) is an important approach to
software architecture because it enables the reuse or customization of
existing components from thousands of commercially available
sources.
4. Visually model software.
 Modeling is important because it helps the development team
visualize, specify, construct, and document the structure and
behavior of a system’s architecture.
 Using a standard modeling language such as the UML (Unified Modeling
Language), different members of the development team can
unambiguously communicate their decisions to one another.

31
 Software Engineering Best Practices…

5. Verify software quality.

 Software problems are 100 to 1,000 times more expensive to find and
repair after deployment.
 For this reason, it’s important to continuously assess the quality of a
system with respect to its functionality, reliability, application
performance, and system performance.
6. Control changes to software.
 Coordinating the activities and the artifacts of developers and teams
involves establishing repeatable workflows for managing changes to
software and other development artifacts.

32
 Reference
1. Grady Booch, Software Development Best Practices

33