Incorporating Problem-solving Patterns in CS1
                        Dave Reed
         Department of Mathematics and Computer Science
                    Dickinson College
                   Carlisle, PA  17013
                   reedd@dickinson.edu
 Two recent trends in CS1 instruction involve the use of programming
 patterns and course themes.  By focusing on programming patterns, i.e.,
 algorithms or problem solving approaches that can be applied to various
 applications, students reason at a higher level of abstraction when
 solving problems.  In addition, code schema can be provided which apply
 to certain patterns, and these schema then serve as frameworks for
 program development.  Closely related to the patterns approach is the
 use of themes in a programming course.  Selecting a particular idea,
 methodology, or application domain provides a framework for learning new
 techniques and concepts.  Once a concept has been studied in one
 context, new applications which similarly utilize that concept can be
 understood more easily.
 This paper describes the use of a particular problem-solving pattern,
 binary reduction, as a recurring theme in the CS1 course.  By
 introducing problem-solving patterns early in the course and then
 revisiting them in different contexts, students learn to look for common
 characteristics in problems, and to use an existing solution as a
 framework for solving related problems.  Perhaps more importantly,
 understanding the behavior of one problem solution can simplify the
 analysis of other problem solutions based on the same pattern.

Title:
Chance-It: An Object-Oriented Capstone Project For CS-1
Author:
Joel C. Adams
Department of Computer Science
Calvin College
Grand Rapids, MI 49546
adams@calvin.edu
Abstract
Most people enjoy playing games.  Most CS-1 students will enjoy a final
project that involves computational game-playing.  Chance-It is a simple
two-person dice game with many possible strategies at varying levels of
sophistication and complexity.  These features make the problem of
formalizing and encoding a strategy to play Chance-it an interesting final
project for CS-1.
	This paper describes an object-oriented final project for CS-1 in
which students build Player1 and Player2 classes to play Chance-It.  A
ChanceItGame class and driver are provided to coordinate the interactions
of these classes.  The project provides students with an enjoyable
introduction to object-oriented design and the problem of formalizing and
codifying human strategy in software.  Examples are given in C++, but
convert easily to Java.

Computer Science Degree Programs: What Do They Look Like?
A Report on the Annual Survey of Accredited Programs
	Renee McCauley and Bill Manaris
	  Computer Science Department
	University of Southwestern Louisiana
	    Lafayette, LA 70504-1771
	  {mccauley, manaris}@usl.edu
This paper presents information from a survey of departments 
offering accredited computer science degree programs.  It 
discusses demographic information related to curricula, 
faculty, and students for all such programs, and identifies 
various trends based on these data.  These results are of 
interest and use to all accredited and non-accredited programs 
alike, since they facilitate monitoring and comparisons among 
individual degree programs in the nation in terms of curriculum 
issues, faculty composition and salaries, student enrollment 
and graduation rates. 

The Distributed Course - A Curriculum Design Paradigm
Bill Toll
ABSTRACT:
One of the curriculum design problems facing computer science is the
pressure to add new courses to cover additional topics.  Often there is no
curriculum space available.  In some cases, the topics are covered more
effectively by distributing them among a set of courses.
However, when parts of a topic, such as parallel processing or scientific
visualization, are distributed among a set of courses, additional problems
arise in areas of coordination and consistency of coverage.
A curriculum design paradigm is presented which seeks to formalize the
distribution of a course in such a way that the integrity of the topics is
maintained and documented.

A Proposed Alternative Track - Applied Computing
Suggests some modifications or updates to traditional CS curricula
to enable us to better serve the needs of some of our students, our
communities, states, nations, and out departments and institutions.
Asks for consideration of an alternative track in computing, one that
includes more practice, more software engineering, and a more
significant experiential component.

USING AN OBJECT-ORIENTED SOFTWARE LIFE-CYCLE MODEL IN THE SOFTWARE
ENGINEERING COURSE
Arturo I Conception
Department of Computer Science
California State University, San Bernardino
San Bernardino, CA 92407
concep@csci.csusb.edu 
Abstract
An object-oriented software life-cycle model, the Modified Spiral Model,
was successfully used as the software process in the software engineering
course in the Department of Computer Science, California State University,
San Bernardino. The model lends itself quite naturally to the object-oriented
approach of producing software systems in the iterative and incremental
manner. The software engineering class is run like a virtual software company
which is composed of teams and team leaders where performance is measured
on being able to submit the software deliverables and the success of the
task(s) assigned to the team. The paper reports on the implementation
of the software project, Algorithma (Algorithm Animation), in the
virtual software company using the Modified Spiral Model.

paper title:  Explication of Object-Oriented Databases:
		A Software Engineering Perspective
authors: A. Dingle, D. Umphress, R. Moul
abstract:  The growing use of Object-Oriented Databases (OODBs)
has necessitated the inclusion of OODBs in introductory database
courses.  Typically such analysis is conducted after the explication
of the dominant industry standard: the Relational Database model (RDB).
Unlike the RDB model, an established data model with defined normal 
forms, the OODB model cannot be easily evaluated for "goodness".  We
address this deficiency by examining the criteria of coupling and
cohesion in database design.  This approach affords the instructor
the ability to better present OODBs as well as the opportunity to
re-emphasize critical software engineering concepts.  

Abstract for "Giving Computer Science Students a Real-World Experience"
by E. E. Villarreal and Dennis Butler
Class assignments should have more relevance to the real world.
There is not enough time to have a realistic project in a class,
but a realistic project would give the students a taste of the
real world.
We attacked this problem by merging two classes, Introduction to
Database Systems and Software Engineering I, thereby allowing enough
time for a more meaningful final project.  We chose to use a loosely
coupled approach to merging our classes.

Title: Using Inheritance for Computing with Physical Quantities:  An
Interdisciplinary Project
Author:  Seth Bergmann
Abstract:
This paper involves an interdisciplinary project in computer science and
physics.  Students in introductory physics courses need to be able to deal
with dimensioned quantities, and to
solve problems using the correct units for various physical quantities.
Computer science students need to understand concepts of object-oriented
programming, including the notion of inheritance.  In this paper we
present a project in which physical quantities such as distance, time,
mass, speed, force, power, etc. are represented as objects.  The student
designing the classes can ensure that the client always combines
quantities in an appropriate fashion.  The student designing the classes
can also allow the client to compute physical quantities using different
units.  This is done by defining subclasses Meters, Miles, and Feet, all
of which inherit from the class Distance, thus providing the student with
a nice example of the proper use of inheritance.

