bluuebunny/crossref_metadata_2025 huggingface dataset:
Identification of complete data flow diagrams
Authors: Vazquez Federico
Published: July 2004

The Structure Design is generated with Data Flow Diagrams (DFD). DFD have been used for more than ten years, and they are still popular. The main drawback of DFD is the lack of mathematical foundation. The great demand for bigger and more sophisticated computer systems makes necessary the formulation of a formal theory for DFD. This theory will provide a way of checking consistency and completeness. Universal Algebra has become a useful and important tool in theoretical computer science. Universal Algebra is used in this paper to represent DFD, to generate DFD, to prove consistency and completeness and to define complete DFD. A process decomposition is defined in strict mathematical way; the famous Birkoff's Variety Theorem is used to prove consistency in the process decomposition; a definition of minimal DFD is given; a relation between Universal Algebra concepts and DFD is defined; and a definition of complete (well-defined) DFD is given. The DFD are defined using basic concepts of Universal Algebra theory. The results from this paper can be incorporated in any of the CASE tools used to generate DFD.
Storage and network requirements of a low-cost computer-based virtual classroom
Authors: Juell Paul , Brekke Daniel , Vetter Ronald , Wasson John
Published: July 2004

In this paper we investigate the network and storage requirements of a virtual classroom. The virtual classroom replaces traditional class methodologies by using the computer as the sole instrument for all class activity. The instructor and the students each have a networked workstation in an X cluster that provides for the creation, modification, and distribution of presentations, note-taking, capturing of presentation material, out-of-class reviewing of presentation material, and viewing of supplemental materials provided by the instructor (including selected readings, exams, and assignments).We have designed and implemented an virtual classroom as a means of enhancing the teaching/learning process. The creation of this virtual classroom was accomplished by using only existing computing resources: SUN workstations, X tools, an Ethernet network, and UNIX operating system support. Network statistics were collected to determine how well existing networks can be utilized within this environment. We also observed the performance of the system in a realistic setting by using it to teach an Office Information Systems class at North Dakota State University.
Understanding the differences between VDM and Z
Authors: Hayes I. J. , Jones C. B. , Nicholls J. E.
Published: July 2004

This paper attempts to provide an understanding of the interesting differences between two well-known specification languages.
Hierarchies of programming concepts
Authors: Návrat Pavol
Published: July 2004

This short note attempts to clarify some fundamental relationships within the domain of programming knowledge. In particular data concepts are discussed. Our aim is to draw a clear distinction between abstraction and generalization. Besides that attention is given to the role of metaknowledge. Deeper methodological understanding of these relationships is crucial for all those studying and practicing programming.
A methodology for monitor development in concurrent programs
Authors: Velázquez-Iturbide J. Ángel
Published: July 2004

Concurrent programming is one of the most difficult programming paradigms; in consequence, innovative methods and practical aids are necessary for a successful instruction. This paper presents a methodology for monitor development by joint use of stepwise refinement and monitor schemes. A monitor is developed in three stages, each one successively dealing with a different part of its specification, namely data abstraction specification, security properties and liveness/priority properties. Guidance is also obtained from some schemes for different parts of a monitor. The methodology is applied to two well known problems, the producer-consumer problem and the dining philosophers problem.
On the design and use of a simulator for teaching computer architecture
Authors: Styer Eugene
Published: July 2004

Most Computer Architecture classes include dicussions of machine instructions and CPU internals, but not many include input/output devices, either as part of that course, or elsewhere in the program. This paper discusses a simulator designed to allow students to work with simulated I/O devices as a part of larger machine simulator.
Using a computer conferencing system to support writing and research skill development
Authors: Cunningham Sally Jo
Published: July 2004

In recent years there has been a growing concern with the low level of communication skills attained by computer science graduates, coupled with a desire to provide writing skills in the context of meaningful computing experiences. This paper describes a course project that attempts to address these issues. Students prepared a series of computing "experiments", posted each experiment in a local conferencing system, and provided peer reviews of each others' work. The advantages of submitting assignments through a course-specific conferencing group include: increased feedback on student work (from other students); a generally higher level of self-editing; and an opportunity for students to survey the work of other students, both to gain a better understanding of expected standards and to learn from the content of each others' work.
Distributed systems in the undergraduate curriculum
Authors: Stewart Carolee
Published: July 2004

