1 Course Structure

1.1 Readings

• Online Lecture Notes
• Other Online Materials
  • Selected chapters from textbooks (VIVA)
  • Oracle Java tutorials

1.2 Assignments

• Programming assignments
  • Individual work
  • Focused on current lesson
  • Usually graded automatically - results available in 60 min or less
• Analysis assignments
  • Recommended to work in teams
  • Explore the process of moving from vague understanding of a problem toward design
• Roughly speaking, programming and analysis assignments will alternate
  • dates may overlap

1.3 Computer Accounts

2 Related Courses

2.1 Pre-Requisites

3 Important Policies

3.1 Late Submissions

• on programming assignments, incur a 5% penalty per day late
• generally not accepted on design and other non-programming assignments

Extensions to due dates and exceptions to grading policy will generally be accepted only in cases of exceptional circumstances beyond the student’s control, and only if reasonably prompt notification is given of those circumstances.

3.2 Academic Honesty

ODU is governed by a student honor code.

• Everything you turn in for grading must be your own work.
• Detailed policy statement is in the syllabus.

3.3 Grading

• Expect an assignment roughly every 2-3 weeks.
  • Most of these will be programming assignments;
  • Two will be analysis/design assignments.

4 Course Themes

• OOAD: Object-Oriented Analysis and Design
• OOP: Object-Oriented Programming

4.1 OOAD

• Early analysis and design techniques focused on functions and functionality.

  • How do we break a program down into major desired areas of functionality?

  • And break those down into functions that we think we can implement?

  • And break those down into even simpler functions that we know we can implement?

• This leads to a lot of functions.

  • How do we organize these?

4.1.1 The Abstract Data Type (ADT)

One of the major themes of CS250.

• A combination of a new data type and the functions that will manipulate it.

  • Quickly and widely accepted as a powerful organizing principle.

• But where do new ADTs come from?

  • The old function-based design techniques were not much help.

4.1.2 The Object-Oriented Philosophy

Every program is really a simulation.

The quality of a program’s design is proportional to the faithfulness with which the structures and interactions in the program mirror those in the real world.

• To put it even more succinctly: “Keep it real!”

4.1.3 OO: Keeping it Real

• Where do new ADTs come from?

  • From our observation of objects that exist in the real world.

• What functions should those ADTs have?
  • The same that we observe them having in the real world.

4.1.4 Evolving Models

That philosophy is the guiding principle of OOAD:

• Examine the real world for relevant objects and behaviors.
• Model the real world as ADTs whose member functions capture those behaviors.
• Evolve that model into a design for the program.

4.2 OOP

• Early programming languages (PLs) focused on functions.

  • FORTRAN, COBOL, etc.,

• When ADTs were invented, PLs quickly followed suit

  • Modula 2, Ada, etc., added
    • modules that grouped data types and related functions
    • public interfaces
    • private (encapsulated) implementation details

4.2.1 Taxonomies

A funny thing happened on the way to programming via the OO philosophy:

• Going back to the ancient Greek philosophers, we have always tended to organize objects into taxonomies, e.g.,

  • All animals eat.

  • Cows are animals.

  • Bessie is a cow.
  • Therefore Bessie eats.

• What do we learn from examples like this?

  • ITRW, classes of things are related to one another.

  • ITRW, objects can belong to more than one class.

4.2.2 Variant Behaviors

• Bessie is a cow.

  • Therefore Bessie is an animal and Bessie eats.

  • As it happens, Bessie eats grass.

• Simba is a lion.

  • Therefore Simba is an animal and Simba eats.

  • But Simba eats meat, not grass.

• What do we learn from examples like this?

  • ITRW, different classes that share a common behavior may implement that behavior differently.

4.2.3 Object-Oriented Programming Languages (OOPL)

OOPLs extend the modular programming languages by

• Allowing classes/types to be related to one another by shared properties & function interfaces.

  • Inheritance
  • Subtyping

• Allowing variant behavior in the implementations of those functions.

  • Dynamic Binding

OOP therefore builds upon ADT-based programming by working with objects that share common interfaces but implement them differently.

4.3 Coming Up This Semester

• Because OOAD and OOP are rooted in ADTs, we will start with a review of ADT-based programming.

  • We will be working in both C++ and Java, so you will start acquiring the basics of Java.

• We will look at how to exploit the OO philosophy in analysis and design.

• We will look at how and when to use the extensions that OOP adds to ADT-based programming.