Java (programming language)

Android (operating system)

Human–computer interaction

Framework vs. Toolkit vs. Library

Android software development

Animation

User Interface Layout

Debugging

Visual Perception

Application security

Accessibility

Event (computing)

Interactor hierarchy

Motor control

Fitts's law

Data analysis

Application Design Principles

Mental Models

Undo (Computing)

Persuasive technology

Location Services

Sensors

Dark pattern

Finite-state machine

Usability testing

User interface

CSE 340 Interaction Programming University of Washington Spring 2022 This course focuses on the design and programming of interactive systems, exploring various programming paradigms, event handling, and accessibility. It requires prior knowledge of Java and familiarity with data structures. This course helps to develop user-friendly interfaces and study existing interfaces. Although the platform used is Android, it's not strictly an Android programming course. Interactive technology is changing society. Some of today’s interfaces are used by a billion people at a time. Almost everything we create is created for people to use, through user interfaces. We will learn about interactive systems, including programming paradigms and design of event handling, layout, undo, accessibility and context awareness. ## Why should I take this class?

Interfaces are an important part of our daily lives and many of them are created as a connection from a human to a machine. Even a new machine learning algorithm or a database system requires some human connection in order for those systems to work.

User interfaces are incredibly important, but interactive user interaction requires a different programming paradigm than you may have learned before. In this you will learn how to:

- write an event-driven program which reacts to user input and displays output using abstractions in a structured and maintainable way. These abstractions generally transfer to almost any other user interface toolkit.
- think about the design and implementation of novel interaction techniques such as voice based interfaces or augmented reality, in order to enrich the user experience.
- build inclusive and accessible user interfaces.
- implement implement user-centered features, such as Undo, that following well studied design principles that are applicable in any user interface.
- critique and study existing user interfaces using light weight informal and formal methods.
- communicate your findings through comprehensive reports as well as reflections on your learning

