This document discusses key concepts in software design including design patterns, separation of concerns, modularity, information hiding, functional independence, and aspects. It defines design patterns as solutions to recurring design problems. Separation of concerns involves subdividing problems into more manageable pieces or concerns. Modularity is a manifestation of separation of concerns through dividing software into separately addressable components or modules. Information hiding hides internal data structures and processing within module interfaces. Together these concepts aim to improve software design, manageability, and maintenance.

1. Introduction to Software Engineering
Muhammad Nasir
Design Concepts (3)
m.nasir@iiu.edu.pk

2. Agenda
 Design Concepts
 Design Pattern
 Separation of Concern
 Modularity
 Information Hiding
 Functional Independence
 Aspects
 Refactoring
 OO Design Concepts

3. Design Pattern
 “Software Design Pattern is a solution
to a recurring design problem.”
 Design patterns have four essential
elements:
 Pattern Name
 Problem
 Solution
 Consequences

4. Separation of Concerns
 Any complex problem can be more easily
handled if it is subdivided into pieces
 A concern is a feature or behavior that is
specified as part of the requirements model
for the software!
 Concern Separation makes a problem more
manageable i.e. Less effort and time to
solve.!

5. Separation of Concerns
 Separation of concerns is manifested
in other related design concepts:
modularity, aspects, functional
independence, and refinement.

6. Modularity
 Modularity is the most common
manifestation of separation of
concerns.
 Software is divided into separately
named and addressable components
 Sometimes called modules, that are
integrated to satisfy problem
requirements.

7. Modularity
 Monolithic software (i.e., a large
program composed of a single module)
cannot be easily grasped by a software
engineer.
 Modularity leads to “divide and
conquer” strategy. – it is easier to solve
a complex problem when you break
into a manageable pieces.

8. Modularity
 Refer figure that state that effort (cost)
to develop an individual software
module does decrease if total number
of modules increase.
 However as the no. of modules grows,
the effort (cost) associated with
integrating the modules also grows.

9. Modularity vs. Software Cost

10. Modularity vs. Software Cost

11. Information Hiding
 Modules should be specified and
designed so that information
(algorithm and data) contained within
a module is in-accessible to other
modules that have no need for such
information.
 The intent of information hiding is to
hide the details of data structure and
procedural processing behind a
module interface.

12. Information Hiding

13. Information Hiding
 It gives benefits when modifications
are required during testing and
maintenance because data and
procedure are hiding from other parts
of software, un-intentional errors
introduced during modification are
less.

14. Why Information Hiding

15. Functional Independence

16. Aspects

17. Aspects – Example

18. Refactoring

19. OO – Design Concepts

20. The End
 Thanks for listening
 Questions would be appreciated.