Much of the design and development for new computing systems in the 1990's is being done in a networked computing environment with distributed goals. So why do so many 4-year college computer science departments still not teach "Distributed computing systems" in their undergraduate curriculum? The reasons are varied, but one main one is the belief that such a course requires expensive hardware and the very latest software development tools. This article demonstrates how a course for undergraduates in distributed computing can be successful at giving the students the concepts and principles, while enabling them to create such an application to experience the distributed environment, and do it all on a limited budget. The principles are highlighted along with a practical design and development component, which can give seniors a way to tie together many of the principles and applications of previous courses.
Taxman revisited
Authors: Trono John A.
Published: July 2004

In an earlier article [1], Carmony and Holliday illustrated how the game called Taxman could be used in CS1 to introduce some elementary concepts from Artificial Intelligence. This article will present several strategies that were created (as part of a CS2 assignment) to play Taxman, and evaluate their performance.
An undergraduate course in concurrent programming using Ada
Authors: Yue Kwok-bun
Published: July 2004

This paper describes a senior level course in concurrent programming using Ada. Unlike other similar courses in the subject area, it is not part of an operating systems course, nor is it tied to a particular hardware architecture. The course is software oriented and it discusses in depth a concurrent programming language, Ada, so that students are able to actually develop effective concurrent programs to solve problems in a wide range of applications. Ada is selected because of its popularity, superb portability, numerous hardware platforms, and rich concurrent constructs. Classical issues in concurrent programming are presented in the context of Ada. General issues in designing concurrent programming languages are elaborated using Ada, together with other concurrent programming languages such as CSP, Occam, and Linda. Finally, general principles of designing parallel programs are also discussed. Therefore, the course provides both the depth in a concurrent programming language for program development and the breadth in concurrent programming theory for insight. Using Ada throughout the course strengthens student's expertise in Ada and provides an useful reference point for understanding concurrent programming theory. The course is heavily based on handouts, examples, homework and programming assignments. A rich set of instructional materials are available from the author.
Q-Sim
Authors: Billard Edward A. , Riedmiller Alice E.
Published: July 2004

A design and implementation are presented for a graphical user interface to a batch queueing simulator, illustrating the benefits of using a high-level script language. Rapid development was made possible with the use of Tcl/Tk scripts to implement the entire interface. The script implements a dynamic display of job and queue movement along with graphs of statistical behaviors. A message system is used to control the interaction between the human interface and the batch simulator.
Assessing the software process maturity of software engineering courses
Authors: Collofello James S. , Kantipudi Manmahesh , Kanko Mark A.
Published: July 2004

Since its introduction by the Software Engineering Institute (SEI) in 1987, the SEI Software Process Maturity Model has gained wide visibility and acceptance by industry. Its overall goal is to enable an organization to assess its software process maturity in order that it might be able to improve its software development process. Inspired by the success of the SEI model, this paper describes an attempt to develop an analogous, but highly simplified and unvalidated process maturity framework applicable to software engineering project courses. Our goal is to enable an instructor of a software engineering project course to assess the software development processes utilized in the course and to improve these processes leading to better managed and more successful projects.
Teaching a first course on data structures
Authors: Mili Rym , Mili Ali
Published: July 2004

We discuss our experience with integrating three key ideas of software engineering into our data structures course: formal specifications, information hiding, and bottom up programming. The idea of formal specifications is fostered by the introduction of a simple formal notation, which students use to describe their data structures and to validate their implementation. The idea of data abstraction is fostered by separating, in the very design of our course, the usage of data structures from their implementation. Finally the idea of bottom up programming is fostered by showing students how complex systems can be designed one layer at a time, where each layer refers exclusively to the layer immediately below it.
Teaching parallel programming and software engineering concepts to high school students
Authors: Rifkin Adam
Published: July 2004

This paper takes the stand that it is never too early to teach so-called “hard” concepts in computer science. Specifically, basic principles in parallel algorithm development and software engineering can be introduced to students first learning about computers. The key is to present ideas in a manner that is simple, fun and suited to the audience. We discuss an interactive exercise developed with this premise in mind, based on sorting algorithms, that we conducted with one hundred minority students aged 14 to 17, on March 19, 1993. Our students, relative neophytes to high level computer science notions, had fun while learning alleged difficult concepts.
An object-oriented approach to algorithm visualization—easy, extensible, and dynamic
Authors: Naps Thomas L. , Swander Brian
Published: July 2004

