Teaching
Software engineering (software architectures, frameworks, and patterns; inclusive software design; formal programming methodologies; modular, object-oriented, functional, and component-based development).
Programming languages (functional and multiparadigm programming; domain-specific languages; language design and processing).
Concurrent and distributed computing.
Writing, critical thinking, ethics, and professional issues in computer science.
Designing and using accessible instructional materials.
See my Courses by Semester document for my current and recent class schedules and materials.
I taught the Pascal-based version of this required undergraduate File Systems course several times in the 1989-95 period.
I began reorganizing the course to use Java in Fall 1996. This was the first use of Java in the Department. The file systems material was later deemphasized, and this course was integrated into a introductory three-semester, Java-based, lab-focused sequence with CSci 111 and 112.
I taught this required undergraduate course on social responsibility and professional ethics during the Fall semesters of 1996, 1997, 1998, 2000, and 2015.
I taught this required undergraduate course on automata and formal languages during the Fall semesters of 1998, 1999, 2000, and 2015. I developed online notes to support my lectures from the Linz textbook (Peter Linz. An Introduction to Formal Languages and Automata, Fifth Edition, Jones and Bartlett Learning, 2012.)
I revived and taught this undergraduate elective course in Spring 2000. I taught it again in Fall 2001 in conjunction with a graduate special topics course on the same topic. I used the process-interaction approach and the Java programming language.
I taught this required undergraduate course in Spring 1999.
I first taught this required undergraduate course in Fall 1995.
I taught the course again in the Fall semesters of 2014, 2016, 2017, and 2018, revising the course to use my own materials. The 2017 and 2018 offerings used drafts of my textbook Exploring Languages with Interpreters and Functional Programming.
I coordinated the senior projects during Spring 1997, Fall 1997, Fall 1999, Spring 2000, Fall 2002, Fall 2013, Spring 2017, and Spring 2018. I co-taught the course with Joey Carlisle in Spring 2019.
I taught this special topics course during Spring 1996 with the topic object-oriented design and programming using C++.
I taught this transitional graduate course during Fall 1999, 2000, and 2015. (It is currently coordinated with CSci 311.)
I taught this transitional graduate course during the Fall semesters of 2014, 2016, 2017, and 2018. (It is currently coordinated with CSci 450.)
In Spring 2008, I revived this course which has not been taught since the early 1990s. I focused on Prolog programming.
I developed this course and taught it in Spring 1990 as a course focused on programming language semantics and program verification.
I refocused the course on program derivation in subsequent offerings in Spring 1991, Fall 1992, Spring 1994, Spring 1995, Fall 1996, Spring 1998, and Spring 2006. I have an extensive set of online lecture notes for this version of the course.
I developed this course and first taught it during Spring 1991. I taught it for the 15th time in Spring 2019. I used the lazy functional programming language Haskell from the 3rd offering in Fall 1993 through Fall 2010. I experimented with the Scala language in Spring 2016 and Spring 2019, but I taught the Haskell-based FP material in CSci 556 in Spring 2017.
In the 1993-96 period I developed an extensive set of lecture notes on Haskell-based functional programming. In 2016-2018, I revised and adapted these notes and incorporated them into the textbook Exploring Languages with Interpreters and Functional Programming.
I developed this course and first taught it in Fall 2008 using the Scala language. I used Scala again in Spring 2012. In Spring 2015, I taught a version of the course that used the new language Elixir and in Spring 2017 one that used Haskell. In Fall 2018, I revised the course to use the language Python 3.
I developed and taught this topic in Fall 1997 to introduce graduate and advanced undergraduate students to object-oriented techniques at a deeper level that was being taught in lower-level courses at the time. I taught a modified version of the course during the spring 1999 semester. Beginning in Fall 2000 I combined a portion of this material into the the Software Architecture topics course. I later used some of this material in offerings of Scala- and Python-based CSci 556 and CSci 658 courses.
I created this lecture-based course to focus on development and processing of domain-specific and general-purpose programming languages. I taught it in Spring 2009 and Spring 2009 using Scala. I used Lua in Fall 2013 in preparation for changes in CSci 450 in Fall 2014 and beyond. In Spring 2018, I focused on Python 3 but used several older examples from the Scala and Lua versions of the course.
This lecture-based course focuses on development of software families—in particular frameworks and product lines. I first taught a course primarily focused on the Software Families content in Fall 2003 as Engr 660. I followed with similar couses in Fall 2007 as Engr 692 and in Fall 2011 as Engr 691. The 2003 and 2007 offerings used Java for programming exercises; the 2011 offering used Scala.
Any subsequent offerings will be given under the new course CSci 663.
I redeveloped this course as seminar and taught it twice during the 1991-3 period.
In Summer 2001, I taught a lecture-based course on formal specification and design techniques for component systems using the Unified Modeling Language (UML) and Object Constraint Language (OCL).
In Fall 2003, I taught a lecture-based course that focused on development of software families — in particular frameworks and product lines.
In Fall 2005, I taught a lecture-based course that focused on software design.
I developed this course and taught it in the Fall 1990 and 1991 semesters using the UNITY notation and programming logic.
I developed an alternative version of the course based on Program Composition Notation (PCN) and taught it during the Spring 1993, 1994, 1995, and 1996 semesters.
I did the first half of the Fall 1997 semester with a theoretical approach and the second half with a more pragmatic approach that emphasized Java threads programming.
I revised the course again to use Labeled Transition Systems and Java for the Fall 1999, Spring 2005, Fall 2009, and Fall 2017 offerings.
I developed and taught this course during Spring 1998. I revised it further for the Fall 2000, Spring 2002, and Spring 2004 offerings. I have used some of this material in subsequent classes, such as the Spring 2010 special topics offering on [Software Design and Scala Programming ](<softwareDesign/csci490.htm>l) as CSci 490-1 and Engr 596-6.
I taught this experimental course on JavaServer Pages JavaBeans in Spring 2001.
I taught this course in Spring 1997 as a part of the Computer Engineering and Telecommunications “program” on the Jackson “campus”.
I developed and taught this course during Fall 2002. It focused on development of component-based systems using Enterprise JavaBeans (EJBs).
I taught this topic on the Ruby programming language and its implications for software development in Fall 2006. Although I only taught this course once, it influenced my development of the new courses CSci 556 (Multiparadigm Programming) and CSci 658 (Software Language Engineering), my modifications of the CSci 450/503 course, and subsequent use of the Prolog, Scala, Lua, Elixir, and Python 3 languages.
This course focuses on scholarly communication, critical thinking, and professional issues facing graduate students, faculty, and researchers in computer science. This is a required course for computer science PhD students. I developed and first taught the course in Spring 2013 and subsequently taught it in Spring 2014, Spring 2016, and Fall 2017.
Note: I first wrote this section in the mid-1990s. I still agree intellectually with the philosophy, but I must acknowledge that the required mathematical approach needs to be relaxed somewhat to accomodate the average computer science student and software engineering professional.
I doubt that my views on and approach to computer science education are coherent and complete enough to be called a “philosophy”. However, here are a few thoughts.
What is computer science?
I prefer the term computing science or perhaps just computing. The discipline should be named for the processes studied, not for a particular technological artifact. The process of computing is what is important, whether the computing “mechanism” consists of a semiconductor device, molecular structures, or the gray matter between the ears of human beings.
Programming is the essence of computing science.
Of course, by “programming” I do not mean merely “coding” — and definitely not “hacking”.
I view programming as the process: of determining what the problem is, whether a solution is needed, what the desired nature of a solution is, and whether such a solution is feasible, ethical, and socially useful; of devising specific abstractions, algorithms, and information structures that correctly, elegantly, and efficiently solve the problem; of implementing the solution effectively within the concrete resources available and validating that it indeed solves the problem; and of evolving the solution and its implementation to handle changing needs. This, of course, encompasses most of what is traditionally called computer science and software engineering. But, perhaps, the perspective is different.
Problem solving is the essence of programming.
In programming, we should focus our attention primarily on the problem to be solved and secondarily on the process for solving it. Although definitely not irrelevant, the details of particular languages or the technological tools are of lesser importance. The most important “tool” we have as computing scientists is the one between our ears.
If computing is a “science” or an “engineering discipline”, then we should teach it as such.
Both hard scientists and traditional engineers are taught the mathematics appropriate to their disciplines and this mathematics is actually used as a tool in the classroom and the laboratory and on the job. In the same way, the mathematics appropriate for computing science should be taught early in the curriculum and reinforced in later computing science courses.
I have included a number of [interesting quotations ](<quotations.html>l) in a separate document.
My goals in teaching and course development include the following:
To have my teaching and course content consistent with the above “philosophy”.
To have fun myself.
I want my students to enjoy (at least some aspects of) the classes I teach. If I do not enjoy (at least some aspects of) what I am doing, how can I expect my students to do so.
To learn something myself.
I try to stay intellectually engaged with what I teach, regardless of the level of the course.
To “shake up” my students.
We often fall into comfortable patterns of thought, thinking we know more about something than we really do.
By approaching tasks from a different perspective, I hope to make students realize that there is always a different way to look at a programming problem than the ones with which they are familiar — to realize that there is more to programming than mastery of a couple of imperative languages and absorption of the details of the latest technology. I also hope my students help to “shake” me up intellectually.
To get my students to think more carefully and precisely.
In this high-speed, video- and audio-oriented age, clear and precise thought and expression do not always seem to be valued highly.
To focus on the long-term life and career needs of my students.
We should never forget that the primary reason for the existence of a university is to create an environment where students can learn the knowledge, skills, and attitudes needed by happy and productive citizens.
A computing science program should help prepare its students for a long career as computing professionals in the 21st Century. Although teaching current technologies in preparation for a first job in business or industry is important, it is less important than laying down a foundation of core computing concepts and skills, including the skill to grasp new technologies quickly.
To communicate a love of the computing science discipline and profession.
I entered the computing profession not just because it could earn me a good paycheck, but because I found the computing science discipline intellectually challenging and the profession socially useful. I hope that my students will also develop that kind of interest and respect for the discipline and the profession.
To teach something “practical”.
Although being “useful” is neither the only nor the first concern of a computing science curriculum, it should not neglect the task of helping real students learn how to solve real problems in the real world.