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 computing.


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. (This course was later renamed Computer Science III and integrated into an introductory sequence with CSci 111 and 112.)
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 Simulation.
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 course.)
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. I taught it again in Fall 2014, revising the course to use my own materials with Haskell and Lua.
CSci 487, Senior Project.
I coordinated the senior projects during Spring 1997, Fall 1997, Fall 1999, Spring 2000, Fall 2002, and Fall 2013.
CSci 490, Special Topics.
I taught this special topics course during Spring 1996 with the topic object-oriented design and programming using C++.
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 503, Fundamental Concepts in Languages.
I taught this transitional graduate course during Fall 2014. (It is currently coordinated with CSci 450.)
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, Functional Programming.
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 Programming.
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, focusing on use of the language Scala. In Spring 2015, I am teaching a version of the course that uses the new language Elixir.
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.
CSci 658, Software Language Engineering
This lecture-based course, taught in Spring 2009 and Spring 2011 as an Engr 691 Special Topics course, focuses on development and processing of domain-specific and general-purpose programming languages. The Fall 2013 offering of the course used the language Lua in preparation for changes in CSci 450 in Fall 2014.
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 software design.
Engr 664, Theory of Concurrent Programming.
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 (EJBs).
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 the new course CSci 663.
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 interesting quotations in a separate document.

My goals in teaching and course development include the following:

[ Cunningham's Home | Current Activities | Research | Papers | Quotations ]

Copyright © 2015, H. Conrad Cunningham
Last modified: Sat Jan 10 14:38:41 CST 2015