CSE 331 Software Design & Implementation Au12 Information and Syllabus

Logistics and Contact Information: Instructor: Hal Perkins, CSE 548, perkins(at)cs.
Teaching Assistants: Kellen Donohue, Wing Lam, and James Okada.
See www.cs.washington.edu/331/ for information about the course, including office hours, etc.

Communications: A discussion list is linked to the course home page so we can keep in touch outside of class meetings. Please participate. You will also automatically be subscribed to a class mailing list at your uwnetid address. This will primarily be used for announcements, clarifications, hints, and other notices from the course staff, and you are responsible for everything that is mailed there.

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:

  • Successfully build medium-scale software projects in principled ways
  • Understand the role of specifications and abstractions and how to verify that an implementation is correct, including effective testing and verification strategies and use of formal reasoning
  • Analyze a software development problem and be able to design effective program structures to solve it, including appropriate modularity, separation of abstraction and implementation concerns, use of standard design patterns to solve recurring design problems, and use of standard libraries
  • Use modern programming languages effectively, including understanding type systems, objects and classes, modularity, notions of identity and equality, and proper use of exceptions and assertions
  • Gain experience with contemporary software tools, including integrated development environments, test frameworks, debuggers, version control, and documentation processing tools

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

Prerequisite: CSE 143 (i.e., intermediate programming in Java, including basic data structures like lists, queues, and binary search trees)

Grading and Exams:

  • 55% - Homework assignments, approximately weekly
  • 15% - Midterm exam, in class, date tbd
  • 25% - Final exam, Monday, December 10, 8:30-10:20
  • 5% - Quizzes, exercises, class participation, citizenship, and other

These numbers are tentative and will be adjusted as the quarter progresses to reflect the relative difficulty of the assignments.

Late Policy: Deadlines will be given with each assignment. These deadlines are strict. It is exceedingly unlikely that skipping class or being late to class because of homework is in your interest. 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. On group projects you may only use late days if all members of the group have them available, and all members of the group will be charged for each late day used. They must be used in 24-hour (integer) chunks. Programming projects will include specific requirements for notifying the course staff if you intend to use late days and you must follow instructions to receive them. 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 in a separate document. You are responsible for knowing the information in that document.

Texts: There are two required books for the course:

  • The Pragmatic Programmer by Andrew Hunt and David Thomas, Addison-Wesley, 2000.
  • Effective Java by Joshua Bloch, 2nd ed., Addison-Wesley, 2008.

These books contain a great deal of distilled wisdom about software construction in general and Java best practices, technical details, and style issues. 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 material that should be read before class. We can make much better use of class time if everyone has read the relevant sections ahead of time.

Besides the two required books, you may find it helpful to have a good Java programming book for reference. Feel free to pick one that you like, but a good one is:

  • Core Java Vol. I - Fundamentals by Cay Horstmann, 8th ed, Prentice-Hall, 2008. This is a good general reference for the Java language and basic libraries. (The 9th edition is due to be published in late November, but the 8th edition should still be fine for the course.)

Approximate Topics (subject to change): We expect to cover the following topics, but perhaps not strictly in this order.

  • Reasoning about programs: pre- and post-conditions, invariants, and correctness
  • Abstract data types, implementations, abstraction functions, representation invariants, notions of equality
  • Java language issues: subclasses and subtypes, generics, exceptions, assertions, etc.
  • Tools: Eclipse IDE, version control, svn
  • Code quality, style, comments, documentation, JavaDoc
  • Testing, test coverage, black- and white-box testing, test-first development, regression testing, JUnit
  • Debugging strategies and tools
  • Design: modular design, coupling, cohesion; design patterns; basic UML as a design notion
  • User interfaces, callbacks, separation of model from view/control