This course presents a basic treatment of the use of toolkits, frameworks, and design patterns in object-oriented design and programming. The concepts of composition, component reuse, inheritance, and parametrization (templates) are studied and used to develop problem-solving strategies, which are then implemented in one or more current object-oriented languages. (Consult the instructor for the language(s) to be used.) Three lecture hours and two hours of scheduled laboratory per week, plus extensive programming work outside of class.
    Prerequisite: CSC 260 with grade of C+ or higher.

• CG1: to present a unified discussion of the important ideas and techniques involved in the use of design patterns and frameworks in object-oriented software design;
• CG2: to guide the student through one or more large-scale projects employing these tools;
• CG3: to provide additional experience in programming in an object-oriented language (normally a language other than one that students already know).

• CO1: explain the concepts of framework and design pattern and the differences between them;
• CO2: name and explain the use of several of the most common design patterns, using appropriate UML diagrams;
• CO3: understand and employ the various types of reuse in object-oriented design;
• CO4: understand and use a variety of components from one or more standard software libraries;
• CO5: understand and use the concept of templates in object-oriented design;
• CO6: design and implement a solution to a large-scale problem using object-oriented tools, and provide appropriate documentation for the solution.

• The engineering of software
• Review of object-oriented concepts and terminology (and the associated UML diagrams):
  • behavior and state
  • instances and classes
  • coupling and cohesion
  • interface and implementation
• Reuse
  • composition
  • aggregation
  • inheritance
• Problem Solving
  • the role of top down design and stepwise refinement
  • steps, cases, divide and conquer, and commonality
• Creating software components in an object oriented language (such as C++ or Java)
  • classes and objects
  • streams
  • containers and iterators
• Component reuse
  • templates
  • inheritance
• Frameworks and design patterns
  • the nature of design patterns
  • survey of some common design patterns
    • Abstract Factory, Adapter, Mediator, and others
  • design patterns vs. frameworks
• Problem-solving strategies
  • breadth-first algorithms
  • backtracking algorithms
• Use of libraries
  • the Standard Library in C++
  • Microsoft Foundation Class library
  • Java Foundation Class Library

The following topics are typical of those used as class examples and programming assignments:

• strings and string processing; pattern matching
• rational number and complex number classes
• large-precision integers
• an inventory control system or a payroll system
• a simple windowing system
• bit vectors and applications
• knight's tour problem
• graph applications

Considerable attention will be paid to implementation details. There will be 4 to 6 programming assignments (possibly one large project divided into progressive stages) in which students will be required to implement appropriate design components. There will also be periodic written homework assignments concerned with design or implementation considerations.

All programs must conform to departmental guidelines for design and implementation, and laboratory reports must conform to the written guidelines supplied by the instructor. Regardless of numeric average or grades on individual assignments or examinations, a student will not be eligible for a passing grade in the course unless he or she has submitted a lab report for every assignment within the time frame specified by the instructor.

The course grade will be determined using the following approximate weights: laboratory reports - 50% total; examinations (midterm and final) - 35%, written homework - 15%.

• Bentley, Jon.   Programming Pearls. Second Edition.   (Addison-Wesley, 2000)
• Bentley, Jon.   More Programming Pearls.   (Prentice Hall, 1987)
• Cormen, Thomas H.; Leiserson, Charles H.; Rivest, Ronald L.; Stein, Clifford.   Introduction to Algorithms. &bsp; Second Edition. (The MIT Press/McGraw Hill, 2001)
• Gamma, Erich; Helm, Richard; Johnson, Ralph; Vlissides, John.   Design Patterns: Elements of Reusable Object-Oriented Software.   (Addison-Wesley, 1995)
• Shalloway, Alan; Trott, James R.   Design Patterns Explained. A New Perspective on Object-Oriented Design.   (Addison Weslet, 2002)

• Fowler, Martin; with Scott, Kendall.   UML Distilled.   A Brief Guide to the Standard Object Modeling Language. Second Edition.   (Addison Wesley, 2000)
• Oestereich, Bernd.   Developing Software with UML.   Object-Oriented Analysis and Design in Practice.   (Addison Wesley, 1999)

• Decker, Rick; Hirshfield, Stuart,   Working Classes.   Data Structures and Algorithms using C++.   (PWS Publishing Co., 1996)
• Feuer, Alan R.   MFC Programming.   (Addison-Wesley Developers Press, 1997)
• Horowitz, Ellis; Sahni, Sartaj. Rajasekaran, Sanguthevar.   Computer Algorithms/C++. (Computer Science Press, 1997)
• Ladd, Scott Robert.   C++Templates and Tools.   (M&T Books, 1995)
• Main, Michael; Savitch, Walter.  Data Structures and Other Objects Using C++.   Second Edition.  (Addison-Wesley, 2001)
• Musser, David R.; Saini, Atul.   STL Tutorial and Reference Guide: C++ Programming with the Standard Template Library.   (Addison-Wesley, 1996)
• Papurt, David M.   Inside the Object Model. The Sensible Use of C++. (SIGS Books, 1995)
• Sanchez, Julio; Canton, Maria P.   Patterns, Models, and Application Development: a C++ programmer's reference.   (CRC Press, 1998)
• Weiss, Mark Allen.  Data Structures and Problem Solving Using C++.   Second Edition.  (Addison-Wesley, 2000)
• Zeigler, Bernard P.   Objects and Systems.   Principled Design with Implementations in C++ and Java.   (Springer, 1997)

• Carrano, Frank M.; Prichard, Janet J.   Data Abstraction and Problem Solving with Java. Walls and Mirrors. (Addison Wesley, 2001)
• Collins, William J.   Data Structures and the Java Collections Framework. (McGraw Hill, 2002)
• Weiss, Mark Allen.   Data Structures and Problem Solving Using Java.   Second Edition.   (Addison Wesley, 2002)