Traffic Simulation: A Case Study for Teaching Object Oriented Design
Viera K. Proulx
Northeastern University
College of Computer Science
Boston, MA 02115, USA
vkp@ccs.neu.edu
Abstract
In teaching object oriented design, it is important for students to
work on projects that use a variety of design patterns, interaction
between objects, and provide the opportunity to explore design options
in a realistic setting.  Originally, object oriented languages have
been designed for use in building simulations.  We use a familiar
simulation of a traffic through an intersection, controlled by a
traffic light as a framework for teaching various aspects of object
oriented design.  We present this project and show how it illustrates a
variety of object oriented design problems.

Java Class Visualization for Teaching Object-Oriented Concepts
Herbert L. Dershem and James Vanderhyde
Abstract
Visualization is a useful tool in many areas of computer science education. 
This paper describes the use of visualization in the introduction of 
object-oriented concepts. A Java application has been developed that allows 
the user to interact with a visualization of any Java class through the 
instantiation of objects, the movement of those objects around the class 
environment, and the activation of class methods. The user may also move 
conveniently between classes in this visualization. 
This Object Visualizer is useful for classroom demonstration, individual 
student use in the laboratory, and class debugging and testing.

Turning Liabilities into Assets in a General Education Course
Author: Gloria Childress Townsend
Abstract:
Typical difficulties (liabilities) that instructors of a general education
(CS0) course encounter include 1) an extremely diverse student population, 
2) the teaching of software modules and 3) evaluation of learning.  
Instructors may capitalize on these difficulties to transform them into
assets.  One example of such a transformation occurs, when a class of 
local grade school children visit a CS0 class.  The CS0 students prepare
more intensely, expecting an audience of very eager ten year-olds rather
than a more traditional project.  In addition, the teaching project allows
an alternative form of evaluation, where CS0 students' lesson plans and
handouts, along with observations of the teaching sessions replace
traditional bluebook evaluation of the concepts being taught.

The Computer as a Problem-Solving Tool:
A Unifying View for a Non-Majors Course
Daniel Joyce
Dept. of Computing Sciences
Villanova University
joyce@vill.edu
At Villanova University we have a popular course for non-majors
focused on problem solving with computers, taught using our
own lecture and lab materials. This paper seeks to describe the
essence of the problem solving course by focusing on an assignment
that is given after the first unit of the course has been 
completed. This assignment, writing an essay about how someone uses
a computer to solve a problem, requires the application of most of 
the topics of the first third of the course and is very representative
of the spirit of the course as a whole.

Title: "The Internet as a Motivating Theme in a Math/Computer Core
        Course for Nonmajors"
Author: Chaya Gurwitz
Abstract:
The challenge of a computer literacy course is to present general
principles of computer science, while at the same time engaging students
who are nonmajors and demonstrating the relevance of the subject.  In
this paper we describe our experience with a course that uses the
Internet as a motivating theme to introduce students to fundamental
concepts of computer science.  The students found the course interesting
and were visibly stimulated by the material.  In comparison with
previous semesters, the students left the course with more practical
skills as well as a greater appreciation of the interrelations between
mathematics and computer science.

Retaining Women in CS with Accessible Role Models
Susan Haller and Timothy Fossum
Computer Science and Engineering Department
University of Wisconsin - Parkside
Abstract
The female role models  presented to young women are often unusual 
individuals who have overcome tremendous social and political obstacles
to pursue outstanding careers in mathematics and science.  
We believe that young women presented with these exceptional role models may 
actually have their  self-confidence  undermined because they cannot
readily identify with them. 
At the University of Wisconsin-Parkside (UW-Parkside),
we are implementing a project that
will employ our own upper-level female computer science (CS) students
as half of our laboratory staff in a CS laboratory
that is maintained and administrated by our CS students.
In this laboratory, women will be as much in control as much as
their male counterparts. This  non-threatening environment, where
women  play a prominent role, will communicate to our beginning female 
students that these roles are realistic and obtainable by them
in their college life and in the workplace.  
We plan to offer our introductory CS sequence to area high school students so 
that high school girls can benefit from this same experience.

"Gender Differences in Personality Components 
 of Computer Science Students:  A Test of Holland's 
 Congruence Hypothesis."
The authors are William Haliburton, Mack Thweatt, and Nancy Wahl.
The problem of disproportional representation of females in computer
science curricula was examined in the context of Holland's theory of
vocational personality.  It was hypothesized that some combination of
standardized mathematical aptitude and congruence would significantly
predict achievement and persistence in computer science.

A Study of Barriers to Women in Undergraduate Computer Science
Worldwide, there is a significant discrepancy between the numbers of male
and female graduates from computer science programs. SUNY Geneseo offers no
exception. The literature cites a number of plausible explanations for the
problem, but no definitive answers. We conducted a study to determine why
few women complete our own computer science major. Our major finding is
that (at least on our campus) the problem is not actually one of retention.
Few women-even those in the introductory computer science courses-actually
plan to major in computer science to begin with. Although some barriers
suggested in the literature do operate within the major, they seem much
less significant than the low entry rates. Retention of women once they
enter the major is important, but it is secondary to getting women into the
major initially. This suggests that the most effective solutions will be
those that concentrate not on retention but on recruitment (including
outreach to secondary schools).

Design and Implementation of an Interactive Tutorial Framework
The work described in this paper is part of an NSF funded project to 
develop tutorial materials for introductory computer science courses.
We had several general goals for these materials that had an impact 
on their design and implementation:
	* they should be delivered on-line;
	* they should be highly interactive;
	* they should be useful on a wide variety of hardware/software 
          platforms; and
	* it should be easy to extend the content to different courses 
          or contexts.