A key component of our attempt to integrate the object-oriented paradigm into introductory and intermediate courses is algorithm visualization. Such visualization depicts an algorithm as a sequence of graphical snapshots of data structures that are operated upon at “interesting events” in the algorithm's execution. Using object-oriented techniques, we have significantly enchanced a previous version of the algorithm visualization system called GAIGS, developed at Lawrence. These enhancements allow instructors and students to develop dynamic visualizations with relative ease and, if desired, extend the graphic operations that are built into GAIGS to allow more personalized visualizations. The resulting software package is being used in a core of courses as a means of illustrating the power of the object-oriented approach while at the same time advancing students' understanding of difficult algorithms. Because of the extensibility of the object-oriented features of the system, we envision many future applications in which it could be used. To encourage the development of such applications, the system is conveniently available via ftp.
Using literate programming to teach good programming practices
Authors: Shum Stephen , Cook Curtis
Published: July 2004

The ability to comprehend a program written by other individuals is becoming increasingly important in software development and maintenance. In an attempt to encourage undergraduate Computer Science students to write informative and usable documentation, the literate programming paradigm was incorporated into the teaching of one undergraduate Computer Science course at Augustana College. This paper describes the concept of literate programming, the experience of using literate programming to teach good programming practices, and the results from the experiment that showed that literate programming encourages more documentation.
From specific problem instances to algorithms in the introductory course
Authors: Kortright Lisa M. Levy
Published: July 2004

In this paper, we present an approach for the introduction of problem solving and algorithm development in the first computer science course. Our technique is a more formal and systematic approach to programming based on generalizing a pattern after studying and expanding on a sequence of specific problem instances. In our approach, the algorithm and justification of its correctness are developed together.
CSI closed lab vs. open lab experiment
Authors: Thweatt Mack
Published: July 2004

Recommendations of the ACM/IEEE Joint Curriculum Task Force on the Core of Computer Science and the dissatisfaction with the poor performance of too many CS1 students at Middle Tennessee State University combined to motivate the Computer Science Department to compare the use of closed labs and open labs. A controlled experiment was conducted in the Fall 1992 and Spring 1993 semester of CS1 classes. Some of these classes were chosen for closed lab and others for open lab experiences. ANOVAs of various comparison groups consistently showed significant differences on comprehensive CS1 exams in favor of the students in closed labs.
The KLYDE workbench for studying experimental algorithm analysis
Authors: Berque Dave , Bogda Jeff , Fisher Brian , Harrison Tim , Rahn Nick
Published: July 2004

KLYDE is a software workbench that helps students study issues related to the design, implementation, and empirical analysis of algorithms. Using the system's graphical user interface students can design and conduct experiments to study the efficiency of a variety of algorithms and their underlying implementations. The data generated by these experiments can be studied directly, or imported into speadsheet and presented graphically. This paper gives an overview of the KLYDE system and illustrates how the system can be used in a variety of undergraduate computer science courses.
An integrated, software-based approach to teaching introductory computer programming
Authors: Herrmann Nira , Popyack Jeffrey L.
Published: July 2004

We have developed a course in scientific and statistical programming consisting of an introduction to computer programming and data analysis concepts using a variety of software packages. This approach addresses the problems inherent in introducing programming to non-computer science majors, particularly those in engineering, the sciences, and the social sciences where computing and statistical data analysis techniques are essential professional tools, as well as to computer science majors with minimal or nonexistent programming backgrounds.

Key programming concepts are introduced, including variables and identifiers, absolute versus relative addresses, assignment statements, IF/THEN/ELSE statements, nested and compound IF statements, truth tables, precedence of operations, use of built-in and user-defined functions, dummy variables, passing by value and reference, the importance of order in specifying input to functions, modular program design, subprograms, debugging and testing techniques, properties of good programs, and iterative loops. Elementary statistical concepts and data analyses are covered within a computing environment context that emphasizes data analysis and interpretation of results.

Assignments and examples are developed in collaboration with the students' major departments to insure relevance and interest to the students.
Using laboratories to teach software engineering principles in the introductory computer science curriculum
Authors: Robergé James , Suriano Candice
Published: July 2004

If students are to internalize software engineering concepts and incorporate them into their individual software development styles, they must use these concepts during the initial stages of their computer science education. In this paper, we examine how laboratories that emphasize software development can be used to familiarize students with the basic elements of software engineering during the introductory computer science course sequence.
A software development process laboratory for CS1 and CS2
Authors: Oliver S. Ron , Dalbey John
Published: July 2004

