About Computer Science 362
This page provides general information about the Fall 2004 offering of Computer Science 362 at Iowa State University. This page is organized as follows:
- Meetings
- Course Textbooks
- Computer Accounts
- Accommodations for Disabilities
- Course Description
- Objectives
- Prerequisites
- Acknowledgments
The course grading policy and syllabus are on separate web pages.
Information about previous offerings of this course is also available.
Meetings
Attendance is required. The meeting time and location is as follows:
Course meetings are Mondays, Wednesdays, Fridays, at 11:00AM-11:50AM, 1134 Sweeney
Course Textbooks
There are two required texts for the course.
- Craig Larman. Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process, Second Edition. Prentice Hall PTR, Upper Saddle River, NJ, 2001. ISBN 0130925691.
- Ken Arnold, James Gosling, and David Holmes. The Java Programming Language Third Edition. Addison-Wesley, Reading, Mass., 2000. ISBN 0201704331.
There are two recommended text for the course.
- Martin Fowler with Kendall Scott. UML Distilled Third Edition: A Brief Guide to the Standard Object Modeling Language. Addison-Wesley Longman, Inc., Reading, MA, 2003. ISBN 0321193687.
- Alan Shalloway and James R. Trott. Design Patterns Explained: A New Perspective on Object-Oriented Design. Addison-Wesley, Boston, MA, 2002. ISBN 0-201-71594-5.
These texts will be on reserve at the Parks library.
We will supplement the texts with other material as described in the syllabus's bibliography.
Computer Accounts
You must have an account on the cs.iastate.edu machines. You should either read your email there, or have it forwarded to where you read it.
Accommodations for Disabilities
We would like to hear from you if you have a disability that may require some modification of seating, testing, or other class requirements. If so, please request that the Disability Resources staff send a SAAR (Student Academic Accommodation Request) form verifying your disability and specifying the accommodation you will need. Then bring the SAAR form along and talk to Gary Leavens as soon as possible so appropriate arrangements may be made.
Course Description
From the Iowa State University Catalog: "Object-oriented requirements analysis and systems design. Design notations such as the United Modeling Language. Design Patterns. Group design and programming with large programming projects."
Some Explanation
An object-oriented system uses abstract data types (ADTs) for information hiding. ADTs also provide behavior (i.e., actions) so that one can describe systems using behavior that is closer to the problem domain than to the computer. Object-oriented languages, like Java, C#, Smalltalk, and C++, provide ADTs (via a "class" construct) and also subtype polymorphism and inheritance (subclassing). Subtype polymorphism comes from the method calling mechanism, which allows one to invoke a method on an object without knowing its exact run-time class. Inheritance allows one to define new classes by stating their differences from existing classes.
Requirements analysis means describing the essential behavior a system is supposed to have; such a description should not bias the implementation towards particular data structures or algorithms. In object-oriented requirements analysis, the requirements are often aided by a conceptual model of the classes of objects in the problem domain.
Object-oriented Design means describing the behavior of classes that will be used to implement the system. The design includes all information needed to begin coding, but still leaves many choices of algorithms up to the implementation. Various aspects of a design can be recorded in a standard notation, such as pre- and postconditions, or something like the Unified Modeling Language (UML). These are supposed to allow precise communication of designs to developers. Designs can be made more flexible or can be optimized in various ways by using standard ideas, which have been codified into design patterns.
Although the focus of the course is not in the implementation of designs, implementation provides important feedback, since the ultimate purpose of a design is to make implementation easier, faster, and more robust.
Time permitting, we will also deal with formalization of design specifications, perhaps using the Java Modeling Language (JML).
Objectives
The general objectives for this course are divided into two parts: a set of essential objectives, and a set of enrichment objectives. These objectives are linked to the course's learning outcomes (in references that look like this: [B3]). The essential objectives will help improve your overall analytical skills [B3] and will be helpful for your career as a computer scientist or software engineer [C1]; hence we want to help you to master them. You are encouraged to explore the enrichment objectives both for their own sake and because learning more about those will help deepen your understanding of the essential objectives.
Essential Objectives
In one sentence, the main objective is that you will be able to analyze system requirements for large applications [B1] [B2], plan and create robust and evolvable object-oriented designs that meet these requirements [A3] [B3], and work effectively and efficiently in a group [C2]. In more detail the essential objectives for this course are that you will be able to:
- Analyze system requirements and model problem domains [B3]. (Expanded)
- Evaluate the quality of an analysis, and be able to explain how to improve it [B3]. (New)
- Use and explain object-oriented concepts and terms [B3].
- Design and build object-oriented systems, making good use of design patterns [A3] [B3]. (Reworded, combined with design patterns)
- Evaluate the quality of a design, and be able to explain how to improve it [A3] [B3]. (Reworded)
- Explain and justify designs based on potential variations, design principles, design patterns, and heuristics [A3] [B3]. (New)
- Write object-oriented code to correctly implement a design [A3]. (Expanded)
- Test object-oriented software applications [B3].
- Write clear project documentation [C2]. (Reworded)
Although not the ultimate main objectives of the course, the following are necessary skills:
- Be able to read and write analysis and design documentation in the Unified Modeling Language (UML) [C2]. (Expanded)
- Be able to read and write object-oriented code, in Java, that uses interfaces, subclasses, inheritance, abstract methods, subtypes, and subtype polymorphism [A3]. (Expanded)
- Be able to function effectively and efficently in a group, demonstratinging the necessary communication, people, and time management skills [C2].
You will be permitted to use the textbooks and course notes for all exams.
Enrichment Objectives
Enrichment objectives could be multiplied without limit, but the following seem most important or most likely to be taught.
- Be proficient at detecting ambiguity in English or other kinds of informal specifications [B2] [C2]. (Expanded)
- Write and analyze research papers about object-oriented analysis and design [C1] [C2].
- Find answers to questions or related work in the research literature on object-oriented analysis and design [C1]. (Expanded)
- Creatively solve and evaluate solutions to research problems in object-oriented analysis and design [C1]. (Expanded)
- Explain the research and scientific questions that are open in the area of object-oriented analysis and design [C1] [C2]. (New)
- Effectively use a testing framework, such as JUnit [A3] [B3]. (New)
- Effectively use formal specification and design by contract [B3]. (New)
- Explain how to design and document object-oriented frameworks or class libraries that are intended for subclassing [C2]. (New)
- Explain how various programming language constructs help or hinder object-oriented design [A1] [B3]. (New)
Prerequisites
The formal prerequisites in the Iowa State University catalog are English 104 and a C- or higher grade in Com S 228 (Introduction to Data Structures). We expect that you have learned the concepts of data structures and the idea of abstract data types. We also expect that you are familiar with sequential programming in an object-oriented language, such as C++ (or Java). However, we realize that these courses do not cover many object-oriented ideas.
Acknowledgments
Many thanks to Curtis Clifton at Iowa State for his initial work on the HTML for these web pages, which I have adapted from another course, and his style sheets, which I have also adapted.
The certification forms used for the homeworks and various other ideas for teamwork were adapted from Wayne Ostendorf's Com S 401 class. Thanks, Wayne.
Thanks to the students in the Fall 2004 offering of this course for help in refining the course objectives.
Last modified Wednesday, October 20, 2004.
This web page is for the Fall 2004 offering of Com S 362 at Iowa State University. The details of this course are subject to change as experience dictates. Students will be informed of any changes. Please direct any comments or questions to the course staff.