CSE 331: Software Design and Implementation


What qualities make a program good? How can we tell if a program is good? How can we build good programs? We will consider these questions as we explore concepts and techniques for the design and construction of reliable and maintainable software systems in modern high-level languages; program structure and design; program-correctness approaches, including testing; and event-driven programming. To practice the concepts from lecture, we will build substantial projects.

Lecture Mon, Wed, Fri 10:30 HCK 132
Section AA : Thu 8:30 MGH 251
AB : Thu 9:30 SAV 131
AC : Thu 10:30 CHL 015
AD : Thu 11:30 MGH 287
Instructor Zach Tatlock (ztatlock@cs)
Wed 11:30 CSE 546
TAs Christopher Chen (chrisc94@cs)
Thu 2:30 CSE 006
Viktor Farkas (vfarkas@cs)
Mon 11:30 CSE 006
Cody Kesting (kesting@cs)
Wed 5:30 CSE 021
Chen (Jason) Qiu (chenq9@cs)
Tue 4:00 CSE 006
Matthew Yang (mattyang@cs)
Fri 4:00 CSE 006
Lucy Zhu (lucyzhu@cs)
Tue 10:30 CSE 006
Garrett Marconet (gmarco@cs)
Mon 3:30 CSE 006
Zhengyang Gao (gaoz6@uw)
Fri 3:30 CSE 006
Qian Yan (qiany7@cs)
Tue 3:00 CSE 006
Resources Piazza
Academic Integrity




We will be reading selections from The Pragmatic Programmer and Effective Java throughout the quarter. You can find quizzes on the reading in Catalyst.


Submit homeworks 0, 1, and 2 via the 331 Dropbox. Submit programming assignments by pushing and tagging your git repo as described in the assignment spec. If you need to, you can use up to 4 late days during the quarter, but at most 2 per assignment.

To get ready for future homeworks, please see the References.


Past Exams

Previous midterms:
15au   (solution)
15sp   (solution)
15wi   (solution)
14au   (solution)
14sp   (solution)
14wi   (solution)
13au   (solution)
13sp   (solution)
13wi   (solution)
12au   (solution)
12sp   (solution)
12wi   (solution)

Previous finals:
15au   (solution)
15sp (solution)
15wi (solution)
14au (solution)
14sp ( solution)
14wi (solution)
13au (solution)
13sp (solution)
13wi (solution)
12au (solution)
12sp (solution)
12wi (solution)



Basic Environment Setup

Version Control

Assignment Submission

Working at home

Editing, Compiling, Running and Testing Java Programs

Eclipse Reference


Java Style Guide

Class and Method Specifications

Rep Invariants and Abstraction Functions




Goals: There is a level of programming maturity beyond introductory programming that comes from building larger systems and understanding how to specify them precisely, manage their complexity, and verify that they work as expected. After completing this course successfully students should be able to:

To gain experience we will use Java and associated tools like Eclipse, JUnit, JavaDoc, and git, but the goal is to understand the underlying ideas and concepts that are widely applicable to software construction.

Prerequisite: The only formal prerequisite is CSE 143. We will very much rely on a thorough understanding of the concepts from CSE 143 as well as Java programming skills. We will go much further and you will be challenged to approach software development much differently than you have in CSE 143 or other courses.

Grading and Exams: Your overall grade will be determined as follows (subject to change as necessary, but substantial changes to the numbers below is unlikely):

There is approximately one assignment per week, but not on an exact schedule (i.e., assignments may be due on different days). The assignments are not weighted equally because they are of different length and sophistication. The exact weighting is to-be-determined and is not likely to be published in advance (we need to see how the course goes). Later assignments are likely to be weighted more heavily because they are more involved.

Late Policy: Deadlines will be given with each assignment. These deadlines are strict. For the entire quarter, you may have four "late days". You are strongly advised to save them for emergencies. You may not use more than two for the same assignment. They must be used in 24-hour (integer) chunks. This policy may not be the same as in your other classes. You are responsible for understanding it if you choose to submit late work.

Academic Integrity: Any attempt to misrepresent the work you submit will be dealt with via the appropriate University mechanisms, and your instructor will make every attempt to ensure the harshest allowable penalty. The guidelines for this course and more information about academic integrity are below. You are responsible for knowing that information.

Texts: There are two required books for the course:

These books contain a great deal of distilled wisdom about software construction in general and Java best practices, technical details, and style issues. Reading about software development is an important skill.

There will be assigned readings from these books during the quarter, and you will be required to complete short online quizzes from time to time about the readings.


Approximate Topics (subject to change): We expect to cover the following, with an emphasis on specification and design. The order these are listed is only very rough as we will revisit some topics iteratively.

Academic Integrity

You are responsible for understanding every word in this document.


Material in this course based on work from Michael Ernst, Hal Perkins, Dan Grossman, David Notkin, numerous TAs, and past 331 students.