Typical introductory courses emphasize programming constructs and language features, and are built around many simple programming assignments that encourage students to use those constructs and features, on a feature-by-feature basis. This has the effect of inculcating a quick and dirty,
programming-in-the-small
mentality. Even if responsible development methods are carefully taught in class, the assignments tend to be so small and simple, any methods, other than just writing the code, come to be seen as a nuisance, rather than an aid to the process.

Introductory students are usually required to work individually, rather than in teams, to ensure each acquires a minimum understanding of the fundamentals. This has the effect of encouraging students, during the formative stages, to develop individualistic work habits, which are often inconsistent with working in teams. Even though group programming projects may be imposed on students in later course work, these experiences are often too late, or otherwise insufficient, to offset the habits and styles established during the CS1 and CS2 courses.

Although laboratory components are becoming more common for upper division Computer Science courses, they are still relatively uncommon at the CS1 and CS2 level. We propose a laboratory component for CS1 and CS2 that will emphasize
programming-in-the-large
and group projects. These and other aspects of the lab will help students, in a positive way, to become comfortable with practices and processes considered essential to do software development. They will not only learn the fundamentals more successfully, but they will also develop habits and styles that will better server them in their careers as Computer Scientists.
The lecturer's assistant
Authors: Buckalew Chris , Porter Alan
Published: July 2004

For many centuries the chalkboard has been the primary means of communication in the classroom, recently augmented by the overhead projector. These media provide one-way communication: from the lecturer to the students. We describe a prototype system, called the Lecturer's Assistant, which as its main feature enables graphic communication from the students to the lecturer and other students. This capability allows students to easily ask questions or present ideas without leaving their seats. The Lecturer's Assistant also provides the lecturer with a complete electronic environment for the preparation, presentation, and subsequent editing of classroom overheads. The system is designed to be portable and inexpensive to enable widespread usage in the nation's university classrooms.
A framework for CS1 and CS2 laboratories
Authors: Waller William A.
Published: July 2004

The development and implementation of closed laboratories in the undergraduate curriculum continues to be an important trend in computer science education. Most textbooks intended for use in CS1 and CS2 level courses are now supplemented with closed laboratory manuals. Many instructors have reported efforts to incorporate closed labs into other courses as well. The National Science Foundation has funded several projects of both local and national scope aimed at promoting the integration of closed laboratories into the undergraduate curriculum. In this paper we describe the experimental authorware system PHIL, which is designed to create laboratory exercises for computer science courses, particularly CS1 and CS2. The outputs of this system are interactive MS Windows “laboratory” documents, which guide students through a series of activities and questions. These activities and questions are presented via windows which provide the students with objectives, instructions, and different types of controls for student responses (such as text edit fields). Activity windows can be linked with useful external applications, such as compilers, through buttons to permit easy access. Menu choices allow the student to save and retrieve lab documents from disk, as well as print equivalent hard-copy versions of the documents. Authors using the system can create new lab programs by customizing and recombining pre-existing activities, or can create entirely new activities based on predefined templates. The PHL system is based on parallel hierarchies of lab activity objects developed using Borland C++ and ObjectWindows, the Borland framework for creating MS Windows applications. The goals of this system are to encourage reuse of lab material developed for CS1 and CS2 courses, to provide a convenient and extensible environment for developing CS lab material, and to provide a stimulating and sophisticated closed lab environment for lower division CS courses.
GATutor
Authors: Prince Charles , Wainwright Roger L. , Schoenefeld Dale A. , Tull Travis
Published: July 2004

In this paper we discuss the design and implementation of GATutor, a graphical tutorial system for genetic algorithms (GA). The X Window/Motif system provides powerful tools for the development of a user interfaces with a familiar feel and look. We implemented the Traveling Salesman Problem (TSP) and the Set Covering Problem (SCP) as two example GA problems in the tutorial. The TSP problem uses an order-based chromosome representation (permutation of
n
objects), while the SCP uses bit strings. The user has numerous buttons to select the GA parameters. These include (a) type of initial population: random or from a file, (b) mode: steady-state or generational, (c) population size, (d) maximum number of generations or trials, (e) generation gap, (f) selection mode, (g) selection bias, (h) selection of the crossover operation from a choice of several possibilities, (i) mutation method, (j) mutation rate, (k) replacement method, (l), elitism, etc. The user has the ability to do astep by step execution or to do a continuous run. The screen layout provides visual representation of the chromosomes in the population with the ability to scroll. This gives the user the option of varying one or two GA parameters to visually see the effect on the algorithm. One of most important features of this tutorial is the set of help screens that explain, with examples, all of the options for each of the GA parameters. This package has already been very useful for teaching the fundamental features of GAs in many different courses, and it has been very valuable in our GA research projects.
LLparse and LRparse
Authors: Blythe Stephen A. , James Michael C. , Rodger Susan H.
Published: July 2004

