UMass Lowell

Computer Science Department

91.522 Object-Oriented Analysis and Design

Syllabus for Fall 1998

http://www.cs.uml.edu/~lechner/91.522/98f522syl.html

(This syllabus is maintained with Microsoft Office97® and is subject to change)

(Last revision date: 98/9/15)

 

INSTRUCTOR: Professor Robert J Lechner

Office: EB402, x3632; OS315 x3630; OS220 (pending)
Phone: (781)444-8321; lechner@cs.uml.edu
 

My 98f Class Schedule:

My 98f Office Hours:
(others by appointment)

Tues: 98F522: 5:15-7:50 in OS415

Tues 8-10PM in OS313

Wed: 98F523: 5:15-7:50 in OS315

Wed. 8-10PM in OS313

Friday: none

Friday 2-5PM in EB402
 

COURSE DESCRIPTION:

Course 91.522 covers both principles and practice of OO Analysis and Design. Object-oriented techniques for analysis, specification, design and prototyping. Static information models and state-based dynamic behavior models applied to rapid prototyping projects that both use and implement object-oriented CASE tools.

Students will use object-oriented CASE tools to specify event-driven distributed software system as a database of block diagrams with procedural attachments. These can be translated semi-automatically into executable prototypes, which are supported by tools such as automatic code generators, state machine interpreters and web browsers.

Course 91.522 OOAD is a prerequisite for 91.523 Object-Oriented Software Engineering (OOSE). Project assignments in 91.522 will include in-depth case studies of our locally-developed software engineering framework or environment; 91.523 project teams are encouraged to re-engineer and enhance this framework.

 

REQUIRED TEXTS:

 

Other useful texts:
[OOSC]: Meyer: "Object-Oriented Software Construction", (2nd edition), P-H 1997 (a required text for course 91. 523; includes CD-ROM contains the text and an evaluation copy of EIFFEL).
Gamma et al: Design Patterns: Elements of Reusable Object-Oriented Software, A-W 1995. (The first of many recent books on O-O software design Patterns. )
Shlaer and Mellor: Object-Oriented Systems Analysis: Modeling the World in Data, P-H 1988. (More details on info modeling, summarized in Ch. 2 of OLC)
Kilov and Ross: Information Modeling: An Object-Oriented Approach, P-H 1994. (A rigorous intro. )
Shaw and Garlan: Software Architecture: Perspectives on an Emerging Discipline, P-H 1996. (Surveys the impact of distributed systems on software design.
Brown: Object-Oriented Analysis: Objects in Plain Englsh, Wiley 1997. (An elementary intro.)
 

PREREQUISITES:

Required: 91.304 or 91.502 (Foundations) plus significant programming experience.

Recommended: 91.301(Languages), 91.308(OS), and knowledge of an application domain such as graphics, databases, multimedia, or engineering.

91.522 Project Topics (in $CASE/98f52* in Fall 1998):

For a list of possible 98f522, 98f523 and 99s523 project topics, see: http://www.cs.uml.edu/~lechner/91.523/98f523projects.html.

 

91.522/523 OO-CASE Tool Framework Support:

98F522 OOAD project teams are encouraged to use our locally-developed software engineering framework of portable generic tools, or another OO-CASE environment which can produce portable and maintainable design documentation. (Many tools save proprietary, non-portable formats.) 91.523 project teams are encouraged to re-engineer and enhance this framework.

This framework consists of four generic CASE tool sub-domains BDE, GEN, LCP, BDE2*, and one integrated application, JPsim, which together comprise the CASE Object-Oriented Laboratory (COOL). Click here to browse or download a PowerPoint slide presentation on COOL: htpp://cs.uml.edu/~lechner/COOL/index.htm

Weekly Topic Outline and Assignments - 98f522:

(This outline is subject to change; for a summary, see the last page of this file.)

This outline specifies topics to be covered biweekly and relevant reading assignments. Handouts include reprints and project reports are to be read by the next class meeting. Many project reports are online at www.cs.uml.edu/~lechner and under the unix path $CASE = /usr/proj3/case/ in a subdirectory named {toolname/../doc or term/project/../doc}). Each 98f522 student will have a user directory under the semester home directory $CASE/98f522.

