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.