In trying to meet these goals we designed and implemented a package of 
Java classes that provided a framework for creating our set of tutorials, 
yet was general enough to be used in other contexts such as interactive 
laboratories. This paper describes the framework and the design decisions 
that governed the implementation.

   Using Java to Develop Web Based Tutorials
                David Cole
             Roger Wainwright
             Dale Schoenefeld
Department of Mathematical and Computer Sciences
          The University of Tulsa
   {cole,rogerw,dschoen}@euler.mcs.utulsa.edu
Abstract.
This paper presents the use of Java applets acting as a
web-based interface to existing, platform dependent
software tools.  We present an example application
called GAWebTutor which was constructed from a
comprehensive genetic algorithm package and web-based
Java components.  In effect, we packaged an
interactive genetic algorithms tutorial and made it
available to anyone on the WWW.  Furthermore, by
building a GUI front end to an existing application in
Java, we leveraged browser technology to overcome
platform compatibility problems.  A blending of Java
and platform dependent code can successfully create
user friendly, portable, more versatile applications that
take full advantage of all available software
components.  Using our approach, educators can make
their educational programs or other software tools
available to anyone through the WWW.

Title:		A Tool for Teaching Curve Design
Authors:	Yuan Zhao, John L. Lowther and Ching-Kuang Shene
Abstract:
Curve construction is important in computer graphics, animation, 
and computer aided design.  This paper describes a tool for teaching curve 
design that permits users to interactively create, modify, and manipulate 
curved objects.  Supported curve types include Bezier, rational Bezier,
B-Spline and NURBS curves.  System design issues, user interface features, 
and implemented curve design elements are discussed.  The paper 
also contains a brief introduction to the mathematical and geometrical 
background of the curve design elements that our system implements.

Paper Title: Network Monitoring System Design 
Authors: Bob Barr (barr@knuth.mtsu.edu),  Sung Yoo (cssung@mtsu.edu),
         Tom Cheatham (cheatham@mtsu.edu)
Affiliation: Middle Tennessee State University
Address : Computer Science Department
          Middle Tennessee State University
          Murfreesboro, TN 37132
Abstract
	Computer networks can be very useful, but difficult to manage. Current
network management tools tend to be either very expensive or inadequate for 
classroom modification.  XSNIFF is a project to develop an alternative network 
monitoring tool  with a graphical display in the X-Window environment. XSNIFF 
uses an efficient network packet filtering system developed by Jacobson, Leres,
and McCanne of Lawrence Berkeley Laboratory[Jacobson, 1994], to receive all 
network traffic from the network wire and then translate it into  usable 
information. The network listening device should not affect the normal flow of 
network traffic, but should observe it. XSNIFF has a graphical interface that 
allows the user to select between statistical information and a TCP connection 
graph. The statistical information displays data belonging to different network
level protocols and   different user level protocols. The connection information
is displayed as a graph showing which network nodes are connected to what other 
nodes. The information can be used by a teacher in a computer network class to 
help students visualize network traffic  and as a learning tool to help students
understand computer network protocols.

Title: Teaching Web Development Technologies in CS/IS Curricula
Billy B. L. Lim
Applied Computer Science Department
Illinois State University
Normal, IL 61790-5150
bllim@ilstu.edu
Abstract
The advent of the World Wide Web changes the way we do things. It also
greatly changes how computer software are built. While this profound
evolution of software development has caused many in the software industry
to change their way of developing software, it has not caused many in the
academics to change their way of teaching computing. This paper describes a
course that teaches web development technologies. The contents of the
course, the experience gained, and related educational resources are
presented.

title: Resources for Teaching Computer Networks
author: Linda B. Lankewicz
        University of the South
        Sewanee, TN 37383-1000 USA
        llankewi@sewanee.edu
abstract:
Teaching a computer networks  course can be a challenge both in terms of
deciding on the focus of the course and providing appropriate practical
experiences to complement the theoretical issues.
However, because the course overlaps other areas of the computer science
curriculum, it is an opportunity to apply some of the concepts from other
areas  and to expose students to the research in the field. This paper
describes a computer networks course to accomplish this along with a
collection of resources.

Computer Scientists Can Teach Writing:
An Upper Division Course for Computer Science Majors
David G. Kay
Department of Information and Computer Science
University of California
Irvine, CA 92697-3425
(714) 824-5072
kay@uci.edu
Abstract
The author's institution requires all students to take one
course that concentrates on writing at the upper division
(junior or senior) level. The computer science department
offers one such course, taught by computer scientists. It
concentrates on communications issues relevant to computer
scientists and computer professionals, going beyond
traditional "technical writing" to give students experience
in oral presentation, document design, and writing in forms
appropriate for various audiences. This course takes
advantage of analogies between writing and software
development and motivates computer science students to pay
more careful attention to their writing.

Title: Towards a Hierarchical Design and Integration of Programming Projects
Author: Wing-Ning Li, University of Arkansas, wingning@uafsysb.uark.edu
Abstract:
The idea of a hierarchical design and integration of programming projects in
the computer science undergraduate curriculum is proposed and discussed.
Research results in software reuse and object-oriented design and development
may be used in the design and the development of the set of integrated
programming projects.
By a hierarchical design and integration of programming projects, this approach
aims to increase the effectiveness of the undergraduate learning experience.
Using the approach, programming projects in computer science courses may 
be developed in such a way that programming projects in the lower level 
courses are used as components (parts) to implement programming projects 
in the higher level courses. In this way, a hierarchical structure of 
programming projects can be built and a student's programming projects in 
different courses can be integrated. Such an integration may lead to the 
development of complex software systems in the senior year.

The ExCon Project: Advocating Continuous Examination
Urban Nulden
Department of Informatics, Goteborg University, Sweden
E-mail: nulden@informatik.gu.se
Abstract
In this paper it is claimed that traditional examination often is
destructive to the process of learning. It does not matter how good
intentions educators have, it is the way they examine students that will
have the strongest impact on how the students learn. The goal of the ExCon
project is intervention in traditional examination. The paper discusses an
alternative model for understanding assessment and examination of students.
Product assessment is questioned as an appropriate approach. Instead it is
argued that educators should, to a larger extent, provide the student with
questions and other types of feedback during the ongoing activity and use
communication as an important element of the examination. For this purpose,
a software prototype for a mobile computing device to support the educator
was designed and developed. An evaluation of the prototype was performed
and the paper ends with some thoughts on the viability of the prototype in
supporting alternative assessment and examination.
Keywords
Assessment, examination, feedback, Newton messagepad