Reading assignments follow the template format < Week#: Keynote: <topic list>; Read first: <list of prior handouts and text chapter refs>; Handouts for next meeting: <list> >. The reading assignments present the authors' various perspectives on OOAD. Most differences are incidental. What is important is to understand the common basis underlying all these views and our generic tools. I expect you to peruse the reading assignments at least once before each class and to email a few questions per week to lechner@cs.uml.edu for a FAQ list.

Assignments are due in one week unless otherwise noted.

 

PART I: INFORMATION MODELING CONCEPTS

  1. Information Modeling: Static and dynamic models; information modeling, cardinality or multiplicity, associative entities; Bachman Data Structure Diagrams(DSDs) and Chen Entity-Relationship Diagrams(ERDs); network, relational and O-O databases; using BDE. Read asap: OLC Ch. 1, 2; DMOD Ch.1, 2. Handouts: Browse/download these PowerPoint presentations:
    2. Bde Overview: http://www.cs.uml.edu/~lechner/bdeUG2htm/index.htm
    Data Modeling Tutorial : http://www.cs.uml.edu/~lechner/DataModels2htm/index.html
     

    Assignment 1: (a) Use bde to draw a DSD called SIS.dat for a course scheduling, student enrollment and transcript archiving database, and (b) manually create a test database called Term98f.dat. Deliverables: SIS. Data Model Diagram and Term98.dat. (Email plain text ONLY - no base64 or .doc atttachments!)

  2. Object-Oriented Analysis: Relations and associations; is-part-of aggregation vs. is-a [kind-of] generalization; classes as tables; 1:M relations as foreign keys; abstract/virtual classes; extension/restriction; multiple inheritance; metadata, candidate keys, constraints. Read first: DMOD Ch. 6; OLC Ch. 1, 2; UML Ch. 1,2. Handouts: BDE User Guide, bde2sch report, $CASE/gen/ver_10log User Manual.

    3. Assignment 2: Run bde2sch/b2s to convert SIS.dat to schema SIS.sch, and run chgen on SIS.sch 'to generate SIS.h and pr*.c database support code. Deliverables: result of executing this command script:
    "whoami; date; pwd; cat SIS.sch; chgen -ansi -metafile SIS.sch ; ls -l;"

  3. Database Applications: persistent data; normalization; Optional-MAX conversion of M:N relationships to associative entities; CHGEN and GENCPP operation. Read first: GEN Ver_10log User Manual, DMOD Ch. 3 and Appendix; UML Ch. 3; Handouts: TBD.

    4. Assignment 3: Write a simple SIS application to (a) pr_load and pr_dump Term98f.dat. (b) print a class roster (CS-->EN) and (c) print a student grade report (ST-->EN); compile and link it with SIS.h and pr_util.a; show that it operates correctly. Deliverables: source code, compile-time and run-time printouts.

  4. Object-Oriented Techniques: Classes are types, runtime instances are objects; virtual classes; inheritance and type conformance; genericity and template classes; static and dynamic typing. Read first: UML Ch. 4;: None.
  5. Exam 1 on Data Modeling and chgen (replaces Assignment 4). Review of Assignment 3 Solution; Handouts for next meeting: Microwave Oven, Checking Account and Tone Generator examples; Logic Simulation project report.

    6. PART II: STATE-EVENT MODELING CONCEPTS

  6. Dynamic behavior modeling: Object Communication models and State-Event models; messages as events; actions as methods; nested state machines; asynchronous behavior. Read first: example handouts; OLCArch User Guide.

    7. Assignment 4: (a) Draw a 2-state machine diagram RSFFBDE.dat for an RS-flipflop using bde, and (b) convert it into a State Model database RSFFSM.dat using bde2sm. Deliverables: RSFFBDE.dat and RSFFSM.dat.OLC Ch. 3, 4, 5. Handouts for next meeting: JPSim reports,

  7. O-O Prototype Design: OLC Architecture and Operation; specifying operations, actions and constraints. Event trace/thread of control/use case diagrams. Read first: JPsim and OLCArch handouts; OOSC Ch. 19, 20, 36. Handouts: None

    8. Assignment 5: (a) Draw an Object Communication diagram for a 4-bit counter state machine using four RS-flipflop objects, (b) Design an OLCArch-based test driver to exercise this counter. Deliverables: OCD (logic diagram), test driver main program source or pseudo-code).

  8. Design by Contract: Pre-conditions required of client/caller, post-conditions ensured by server/callee; Read first: Handouts for next meeting: OLCP OPerator Class User Guide.

    9. Assignment 6: Augment your program actions (5) and driver (6). with require and ensure assertions. Deliverables: Revised source code.

  9. Executable Prototypes: State Model instantiation using Active Instances and Event Instances; Database initialization, change history and checkpointing; OPerator control over reproducible scripts. Read first: JPsim and OLCArch handouts; OLC Ch. 9. ReviewCheck out the Juice Plant data and state models at this URL: http://www.cs.uml.edu/~lechner/97f522/jp2htm/ksuresh/DEMO/index.html

    10. Assignment 7: (a) Adapt your 4-bit counter program to use the OPerator class as a simulator controller and stimulus history (script file) reader; (b) Run this program and print the FF state sequence that represents the counter's response to an input sequence of 16 count events. Deliverables: (a) Source code and Thread of Control diagram (Use Case), and (b) test run with input and state transition history.

  10. Exam 2 on State-Event modeling and OLCArchitecture; Review Assignment 7 Solution. Handouts for next class:: OLC Project docs, chgen and OLCArch reports.
 

