CS594--Graphical User Interfaces
- Office: Ayres 6C
- Text: Designing the User Interface: Strategies for Effective
Human-Computer Interaction, 2nd Ed., Ben Shneiderman.
- Reference Materials: Location where they can be purchased to be announced
- Python reference manual
- Amulet reference manual
- Handouts: Many of the lecture topics do not have good textbook
descriptions and hence will be covered via handouts
- Good C++ Book: C++ Primer, 2nd Ed. Stanley B. Lippman
- TA: Dave Brown
- Office: Ayres 6
- Office Hours:
- Tuesday 2:00 - 3:00 (except 1/28 1:00 - 2:00)
- Thursday 1:00 - 2:00
Topics To Be Covered
The course will be a survey of tools and techniques
for constructing highly interactive, graphical user interfaces. The
emphasis will be on four major areas:
The course will also cover graphical interface design and usability at a
high-level. Each week you will be assigned one chapter from the text book.
We will spend a portion of each class discussing the material from the
chapter and seeing how it applies to your project design.
- Object Oriented Programming: Object-oriented programming is a buzzword
that is frequently thrown around these days. We will discuss the major
aspects of object oriented programming, including inheritance, data
encapsulation, and polymorphism, and discuss how they can simplify the
task of creating a user interface.
- Spreadsheet-Style Programming: A spreadsheet allows equations to be
attached to variables (cells). An equation may reference other variables
(cells). When the user changes the value of a variable, all the equations
that depend on that variable are reevaluated in the appropriate order.
This spreadsheet-style paradigm is useful for specifying graphical
relationships between objects, such as keeping a piece of text centered
within a box. It is also useful for scheduling and executing the
numerous side-effects that an operation may have on an application.
We will discuss how aspects of the spreadsheet paradigm can be applied
to graphical interfaces. We will also discuss algorithms for efficiently
scheduling and executing equations.
- Display Management: When the user manipulates objects in a user interface,
both the interface and the application typically provide various types
of pictorial feedback. This feedback may "damage" various areas of the
screen, and may require that the graphical objects that inhabit these
areas be redrawn. We will discuss efficient algorithms for incrementally
detecting and updating damaged areas of the display.
- Input Handling: The user interface must translate low-level input events,
such as keyboard presses or mouse presses, into high-level behaviors
that an application understands (e.g., delete an object, move an object, etc.).
We will discuss models and algorithms for handling input. We will also
explore the concept of interaction techniques (combinations of graphics
and behaviors that are reused in many interfaces).
- Project: 30%
- Programming Assignments: 25%
- Midterm: 15% (March 11)
- Final: 30%
There will be a number of programming assignments throughout the semester
to give you familiarity with both the algorithms presented in class
and with object-oriented programming.
Although subject to change, I currently envision three
programming assignments, one related to learning object-oriented
concepts, one related to
constraint satisfaction (to be done in Python), and one related to
You will be expected to design and implement an interactive,
graphical application based on the concepts and principles presented
The project is broken into five assignments, the last four of which will
be graded. The first assignment will ask you to design an
interactive, graphical application of your choice but will not be graded.
The remaining four assignments will cover creating a "sketchboard" of
your graphical interface, building a prototype of your interface in Python,
refining your prototype in Python,
and then building the final version of your interface in C++.