Courses Taught
I briefly describe here the courses I have taught at Purdue and UNC
and contributions I made to their contents.
I created this writeup as part of my tenure package at UNC and
am publishing it here since it gives potential students an idea
of the topics I like to teach.
CS 503: Operating Systems (Purdue)
CS 503 is a graduate operating system course and
one of the basic courses all Ph.D. students at Purdue must take.
It is one of the few operating system courses in the country
that uses
the technique, pioneered by Doug Comer,
of giving students hands-on experience with designing,
implementing, and experimenting with a real operating system.
The operating system used for this course,
called Xinu,
has been developed at Purdue by Comer and
can be easily extended by students to implement new features.
I extended his
technique by using Xinu to teach
several additional, recent topics in operating system design
including
synchronous interprocess communication,
capability-based security, and server-based operating systems.
To cover these topics,
I designed several new Xinu-based projects.
Moreover,
I published an original 100-page set of notes that covered
all the topics I taught in class and distributed research papers
from which this material was drawn.
CS 565: Programming Languages (Purdue)
CS 565 is a graduate/undergraduate programming language course and
also one of the basic courses all Ph.D. students must take.
Before I taught this course,
it covered mainly functional and algebraic programming languages.
I extended it to cover several
new unconventional languages including
dataflow, logic, and object-oriented languages.
I developed an effective technique to
teaching a series of programming languages by
asking students to implement a new programming
language using the previous programming language they had learned.
In particular,
they implemented a conventional interpreter in Smalltalk,
a Smalltalk interpreter in Modula-3,
a Lisp interpreter in PROLOG,
and a PROLOG interpreter in ML.
As a result,
they learned a language from both the users' and implementors' views,
both of which are essential for understanding the rationale behind
a language design.
I published a 150-page set of class notes for the topics I covered in
class,
which consisted of both original material I wrote and
material collected from
Prof. Stansifer of
Purdue University and Prof Fischer of Univ. of Wisconsin.
I also distributed research papers.
CS 690P: Programming Environments (Purdue)
Much of the research related to programming in the 1980s has focussed on
replacing languages with ``integrated environments'' for supporting the
programming process.
An integrated programming environment consists of a programming language
and tools such as
debuggers,
databases,
and editors based on the programming language.
Because of its newness,
this area is not well understood in the community and not
addressed by text books.
CS 690P was a research graduate
seminar course I developed in Fall'88 to cover this topic.
In this course,
the students studied
environments that offer a single language for
programming,
command invocation,
debugging,
and other activities carried out by a programmer;
editors that understand the syntax and semantics of the
programming language;
language constructs that support development of integrated
programming environments;
and environments that use the notion of Smalltalk-like objects to
combine language,
operating system,
and database abstractions.
The goals of the course were to teach students about this important
new area and encourage them to do research.
Therefore,
I taught for the first half of the semester and
asked students to present papers in the second
half.
Also students
did original class projects involving either programming
or reading,
and presented reports on their projects.
The course drew 22 students,
which is well above the average for a seminar course - specially
a 690-level course - and
included most of the Ph.D. students working in the general area
of computer systems.
CS 590P: User Interface Development Environments (Purdue)
The term ``user interface development environment'' refers to
the sum total of software meant to ease the task of programming user interfaces.
Traditionally,
this software has consisted mainly of stream-based
I/O routines,
which are suitable only for building teletype-oriented user interfaces.
Recently,
there has been much work done in software for creating user
interfaces that use the capabilities
of (networks of) modern workstations.
Some of this software,
such as window systems and toolkits,
has had great impact in that it is considered an essential
part of any computing system.
Like programming environments,
the fundamentals in this area are
not well understood in the community and not
addressed by text books.
CS 590P was a research graduate/undergraduate seminar course
I developed in Fall'92 to teach fundamental
principles,
design choices, and
mechanisms
related to user interface development environments.
We looked at
user interface architectures,
window systems,
toolkits,
multimedia systems,
high-level I/O constructs,
animation systems,
and collaborative systems.
As in 690P,
I taught for the first half of the semester and students
presented papers in the second half.
The course
attracted 21 students from
both the Computer Science and other departments.
COMP 290: Collaboration Systems (UNC)
The term ``collaboration system'' refers to
a software infrastructure meant to ease the task of programming
collaborative applications.
Currently, this infrastructure consists mainly of traditional operating
systems database systems, which have not been designed to
support the current generation of collaborative applications.
This course focused on research collaborative systems
designed to support novel collaborative applications.
It examined in-depth the ``next-generation'' collaborative applications,
taxonomies of these applications, a framework for describing collaboration
systems, and the issues of coupling and concurrency control.
Students did design and implementation projects and made
class presentations on these projects.
I published an original 70-page set of notes that covered
all the topics I taught in class and also distributed
research papers.
COMP 242: Operating Systems (UNC)
This course was similar to the Purdue CS 503 course,
with the following differences:
Students did not have access to dedicated stations required to
run the Xinu operating system.
Therefore,
I developed new projects that required them to
simulate a Xinu-like kernel in the address space of a Unix process,
which was consistent with the approach taken by previous instructors
of the course.
Also,
the second time I taught the class,
I covered some new topics such as
transactions, remote procedure calls, and
multiprocessor operating systems.
Both times,
students were asked to write a paper on an emerging area in
operating systems.
In Spring '94 it was multiprocessor operating systems
and in Spring '95 it is operating system support for mobile computing.
(One student published his paper in the ACM Operating Systems Review.)
Both times,
I published a set of notes that covered
all the topics I taught in class.
COMP 14: Introduction to Programming (UNC)
This is the first programming course for undergraduates,
which I have taught twice.
The approach I used the first time I taught the course
was similar in many ways to the one used by previous
instructors.
One difference was that I covered functions before procedures,
thereby allowing them to see the more fundamental concept earlier.
I believe this allowed them to better understand both functions and procedures,
which in turn allowed me to easily cover recursion in this class.
The second time I taught the course,
I used an object-oriented teaching technique by covering records (which
are like objects)
early,
and encouraging students to closely couple the definition and operations
of a record type.
I believe this approach allowed them to write programs that were significantly
more complex than the ones they wrote the first time I taught the course.
Both times,
I published a set of notes that covered
all the topics I taught in class.