PART III: O-O PROTOTYPING PROJECTS

For a list of possible 98fall project topics, see: http://www.cs.uml.edu/~lechner/91.523/98f523projects.html

 

91.522 GRADING POLICY

(Fall 1997 - TBRevised for Fall 1998)
Two exams with a combination of in-class and take-home problems will contribute 50%;
Other assignments and two-person software projects will contribute the other 50%.
The following factors will carry approximately equal weight toward project grades:
Problem analysis: (reverse engineering, user guide & interface updates)
Project plan: (work breakdown, incremental build/test plan)
Design specs: (information, communication and state diagrams, events and actions.)
Source code: (history, source code style and robustness)
User & maintenance guides: (version tracking, readability and thoroughness)
Test reports: (specs, coverage, predicted and actual results).
 

 

OOAD Course BACKGROUND INFORMATION:

Course 91.522, Object-Oriented Analysis and Design, evolved out of 91.523, Software Engineering I. OOA&D expands the front-end analysis and design aspects that object orientation requires. It uses the most common implementation languages C and C++ or Java. To avoid overlap, 91.522 is now a prerequisite for 91.523. The follow-on course 91.523 Software Engineering I emphasizes implementation and maintenance phases of large-scale object-oriented software development.

OOA&D also provides relevant information and behavior modeling background for the graduate database course sequence.

OOA&D, like traditional system analysis and design, deals with understanding a vaguely defined problem and mapping it into a software architecture with precisely specified requirements for its solution. OOA is not language-dependent and does not require programming sophistication; however, it does require extensive problem domain knowledge and system integration experience, compared to the traditional view of programming as implementation and testing. Thus, OOA&D techniques are accessible to scientists and engineers with application domain knowledge but without extensive programming experience.

On the other hand, sophisticated OO programming languages and complex reusable class libraries are used to implement OO-designs. These require a steep learning curve due to the paradigm shift required from traditional programming methods. We will use the most common implementation languages, C, and C++ and Java, and graphic user interfaces (X-Windows and Microsoft Windows) and amortize the learning process over two semesters in 91.522 and 91.523.

OOA&D is used to derive a model of the system, specify its requirements, and document its design before effective object-oriented programming can begin. The system model is a set of interrelated data and design object models. These represent interacting real-world entities whose concurrent behavior is simulated as a set of event-driven software processes.

Entity-relationship diagrams, extended with inheritance, model the system's static structure as a network of related classes. All objects are instances of these classes and optionally persist in the form of relational database tables. State transition and event communication diagrams, extended with additional semantics, are used to specify the dynamic life-cycle behavior of concurrently executing objects and their interactions.

There is still no consensus on a standard method of formally specifying software structure and behavior. This course uses the Shlaer-Mellor Object Life Cycle method (OLC), which is designed for imbedded computer systems, and the Unified Modeling Language (UML).

 

 

98f522syl.htm: Summary of Readings and Assignments:

For this class:

Read these sections and prior /handouts:

And complete these Assignments:

Wk#

Date

DMOD

OLC

UML

Other

#

Description/URL

1

2

3

4

5

6

7

8

9

10

11

12

13

14