Large Introductory Computer Science Classes:
Strategies for Effective Course Management
David G. Kay
Department of Information and Computer Science
University of California
Irvine, CA 92697-3425
(714) 824-5072
kay@uci.edu
Abstract
Traditionally, a large introductory course meant a lecture
hall with a single lecturer talking and students taking
notes--but no longer. Today a wide variety of techniques, not
only in the classroom but in labs and faculty offices and
cyberspace, can make a large introductory course an
extremely effective educational experience. We explore
these practices, with pointers for further information, as
a guide for instructors or departments faced with the
large-course model of instruction.

Using Software to Solve Problems in Large Computing Courses
Spreading the good word of computer science to the whole world
means teaching introductory computer science courses to large numbers of
students every year.  At Georgia Tech, we use teaching assistants
to help manage these courses. We have also learned that appropriate
software support is essential to making such a large, complex, 
instructional system work properly. This paper is a description
of that software.
 

TITLE: Integrating Technology into Computer Science Examinations
AUTHORS: Dr. Denise M. Woit and Prof. David M. Mason
ABSTRACT:
On-line programming tests and examinations were administered to
approximately 120 first year computer science students
in order to evaluate their practical skills.
We describe our motivation for on-line testing, outline the
technical details of our closed testing environment, and present our
observations about student performance.
We also compare the effectiveness of on-line tests
versus conventional tests, report the problems we encountered and our
solutions, relate student opinion regarding the on-line testing
experiment, and present some insights gained by this experiment.

	  A Paradigm Shift!  The Internet, the Web, Browsers, Java and
		    the Future of Computer Science Education
  
  
 Christopher M. Boroni, Frances W. Goosey, Michael T. Grinder, 
 Rockford J. Ross
 CS Department, Montana State University, Bozeman, MT 59717
			  
 ross@cs.montana.edu
The World Wide Web is the harbinger of one of the most profound 
shifts in the way teaching and learning will be done to occur 
in recent history. While few of the innovations for teaching and 
learning currently afforded by the Web are actually new (e.g., 
live classroom projections of dynamic, computer-based concepts 
for teaching; interactive, educational software for self-paced 
learning by students; distance learning; and other multimedia 
educational possibilities based on computers and communications 
networks), prior to the Web these innovations were not widely 
applied in computing curricula for three primary reasons:  
platform dependence (most educational software systems run only 
in specific computer/operating system environments), the cost of 
acquiring the necessary hardware and educational software, and 
the time and effort required to learn each new educational system.  
All of these complaints are eliminated or greatly mitigated by the 
Web.   Because of the Web, its browsers, the platform independence 
of the Java Virtual Machine, and the ubiquity of the Internet, for 
the first time instructors can--from virtually any location and 
with virtually any computing equipment--incorporate dynamic 
presentations of concepts into their lectures, presentations that 
are accurate, interactive, repeatable, modifiable on the fly, and 
stimulating.  More importantly, for the first time students can 
also--from virtually any location and with virtually any computer
--access the same dynamic, interactive demonstrations (and more) 
as they learn.  The implications for teaching and learning are 
profound.  Instructors will have more opportunity to engage their 
students in discussions, and students will be more often involved 
in active learning in the classroom, in laboratories, and on their 
own study time.  A number of researchers are working on Web-based 
educational systems with the attributes described here.  Their 
combined work in algorithm, program, and concept animation will 
help fuel the paradigm shift.
			      

  Design Patterns: An Essential Component of CS Curricula
  Owen Astrachan, Geoffrey Berry, Landon Cox, Garrett Mitchener
  The field of software patterns has seen an explosion in interest in
  the last three years.  Work to date has been on the recognition,
  cataloging, and finding of patterns with little attention to the
  use of patterns, especially by students and practitioners not
  well-versed in object-oriented technologies.  This project addresses
  pattern use through the development of several programming and
  pedagogical frameworks that supply support for using patterns
  throughout a computer science curriculum.  Although we do not claim
  that patterns are Brooks' silver bullet, their use can
  help cope with the accidental complexity of software development and,
  we argue, their use is essential for a successful adoption of
  object-oriented techniques in academic computer science programs.
  This project addresses practical concerns of the
  computer science and software engineering communities in
  using, teaching, and learning patterns.  In this paper we argue that
  patterns are an essential programming and pedagogical tool and report
  on our work in making them accessible to the educational community.

Class to Survey Application Programming Topics
This paper describes a class that we developed at the
University of Northern Iowa to address covering the
topics suggested in ACM/IEEE Computing Curricula
1991. All junior level students take this course, and 
thus are ensured of a minimum introduction to the 
topics of software engineering, database management,
human computer interfaces, and computer ethics. This
paper describes the course and the lessons learned in
teaching the course, and also discusses the benefits
and challenges associated with the course.

An Undergraduate Course in Formal Methods
We present a new undergraduate course in formal methods which
emphasizes software specification and description instead of formal
program correctness or program derivation.
This course is motivated by the idea that specifications play a key
role in the software development process and that precise and clear
descriptions of software systems and artifacts are important. It wants
to show students that some simple notions from logic and mathematics
(predicates and quantifiers, set theory, maps), together with
appropriate constructs for defining software components and systems,
can be useful for this purpose.
The course is taught using the Spec notation and we first discuss why
we did not choose the ubiquitous Z notation.  The content of the
course is then presented, followed with a brief description of an
on-line WWW system that was developed to help the students do the
exercises presented in the course notes.

Bring Real-World Software Development into the Classroom
A proposal is made for combining ongoing volunteer efforts
to produce and freely distribute real-world, consumer-oriented
software with the existing curricula in computer science.
The differences between such an endeavor and currently ongoing
free software efforts is described. The pedagogical advantages
of working with and contributing to such an effort are
explored. Potential enhancements to existing course work are
discussed, as are some possible new avenues of instruction.
The economic viability of such an enterprise is also briefly
described.