This paper describes instructional tools, LLparse and LRparse, for visualizing and interacting with small examples of LL and LR parsing. These tools can be used to understand the process of constructing LL(1) and LR(1) parse tables through a series of steps in which users receive feedback on the correctness of each step before moving on to the next step. For example, in LRparse, the user initially enters an LR(1) grammar, calculates FIRST and FOLLOW sets, graphically constructs a deterministic finite automaton of item sets, and finally constructs the LR(1) parsing table. Upon completion of the constructed table, the user can observe a visualization of the parsing of input strings. These tools can be used to provide problem solving feedback in courses on automata theory or compiler design.
Dynamic programming for pennies a day
Authors: Heck Patrick
Published: July 2004

An elegant solution to a fun problem is presented as a way to introduce dynamic programming. This problem, the Nine Tails, can be used as an introductory supplement to the traditional examples offered in many textbooks which cover dynamic programming.
A seminar course in computer ethics
Authors: Lelewer Debra A.
Published: July 2004

This paper describes the transformation of a required Senior Seminar course. The transformed course emphasizes ethical, social, political, legal, and economic aspects of computing. In addition, the new rendition of the course increases the requirement for oral and written communication. We describe the previous definition of the course, goals of the redesign, and students' reactions to both the new and old versions. To this author's surprise, student satisfaction is higher with the new course, although it requires more of them.

We discuss course organization, and suggest assignments and teaching strategy. The course was a joy to teach and, fortunately, a very pleasant and meaningful experience for the students.
Assessing student's critical thinking skills and attitudes toward computer science
Authors: Moore Thomas , Wick Michael , Peden Blaine
Published: July 2004

This report describes several evaluation procedures used to assess the effectiveness of a newly-developed introductory computer science curriculum. The authors describe the development of a tool to evaluate changes in student's attitudes toward the computer science discipline. The process used to develop this survey is presented, along with several interesting preliminary results. The authors also describe the use of an existing tool in the evaluation of the development of student's critical thinking skills.
Teaching EBNF first in CS 1
Authors: Pattis Richard E.
Published: July 2004

This paper is a guided tour through the first day of a CS 1 course. It discusses teaching Extended Backus-Naur Form (EBNF) as the first topic—not to facilitate presenting the syntax of a programming language, but because EBNF is a microcosm of programming. With no prerequisites, students are introduced to a variety of fundamental concepts in programming: formal systems, abstraction, control structures, equivalence of descriptions, the difference between syntax and semantics, and the relative power of recursion versus iteration. As a non-numeric formal system, EBNF provides a small but concrete context in which to study all these topics.

EBNF descriptions include abstraction (named rules) and the four fundamental control structures (sequence, decision, repetition, and recursion). Because there are no data or parameters in EBNF, it is easy to sidestep tricky issues surrounding variables, scope, assignment statements, and parameter modes. Describing entitles in EBNF is similar to describing computations in a programming language. Students learn to read a description and analyze whether it generates/matches candidate symbols; then they learn to synthesize descriptions from English specifications, augmented by legal and illegal exemplars of symbols.

All these concepts can be covered in one lecture, establishing a high level of formality early in the course, while foreshadowing actual programming language features and techniques to be covered later. Of course, learning EBNF also facilitates presenting the syntax of a programming language concisely during the rest of the course.
Reciprocal peer reviews
Authors: Sullivan Sarah L.
Published: July 2004

Reciprocal peer reviews empower students to master computer science concepts. This industry practice employs peer-to-peer communication within an egoless team structure. As pedagogy, reviews provide a human-interaction laboratory setting where students: hone teamwork and communication skills, master the peer review process, and learn to learn from each other.
On object-oriented libraries in the undergraduate curriculum
Authors: Tewari Rajiv , Gitlin David
Published: July 2004

