\section*{Coverage of Computer Science Subject Areas in\\
COM 1205: Software Design and Development and\\
COM 3360: Adaptive Object-Oriented Software Development}
%\section*{Curriculum Content}

``Computing as a Discipline'' \cite{comp-discipline:young} 
presents nine subject areas
comprising the discipline of computing.
Accreditation boards are using the classifications
in ``Computing as a Discipline'' to evaluate computer science programs.
These courses include some of the material in six of the nine areas.
In the graduate course (COM 3360), the material is covered in 
greater breadth and depth.

\begin{enumerate}
\item
{\em Algorithms and data structures}

Students learn to write algorithms without encoding the details of the 
data structures in the algorithms.
This makes the algorithms more general and more reusable.
Students learn about basic graph algorithms, such as depth-first
traversal.

\item
{\em Artificial intelligence and robotics}

Students learn to express algorithmic knowledge at a high level
of abstraction through traversals and visitors.
Structural knowledge representation is introduced through class dictionaries.
Students learn about analogical reasoning by transforming
a program from one data structure to another.

\item
{\em Database and information retrieval}

Students learn to design schemas for object-oriented databases.
They also learn a novel query notation: traversals and visitors. 

\item
{\em Human-to-computer communication}

Students learn a new visualization of programs based 
on collaborating objects and classes.

\item
{\em Programming languages}

Students learn to use a family of programming languages that live
on top of object-oriented languages. 
Implementation of these languages is discussed through 
operational semantics.

Class dictionaries and traversals and visitors
are a new programming language and
at the same time a new specification and design language.

\item
{\em Software methodology and engineering}

Students learn principles of 
development of {\em flexible} software systems.
They learn about several design patterns, such as Visitor,
Observer, Structure-Shy Traversal, Structure-Shy Object, Context, etc.

\end{enumerate}

``Computing as a Discipline'' describes three important processes
used in the computing discipline: Theory, Abstraction, and Design.
These courses cover aspects of all three processes:

\begin{itemize}
\item
Theory

Students learn definitions of class dictionaries and traversals and visitors and a few
theorems and proofs. They become experts at proving very
simple ``theorems'' of the form: This object O is a legal
object with respect to a given set of classes.

\item
Abstraction

Students learn to abstract class dictionaries from objects. 
They learn to abstract adaptive programs from object-oriented
programs. They learn to abstract parameterized classes from classes.
% They learn to model ``potential'' algorithms and data structures.

\item
Design

Students learn about requirements in the form of use-cases.
Students learn about specification, design, implementation, and
testing of adaptive software.

A large part of the courses explains how adaptive software works.
Since adaptive software uses an excutable specification language
for object-oriented programs, specification, design, and implementation
are closer together than in other approaches to software development.
\end{itemize}

Finally, ``Computing as a Discipline'' identifies twelve recurring
concepts fundamental to computing.
The following concepts are covered extensively in these courses:
\begin{itemize}
\item
Binding

Adaptive software uses a sophisticated mechanism to bind methods
to classes.

\item
Conceptual and formal models

Students learn to design their own models and to debug them
first with respect to structure and then with respect to functionality.
Debugging of the structure is accomplished through parsing. Debugging
of the functionality is achieved through ``evolution histories'' which
allow debugging in layers.

\item
Evolution

Ease of evolution is one of the key properties of adaptive software.
Students learn how to evolve their Java or C++ programs by controlling the
evolution through class dictionaries and traversals and visitors.

\item
Levels of abstraction

Students learn to effectively deal with multiple levels of abstraction,
most importantly learning the distinction between groups of objects and 
groups of classes.
Students are challenged by abstraction level collapsing, such as when
a group of classes is suddenly viewed as a group of objects
(which happens, for example, when students learn about self-describing
class dictionaries and how to write programs for them).
Parameterized classes are also used extensively, adding a third layer
of abstraction.

When students write traversals and visitors,
they operate at multiple levels of abstraction:
the object, class, and parameterized class level for the structural
information, and the adaptive and object-oriented level for the
behavioral information.

\item
Reuse

Ease of reuse is one of the driving forces behind adaptive software.
Students learn how to write software with fewer built-in assumptions,
which makes the software easier to reuse in new environments.
The Law of Demeter plays an important role.
\end{itemize}