Conrad Cunningham's Teaching
Primary Teaching Interests
Software engineering (software architectures, frameworks, and
patterns; programming methodology; object-oriented and component-based
development). Programming languages (domain-specific languages,
functional and multiparadigm programming). Concurrent and distributed
See my Current Courses document for my
current and recent class schedules and materials.
- CSci 211, Computer
Science III (File Systems).
- I taught a Pascal-based version of this course several times in
the 1989-95 period. I began reorganizing it to use Java in Fall 1996.
This was the first use of Java in the Department.
- CSci 300, Social
Responsibility in Computer Science.
- I taught this required undergraduate course during the Fall 1996,
1997, 1998, and 2000 semesters.
- CSci 311, Models of
Computation (Automata Theory)
- I taught this required undergraduate course during the Fall 1998,
1999, and 2000 semesters.
- CSci 405, Computer
- 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. (In
the 2003-10 period, Dr. Steve Rice taught a different version of this
- CSci 433
Algorithm and Data Structure Analysis.
- I taught this required undergraduate course in Spring 1999.
- CSci 450,
Organization of Programming Languages.
- I taught this required undergraduate course in Fall 1995.
- CSci 487, Senior
- I coordinated the senior projects during Spring
1997, Fall 1997, Fall 1999, Spring 2000, and Fall 2002.
- CSci 490, Special
- I taught this special topics course during Spring 1996
with the topic object-oriented design and programming using
- CSci 500, Fundamental
Concepts in Computing.
- I taught this transitional graduate course during Fall 1999
and 2000. (It is currently coordinated with CSci 311.)
- CSci 541, Expert
Systems and Logic Programming
- In Spring 2008, I revived this course which has not been
taught since the early 1990s. I focused on Prolog programming.
- CSci 550,
Program Semantics & Derivation.
- I developed this course and first taught it during Spring 1990
semester. I taught it several times through Spring 1998. After
several years of dormancy, I revived it in Spring 2006.
- CSci 555,
- I developed this course and first taught it during Spring 1991
semester. I taught it for the 13th time in Fall 2010. During the
Fall 1993 semester I wrote a draft of an extensive set of lecture
notes that has continued to evolve. I use the lazy functional
programming language Haskell.
- CSci 556, Multiparadigm
- I developed this course and taught it for the first time in Fall
2008 as a CSci 581 Special Topics course. I subsequently created a
new course CSci 556 for this material and taught it in Spring 2012.
This course focuses on use of the language Scala, which combines the
object-oriented and functional paradigms and executes on the Java
- CSci 581, Special
Topics on Object-Oriented Design and Programming.
- 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.
- Engr 660, Software Engineering II.
- I redeveloped this course as seminar and taught it twice
during the 1991-3 period. Dr. Pam Lawhead taught this course with a
similar organization during the summer of 1995.
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
- Engr 664, Theory of
- I developed this course and taught it during the Fall 1990 and
Fall 1991 semesters to use the UNITY notation and programming logic.
I developed an alternative version of the course based on PCN and
first taught it during Spring 1993. 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
in Fall 1999, an approach I used in the Spring 2005 and Fall 2009 offerings.
- Engr 691, Special
Topics on Software Architecture.
- 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 as CSci 490-1 and Engr 596-6.
- Engr 691, Special
Topics on Distributed Objects.
- I taught this experimental course on JavaServer Pages Javabeans
in Spring 2001.
- Engr 691 (at
Jackson), Special Topics on Analysis of Algorithms.
- I taught this course for the first time during Spring 1997.
This was part of the Computer Engineering and Telecommunications
"program" on the Jackson "campus".
- Engr 691, Special
Topics on Component Software.
- I developed and taught this course during Fall 2002. It focused
on development of component-based systems using Enterprise JavaBeans
- Engr 691, Special
Topics on Software Families
- This lecture-based course focuses on development of software families--in
particular frameworks and product lines. The Fall 2007 and Fall 2011
offerings were similar to the Fall 2003 offering of Engr 660. The
latter offering used Scala instead of Java for the programming
examples. Subsequent offerings will be given under a new CSci
- Engr 691, Special
Topics on Software Language Engineering
- This lecture-based course, first taught in Spring 2009, focuses on
development and processing of domain-specific languages. I
subsequently taught the material in Spring 2011. A future offering
will teach this material under a new 600-level CSci number.
- Engr 692, Special
Topics on Ruby and Software Development.
- I taught this topic on the Ruby programming language and
its implications for software development in Fall 2006.
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
in a separate document.
My goals in teaching and course development include the
- To have my teaching and course content consistent with the above
- 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
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
- 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
- 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
[ Cunningham's Home
| Current Activities
Copyright © 2012, H. Conrad Cunningham
Last modified: Mon 16 Jan 2012