As the object-oriented paradigm becomes increasingly important in the computer science curriculum, educators will face a new set of challenges and issues. One of these new issues will be the role that programming libraries should assume in teaching both software engineering methodologies and recurring concepts in computer science. Object-oriented languages place a strong emphasis on both code and design reuse, and data abstraction via encapsulation, in order to model complex problem domains. Libraries provide the primary technology for reuse and storage of modules. As a result, they assume great importance in this programming methodology. This paper explores pedagogical issues related to object-oriented class libraries and presents empirical evidence based on an exploratory study conducted by us. Experimental results indicate the superiority of object-oriented class libraries in writing data-structure intensive applications.
Engaging students and teaching modern concepts
Authors: Meter Glenn , Miller Philip
Published: July 2004

This paper describes our experience in using situated programming to deliver modern computer science concepts in the introductory programming course at Carnegie Mellon University. We used an artificial life simulation and taught object-oriented programming as well as more traditional material. The course was an experience, not an experiment, since many aspects of the course simultaneously changed from prior offerings. Nevertheless, what we saw was fundamental and potentially far-reaching. The most important result was that students were intellectually engaged. They came to grips with basic object-oriented programming, they mastered the topics of procedural programming, they learned first hand about computer simulation, they learned perhaps a bit about biology. Most importantly, through it all they used programming to express and explore their own powerful and novel ideas.
The art and science of computer graphics
Authors: House Donald , Levine David
Published: July 2004

This paper describes a course in computer graphics which is designed for students with little or no background in computer science. The course is centered around custom software which was designed with the pedagogical goals in mind. The goals of the course, the software, and some experiences at two institutions are discussed.
Multimedia across the disciplines
Authors: Epstein Steven , Fischer Marla , Golshani Forouzan , Ricardo Catherine
Published: July 2004

The use of multimedia, including voice, music, text, still images, and full motion video is becoming more and more widespread in education at all levels. Faculty must consider how to utilize the power of this technology to motivate students and to improve learning. The presenters will discuss how they have developed and used multimedia to enhance classroom presentations in various disciplines and how students have responded to this new technology.
A new model of program dependences for reverse engineering
Authors: Jackson Daniel , Rollins Eugene J.
Published: July 2004

A dependence model for reverse engineering should treat procedures in a modular fashion and should be fine-grained, distinguishing dependences that are due to different variables. The program dependence graph (PDG) satisfies neither of these criteria. We present a new form of dependence graph that satisfies both, while retaining the advantages of the PDG: it is easy to construct and allows program slicing to be implemented as a simple graph traversal. We define 'chopping', a generalization of slicing that can express most of its variants, and show that, using our dependence graph, it produces more accurate results than algorithms based directly on the PDG.
Duplication, insertion and lossiness errors in unreliable communication channels
Authors: Cécé Gérard , Finkel Alain , Iyer S. Purushothaman
Published: July 2004

We consider the problem of verifying correctness of finite state machines that communicate with each other over unbounded FIFO channels that are unreliable. Various problems regarding verification of FIFO channels that can lose messages have been considered by Finkel [10], and by Abdulla and Johnson [1, 2]. We consider, in this paper, other possible unreliable behaviors of communication channels, viz. (a) duplication and (b) insertion errors. Furthermore, we also consider various combinations of duplication, insertion and lossiness errors.Finite state machines that communicate over unbounded FIFO buffers is a model of computation that forms the backbone of ISO standard protocol specification languages Estelle and SDL. While an assumption of a perfect communication medium is reasonable at the higher levels of the OSI protocol stack, the lower levels have to deal with an unreliable communication medium; hence our motivation for the present work.The verification problems that are of interest are
reachability, unboundedness, deadlock
, and
model-checking against CTL
. All of these problems are undecidable for machines communicating over reliable unbounded FIFO channels. So, it is perhaps surprising that some of these problems become decidable when unreliable channels are modeled. The contributions of this paper are: (a) An investigation of solutions to these problems for machines with insertion errors, duplication errors, or a combination of duplication, insertion and lossiness errors, and (b) A comparison of the relative expressive power of the various errors.
Automated support for encapsulating abstract data types
Authors: Bowdidge Robert W. , Griswold William G.
Published: July 2004

