Introduction and Goals
The aim of this course is to teach you about:
- User-Interface Design.
This part covers task based and user centered design,
as techniques to ensure that the user-interface that is developed matches
the task to be performed with it, by the users who will be performing
that task.
System-based design, task-based design, user-centered design
- User-Interface Evaluation.
This part covers evaluation techniques that enable you to
find problems with user-interfaces by means of cognitive walkthroughs
(without actual users) and by means of observations of users actually
trying to perform a task with the user-interface.
Evaluating user-interfaces, with and without users.
- Guidelines for
Designing Usable Interfaces.
Many "rules of thumb" are given and illustrated by examples,
to show examples of good design as well as noteworthy failures.
Despite the provided guidelines, you are likely to only learn them
by first ignoring them during your initial user-interface designs,
and finding out the hard way that these rules are to be obeyed at all times.
Apart from "good" advice, one often also needs to take into account
specific style guides that may apply to user-interfaces for a
specific computing platform (Macintosh, MS-Windows, Motif, etc.).
guidelines for developing user-friendly (ergonomic) interfaces.
style-guides for specific windowing platforms.
- User-Interface Development.
In this part you will learn about creating user-interfaces for
windows-systems and for browser-systems.
The typical way in which interfaces are developed is by means of
objects that are placed on top of each other,
and that handle (input) events.
Such objects are often called widgets (short for
window gadgets).
Object-oriented and layered construction of windows- and browser-interfaces.
- The Java Programming Language
A brief summary is given of the most important aspects of the
Java programming language. The emphasis is on the translation of aspects
of object-oriented design and programming into Java.
Object-oriented programming in Java.
- Developing
User-Interfaces in Java
This part describes how to program user-interfaces in Java.
Specific topics include:
- AWT, the Abstract Window Toolkit.
- The Swing Toolkit.
- JavaBeans, reusable component architecture.
- Event-driven programs, and how to write them for Java 1.1.
- Exceptions, a means for separating error-handling code from the
"main" part of the source code.
- Threads, or how a single program can do many things simultaneously.
AWT, Swing, JavaBeans, events, exceptions, threads.
- GUI Builders
High-level tools exist that let you draw a user-interface.
These tools generate all the code that is required to generate the
visible aspects of the user-interface. They separate this code from the
application code you still have to write.
Some GUI builders even generate dummy or empty versions of the methods or
functions you have to write to complete the interface.
A GUI builder may enforce a style-guide, so that the programmer cannot
create user-interfaces that violate the guidelines for a specific platform.
Other GUI builders do not enforce style-guides but are targeted towards
the development of user-interfaces that are usable on several computing
platforms without the need for changes in the source code.
Drawing user-interfaces and adding code for each component later.