Skip to content

It 210 Week 8 Individual Object-Oriented Design Assignment

About this course: This course takes Java beginners to the next level by covering object-oriented analysis and design. You will discover how to create modular, flexible, and reusable software, by applying object-oriented design principles and guidelines. And, you will be able to communicate these designs in a visual notation known as Unified Modelling Language (UML). You will be challenged in the Capstone Project to apply your knowledge of object-oriented design by evolving and documenting the Java codebase for an Android application with corresponding UML documentation. After completing this course, you will be able to: • Apply the Class Responsibility Collaborator (CRC) technique to analyze and design the object-oriented model for a problem. • Explain and apply object-oriented modeling principles and their purpose (e.g., abstraction, encapsulation, decomposition, generalization). • Explain and apply different types of inheritance • Explain the difference between association, aggregation, and composition dependencies. • Express object-oriented models as Unified Modeling Language (UML) class diagrams. • Translate between UML class diagrams and equivalent Java code. • Apply design guidelines for modularity, separation of concerns, information hiding, and conceptual integrity to create a flexible, reusable, maintainable design. • Explain the tradeoff between cohesion and coupling.

CSci 210: Data Structures
Advanced programming through data structure design and analysis

Spring 2011

Class: Mon, Wed 1 - 2:25, Lab: Wed 2:30-3:55 in Searles 126/128

Syllabus & Labs

Solving computational problems requires knowledge of algorithms and data structures and the ability to estimate efficiency in order to make effective choices among alternative solutions. This course is a continuation to csci101 (Intro to Computer Science), and is a study of fundamental data structures, their design, implementation, efficiency and effective use in solving problems. Though the class is programming-intensive and most of the assignments involve programming, programming is not the main focus of the class. The class is rather about program development, from algorithms and analysis to degugging and testing. More precisely, the class focuses on the following broad topics:
  1. Basic data structures: The class will study the basic data structures that come up in computer science. You will learn about lists, vectors, stacks, queues, priority queues, trees and hash tables.
  2. Design: You will refine your learning of how to come up with a solution to a problem. This involves thinking abstractly about the problem, modeling with appropriate classes and methods, thinking about modularity and data abstraction, dividing a task into building blocks, and identifying the appropriate data structures.
  3. Analysis: You will learn to analyse the efficiency of your solution, and to use efficiency considerations to make the right choice of data structures.
  4. Program development: Programming can be tedious and brain-damaging if not approached in the right way. You will learn about incremental development, debugging and testing.
  5. Programming style: Not all code that works is good. When programming, you will learn to strive for simplicity, clarity and generality.

As a programming language, we'll use Java for the most part. In the last part of the semester we'll learn Python.


csci 101 or programming experience from highschool

Instructor: Laura Toma

TAs: Jack Morrisson (), Jesus Navarro (), Lizzie Mamantov ().

Office hours:

  • Laura: Mon, Tue 3-4:30pm. For quick questions you can come to my office anytime.
  • Jack: Mon 8-10 pm
  • Lizzie: Sun 2-4pm
  • Jesus: Tue 8-10pm
The TA office hours will be in Searles 224.

Class Email:

Class webpage: All material will be available from this page throughout the semester. This class does not have a Blackboard site.

Useful books (not required):

Approximate course Outline

Week 1 Sorting and searching.
Week 2 Algorithms analysis.
Week 3Object-oriented (OO) concepts.
Week 4Vectors and linked lists.
Week 5, 6Recursion.
Week 7Stacks and queues.
Week 8Exam1
Week 9, 10 Searching and backtracking using recursion, stacks and queues. Breadth- and depth-first search.
Week 11 Maps and hash tables.
Week 12Trees and binary search trees.
Week 13 Graphs.
Week 14 Python.
--------Exam 2

Work for the course and grading policy:

The work for this course includes two tests, in-class assignments, readings, homeworks and labs. The bulk of your work will be on the lab assignments. Approximately 50% of your grade will be based on the exams. The rest will be based on labs and homeworks.

Lab work will be done individually or in teams of 2 people. The lab-time is dedicated to getting started on the lab. Each lab assignment will be due one week after it is assigned (unless otherwise specified in class). The lab assignment must be turned in electronically (by email), as well as hard-copy. Endorse each assignment with your signature to acknowledge that you have followed the honor code for the class.

Since the major goal of the class is to learn about program development, not handing in any lab is grounds for failing the course (this does not assume, however, that all labs need to be completed satisfactorily).

One of the goals of the class is to learn the difference between programs that work, and quality programs. Therefore do not assume that completing an assignment will result in an A. Even if the program works and does what it's supposed to do, that does not make it an A program.

Late policy

The assignments must be turned in at the specified time. The reason is that it is absolutely essential that you do not fall behind in the class. Furthermore, once an assignment is due, I will no longer provide help on it. In addition, you may not work on late assignments during class time. The late penalty for an assignment is 25% per day. Failure to hand in an assignment is grounds for failing the course. So you are better off handing in something incomplete than not handing in at all.

Honor code and cheating policy

Students are expected to follow the Bowdoin Computer Use Policy and the Academic Honor Code. You are encouraged to discuss ideas and techniques broadly with other class members, but not specifics of assigned problems except as part of group projects. Discussions should be limited to questions that can be asked and answered without using any written medium (e.g. pencil and paper or email). This means that at no time should a student read any code written by another student unless they are part of the same group. Sharing of code or intermediate designs is expressly prohibited. The same rules apply once you have finished the course - sharing your code with other students will be considered a violation of Bowdoin's honor code. Violation of this policy is grounds for me to initiate an action that would be filed with the Dean's office and would come before the J Board. If you have any questions about this policy, PLEASE do not hesitate to contact me. This will be a zero-tolerance policy.

It is permissible to use software and materials available from other sources (understanding that you get no credit for using the work of others on those parts of your projects) as long as: 1) You acknowledge explicitly which aspects of your assignment were taken from other sources and what those sources are. 2) The materials are freely and legally available. 3) The material was not created by a student at Bowdoin as part of this course this year or in prior years.

All write-ups, reviews, documentation, and other written material must be original and may not be derived from other sources.

If in the future you will provide your work to students in 210 this will also constitute a violation of Bowdoin's honor code.