Lahore University of Management Sciences

CS 569 Design Patterns & Refactoring

Fall 2015-16

Instructor Hamid Abdul Basit

Room No. 9-124A/9-116A
Office Hours TBA
Email hamidb@lums.edu.pk
Telephone 8190/8194
Secretary/TA TBD
TA Office TBD
Hours
Course URL TBD
(if any)

Course Basics
Credit Hours 3
Lecture(s) Nbr of 2 Duration 75 minutes
Lec(s) Per
Week
Recitation/Lab Nbr of None Duration None
(per week) Lec(s) Per
Week
Tutorial (per Nbr of None Duration None
week) Lec(s) Per
Week

Course Distribution
Core No
Elective Yes
Open for MS Computer Science
Student
Category
Close for BS Computer Science (Seniors)
Student
Category

COURSE DESCRIPTION
A primary goal of object oriented programming is to create software that
is easy to modify and extend. In this course we will look at two
complementary paradigms targeted to achieve this goal.

In the first part of the course, we explore advanced principles of

object-oriented design by studying key software design patterns. Design
 Lahore University of Management Sciences
patterns are standard solutions to common software design problems.
Instead of focusing on how individual components work, design patterns
are a systematic approach that focus and describe abstract systems of
interaction between classes, objects, and communication flow.

In the second part of this course, we will take an in-depth look at

software refactoring and how it is used to improve the design of software
and minimize the amount of code produced. A range of refactoring
techniques to root out and identify poorly structured code will be
covered. We will also discuss the code smells that indicate that code rot
is occurring. Once we've detected the code rot, we apply object oriented
principles to refactor the code and eliminate the problem.

COURSE PREREQUISITE(S)

Familiarity with an object-oriented programming language

such as Java, C# or C++
Familiarity with object-oriented design in general

COURSE OBJECTIVES
By the end of this course, students will:
Have a deeper knowledge of the principles of object-
oriented design
Understand the design patterns that are common in software
applications
Understand how these patterns are related to object-
oriented design
Use refactoring to facilitate adding new functionality to
system
Use refactoring to improve design
Refactor existing applications to make them more
maintainable
Recognize when and when not to refactor
Identify and choose the appropriate type of refactoring
technique to solve specific problems

Learning Outcomes

Grading Breakup and Policy
 Lahore University of Management Sciences
Assignment(s): 10%
Home Work:
Quiz(s): 10%
Class Participation:
Attendance:
Midterm Examination: 25%
Project: 30%
Final Examination: 25%

Examination Detail

Yes/No: Yes
Combine Separate: N/A
Midterm
Duration: 75 minutes
Exam
Preferred Date: N/A
Exam Specifications: Closed book, closed notes

Yes/No: Yes
Final Combine Separate: N/A
Exam Duration: 75 minutes
Exam Specifications: Closed books, closed notes

COURSE OVERVIEW
Recommended Objectives/
Lecture Topics
Readings Application
Introduction to Design
1.
Patterns
2. Strategy Pattern
3. Observer Pattern
4. Decorator Pattern
Factory Method Pattern
5. Abstract Factory
Pattern
6. Singleton Pattern
7. Command Pattern
Adapter Pattern
8.
Faade Pattern
9. Template Method Pattern
Iterator Pattern
10.
Composite Pattern
11. State Pattern
12. Proxy Pattern
 Lahore University of Management Sciences
13. Compound Patterns
14. Other Patterns
Patterns in the Real
15.
World
Introduction to
16.
Refactoring
17. Bad smells in code
18. Composing Methods
19. Composing Methods
Moving Features between
20.
Objects
21. Organizing Data
22. Organizing Data
Simplifying Conditional
23.
Expressions
Making Method Calls
24.
Simpler
Making Method Calls
25.
Simpler
Dealing With
26.
Generalization
Dealing With
27.
Generalization
28. Big Refactoring

Textbook(s)/Supplementary Readings
29. Head First
Design Patterns by Freeman et al.
30. Design Patterns:
Elements of Reusable OO Software by GoF
31. Refactoring:
Improving the Design of Existing Code by Martin Fowler
32. Refactoring to
Patterns by Joshua Kerievsky