Event Driven Computing
Course offerings
Why should I study this course?
Modern software is controlled through graphical user interfaces (GUIs),
that allow users to "fill in a form" on the screen, and click buttons.
This style of input is very convenient for users, but makes things more
complex from the computer's viewpoint, because users can enterer data
in any order, and at any time.
For this reason, building GUI-based programs to accept user input is
substantially more difficult than building old-style
computer-prompted input.
You may already know from your own experience that it is very easy for
a GUI program to have bugs that remain undetected for a long time, then
cause an unexpected (and probably unreproducible) crash.
GUI programs are just one example of event-driven systems, which must
react to a number of events when they occur.
Programs of this type exist in most electronic equipment that you own,
such as your car, microwave oven, DVD player, iPod, and so on.
Writing bug-free event-driven programs requires that you think about the
problem in new and unfamiliar ways.
This course introduces appropriate techniques for building reliable
event-driven programs.
Large software systems are hard to build.
Experiance has shown, however, that many large systems are constructed in
"similar" ways.
By studying these similarities, called design patterns, you can
learn how to construct future programs in the same way, thus ensuring
that your program will work correctly, and will be easy to modify in future.
Building GUIs that are easy and intuitive to use, requires that you know
how big to make buttons and fields, and where to locate them on the screen.
This problem, known as man-machine interaction, has been studied by
psychologists and others, and is important knowledge for a GUI designer.
What will I learn?
We introduce the concepts and techniques underlying finite-state-machines, including:
- The definition of Alphabet
- The definition of String
- The specification of a deterministic Finite-State Automaton (FSA)
- The specification of the state-transition function
- The definition of a non-deteministic FSA (NFA)
- A method for converting an NFA to a deterministic FSA
- The concept of epsilon-transitions
- Regular expressions, and their relationship to FSAs
We introduce a number of design patterns: - Adapter
- Decorator
- Singleton
- Strategy
- Iterator
- Visitor
We cover material on GUI construction: - Overview of how GUIs work
- Coordinate systems
- Graphics drawing primitives
- Event-handling mechanism
- Model-view-controller paradigm
What should I know before I enrol?
The assignment work will assume you are a confident object-oriented
programmer, and requires extensive programming in Java.
If you are not a confident programmer, you will find this course
very difficult.
The following courses provide the skills you will need: What comes next?
If you are invited to enter the honours computer science program (see
Honours Degrees) the following courses are of interest.
- The course cds
will greatly extend your knowledge of concurrent systems.
- The course css
will use finite state machine models to explain the operation of
communications protocols.
What do students think of this course?
From time-to-time, we ask students to give their opinion of this course,
and allow the lecturers to respond to the evaluation.
The most recent results, labelled 'courseEvaluation', and 'courseResponse'
are here:
Handy links
Disclaimer
The information presented here should apply to most students.
It is possible, however, that special conditions may apply to you.
You can find out by reading the
University Calendar program rules
|
