I taught a large number of courses, but these are the ones I had a reasonable record of. All but CS3743 and CS4313 were online.

For a chronological listing, see Courses Taught by Year.
For programming projects, see Projects.

Fall00, Spr00, Fall99.
• I created this course and taught it three times. I chose the ridiculous title to help get it approved.
• The first time I had them write a "research paper". Most of them just copied from the internet, so after that I asked for a "web research project" on a very specific topic (different for each student), asking them to show what could be found on the internet about the topic. "If you can't beat them, join them."

Spr06 (not taught), Fall05.
• Most of this course was standardized: lecture material, examples, recitations, and the way to run the course. The material was well-prepared, but it was not the way I would have structured the course myself.

Fall04.
• I taught this course just once. It was supposed to be taught using Fortran, but because Fortran would have been useless for most of the students, I rebelled and used Java. This class included some of the weakest programming students I've ever had.

Fall03, Spr01, Spr98.
• The latest two iterations of this course had mostly standard content, course materials, and method of teaching it. The materials were well-prepared, but not the way I would have taught the course on my own.

Fall01, Fall98, Spr97.
• The most recent iteration had required standard content and course materials, which were well-prepared but not the way I would have taught the course by myself.

Spr06, Fall05, Spr92.
• Some of the notes for the two most recent iterations were cribbed from those of Dan Jimenez.

Spr05.
• I only got to teach this course once. The students had already seen Java through data structures, and now we were teaching them C. My idea was to do C well, but to give them an overview of the differences and similarities between C, Java, and C++. I planned to improve the notes at the next iteration.
• I loved my material about self-reproducing programs (see Recitation 7 or Self Replicating C Programs).

Fall04, Spr04, Fall03, Spr03, Fall02, Spr02, Fall01, Spr01, Fall00, Spr00, Fall99, Spr99, Fall98.
• The first time I taught this course (Fall 1998), it was particularly challenging because I had never studied the material. (I've never been much of a hardware person.) That first time I leaned heavily on the materials that Kay Robbins had prepared the semester before. I continued to use some of her materials the whole time I taught the course.
• As time went on, I eased up on the difficulty of the recitation material because of all the copying that occurred with harder recitations. (See MIPS Single-cycle Simulator.)
• I liked teaching the course and admired the textbook. The last time I taught this course, they came out with the 3rd edition (with my name in the Preface!).

Fall99, Spr99.
• For many years, UTSA had 1-hour language courses. Eventually these were replaced by a 3-hour course covering 3 languages, initially Ada/C/Lisp. By the time I taught the course, the three languages had become Java/C++/Lisp.
• The first time I taught the course, I used a Lisp project that asked them to write an interpreter for "pure" Lisp. The resulting interpreter included functions with parameters, so it wasn't a completely toy system. This assignment was first conceived by William F. Dowling at Drexel University. I used the assignment myself at that time, and we worked on it together, but the details were mostly his. The assignment and a solution (in C) are at: Lisp Interpreter. My solution seems to have some problem with "defun". Since it once worked, there must be some simple problem.

Spr04 (9 weeks).
• I taught the first 9 weeks of this course because the regular instructor took a leave to take care of a new child. Initially it was to be 6 weeks, but that stretched out to 9 weeks, complicating the course organization.

Spr05, Fall04, Spr04, Fall03, Spr03, Fall02, Spr02, Fall01, Spr01, Fall00, Spr00.

• I taught programming languages and compiler courses starting in 1977. This was not my field, but I got started and continued with them because of a lack of instructors.
• Before the Spring of 2000, UTSA had a required course "Topics in Programming Languages", CS 3323. For the Spring 2000 course, most of my students had already taken CS 3323, so I decided to make it more challenging by covering mainly compiler topics. I liked these topics more anyway, and thought they were more worthwhile. (See All Compilers.)
• In Fall 2002, we added a required 1-hour recitation. I restructured the homework so that there was something each week. I also came to realize that if the recitations were too hard, some students would just copy.
• During the lifetime of this course, a high priority for me was to teach syntax-directed translation. Each time I taught the course I made this part easier and added other material. The final iteration (Spr05) still has a legitimate compiler, but it is feasible to complete in just 3 recitations. The language is structured so that are tokens are just single characters, so that a scanner is trivial to write. (See Simple Compiler.)
• Starting with Spring 2004, I added to the course the Ruby language as an interesting object-oriented example. This was before Ruby became so popular.

Fall93.
• I no longer have a machine-readable copy.
• The main interesting feature of this course is a programming project to implement a relational database management system based on the relational algebra. (See Database Management System.)

Spr97.
• I no longer have a machine-readable copy.
• The main interesting feature of this course is a programming project to implement a recognizer of arbitrary regular expressions. (See Regular Expression Recognizer.)

Spr07 (5 classes), Spr03, Spr02.
• This is one of my areas of research. The course is complicated by the need for mathematics background that few of our students have. In the end I partially completed a textbook for this course (not published): The Laws of Cryptography.

Spr02 (not offered).
• This was a special topics course without enough enrollment to be offered. I had just started organizing the course.

Fall02.
• The course had 53 students in it -- the most of any graduate course ever offered in computer science at UTSA. This size was a tremendous burden that affected the course adversely. The course was taught from 8:30-9:45pm, equally horrible. Also, when I gave a slightly harder assignment, there was a lot of copying, which I had not expected from graduate students. Finally, the topic was not my research area. Not a pleasant experience.