A software engineer can use a meaning-preserving program restructuring tool during maintenance to change a program's structure to ease modification. One common restructuring action is to create a new abstract data type by encapsulating an existing data structure. Data encapsulation simplifies modification by isolating changes to the implementation and behavior of an abstract data type. To perform encapsulation, a programmer must understand how the data structure is used in the code, identify abstract operations performed on the data structure, and choose concrete expressions to be made into functions. We provide a manipulable program visualization, called the star diagram, that both highlights information partinent to encapsulation and supports the application of meaning-preserving restructuring transformations on the program through a direct-manipulation user interface. The visualization graphically and compactly presents all statements in the program that use the given global data structure, helping the programmer to choose the functions that completely encapsulate it. Additionally, the visualization elides code unrelated to the data structure and to the task, and collapses similar expressions to allow the programmer to identify frequently occurring code fragments and manipulate them together. The visualization is mapped directly to the program text, so manipulation of the visualization also restructures the program. We describe the design, implementation, and application of the star diagram, and evaluate its ability to assist data encapsulation in large programs.
Exploiting style in architectural design environments
Authors: Garlan David , Allen Robert , Ockerbloom John
Published: July 2004

As the design of software architectures emerges as a discipline within software engineering, it will become increasingly important to support architectural description and analysis with tools and environments. In this paper we describe a system for developing architectural design environments that exploit architectural styles to guide software architects in producing specific systems. The primary contributions of this research are: (a) a generic object model for representing architectural designs; (b) the characterization of architectural styles as specializations of this object model; and (c) a toolkit for creating an open architectural design environment from a description of a specific architectural style. We use our experience in implementing these concepts to illustrate how style-oriented architectural design raises new challenges for software support environments.
Object-oriented simulation of computer architectures using C++
Authors: Reid Richard J.
Published: July 2004

Object-oriented languages such as C++ allow class definitions which eliminate the need for writing special-purpose simulators in many cases. Simulating digital logic components and computer architectures is one case where the simulation model can be effectively and conveniently expressed in the programming language itself.

A class library supporting: schematic organization, multi-level digital-signal representation, and implementations of a modest set of component primitives has been developed. This library supports two forms of hierarchical arrangements; first, the digital signals themselves can be expressed as vectors (as for a bus), either directly or by composition, and second, the digital components can be arranged hierarchically as modules, and the modules can be used in an identical manner in which the primitives are used.

The library code described here is available from the author.
Socket programming in the data communications laboratory
Authors: Toll William E.
Published: July 2004

Although many data communications courses are taught with no programming content, courses designed for computer science majors should include programming. Many data communications courses with a programming component make use of serial ports on PCs while some deal with detailed network layer projects. UNIX socket programming allows the students to deal with the same issues and problems, but in a context that is more likely to be useful and that is more interesting. In addition, if socket classes are used with C++, only as much detail of socket operation as desired need be presented.
Solving a problem using cooperating data structures
Authors: Kooshesh Ali A.
Published: July 2004

In this write-up, we describe series parallel graphs, a simple class of general graphs, and show how to compute their minimum spanning tree or shortest path. The problem is intended to be used as an assignment in an undergraduate course on Data Structures. It is a simple problem, yet non-trivial, and allows the students to implement several interesting data structures in one programming assignment.
A laboratory for teaching parallel computing on parallel structures
Authors: Jin Lan , Yang Lan
Published: July 2004

For the effective use of a laboratory for teaching parallel processing, it is desirable to have parallel systems that can implement various parallel structures at hardware or software level. Such systems developed in our laboratories are described in this paper. They are a multi-computer with reconfiguration and the PVM (Parallel Virtual Machine) with structural implementation. The paper proposes a methodology and several classes of problems for teaching message-passing programming on parallel structures.
A data-parallel programming library for education (DAPPLE)
Authors: Kotz David
Published: July 2004

In the context of our overall goal to bring the concepts of parallel computing into the undergraduate curriculum, we set out to find a parallel-programming language for student use. To make it accessible to students at all levels, and to be independent of any particular hardware platform, we chose to design our own language, based on a data-parallel model and on C++. The result, DAPPLE, is a C++ class library designed to provide the illusion of a data-parallel programming language on conventional hardware and with conventional compilers. DAPPLE defines
Vectors
and
Matrices
as basic classes, with all the usual C++ operators overloaded to provide elementwise arithmetic. In addition, DAPPLE provides typical data-parallel operations like scans, permutations, and reductions. Finally, DAPPLE provides a parallel if-then-else statement to restrict the scope of the above operations to partial vectors or matrices.
A successful five-year experiment with a breadth-first introductory course
Authors: Bagert Donald , Marcy William M. , Calloni Ben A.
Published: July 2004

This paper discusses the implementation and evolution over a five-year period of a breadth-first introductory computer science course which has both lectures and structured, closed laboratory sessions. This course significantly increased both the retention and passing rates for the next computer course (which emphasizes programming), and computer science graduation rates.
A domain centered curriculum
Authors: Hirmanpour Iraj , Hilburn Thomas B. , Kornecki Andrew
Published: July 2004