Using HTML and JavaScript in Introductory Programming Courses
Students with little or no computer programming experience prior to entering
college often have difficulty keeping up with the fast pace of college-level
programming courses, even at the introductory level.  For the past several
years we have developed a curriculum for teaching fundamental language
concepts to this population of individuals using the programmable features of
a variety of software packages -- thus giving students nontrivial results
with relatively little syntactic "overhead."  These "pre-programming" courses
prepare students to succeed in subsequent language sequences, or they can
serve to provide computer literacy credits for non-technical majors.
Here we report on a course designed to exploit students' burgeoning interest
in the World Wide Web (WWW), where we used HTML and JavaScript to teach
programming concepts.  These languages allow students at different skill
levels to work side by side, learning common abstract ideas while implementing
them at different levels of complexity, motivated by the rewarding and 
exciting interactive environment of the WWW.

TITLE:
Incoming Freshmen Build Their Own PCs 
AUTHORS:
Donald H. Beil (dhbndp@rit.edu)
Donna Lange (dalndp@rit.edu)
Elissa Olsen (emondp@rit.edu)
Anthony Spiecker (aesnet@rit.edu)
AFFILIATION:
Applied Computer Technology Department
The National Technical Institute for the Deaf
Rochester Institute of Technology
Hugh L. Carey Building
96 Lomb Memorial Drive
Rochester NY 14623-5604
ABSTRACT:
The Applied Computer Technology Department (ACT) of the National 
Technical Institute for the Deaf (NTID), a college of the Rochester 
Institute of Technology (RIT), offered a unique two-day workshop at 
which incoming freshmen students who are deaf or hard of hearing 
built their own personal computers.
This paper provides extended details of our experience at the most 
recent offering of this workshop attended by 28 freshmen students. 
The workshop was held in September, 1997 after new-student 
orientation and before school began.
Sufficient details are provided so that our experience might serve 
as a reference point for other universities interested in offering a 
similar workshop.

Extending an Iterator Model for Binary Trees to
Backtracking Problems
Rasala developed a design for an OO tree-iterator. This
paper extends that design to provide an iterator for
backtracking problems. The developed iterator explicitly
uses a stack to store partial solutions which must be
evaluated and/or extended.
The discussed design can be used as a teaching tool for 
recursion. Students often struggle with this paradigm
since - for their taste - too much is happening behind
the scenes. Students can explore the explicit stack of 
the backtracking iterator after each recursion step.
The design can be reused for different domains, since it
separates domain-specific code from general iterator
code. Solutions to the set and the maze problems are shown.

LongNbrs and Palindromes
An Interesting Application of a Class
Christine Shannon
Abstract
What started off as an enrichment assignment for a third grader has
developed into a rich source of programming assignments.  The long
integers, needed to determine whether a number eventually becomes a
palindrome under the process of reversal and addition, can be described
as an abstract data type and implemented as a C++ class.  There are
intriguing open questions which call for great creativity and efficiency
in terms of data structures.  Even graphics have been employed to
illuminate the problem.  The next step is probably parallel processing.

Title: 
	Teaching User Interface Design and Programming 
	to Computer Science majors
Authors:
	Judy Kay
	Bob Kummerfeld
Abstract:
This paper describes an innovative approach to teaching about
human-computer interaction to a large class of students in their third
year of a Computer Science major.  Because of the tight time
constraints on the course and the student's learning preferences and
orientation, we have created a course which interweaves the learning of
several programming tools for interface construction with the
development of knowledge and skills in the design of user interfaces.
We present the structure of the course, especially its most unusual
aspects.  We also describe our rationale for the course design, our
evaluation of student learning and the response to the course.

Teaching the Empirical Approach to Designing Human-Computer Interaction
via an Experiential Group Project
ABSTRACT
Empirical research plays an important role in the design of user-interfaces
and is frequently included in university courses on human-computer
interaction. For instance, the ACM SIGCHI guidelines refer to the
importance of empirical research, although they do not specify how this
approach to user-interface design should be taught. In an Honours
(fourth-year) course at the University of NatalUniversity of Natal,
Pietermaritzburg, the theoretical foundation of empirical research is
augmented with a real experience of running a simple experiment. This
experiment is planned, executed and analyzed by the class as a whole. This
paper describes the type of empirical studies carried out and discusses the
benefits and limitations of such studies in this educational context.

