Generics

Reasoning

Data Abstraction

Representation Invariants (RIs)

Hashing

Exception handling

HTTP Servers

JSON

Loops

Abstract Data Type (ADT)

Software testing

Equality

Module Design & Style

User interface

React

Web Clients

Debugging

Specifications

Abstraction Functions (AFs)

Identity (object-oriented programming)

Assertion (software development)

Subtypes

Event-Driven Programming

TypeScript

Software design pattern

JavaScript

CSE 331 Software Design & Implementation University of Washington Spring 2022 This course aims to improve students' software development skills, focusing on building correct, scalable, and easy-to-understand software. It relies on a solid understanding of Java and the concepts covered in CSE 143. Students will learn about software design principles, modern programming languages, and software tools. It covers software testing, type systems, design patterns, and more. The aim of this course is to help students write programs of higher quality and increased complexity. This requires creating software that is correct, easy to change, easy to understand, and easy to scale. The course covers principled approaches to achieving each of these. The aim of this course is to help students write programs of higher quality and increased complexity. This requires creating software that is (1) correct, (2) easy to change, (3) easy to understand, and (4) easy to scale. We will study principled approaches to achieving these four goals.

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

In this class, we will use Java and associated tools like IntelliJ, JUnit, JavaDoc, and git, but the goal is to understand the underlying ideas and concepts that are generally applicable to software construction. 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. ### Texts

The required text for the course is the following:

- Effective Java by Joshua Bloch, 3rd ed., Addison-Wesley, 2018.

Contains a great deal of distilled wisdom about Java best practices, technical details, and style issues.

There will be assigned readings from this book during the quarter, and there will be questions on the exams about those readings.

Besides the required text, the following books may be helpful to you:

- The Pragmatic Programmer by Andrew Hunt and David Thomas, 20th anniversary (2nd) edition, Addison-Wesley, 2020.

Contains a great deal of distilled wisdom about software construction and the craft of programming, including many things that those who read the book later in their careers wish they had learned early on.

- Program Development in Java by Barbara Liskov and John Guttag, 1st ed, Addison Wesley, 2000.

The content of this well-written book closely mirrors much of the content of the course. The only downside is that it was written 17 years ago, so it is out-of-date with regard to some of key parts of the Java language and libraries. Nonetheless, it is a good place to look for another presentation of the material covered in class, if you can ignore those parts.

- Core Java Vol. I - Fundamentals by Cay Horstmann, 10th ed, Prentice-Hall, 2016; 11th ed, 2018.

This is a good general reference for the Java language and basic libraries. While technical documentation for these things is available on the web, the discussions in a book like this one are usually easier to follow and typically include advice not found in the formal documentation. Either recent edition will cover what we need for CSE 331.

CSE 331 Software Design & Implementation

Software Engineering

Assembly

Heap Allocator Work Time

Unix

Binary Representation

C Strings

Computer memory

Heap (data structure)

Integers

Bitwise Operators

String (computer science)

Explicit List

Stack (abstract data type)

CS 107A: Problem-solving Lab for CS 107 Stanford University Autumn 2022 This supplementary section provides extra support for CS 107 students. It offers an opportunity to review and practice course material in a small group setting, boosting understanding of CS 107 content. It uses a Satisfactory/No Credit grading scheme and is based on effort and participation. ### Welcome to 107A!

🌽 **CS 107A** is the [ACE](https://engineering.stanford.edu/students-academics/equity-and-inclusion-initiatives/undergraduate-programs/additional-calculus) section for [CS 107](https://cs107.stanford.edu), meeting two hours a week to give students an opportunity to review and practice course material in a smaller group setting. We also have CS 107A-specific office hours and support such as exam review sessions to help you do your best in CS 107.

### What is CS107A?

CS 107A is the ACE course for CS107. We spend two hours a week reviewing and practicing CS 107 material in a small-group environment. CS 107A also offers CS 107A-specific office hours and exam review sessions. CS 107A is worth 1 unit and uses a Satisfactory/No Credit grading scheme. Grading is based on effort and participation. If you feel like you would benefit from extra support as you take CS 107, Consider applying to take the course. If your application is accepted, you will be given a permission number in advance of the Add/Drop deadline to enroll in CS 107A on Axess, but you should attend class in the meantime anyway. - To provide students with extra opportunities to review and practice CS 107 material
- To provide an environment where students feel supported and part of a community as they take CS 107  About Ace
### About Ace

Additional Calculus for Engineers (ACE) is designed to provide the skills and solid foundation in mathematics, computational math in engineering, and computer science to undergraduate students interested in pursuing an engineering degree.

The goal of ACE is to increase confidence and increase content knowledge through small group interactive sessions and the academic resources provided to students enrolled in the program.

CS 107A: Problem-solving Lab for CS 107

Computer Systems

Linked list

Interface

Encapsulation

List (abstract data type)

`ArrayIntList`

pre/post conditions

Reference Semantics

Queue (abstract data type)

List Nodes

`LinkedIntList`

Recursion (computer science)

Recursive Tracing

Set (abstract data type)

Map (higher-order function)

Grammars

Binary Search

Recursive Backtracking

Binary tree

Binary Search Tree (BST)

Comparable

Priority Queues

Huffman

Inheritance (object-oriented programming)

Sorting algorithm

Iterators

Resizing

Abstract Classes

Computational complexity

CSE 143 Computer Programming II University of Washington Summer 2022 This course is a continuation of CSE 142, focusing on manipulating data, implementing data structures, and learning about algorithms in Java. It delves into abstract data types, recursion, inheritance, and more.  This course is a continuation of CSE 142. While CSE 142 focused on topics of program control (loops, conditionals, methods, parameter passing, etc.), CSE 143 focuses on topics ofb manipulating data. Topics include: abstract data types (ADTs), lists, stacks, queues, linked lists, binary trees, recursion, interfaces, inheritance, and encapsulation. Students will also learn about the notion of complexity and how to evaluate performance trade-offs of classic algorithms (such as sorting and searching) and classic data structures (such as lists, sets, and maps). The course will include a mixture of implementing data structures and using components from the Java Collections Framework.  ## Textbook

Our optional textbook for CSE 143 this quarter will be the following:

Reges/Stepp. Building Java Programs: A Back to Basics Approach, 5th edition. ISBN 978-0135471944

- [Building Java Programs: A Back to Basics Approach (authors' web site)](http://www.buildingjavaprograms.com/)

This book was written specifically for this course and makes a valuable supplement to the lecture presentations.

## Code Files

The textbook includes many sample programs. You can access a full set of [code files](http://www.buildingjavaprograms.com/code_files/) that is organized chapter by chapter. This will allow you to download any of the programs and run them on your own computer.

## Video Notes

New copies of the textbook come with an access code to watch "Video Notes." These videos supplement the lecture and book material by walking through more examples in detail. You can access the video notes at the Pearson [VideoNotes](http://www.pearsonhighered.com/regesstepp/) web site.

CSE 143 Computer Programming II

Computer Programming

Generic programming

Generics

3 courses cover this concept

CSE 331 Software Design & Implementation

CS 107A: Problem-solving Lab for CS 107

CSE 143 Computer Programming II