This paper presents a new approach to computer science education by proposing a model curriculum that presents computer science fundamentals and software engineering concepts in the context of an application domain. This domain-centered model is discussed in terms of its philosophy and structure, and emphasizes curriculum features that enhance the ability of a graduate to be part of a team that develops software in the application domain. In particular, the curriculum model proposes integration of software engineering education with the application domain. The undergraduate computer science curriculum at Embry-Riddle Aeronautical University is used to illustrate the principle features of the model and to advance arguments about the model's viability.
Integrating parallel algorithm design with parallel machine models
Authors: Yang Lan , Jin Lan
Published: July 2004

In teaching of Parallel Algorithms, emphasis is usually placed on algorithms that are based on parallel random access machine (PRAM) model, but those algorithms may or may not be efficiently implementable on real parallel machines. In this paper we design parallel algorithms in relation with the actual parallel machine models and show the importance of integrating parallel algorithms with parallel machine models. We discuss this approach using traveling salesperson problem (TSP) as an example.
A low-tech introduction to operating systems
Authors: Moen Selmer
Published: July 2004

Operating systems can be taught using DOS as the basis for an introductory course. This approach is both practical and pedagogically sound. It leads to a course which is valuable both as a terminal course on operating systems and as the basis for further theoretical study. It is possible to use DOS as an environment for teaching rudiments of multitasking.
CAP
Authors: Schorsch Tom
Published: July 2004

Student programmers have difficulty finding and fixing syntax, logic and style errors in their programs. The Code Analyzer for Pascal (CAP) analyzes programs that use a subset of the Pascal language and provides user-friendly feedback on the errors that it finds. This paper describes CAP and reports its use in teaching introductory programming at the United States Air Force Academy.
Requirements for a first year object-oriented teaching language
Authors: Kölling Michael , Koch Bett , Rosenberg John
Published: July 2004

Interest in teaching object-oriented programming in first year computer science courses has increased substantially over the last few years. While the theoretical advantages are clear, it is not obvious that the available object-oriented languages are suitable for this purpose. None of the existing languages is appropriate for
teaching
object-oriented principles. In this paper we discuss the requirements for an object-oriented teaching language and draw attention to the deficiencies of existing languages. In particular, the paper examines C++, Smalltalk, Eiffel and Sather. Finally we outline characteristics of a new language, specifically designed for teaching purposes.
Integrating introductory courses in computer graphics and animation
Authors: Schweitzer Dino , Appolloni Tom
Published: July 2004

Introductory Computer Graphics is a popular and motivational course for computer science undergraduates. The students have the ability to “see” the results of their programs, the opportunity to apply a high level of creativity, and the satisfaction of impressing their peers. Computer animation provides similar advantages from a motivational point of view. A normal scheduling sequence for these two courses would place them in successive semesters (or quarters) in the curriculum, presumably in the senior year so students have as much computer science experience as possible prior to starting the graphics course. Unfortunately, at the Air Force Academy, such a sequence was not possible, forcing us to investigate the integration of the two courses during the same semester (second semester senior year). Our experience is that the two courses could not only be successfully integrated during the same semester, but that the student experience in each course benefited from the concepts being simultaneously presented in the complementary course. This paper will provide background on the two courses, describe our experience in teaching them simultaneously, and discuss our future plans for expanding the pilot program.
Inexpensive advanced graphics applications for the C.S. majors graphics class
Authors: Tichenor Lee H.
Published: July 2004

To demonstrate more advanced topics we have changed the focus of our graphics assignments in our upper division C.S. majors course from strictly programming basic algorithms to working in existing software packages. In addition to three standard programming assignments in Pascal or C the students perform experiments and develop designs with L-grammar, fractal generator, morph, ray-tracing, and animation packages. Excellent and inexpensive versions of all these systems are available through shareware or freeware. The student response has been overwhelmingly positive.
Visual analysis
Authors: Sears Andrew , Wolfe Rosalee
Published: July 2004

Visual Analysis adds breadth to a computer graphics course by teaching students to compare and contrast the visual effects of rendering algorithms. Using slides to teach visual analysis minimizes the amount of required lecture time, and the interactive tool TERA facilitates further study outside of class. Visual analysis enhances depth as well as breadth of knowledge, because students become familiar with an algorithm's visual effect before they implement it.