Software design pattern

Reasoning

Data Abstraction

Representation Invariants (RIs)

Hashing

Exception handling

Generics

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

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

Object (computer science)

Polymorphism (computer science)

Interface (object-oriented programming)

Inheritance (object-oriented programming)

Graphical User Interface (GUI)

Array (data structure)

Recursion (computer science)

Big-O notation

Sorting algorithm

Search algorithm

Data structure

Linked list

Stack (abstract data type)

Queue (abstract data type)

Tree (data structure)

Set (abstract data type)

CSCI 0150: Introduction to Object-Oriented Programming and Computer Science Brown University Fall 2022 CS0150 introduces Computer Science via object-oriented design and programming using Java and JavaFX for creating interactive programs with GUIs. Concepts like data structures, algorithms, and computational efficiency are explored. Practical exercises include engaging programming assignments like Doodle Jump and Tetris. The course is designed for all, requiring no prior knowledge. This course introduces students to Computer Science through object-oriented design and programming, using Java and the JavaFX graphics library. You will use these tools for building interactive programs with graphical user interfaces. CS0150 reinforces concepts with practical exercises in weekly lab sessions and with challenging and engaging programming assignments, such as Doodle Jump and Tetris!

There are no prerequisites for CS0150 and the course expects no prior programming experience. This course introduces principles of computer science, emphasizing object-oriented design and programming in Java, an effective modern technique for producing modular, reusable, and internet-aware programs. It also introduces interactive 2D computer graphics, user interface design, some fundamental data structures and algorithms, and computational efficiency. A sequence of successively more complex graphics programs, including Tetris and culminating in a significant final project, helps provide a serious introduction to the field. Each assignment includes an interactive user interface. Therefore, most of the games you program can be played! However, this course is not focused on games nor game design. It uses games as a natural and fun vehicle for learning object-oriented programming and graphical user interfaces.  The course takes an interactive approach to programming assignments and an equally interactive approach to lectures. Andy’s lectures are supplemented by skits performed by the UTAs (Undergraduate Teaching Assistants) to teach course concepts and to make the class fun and enjoyable!  This course is intended for both potential concentrators and those who may take only a single course. No prerequisites and no prior knowledge of programming and mathematics, beyond basic algebra, are required.  

CSCI 0150: Introduction to Object-Oriented Programming and Computer Science

Computer Programming

Software design pattern

2 courses cover this concept

CSE 331 Software Design & Implementation

CSCI 0150: Introduction to Object-Oriented Programming and Computer Science