CS494 – Object-Oriented Analysis and Design

Dr. Tom Horton

Notes:

The pre-requisite is important. Students without CS216 will not be allowed to take the course. Contact me if you have questions.
If the course is full and you've met the pre-requisites, see the CS page on waiting lists to get on the list and/or talk to me at the first class.

Course Description:

The course will focus on using the how to create good object-oriented designs and implement them in Java. It will also emphasize using the Unified Modeling Language (UML) as a tool for modeling requirements and designs for software systems. We will use UML notations and techniques for modeling a system's domain in terms of class models and for describing a system's functionality using use cases. We will then look at issues of architecture and system design, using UML's class diagram models, interaction diagrams, state diagrams, and packages. We will address how to use design notations to implement systems in Java (with some reference to C++). We learn what object-oriented design patterns are and how they can be used in design and implementation . The course will attempt to balance emphasis on OO principles, techniques and methodologies with practical skills need to create successful software systems. A number of case studies will be used.

Note: Java will be introduced and used throughout the course, but students will be expected to develop most of their Java knowledge independently. The course will focus on OO design and will not provide a comprehensive
coverage of all of Java's features, focusing only on what's needed to cover the design and implementation issues. (For example, in class we won't do much with user-interfaces, graphics, etc.)

Textbooks:

  1. Designing Flexible Object-Oriented Systems with UML. Charles Richter (Macmillan Technical Publishing, 1999). On the Web: at Amazon; at Bookpool.
  2. Thinking in Java, 2/e. Bruce Eckel (Prentice-Hall, 2000). On the Web: at Amazon; at Bookpool.
    Note: Any good Java book will be fine. An early but decent HTML version of Eckel's text is available for free at http://www.bruceeckel.com. I also recommend any of these: I recommend you own one printed Java book, and also download the HTML version of Eckel's text if you don't buy his book.

Also, required readings from:

  1. Patterns in Java, Volume 1. Mark Grand (John Wiley, 1998).
  2. Design Patterns: Elements of Reusable Object-oriented Software. Erich Gamma et al. (Addison-Wesley, 1995).
  3. Thinking in Patterns with Java. Bruce Eckel. (In progress, available on-line at: http://www.bruceeckel.com)

Other required readings (book chapters, papers) will be given during the term.

Topics:

  1. Identifying classes and objects for small and medium program.
  2. Identifying classes and objects for larger systems from user requirements.
  3. Describing functional requirements with use-cases and "stories".
  4. Thinking about and describing OO software designs for programs.
  5. Thinking about and describing software architectures for large systems.
  6. Using UML notation to model requirements and designs.
  7. Heurtistics and guidelines for increasing design quality.
  8. OO design patterns (the study of proven design "idioms").
  9. Fundamental Java programming.
  10. Implementing UML-based designs in Java.
  11. Possible exposure to other topics: Extreme Programming (XP), testing and OO, refactoring, reverse engineering, using Java and databases, etc.

Grading:

  1. Midterm Exam -- 20%.
  2. Final Exam -- 25% (partly comprehensive). Weds., December 12, 9 am -- noon.
  3. Small homework assignments (probably individual) -- 25% total
  4. Group project work -- 30%

Homework: There will be about 4-5 relatively small homework assignments, probably all to be done individually. One or two of these may require you to explore a new topic outside the mainstream of the class focus.

Project Work: Complete details about the project will be supplied. It will likely be submitted in stages. It will involve groups of two or three students. Projects will involve using OO methods, UML, and Java to create:

  1. Requirements models of a system (e.g. use-cases, class diagrams)
  2. Design models of a system (e.g. class diagrams, state diagrams, sequence diagrams)
  3. Partial Implementation from design or prototypes.

We may find a real customer with a real problem for you to tackle. It is highly likely that class presentations of preliminary results (as carried out in CS340) will be required. For some projects, evaluation of work-products will be emphasized, so in some manner students will be asked to carry out a review of another group's models.

Honor policy: The Honor Policy will be in effect in this class. Each assignment will describe allowed collaborations, and deviations from these will be considered Honors violations. If you have questions on what is allowable, ask! Unless otherwise noted, exams and individual assignments will be considered pledged that you have neither given or received help.

Software to be Used by Students:

BlueJ. A Java IDE that is very good for beginning Java programmers. We'll discuss this in class. Free from http://www.bluej.org (Be sure to look at the 13-page tutorial.) Requires a Java SDK installation; you can use what comes with JBuilder or install Sun's (http://java.sun.com/j2se/1.3)

Together. A UML OO analysis and design tool, with support for code generation from diagrams and reverse engineering of code. (Similar to the tool Rational Rose.) Installed in 001 and Thornton labs. Free for use on home machines from http://www.togethersoft.com (get a license key from me).

Borland JBuilder 5 Personal. An IDE based Java environment. Installed in 001 and Thornton labs. Free for download at http://www.borland.com/jbuilder/personal/
Note: If you have another Java IDE or you prefer just using the Sun SDK, that's fine.

Last updated: 8/30/01