Average-case Analysis in an Elementary Course on Algorithms
Francesc J. Ferri, Jes\'us Albert
Dept. Inform\`{a}tica i Electr\`{o}nica
Universitat de Val\`{e}ncia
ferri@uv.es
Abstract
Average-case algorithm analysis is usually viewed as a tough
subject by students in the first courses in Computer Science.
Traditionally, these topics are fully developed in advanced
courses with a clear mathematical orientation.
The work presented here is not an alternative to this, but,
it presents the analysis of algorithms (and average-case in particular) 
adapted to the mathematical background of students in an 
elementary course on Algorithms or Programming by using some
specially selected examples.

Teaching the Analysis of Algorithms with Visual Proofs
by Michael T. Goodrich and Roberto Tamassia
Abstract:
We describe an approach for visually teaching important proofs in the
Junior-Senior level course on the design and analysis of data
structures and algorithms (CS7/DS&A).  The main idea of this
educational paradigm is to justify important claims about data
structures and algorithms by using pictures that visualize proofs so
clearly that the pictures can qualify as proofs themselves.  The
advantage of using this approach for DS&A is that it augments or even
replaces inductive arguments that many students find difficult.
Moreover, this paradigm communicates important algorithmic facts in a
compelling way for students who are more visually-oriented.  We
illustrate this technique by giving examples of visual proofs of
several key concepts in DS&A.

Parallel Computing in the Undergraduate Curriculum
Barry L. Kurtz
Chinhyun Kim 
Jamal Alsabbagh
This paper reports on our NSF grant (CDA-9414309) from the Education 
Innovation program in the CISE directorate.  We not only present the 
current status of grant activities as we near completion, but we also 
present a "how to" approach for those faculty from teaching-oriented 
schools who want to submit a proposal in the area of educational computing.  
We discuss both our successes and our failures and we give 
advice on how to avoid the pitfalls we have encountered.  Most important, 
throughout the paper, we give advice on how to obtain funding in the 
first place.

Title: An Integrated Course on Parallel and Distributed Processing
=========================================================
Authors: Jose' C. Cunha and Joao Lourenco
=========================================================
Address:
Departamento de Informatica       
Faculdade de Ciencias e Tecnologia 
Universidade Nova de Lisboa       
2825 Monte de Caparica -- Portugal
=========================================================
Abstract:
=========================================================
Most known teaching experiences focus on parallel computing courses only, 
but some teaching experiences on distributed computing courses have also 
been reported.  In this paper we describe a course on Parallel and 
Distributed Processing that is taught at undergraduate level in the 
Computer Science degree of our University.
This course presents an integrated approach concerning concurrency, 
parallelism, and distribution issues. It's a breadth-first course 
addressing a wide spectrum of abstractions: the theoretical component 
focus on the fundamental abstractions to model concurrent systems, 
including process cooperation schemes, concurrent programming models, data 
and control distribution, concurrency control and recovery in 
transactional systems, and parallel processing models; the practical 
component illustrates the design and implementation issues involved in 
selected topics such as a data and control distribution problem, a 
distributed transaction-based support system and a parallel algorithm.
We also discuss how this approach has been contributing to prepare the 
student to further actions regarding research and development of 

Tools for Web-Based Sorting Animation
Herbert L. Dershem and Peter Brummund
Abstract
There is a long and rich tradition of sort algorithm animations that have 
been used effectively in instruction. This paper describes a new tool that 
combines the best of this tradition with the advantages of being in the 
form of an applet for use on the World Wide Web and of animating the code 
of the algorithm in concert with the animation of the data. In addition, 
this tool facilitates student-designed animations that are useful for the 
debugging of student-written sort algorithms. Recursive sort algorithms are 
made more accessible through the use of a special feature of the tool that 
animates the recursion.

Title:  FCLUST:  A Visualization Tool for Fuzzy Clustering
Authors:  Mary Anne Egan, Mukkai Krishnamoorthy, Krishna
Rajan
Abstract:  Emerging technologies on the World Wide Web
promise to make program, algorithm and concept simulations
universally accessible. Simulations involving animation and
visualization have a tremendous benefit when applied to
various algorithms.  We present a simulation tool for
experimenting with concepts in fuzzy clustering that has
proved useful in visualizing the results and demonstrating
the computation method of the algorithms.  This is
especially advantageous in a classroom or laboratory setting
where students may become more comfortable with the
mechanics of fuzzy clustering through personal discovery and
online experimentation.

Title:		 Animating Parsing Algorithms
Authors:	Sami Khuri and Yanti Sugono
Abstract:
	The paper describes a package that can be used to present
the parsing algorithms. The package fully animates the top-down LL(1) 
and bottom-up SLR(1) parsing algorithms. By full animation we 
mean that the input string being parsed, the corresponding actions
that take place in the stack, and 
the building of the parse tree are all simultaneously animated 
on the same screen, thus enabling the user to get a full appreciation
of all the intricate details that occur during parsing. The package 
makes use of XTANGO and can be used in the beginning of the semester as a 
teaching tool. Later, the students could be asked to write their
own animations of the compiling process.

A Concurrency Simulator Designed for Sophomore-level Instruction
Barry L. Kurtz
Hong Cai
Chris Plock
Xijia Chen
The Concurrency Simulator is used in a sophomore-level course to 
introduce students to parallel computing.  This simulator is unique 
since it integrates a graphical topology into the programming environment.  
This makes algorithms much easier to express and, combined with a 
context-sensitive editor, makes it easy for students to enter 
their algorithms without becoming bogged down in the details of 
language syntax.  We provide detailed examples for the semaphore, 
rendezvous and monitor paradigms.  We briefly describe the development 
process for this Java 1.1 program and then describe our 
classroom experiences with students at this level.

Title:	Multithreaded Programming in an Introduction to Operating Systems Course
Author: Ching-Kuang Shene
Abstract:
     This paper presents a way of teaching multithreaded programming as
a component in an introduction to operating systems course.  Topics include
programming assignments, term projects, and experiences.
This paper also suggests future work for overcoming a bottleneck that
occurs in the current version of this course.

Alfonse, Your Java Is Ready!
Abstract
Is Java suitable for teaching concurrent programming?          
This paper describes the features Java has for this,
how well they work, and what is missing.               
The author has written a library of classes, also described here,
to provide the missing features.
Supplemented with these classes, Java works well as the concurrent
programming language in operating systems and related courses.

Title: Providing Intellectual Focus To CS1/CS2
Authors:
Timothy J. Long, Bruce W. Weide, Paolo Bucci, David S. Gibson
Computer and Information Science
The Ohio State University
Columbus, OH  43210
{long,weide,bucci,dgibson}@cis.ohio-state.edu
Joe Hollingsworth
Computer Science
Indiana University Southeast
New Albany, IN  47150
jholly@ius.indiana.edu
Murali Sitaraman, Steve Edwards
Computer Science and Electrical Engineering
West Virginia University
Morgantown, WV  26506
{murali,edwards}@cs.wvu.edu
Abstract:
First-year computer science students need to see clearly that computer
science as a discipline has an important intellectual role to play and
that it offers deep philosophical questions, much like the other hard
sciences and mathematics; that CS is not "just programming".  An
appropriate intellectual focus for CS1/CS2 can be built on the
foundations of systems thinking and mathematical modeling, as these
principles are manifested in a component-based software paradigm.  We
outline some of the main technical features of this approach to CS1/CS2
and report preliminary observations from our experience with it.

Constructivism in Computer Science Education
Mordechai Ben-Ari
Department of Science Teaching
Weizmann Institute of Science
Rehovot 76100 Israel
ntbenari@wis.weizmann.ac.il
Constructivism is a theory of learning which claims that students
construct knowledge rather than merely receive and store 
knowledge transmitted by the teacher.
Constructivism has been extremely influential in science
and mathematics education, but not in computer science education (CSE).
This paper surveys constructivism in the context of CSE,
and shows how the theory can
supply a theoretical basis for 
debating issues and evaluating proposals.

Extended Analogy: An Alternative Lecture Method
Jeff Matocha, Tracy Camp, and Ralph Hooper
In computer science education one should employ creative teaching
methods, especially for non-majors or beginning students.  Students
who are new to computer science typically find the field full of
theoretical, technical, or even tedious concepts.  Lack of interest,
motivation, or understanding creates a difficult mix of students.
This paper describes a technique which combines analogy and simple
memory techniques to aid in the teaching of technical concepts.

TITLE: Web-based Animation of Data Structures Using JAWAA
AUTHORS:
   Willard C. Pierson and Susan H. Rodger
             Duke University
           rodger@cs.duke.edu 
ABSTRACT:
JAWAA is a simple command language for creating animations of data
structures and displaying them with a Web browser. Commands are stored in a
script file that is retrieved and run by the JAWAA applet when the applet's
Web page is accessed through the Web. JAWAA commands allow for creation and
movement of primitive objects (circles, lines, text, rectangles) and data
structure objects (arrays, stacks, queues, lists, trees and graphs).  A
JAWAA script can be generated as the output of a program written in any
language.

A System for Program Visualization in the Classroom
This paper describes the use of a system which will allow
effortless visualization and animation of standard C/C++
programs.  The system brings alive programs so that students 
in CS1 and CS2 classes can more easily see each instruction
and its effects.  They can also see the effects of larger
entities such as functions. The system serves as an 
excellent instructional tool and debugger.

A multi-windowed environment for simultaneous 
visualization of related algorithms on the 
World Wide Web
Thomas L. Naps and Eric Bressler
Lawrence University
napst@lawrence.edu and bresslee@lawrence.edu
Abstract 
Using algorithm visualization, we can depict 
the execution of an algorithm as a sequence 
of graphical snapshots, the viewing of which 
is controlled by the user.  Although the 
delivery of such visualizations over the Web 
greatly increases their accessibility, Web-
based environments for viewing algorithms 
often lack the richness of features that 
characterize similar viewing environments on 
standalone machines.  Here we describe 
enhancements recently made to such a Web-
based system.  These enhancements 
conveniently present a variety of windowing 
options that allow the user to simultaneously 
view multiple snapshots.  These snapshots may 
depict (1) similar views of the states of an 
algorithm over a range of time, (2) different 
views of the state of an algorithm at a given 
point in time, or (3) side-by-side 
comparisons of different algorithms that 
solve the same problem.  We illustrate each 
of these options using variations of the 
quick sort algorithm.  

Do Lab Modules in CS Actually Help Students?
An Empirical Study
Bunny J. Tjaden
The George Washington University
School of Engineering and Applied Sciences
Washington, DC 20052
tjaden@seas.gwu.edu
Abstract
     Three laboratory modules were developed to teach
C pointers to novice programming students, using two
different versions of software.  The first version was an
intelligent tutoring system; the second was a multimedia
tutorial.  Six classes of students participated in an empirical
study involving both versions of software.  What was
discovered as a result of this experiment was more than just
the answer to whether or not a particular piece of software
helped the students to learn the subject matter.  We
discovered who used the software, given the freedom of
choice.  We learned about the characteristics of software
users, which software was more helpful, and what the
students think about using software to learn.  The more
significant results of this study are presented in this paper.

The Effects of Partially-Individualized Assignments on Subsequent 
Student Performance.
Brian Toothman and Russell Shackelford
Abstract
At Georgia Tech, we investigated aspects of student performance in the 
Introduction to Computing course offered by the College of Computing.  Our 
goal was to investigate the effects of customizing assignments based on 
individual student needs.  This was motivated by the fact that our technology 
can enable us to create and distribute individualized assignments. Thus, we 
sought to answer the question, "In the span of a single academic quarter, can 
we (a) identify weaknesses in each student's performance, then (b) give them 
assignments targeted to their individual weaknesses such that (c) we achieve 
a positive impact on their subsequent performance?"   Significant results 
were found with respect to certain aspects of individualization.  They 
suggest individualized assignments can be effective for students who 
evidence neither very strong nor very weak topical performance.

Conceptual Models and Cognitive Learning Styles in Teaching Recursion
Cheng-Chih Wu, Nell B. Dale, Lowell J. Bethel
Abstract
An experimental research design was implemented in an attempt to understand
how different types of conceptual models and cognitive learning styles
influence novice programmers when learning recursion. The results indicate
that in teaching recursion to novice programmers: concrete conceptual models
are better than abstract conceptual models, novices with abstract learning
styles perform better than those with concrete learning styles, abstract
learners do not necessarily benefit more from abstract conceptual models,
and concrete learners do not necessarily benefit more from concrete
conceptual models.

WEB-Based Query Processing in a Database Course Project

Sohail Aslam

Developing Integrated Web and Database Applications 
Using JAVA Applets and JDBC Drivers
Andrew Yang, James Linn, David Quadrato
Computer Science Department
Southern Connecticut State University
501 Crescent Street,  New Haven, Connecticut  06515 USA
E-mail: yang@scsu.ctstateu.edu
http://yang.scsu.ctstateu.edu/
 	Abstract
With the maturity of network technology, the deterministic factor of a
'successful' web site does not as much depend on its connectivity to the
Internet, rather the content of web pages plays a more important role. 
The inclusion of dynamic data, for example, has become an increasingly
desirable feature of a web page.  Web servers that support dynamic web
pages are capable of retrieving data at the time of user requests. 
Rather than being statically included in the web page, these dynamically
retrieved data may physically reside in various file systems or database
servers across the Internet.  JAVA, a new object-oriented programming
language, has become a buzzword since its introduction by Sun
Microsystems in 1994.  It was claimed that JAVA, via its ability to
embed applets in a web page, would make the content of a web page alive
and dynamic.  Data and information on a web page can now be updated
dynamically when users request them.  In this paper, we discuss our
experience of developing JAVA applets that use various types of JDBC
(JAVA Database Connectivity) drivers to connect to and then manipulate
data stored in SQL (Structured Query Language) database servers.  We
first start with the discussion of general client/server model involving
JDBC, and then introducing the procedure of setting up programming
projects employing this approach in an undergraduate database course.

Learning SQL with a Computerized Tutor
SQL, the dominant database language, is a simple and
highly structured language; yet, students have many
difficulties learning it. This paper presents SQL-Tutor, an
Intelligent Teaching System designed as a guided discovery
learning environment, which helps students in overcoming 
these difficulties. We present design issues and the current
state in the implementation of the system, with special
focus on individualization of instruction towards a
particular student.

Computer Science Through the Eyes of Dead Monkeys:
     Learning Styles and Interaction in CS I
Gary Lewandowski and Amy Morehead
Xavier University
{lewandow, amy}@cerebro.xu.edu
Abstract:
Instructors in Computer Science I courses are challenged by the wide
range of experience and great diversity of learning styles among
students.  We have developed presentation strategies to deal with
these issues. Material is presented in three phases: a demonstration
phase called the Common Learning Experience that uses playful
analogies to involve students while introducing the topic, a
presentation phase in which basic facts are presented, and a problem
solving phase in which students explore questions about the topic.
These strategies cover the material in ways accessible to many
learning styles and also create a lively, comfortable classroom in
which students take ownership and work with the instructor to find
ways of learning the material.  Thus, interaction becomes a viable
tool for reaching students of varied experience and differing learning
styles.

TITLE: Animation, Visualization, and Interaction in CS 1 Assignments
AUTHORS: Owen Astrachan and Susan H. Rodger
               Duke University 
        ola@cs.duke.edu, rodger@cs.duke.edu 
ABSTRACT:
Programs that use animations or visualizations attract student interest and
offer feedback that can enhance different learning styles as students work
to master programming and problem solving.  In this paper we report on
several CS1 assignments we have used successfully at Duke University to
introduce or reinforce control constructs, elementary data structures, and
object-based programming.  All the assignments involve either animations by
which we mean graphical displays that evolve over time, or visualizations
which include static display of graphical images.  The animations do not
require extensive programming by students since students use classes and
code that we provide to hide much of the complexity that drives the
animations.  In addition to generating enthusiasm, we believe the
animations assist with mastering the debugging process.

Title: Applying the Personal Software Process in CS1: An Experiment
Authors:	Lily Hou and Jim Tomayko
		School of Computer Science
		Carnegie Mellon University
Abstract:
The authors conducted an experiment in applying components of the Personal 
Software Process (PSP)described in Humphrey[2,3] to a large group of CS1 
students. Half of the students were taught selected PSP principles and the
other half were asked only to keep track of total time spent on 
programming assignments. Results indicate that PSP is of value not only to 
software professionals involved in large projects, or to students in a 
software engineering school, but also to novices at the CS1 level, 
regardless of their background.

Scaling: A Design Pattern in Introductory Computer Science Courses
Harriet J. Fell, Viera K. Proulx, and Richard Rasala
Northeastern University
College of Computer Science
Boston, MA 02115, USA
fell@ccs.neu.edu, vkp@ccs.neu.edu, rasala@ccs.neu.edu
Abstract
We present a series of programming exercises that use scaling as a theme
for teaching design techniques in the introductory computer science course
sequence.  All exercises are on the level easily mastered in the first year
of programming.  Additionally, the exercises introduce a rich variety of
applications of computer science.

Teaching Data Structure Design Patterns
by Natasha Gelfand, Michael T. Goodrich and Roberto Tamassia
Abstract:
In this paper we present an approach for teaching the
Freshman-Sophomore introduction to data structures course (CS2) in a
way that provides an introduction to object-oriented software
engineering patterns in addition to the theory of data structures.  We
survey several design patterns and describe how they can be naturally
integrated in the CS2 curriculum.

Design Patterns for Data Structures
by 
Dung ("Zung") Nguyen
Pepperdine University
Synopsis
Design patterns provide ways to structure software components into systems
that are flexible, extensible, and have a high degree of reusability. The
state pattern, the null object pattern, and the singleton pattern are used
to implement common data structures such as lists and trees.  These patterns
help narrow the gap between the abstract views of the data structures and
their concrete implementations.  The smaller the gap, the higher the level
of abstraction.  The more abstract, the less complex the coding structure.
As a result, algorithms are easier to understand and more manageable.  This
paper advocates teaching the above design patterns in data structures courses.

A Robot Laboratory for Teaching Artificial Intelligence
Deepak Kumar                   Lisa Meeden
Department of Mathematics      Computer Science Program
Bryn Mawr College              Swarthmore College
Bryn Mawr, PA 19010            Swarthmore, PA 19081
dkumar@brynmawr.edu            meeden@cs.swarthmore.edu
Abstract
We describe a project that involved the creation of two
identical robot building laboratories at two undergraduate
institutions. The laboratory has been used for teaching the
undergraduate AI course. Laboratory materials have been made
available along with detailed information on how to create
such a laboratory at other institutions. The laboratory helps 
introduce a central theme in the teaching of AI, and, at the
same time, strengthens the role AI plays in the core computer
science curriculum.

A Virtual Learning Environment for Entity Relationship Modelling
Lynne Hall, Adrian Gordon
Abstract 
Entity Relationship Modelling (ERM) is a fundamental skill in database design.
Though ERM concepts are simple, the modelling process itself is a complex 
activity. Novice ER modellers make systematic errors in their models. Current
tool-based support for learning ER modelling is limited, since it concentrates
on notation at the expense of methodology, and provides little or no feedback 
to the learner about the quality of her constructed models. A text-based 
virtual learning environment, based on the Multi-User Dimension paradigm, is
described, in which learners undertake ER modelling tasks by interacting with 
objects in a virtual world. This learning environment concentrates on the 
methodology of ER modelling rather than its notation, and provides immediate 
feedback to a learner about the quality of her models. Preliminary results 
suggest that this learning environment is both easy to use and effective.

Experience with an Analytic Approach to Teaching Programming Languages
by Christopher T. Haynes
Through the use of interpreters it is possible to teach programming
languages in an analytic way without the mathematical overhead associated
with other formal methods.  This is a natural evolution of programming
language pedagogy from present approaches that are largely descriptive.  As
a bonus, students receive training in the use of meta-linguistic abstraction
in program design. An example of this approach is presented along with
suggested variations and discussion of a number of practical considerations
that may be crucial to success in the classroom.