CSE 331 17sp Software Design & Implementation: Information and Syllabus

Logistics and Contact Information: See the main course web site www.cs.washington.edu/331/ for information about the course, including meeting times, staff, office hours, communications, etc.

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
Use and learn new 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 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):

55% - Homework assignments, approximately weekly
15% - Midterm exam
25% - Final exam
5% - Reading quizzes and other

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 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. 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.

Besides the two required books, a good Java programming book for reference is extremely valuable. Feel free to pick one that you like, but a good one is:

Core Java Vol. I - Fundamentals by Cay Horstmann, 10th ed, Prentice-Hall, 2016. This is a good general reference for the Java language and basic libraries. (If you have a previous edition describing Java 7 it should be fine for the course. We do not rely on any specific features introduced in Java 8.)

Advice:

Do not skip class or section to work on homework, not even late in the quarter when you are more tired and busy. This will cost you time (not to mention learning) in the long run. Class will start promptly, and you will find the entire course easier and more educational if you arrive punctually, well-rested, and ready to pay attention for 50 minutes.
Do buy a Java programming book. In general, a large, well-written reference book for any programming language you are using is a great value, sure to save you time over frustrating web-searching and time on sites like stackoverflow.com (though those are useful too -- it is not "one or the other"). Web-searching is cheaper, but you are spending a lot of money on your education and will likely get a high-paying job when you finish. The cost of a book that helps you do better in classes, internships, etc. is miniscule compared to the benefits you get from doing better work in less time. And such a book will be valuable long after you complete CSE331.
A common misconception about this course is that the lectures, readings, and homeworks are disconnected. They are different since there is no point repeating something in multiple ways, but they also are connected. If you are approaching a homework and not using the concepts in the rest of the course materials, you are making it harder. When you are sawing something with a dull blade, it can seem like you do not have time to sharpen the blade because you need to finish sawing. In fact, you likely do not have time not to stop and sharpen the blade.
Start homeworks early. They are more difficult than assignments in earlier courses and you need time to make mistakes.
Enjoy this course and learn a lot! It is invaluable for making you a better software developer. The more you master these ideas now, the more effective you can be in jobs, other courses, and any other projects.

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.

Reasoning about programs: pre- and post-conditions, invariants, and correctness
Abstract data types, specification, implementation, abstraction functions, representation invariants, notions of equality
Java language issues: subclasses and subtypes, generics, exceptions, assertions, etc.
Tools: Eclipse IDE, version control, git
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
User interfaces, callbacks, separation of model from view/control