The [Course Details](https://courses.cs.washington.edu/courses/cse340/22sp/course-details.html) page describes each of our course modules as well as other classes that complement the learning goals in CSE 340.
 The only official requirement for this class is that you have taken **CSE 142 and 143 or an equivalent class**, meaning you are comfortable programming in Java, and have some experience with data structures.

There are other skills that are required for the class that are not explicitly taught, which means you should **plan to spend extra time (either independently or in OH) learning and practicing those skills**. These include:

- working in an Integrated Development Environment (IDE) that is more complicated than JGrasp
- Using a version control systems (Git)
- Reading and understanding library and toolkit documentation
- Reading and understanding a larger starter code base
- Reflecting on and explaining the coding work you have done
- Reading through assignment specifications which are “more complicated and less detailed” than a typical Introduction to CS assignment specification.

Taking CSE 391 just before or concurrently with 340 can help, but our staff can also assist where needed.

The specific platform and language for this class are **Java on Android phones** (or simulators); using the IntelliJ IDE (Android Studio). While Google is switching over to Kotlin, there are good reasons to [start learning Android with Java first](https://dzone.com/articles/java-vs-kotlin-which-language-android-developer-sh).

Note that this class is designed for CSE majors, and other students who work regularly with information technology and are strong programmers. While we will consider applications from outside the major, other restrictions may limit space for such students. ### What should I expect as a student in this class?

This is an **interaction programming course** which will teach the abstractions that underly all user interfaces (see the [Course Details](https://courses.cs.washington.edu/courses/cse340/22sp/course-details.html) page for more information). To learn these concepts, we will cover a mix of theoretical aspects of HCI (such as how to predict the time it will take to click on a button, or why Undo is important to implement) and practical aspects of HCI (such as how to handle user interface events). What we will not cover is Android programming.

To re-iterate, *this is not an Android programming class and you will be expected to research Android programming yourself*. We will point you at the relevant of Android documentation but you must be willing to read through and explore this documentation on your own.

Taking any class is a commitment, and this one is no exeception. We want to make sure you get the most out of your experience. Below is some information about prerequisites and expectations.

CSE 340 Interaction Programming

Software Engineering

Pointer (computer programming)

The GNU Debugger (GDB)

Recursion (computer science)

System Control Flow

C (programming language)

Executables

Virtual memory

C Programming

Floating Point

Buffer overflow

Memory & Data

x86 Programming

Array (data structure)

Memory & Caches

Integers

x86-64 Assembly

Binary

Bitwise Operators

Procedures & Recursion

Data structure alignment

Process (computing)

Computers and Society

The Stack & Procedures

Cache (computing)

Memory allocation

CSE 351 The HW/SW Interface University of Washington Autumn 2022 This course develops students' understanding of software functioning at different levels of abstraction. Focus areas include C, assembly, and low-level data representation. It also introduces concepts of operating systems and differences between Java and C. It serves as a starting point for those interested in hardware or high-level abstractions. This course should develop students' sense of what really happens when software runs – and that this question can be answered at several levels of abstraction, including the hardware architecture level, the assembly level, the C programming level, and the Java programming level. The core around which the course is built is C, assembly, and low-level data representation, but this is connected to higher levels (roughly how basic Java could be implemented), lower levels (the general structure of a processor), and the role of the operating system (but not how the operating system is implemented).

For (computer science) students wanting to specialize at higher levels of abstraction, this could, in the extreme, be the only course they take that considers the "C level" and below. However, most will take a subset of [Systems Programming (CSE333)](http://courses.cs.washington.edu/courses/cse333/), [Operating Systems (CSE451)](http://courses.cs.washington.edu/courses/cse451/), [Compilers (CSE401)](https://www.cs.washington.edu/education/courses/cse401/), etc.

For students interested in hardware, embedded systems, computer engineering, computer architecture, etc., this course is the introductory course after which other courses will delve both deeper (into specific topics) and lower (into hardware implementation, circuit design, etc.). Of particular interest are [Introduction to Digital Design (CSE369)](https://www.cs.washington.edu/education/courses/cse369/), [Design of Digital Circuits and Systems (CSE371)](https://www.cs.washington.edu/education/courses/cse371/), [Introduction to Embedded Systems (CSE474)](https://www.cs.washington.edu/education/courses/cse474/), and [Computer Architecture I (CSE469)](https://www.cs.washington.edu/education/courses/cse469/). At the end of this course, students should be able to:

- Describe the multi-step process by which a high-level program becomes a stream of instructions executed by a processor;
- Describe the basic organization of the memory hierarchy and the effect of its parameters on system performance;
- Trace the execution of assembly code (x86-64), map the assembly to high-level language constructs, and write simple pieces of assembly programs;
- Write C code using pointers to create and manipulate complex data structures;
- Write (or rewrite) code to be take advantage of the computer execution model to improve execution efficiency;
- Debug small-ish C and assembly programs using GDB;
- Explain the role of an operating system;
- Describe fundamental differences between Java and C.  Course Themes
## Course Themes

The course has four principal themes:

- Representation: How different data types (from simple integers to arrays of data structures) are represented in memory, how instructions are encoded, and how memory addresses (pointers) are generated and used to create complex structures.
- Translation: How high-level languages are translated into the basic instructions embodied in process hardware with a particular focus on C and Java.
- Control Flow: How computers organize the order of their computations, keep track of where they are in large programs, and provide the illusion of multiple processes executing in parallel.
- History and Society: The principles computers are built upon were influenced by the societal context of the historical periods in which they were designed and, in turn, computers influence society in ways far beyond pure computational power.

CSE 351 The HW/SW Interface

Computer Systems

Class (computer programming)

Software testing

References

List (abstract data type)

SLLists

Nested Classes

Array Resizing

Inheritance (object-oriented programming)

Extends

Higher-order function (HOF)

Exception handling

Object Methods

Disjoint Sets

Set (abstract data type)

Binary Search Tree (BST)

Red Black Trees

Tree traversal

Multi-Dimensional Data

Prefix Operations and Tries

Reductions and Decomposition

Quick Sort

Algorithmic Bounds

Data structure

Scope

Linked list

Shortest paths

Heap (data structure)

Kolmogorov complexity

Sentinel Nodes

DLLists

ALists

SLists

Implements

Casting

Subtype Polymorphism

Iterators

Asymptotics

Abstract Data Type (ADT)

Map (higher-order function)

B-tree

Hashing

Priority queue (PQ)

Graph traversal

Range Searching

Sorting algorithm

Radix Sorts

Compression

P=NP

Static

Minimum Spanning Tree (MST)

CS 61B: Data Structures UC Berkeley Fall 2022 CS 61B focuses on software efficiency from design and runtime perspectives. It covers object-oriented programming with Java, teaching data structures and various programming concepts. The course promotes hands-on learning with optional assignments. The CS 61 series is an introduction to Computer Science, with particular emphasis on software and machines from a programmer’s point of view. CS 61A covered high-level approaches to problem-solving, providing you with a variety of ways to organize solutions to programming problems as compositions of functions, collections of objects, or sets of rules. In CS 61B, we move to a somewhat more detailed (and to some extent, more basic) level of programming by focusing particularly on the efficiency of writing programs (design) and running programs (runtime).  This class assumes you have taken CS 61A, CS 88, or E 7, or have equivalent background to a student who has taken one of these courses. The course is largely built upon the assumption that you have taken CS 61A. CS 88 and E7 students may find the beginning of the course to be a bit scarier, particularly when it comes to object oriented programming. We assume you are coming in with zero Java experience, but we will move through basic Java syntax very quickly.

We recommend all students to complete the [optional introductory assignment](https://fa22.datastructur.es/materials/hw/hw0/) by the beginning of the semester to get comfortable with Java and practice some of the programming skills expected by this class.

If you already have Java experience, great! We hope that you’ll help out your fellow students in discussion, lab, and on our class forum, particularly in the opening weeks when everyone is catching up on Java. **There is no required textbook for the class.**

There is an online textbook written by myself and a large team of former TAs. It can be found at https://joshhug.gitbooks.io/hug61b. If you find these notes insufficient, you might consider consulting [Paul Hilfinger’s (free) Java Reference](http://www-inst.eecs.berkeley.edu/~cs61b/fa14/book1/java.pdf) or [Head First Java, 2nd Edition by Sierra and Bates (O’Reilly, 2005)](https://www.google.com/search?q=head+first+java). These are not required for the course. The **optional** textbook for the weeks 5-14 of the course is Algorithms, 4th Edition by Wayne and Sedgewick.

The official description of the Java core language is available online in [The Java Language Specification](https://docs.oracle.com/javase/specs/jls/se17/html/index.html) (Java SE 17 Edition) by James Gosling, Bill Joy, Guy Steele, Gilad Bracha, Alex Buckley, Daniel Smith, and Gavin Bierman. It’s extremely thorough and precise, at the expense of being quite dense and technical. You will find the official [Java 17 documentation](ttps://docs.oracle.com/en/java/javase/17/docs/api/index.html) to be useful as well

CS 61B: Data Structures

Data Structures and Algorithms

Functional Decomposition

Control Structures

Data Abstraction

Documentation and Readability

Static methods

Types

`print` statements

Scanners

Conditional (computer programming)

While loop

Object-Oriented Programming (OOP)

ArrayList

Java

Expressions

Parameters

`Math` class

Information flow

Pseudorandomness

Line-based file input

reference semantics

Constructors

Polymorphism (computer science)

Escape sequences

`for` loops

Class constants

Return values

Chaining

Sentinel loops

Token-based file input

Array Traversals

Fields

`println`

Variable (computer_science)

Nested `for` loops

String (computer science)

Cumulative algorithm

Fencepost problems

Boolean

File output

Array Shifting

Instance Methods

Critters

CSE 142 Computer Programming I University of Washington Summer 2022 This introductory course teaches programming using Java. Students learn computational problem-solving techniques, functional decomposition, control structures, data abstraction, and code documentation. No prior programming experience is required. This course provides an introduction to programming using the Java programming language. We will explore common computational problem-solving techniques useful to computer scientists, but also to anyone who has large data sets, repetitive processes or other needs for computation. No prior programming experience is assumed, although students should know the basics of using a computer (e.g., using a web browser and a text editor) and should be comfortable with math through Algebra 1. Students with significant prior programming experience should consider skipping CSE 142 and taking [CSE 143](https://cs.washington.edu/143). CSE 142 is organized around five key learning objectives. At the end of the course, students will be able to do the following:

1. Functionality/Behavior: Write functionally correct Java programs that meet a provided specification and/or solve a specified problem
1. Functional Decomposition: Break down problems into subproblems that are modular and reusable, and define methods to represent those subproblems
1. Control Structures: Select and apply control structures (e.g. methods, loops, conditionals) to manage the flow of control and information in programs
1. Data Abstraction: Select and apply basic data abstractions (e.g. variables, parameters, arrays, classes) to manage and manipulate data in programs
1. Documentation and Readability: Define programs that are well-written, readable, maintainable, and conform to established standards  Recommended textbook: [*Building Java Programs* by Reges and Stepp (5th edition)](https://courses.cs.washington.edu/courses/cse142/22su/textbook.html)

CSE 142 Computer Programming I

Computer Programming

Java (programming language)

4 courses cover this concept

CSE 340 Interaction Programming

CSE 351 The HW/SW Interface

CS 61B: Data Structures

CSE 142 Computer Programming I