bluuebunny/crossref_metadata_2025 huggingface dataset:
Our failing students
Authors: Sheard Judy , Hagan Dianne
Published: July 2004

The high failure and low retention rates of students in introductory programming courses are of growing concern.This study looks at a group of students who are repeating an introductory programing subject, exploring issues which may affect their learning and ultimate success. Comparisons are made with a group of new students undertaking the same subject.The students were surveyed in the middle and at the end of one semester. A profile of the students, focussing on their motivation for their course selection and commitment to this course, was established. Their opinions on the usefulness of their classes, various resources, tutorial work and assignment work were sought. The needs and concerns of these students, highlighted in the surveys, are discussed and suggestions are made for the establishment of a special learning environment for failing students.
Motivating the Church-Turing thesis in the twenty-first century
Authors: Taylor R. Gregory
Published: July 2004

Theory of Computation students frequently fail to appreciate the significance of the Church---Turing Thesis for one of two reasons. First, there is a tendency, on the part of students, to regard Church---Turing as tautologous and, consequently, devoid of important content. Second, there is a contrary impulse to view Church---Turing as unmotivated or even implausible. We describe our experience using simulation software in an effort to combat these two tendencies.
Using the BURKS 2 CD-ROM in a principles of programming languages course
Authors: Van Scoy Frances L.
Published: July 2004

In this paper, we describe the use of the BURKS 2 CD-ROM in a principles of programming languages course. The CD-ROM contains compilers and documentation for many programming languages. The course described in this paper emphasises principles and paradigms of languages rather than the details of one or two specific languages.
Lessons from on-line programming examinations
Authors: Woit Denise M. , Mason David V.
Published: July 2004

We have been using a combination of conventional and on-line programming examinations for the past 3 years in our first year programming courses. We plan to continue using on-line components because of the positive feedback from both students and faculty. We describe the operational and pedagogical lessons we have learned, illustrating problems encountered and our solutions, in the hope that others considering on-line examinations may also benefit from our experiences.
A generic collaborative database—part of a strategy to internationalise the curriculum and develop teamwork and communication capabilities (poster)
Authors: Clear A. G.
Published: July 2004

This presentation reports on progress in using Groupware concepts, to assist collaborative learning across boundaries of time and space, to broaden the student learning experience and develop capabilities in the use of IT for cross cultural communication.
Designing Internet instructional environments (poster)
Authors: Cooper Peter A.
Published: July 2004

In the last 15 years, there has a sea change in technology-based instructional environments. Early and simple environments such as Hypercard stacks have given way to richer interactive instructional environments where the learner is relatively free to explore at her own pace and to construct meaningful conceptual schema within the context of that environment.Transferring these new and rich environments to the Internet pose significant problems among which are security, interactive communication, data storage and bandwidth.The purpose of this poster session is to present an example of how an instructional environment can be delivered via the World Wide Web. The purpose is to identify strategies for the deliver of instructional materials and environments over the Internet. In doing so, the author hopes to open the door to discussion and to the development of well-defined tools for instructional application development.
Pattern-based design recovery of Java software
Authors: Seemann Jochen , von Gudenberg Jürgen Wolff
Published: July 2004

In this paper we show how to recover design information from Java source code. We take a pattern-based approach and proceed in a step by step manner deriving several layers of increasing abstraction. A compiler collects information about inheritance hierarchies and method call relations. It also looks for particular source text patterns coming from naming conventions or programming guidelines.The result of the compile phase is a graph acting as the starting graph of a graph grammar that describes our design recovery process. We define criteria for the automatic detection of associations and aggregations between classes, as well as for some of the popular design patterns such as composite or strategy.
Systems reengineering patterns
Authors: Stevens Perdita , Pooley Rob
Published: July 2004

The reengineering of legacy systems --- by which we mean those that have value and yet "significantly resist modification and evolution to meet new and constantly changing business requirements" --- is widely recognised as one of the most significant challenges facing software engineers. The problem is widespread, affecting all kinds of organisations; serious, as failure to reengineer can hamper an organisation's attempts to remain competitive; and persistent, as there seems no reason to be confident that today's new systems are not also tomorrow's legacy systems.This paper argues1. that the main problem is not that the necessary expertise does not exist, but rather, that it is hard for software engineers to become expert;2. that the diversity of the problem domain poses problems for conventional methodological approaches;3. that an approach via
systems reengineering patterns
can help.We support our contention by means of some candidate patterns drawn from our own experience and published work on reengineering. We discuss the scope of the approach, how work in this area can proceed, and in particular how patterns may be identified and confirmed.
Event-based detection of concurrency
Authors: Cook Jonathan E. , Wolf Alexander L.
Published: July 2004

Understanding the behavior of a system is crucial in being able to modify, maintain, and improve the system. A particularly difficult aspect of some system behaviors is concurrency. While there are many techniques to specify intended concurrent behavior, there are few, if any, techniques to capture and model actual concurrent behavior. This paper presents a technique to discover patterns of concurrent behavior from traces of system events. The technique is based on a probabilistic analysis of the event traces. Using metrics for the number, frequency, and regularity of event occurrences, a determination is made of the likely concurrent behavior being manifested by the system. The technique is useful in a wide variety of software engineering tasks, including architecture discovery, reengineering, user interaction modeling, and software process improvement.
On-line change mechanisms
Authors: Stuurman Sylvia , van Katwijk Jan
Published: July 2004

Our interest in the field of software architecture is focused on the application in technical systems, such as control systems. Our current research in this field is centered around a real-life case study, a control system for unmanned vehicles transporting containers on the "Maasvlakte" , an area in the ports of Rotterdam.Important issues in this control system are scalability, evolvability, and on-line change capacities.In this paper, we discuss two mechanisms for on-line change in the distributed control system for the Maasvlakte system, which we have implemented in Java. The software architecture we use is a configuration of distributed processes, communicating according to the subscription model. We will focus on the software architectural aspects of the mechanisms for on-line change. One of these mechanisms is associated with the decoupling of processes as a result of the subscription-based communication model. The other mechanism is based on the late-binding properties of Java.
Toward a formal theory of extensible software
Authors: Krishnamurthi Shriram , Felleisen Matthias
Published: July 2004

As software projects continue to grow in scale and scope, it becomes important to reuse software. An important kind of reuse is
extensibility,
i.e., the extension of software without accessing existing code to edit or copy it. In this paper, we propose a rigorous, semantics-based definition of software extensibility. Then we illustrate the utility of our definitions by applying them to several programs. The examination shows how programming style affects extensibility and also drives the creation of a variant of an existing design pattern. We consider programs in both object-oriented and functional languages to prove the robustness of our definitions.
Further empirical studies of test effectiveness
Authors: Frankl Phyllis G. , Iakounenko Oleg
Published: July 2004

This paper reports on an empirical evaluation of the fault-detecting ability of two white-box software testing techniques: decision coverage (branch testing) and the all-uses data flow testing criterion. Each subject program was tested using a very large number of randomly generated test sets. For each test set, the extent to which it satisfied the given testing criterion was measured and it was determined whether or not the test set detected a program fault. These data were used to explore the relationship between the coverage achieved by test sets and the likelihood that they will detect a fault.Previous experiments of this nature have used relatively small subject programs and/or have used programs with seeded faults. In contrast, the subjects used here were eight versions of an antenna configuration program written for the European Space Agency, each consisting of over 10,000 lines of C code.For each of the subject programs studied, the likelihood of detecting a fault increased sharply as very high coverage levels were reached. Thus, this data supports the belief that these testing techniques can be more effective than random testing. However, the magnitudes of the increases were rather inconsistent and it was difficult to achieve high coverage levels.
Model checking of hierarchical state machines
Authors: Alur Rajeev , Yannakakis Mihalis
Published: July 2004

Model checking is emerging as a practical tool for detecting logical errors in early stages of system design. We investigate the model checking of hierarchical (nested) systems, i.e. finite state machines whose states themselves can be other machines. This nesting ability is common in various software design methodologies and is available in several commercial modeling tools. The straightforward way to analyze a hierarchical machine is to flatten it (thus, incurring an exponential blow up) and apply a model checking tool on the resulting ordinary FSM. We show that this flattening can be avoided. We develop algorithms for verifying linear time requirements whose complexity is polynomial in the size of the hierarchical machine. We address also the verification of branching time requirements and provide efficient algorithms and matching lower bounds.
Reasoning about implicit invocation
Authors: Garlan D. , Jha S. , Notkin D. , Dingel J.
Published: July 2004

Implicit invocation [SN92, GN91] has become an important architectural style for large-scale system design and evolution. This paper addresses the lack of specification and verification formalisms for such systems. Based on standard notions from process algebra and trace semantics, we define a formal computational model for implicit invocation. A verification methodology is presented that supports linear time temporal logic and compositional reasoning. First, the entire system is partioned into groups of components (methods) that behave independently. Then, local properties are proved for each of the groups. A precise description of the cause and the effect of an event supports this step. Using local correctness, independence of groups, and properties of the delivery of events, we infer the desired property of the overall system. Two detailed examples illustrate the use of our framework.
Proof linking
Authors: Fong Philip W. L. , Cameron Robert D.
Published: July 2004

Security flaws are routinely discovered in commercial implementations of mobile code systems such as the Java Virtual Machine (JVM). Typical architectures for such systems exhibit complex interdependencies between the loader, the verifier, and the linker, making them difficult to craft, validate, and maintain. This reveals a software engineering challenge that is common to all mobile code systems in which a static verification phase is introduced before dynamic linking. In such systems, one has to articulate how loading, verification, and linking interact with each other, and how the three processes should be organized to address various security issues.We propose a standard architecture for crafting mobile code verifiers, based on the concept of proof linking. This architecture modularizes the verification process and isolates the dependencies among the loader, verifier, and linker. We also formalize the process of proof linking and establish properties to which correct implementations must conform. As an example, we instantiate our architecture for the problem of Java bytecode verification and assess the correctness of this instantiation. Finally, we briefly discuss alternative mobile code verification architectures enabled by our modularization.
Virtual environments at work
Authors: Churchill Elizabeth F. , Bly Sara
Published: July 2004

In recent years much attention has been paid to network-based, distributed environments like text-based MUDs and MOOs for supporting collaborative work. Such environments offer a shared virtual world in which interactions can take place irrespective of the actual physical proximity or distance of interactants. Although these environments have proven successful within social, recreational and educational domains, few data have been reported concerning use of such systems in the workplace. In this paper we summarize in-depth interviews with 8 MUDders from a software research and development community where a MUD has been operational and actively used for a number of years. The interviews suggest that the MUD fills a valuable communication niche for this workgroup, being used both synchronously and asynchronously to enable the establishment of new contacts and the maintenance of existing contacts. These observations are discussed in the context of the organization under study.
Temporal workflow management in a claim handling system
Authors: Zhao J. Leon , Stohr Edward A.
Published: July 2004

Temporal workflow management is important for processes that are time-driven. Claim handling, which requires the documentation, diagnosis, and resolution of customer claims due to faulty products or unsatisfactory services, is an example of such a process because fast turnaround is critical for customer satisfaction. However, little research has been reported in this area, especially at the policy level. In this paper, we develop a framework for temporal workflow management, which includes issues such as turnaround time predication, time allocation, and task prioritization. We propose also the use of reward functions to guide workers' behavior with the goal of increasing efficiency while allowing flexibility.
Building a federation of process support systems
Authors: Estublier Jacky , Amiour Mahfound , Dami Samir
Published: July 2004

The effort in software process support has focused so far on modeling and enacting processes. A certain amount of work has been done, but little has reached a satisfactory level of maturity and acceptance. In our opinion, this is due to the difficulty for a system to accommodate the very numerous aspects involved in software processes. A complete process support should cover topics ranging from low level tasks (like compiling) to organizational and strategic tasks. This includes process enhancement, resource management and control, cooperative work, etc. The environment must also be convenient for software engineers, team leaders, managers and so on; it must be able to describe details for efficient execution, and be high level for capturing, understanding, etc. As a matter of fact, the few tools that have reached sufficient maturity have focussed on a single topic and addressed a single class of users.It is our claim that no single system can provide a satisfactory solution except in a clearly defined subdomain. Thus we shifted our attention from finding the universal system to finding ways to make many different systems cooperate with their associated formalisms and process engines.This paper presents a novel approach for software process support environments based on a federation of heterogeneous and autonomous components. The approach has been implemented and experimented in the APEL environment. It is shown which architecture and technology is involved, how it works, which interoperability paradigms have been used, which problems we have solved and which issues are still under study.
A graphical tool for the design and prototyping of distributed systems
Authors: Dähler J. , Gerber P. , Gisiger H.-P. , Kündig A.
Published: July 2004

This paper presents an approach of using modem graphical user interface techniques in the design and specification of complex distributed systems. A window-oriented and menu-driven net-editor and an integrated simulator with animation support have been implemented. This toolset is based on high-level Petri Nets, extended with an object-oriented paradigm and a hierarchical structuring facility. The flexibility and high level of abstraction support Rapid Prototyping.
The impact of campus-wide portable computing on computer science education
Authors: Laxer Cary , Nishida Tomohiro , Sherlock Helen , Thomas Stan J.
Published: July 2004

At least fifty colleges and universities throughout the world have initiated plans under which all students buy, lease, or provide their own portable/laptop computer. The impact of these initiatives on the general educational environment has been widely discussed; however, the impact on the delivery of computer science education has not been. In this working group report we discuss a number of issues pertaining to computer science education in light of campus-wide computing initiatives. Our report relates experiences of faculty already involved in such endeavors plus ideas regarding the future of portable computers in computer science education. As such, it will be beneficial to computer science programmes currently involved in campus-wide computing initiatives as well as those that may become involved in the near future.
Some reflections on software engineering research
Authors: Fuggetta Alfonso
Published: July 2004

The May and July issues of
ACM Software Engineering Notes
include three stimulating and thought-provoking papers, two by David Lorge Parnas and one by David Notkin. The papers discuss the nature of software engineering research and identify problems and issues that the community is facing. After reading them, I felt compelled to assess the research I have been doing during the past years. These notes are just an attempt to organize and structure in a written form the impressions and concerns that I have derived from this reflection. I hope they can be useful to continue and deepen the discussion on the subject.To anticipate some possible negative reactions to these notes, I admit up front that my comments might appear biased, harsh, and perhaps too pessimistic.
Please consider them first and foremost as a sincere critique of myself.
I do believe that the only way to solve problems is to address them without any fear or ambiguity. Ignoring or avoiding problems would just mean that we do not have the ability or the courage to solve them.
Multiple downcasting techniques
Authors: P. Puppydog P. O. , Raccoon L. B. S.
Published: July 2004

In this paper, we describe and compare techniques that implement multiple downcasting in strongly-typed languages. We conclude that multimethods stand out as the single best technique. In the first section, we describe seven commonly used techniques. In the second section, we compare these seven techniques using ten criteria. And, in the third section, we comment on some additional techniques.Multiple downcasting occurs so often that developers use a variety of terms to describe it, and a variety of language constructs and patterns to implement it. "Feed the animals," "driver-vehicle," and "parallel hierarchies" are well-known examples that require multiple downcasting. "Multiple type dispatch" and "covariant subclassing" identify different facets of multiple downcasting. "Dynamic type casting," "typecase statements," and the "visitor pattern" are frequently used to implement multiple downcasting. We believe that multiple downcasting is not a mistake or the result of poor program design, rather multiple downcasting is a specific technique that implements a specific kind of application semantics.In the animal hierarchy shown in Figure 1, cows eat grass, wolves eat meat, and in the superclass, animals eat food. The generalization that animals eat food is imprecise: it ignores the facts that cows only eat grass and wolves only eat meat. So, how should developers write a function to safely "feed the animals" without getting the types mixed up? In Program 1, we show how a developer might like to "feed the animals" in C++. The feed_unsafely function may fail, while the feed_safely function works properly for all combinations of foods and animals. The animal hierarchy will not compile in C++, because the eat method is covariant.In this paper, we elaborate ideas and examples from A Middle-Out Concept of Hierarchy. We adapted the "feed the animals" example from Are Cows Animals? by Shang.
Extending use cases throughout the software lifecycle
Authors: Kirner D. , Porter R. , Punniamoorthy P. , Schuh M. , Shoup D. , Tindall S. , Umphress D.
Published: July 2004

The relevance of
use cases
throughout the software development life cycle is considered in the context of an actual project. Extensions, called
behavior case
and
test cases
are proposed to address design and testing activities.
Entity-relationship diagrams and English: an analysis of some problems encountered in a database design course
Authors: Wilson Judith D.
Published: July 2004

The simplicity and clarity of the entity-relationship approach recommends its use as a tool for teaching database design. Nonetheless, the approach does not appear to be problem-free. Analysis of student entity-relationship diagrams for two database design projects reveals a tendency students have to model English sentences and to use English syntax to guide the modeling process. The paper discusses why this may be the case, and how it may be avoided.
A project centered programming language course
Authors: Trenary Robert
Published: July 2004

A programming language course is difficult to organize because of the diversity of languages and concepts discussed. A Lisp-based project described here provides a unifying context within which to demonstrate programming language features such as data abstraction, packages, and overloading. This approach has proven to be a successful strategy in organizing a programming language course.
Advanced placement-plus in computer science: a summer institute at the University of Tulsa
Authors: Wainwright Roger L. , Schoenefeld Dale A.
Published: July 2004

In this paper we discuss an in-service course designed to give secondary school teachers the background needed to teach an Advanced Placement (AP) course in Computer Science. In order to do this effectively, we argue that additional computer literacy and computer system concepts must be developed as well (PLUS). We present the (AP) course outline and objectives as well as the outline and objectives for some additional computing skills.
Assessing the quality of programs: a topic for the CS2 course
Authors: Sanders Dean , Hartman Janet
Published: July 2004

Measuring the quality of programs is commonly discussed at widespread intervals in the computer science curriculum. Because discussions of quality are fragmented, the students do not develop a set of criteria by which they can evaluate the quality of a program. Since an assessment of quality must depend on the specifications that are set forth before the programming begins, it is important for students to be aware of the various criteria by which a program can be evaluated. Various measures of quality can be introduced in the CS2 course. These include evaluating the utilization of resources by a program, evaluating the correctness of the program and examining various human factors associated with program development and maintenance. Students should be provided with activities which allow them to explore and practice using thecriteria for evaluation in each context. Ultimately the development of skills in evaluating program quality will make students more effective programmers.
Introducing object-oriented programming into the computer science curriculum
Authors: Pugh John R. , LaLonde Wilf R. , Thomas David A.
Published: July 2004

In recent years, object-oriented programming languages and object-oriented program design have become increasingly popular. Dialects of many popular programming languages are now available which support the major concepts of object-oriented programming; namely message-passing, classes, generic operations and inheritance. Experience in the paradigm is increasingly supporting the view that object-oriented programming may be to the 80's what structured programming was to the 70's in terms of its influence on software development.

After reviewing the notions of object-oriented programming, we describe our experiences in introducing the object-oriented paradigm into the Computer Science curriculum. The impact was felt in four courses dealing with data types and data structures, programming languages, software engineering, and compiler construction. In addition, we describe the use of the Smalltalk environment in advanced course and project work. We chronicle our experiences in the expectation that they will be of benefit to other educators considering adopting the object-oriented paradigm. Finally, we review the potential benefits of introducing object-oriented programming into the computer science curriculum.
Using emulators as vehicles for instruction in systems programming: prospective consideration
Authors: Olagunju Amos O. , Borders Elvis
Published: July 2004

Microprogramming is a technique for implementing machine language instruction sets —it is critical in today's computer architectures and operating systems. An emulator is a set of microprograms that implements the architecture of one machine on another; microprogramming is often used in emulation to make one computer system appear as if it were another. This paper presents the architecture for a microprogrammed computer system, the VSEM. The simulated virtual computer system, its monitor and a simulated concurrent PASCAL are discussed. The usefulness of the VSEM, its monitor and the concurrent PASCAL as vehicles for instruction in systems programming is addressed.
Retraining high school teachers to teach computer science—observations on the first course
Authors: Epstein Richard G. , Aiken Robert M. , Snelbecker Glenn , Potosky Jane
Published: July 2004

This paper discusses the authors' experience in teaching the first of four courses which comprise a sequence of courses especially constructed to retrain junior and senior high school teachers to teach Computer Science. A description of the goals of the project and details about this first course serve as a springboard for discussing how the objectives were met. Also included is a brief analysis of how teachers with various backgrounds fared and some suggestions for others desiring to teach a similar course.
Modern introductory computer science
Authors: Henderson Peter
Published: July 2004

There have been numerous testimonies to the inadequacies of our educational system [83]. For undergraduate computer science educators, major concerns regarding student preparation include poor problem solving and critical thinking skills, weak mathematics background, an inability to convey thoughts and concepts, and a lack of motivation. These problems can be addressed in the introductory computer science course by developing an integrated approach to effectively teaching discrete mathematical foundations, fundamental computer science concepts, and problem-solving skills. This paper is conceptual in nature and introduces some specific examples of possible approaches to overcoming these deficiencies and problems.
Concurrent programming in Modula-2
Authors: Brumfield Jeffrey
Published: July 2004

This paper describes a concurrent process manager that has been developed for the Modula-2 programming language. Using this software, students can gain practical experience in designing and implementing concurrent programs using processes, semaphores, and message links. The use of abstraction in describing the process manager is advocated, and a variety of concurrent programming exercises are presented.

This paper describes a concurrent process manager that has been developed for the Modula-2 programming language. Using this software, students can gain practical experience in designing and implementing concurrent programs using processes, semaphores, and message links. The use of abstraction in describing the process manager is advocated, and a variety of concurrent programming exercises are presented.
Graphos: a graphic operating system
Authors: Cañas Daniel A.
Published: July 2004

To fully understand the conceptual principles behind operating systems it must be possible to 'see' what is happening inside the system as the execution of a task progresses. A graphic representation of information flow would give a clear picture of what is happening inside an operating system at every moment. Currently there are no tools which help visualize the flow of information as a task executes. GraphOS is a teaching tool that presents to the student a graphic representation of information flow inside an operating system. This paper discusses GraphOS and the advantages of using the system as a complement to the lectures in an operating systems course.
Operating system projects on two simulated machines
Authors: Wolfe James L.
Published: July 2004

Descriptions of the capabilities, implementation, and pedagogic worth of operating system projects based on two simulated machines are presented. One machine requires a batch-oriented operating system, involving a complete spooling system and multiprogramming. The other machine requires a terminal-oriented operating system that handles a command language and performs simple file operations. The simulators perform the actions of a real machine, monitor the operating system's performance as it handles simulated workloads, generate reports on the quality and quantity of service provided by the students' systems, and help the students debug their programs by providing traces and dumps on request.
Recommendations for software engineering education
Authors: Carver Doris L.
Published: July 2004

The increasing emphasis on software engineering in the computer science curricula directly correlates with the expansion of the area of software engineering. The increased occurrence of software engineering courses has produced significant discrepancies in the content of the courses at the undergraduate level. These discrepancies have percipitated the need for recommendations for the inclusion of software engineering in the curriculum. The recommendations presented in this paper include both the integration of software engineering principles throughout the undergraduate curriculum and the content of a separate software engineering course. The recommendations for course content are based on a survey of the contents of recently published software engineering textbooks.
Augmenting a software engineering projects course with oral and written communication
Authors: Meinke John G.
Published: July 2004

The institutional philosophy and educational goals determine the computing needs for any college. The philosophy and goals are also affected by various factors such as size and type of institution, geographic setting, community resources and background of the student body.
A course on “expert systems” for electrical engineering students
Authors: Witten Ian H.
Published: July 2004

A final-year undergraduate course on Expert Systems, designed for Electrical Engineering students, is described. To cater for this audience the course has a highly practical nature, despite the students' lack of relevant prerequisites in Computer Science. This is achieved by emphasizing logic programming throughout to illustrate all concepts taught; weekly, scheduled laboratory sessions; and a carefully-graded series of assignments.

We have demonstrated that bright engineering students can get to grips with practical issues in applied artificial intelligence through a short, intensive, course — starting from ground level. PROLOG was found invaluable as a pedagogical tool, as was the highly-structured engineering-style laboratory. Informal feedback indicates that the course has achieved its objectives and indeed exceeded expectations.
Tiling and recursion
Authors: Chu I-Ping , Johnsonbaugh Richard
Published: July 2004

A tiling problem is presented that demonstrates the power of recursion in the design of algorithms. When implemented as a program, the solution can be shown using a computer graphics display.
Visual simulations of data structures during lecture
Authors: Barnes G. Michael , Kind Gary A.
Published: July 2004

A microcomputer based software package for the graphic simulation of fundamental binary search tree algorithms is presented. This application was developed to augment instructional aids available to the instructor during classroom lecture. The system is mouse controlled and was designed to be used on an IBM PC compatible microcomputer connected to either a large screen video monitor or a projection display. Several screen dumps are presented to illustrate the multi-level graphical representation of trees, pseudocode algorithms, and window environment incorporated in the package. In addition, the literature on CAI oriented simulations for Computer Science topics, with a focus on data structures, is reviewed briefly.

Computer Aided Instruction (CAI) is an educational application area with tremendous potential. The recent advent of reasonably priced personal computers with medium resolution color graphic capabilities will hopefully increase the generation of CAI materials in all fields. Ironically, there has been little CAI material developed to aid in the instruction of Computer Science. Furthermore, earlier efforts at courseware development for computer science was centered on programming languages not more advanced topics. In recent years, however, several researchers have been developing personal computer based courseware simulations of more advanced topics: program execution [2,6,21,16], computer architecture [15,17], and data structures algorithms.

This work is part of a growing body of research being performed in the emerging area of Visual Programming [11,10]. In this paper we will first briefly review the area of graphic simulations of fundamental data structures and their algorithms. Second, we will describe the CABTO (Computer Animation of Binary Tree Operations) package. We developed CABTO to be used as a lecture aid in a lower division data structures course.
File processing and the undergraduate computer science curriculum
Authors: Malmrose Kirk L. , Burton Robert P.
Published: July 2004

In March of 1979, the Curriculum Committee on Computer Science (C
3
S) of the Association for Computing Machinery (ACM) proposed recommendations for the undergraduate curriculum in computer science: “Curriculum '78.” “Curriculum '78” includes CS 5, “Introduction to File Processing,” as an undergraduate core requirement. Seven years after “Curriculum '78,” findings show that more than 70% of universities offering undergraduate degrees in computer science do not require a course similar to CS 5. The controversial role of CS 5 in the undergraduate computer science curriculum id discussed.
Trees—a CS2 programming project which introduces a data type using procedural and data abstraction
Authors: Liss Ivan B. , McMillan Thomas C.
Published: July 2004

This paper describes a programming project used in CS2 classes to introduce trees as an abstract data type. The student is required to manipulate tree structures with a set of primitive functions supplied by the instructor. The student does not have access to the implementation details of these primitive functions, and is initially required to complete a series of exercises in which trees are handled abstractly. After completing this phase of the assignment, the student is required to write his or her own implementation of the primitive functions originally supplied. These are written in two different phases, one using dynamic storage, and the other using static storage. This emphasizes the concept of trees as an abstract data type, as well as the benefits of abstraction and information hiding.
Using Ada on microcomputers in the undergraduate curriculum
Authors: Owen G. Scott
Published: July 2004

Currently, many Computer Science Departments are considering the use of a language other than Pascal either for an entire Computer Science curriculum, or at least for some courses, such as data structures. At Georgia State University, where our program is primarily based on IBM PC compatible microcomputers, we have converted our data structures course from Pascal to Ada, and use Ada in several other courses. In this paper I will discuss the rationale behind our choice and our experience with using Ada on microcomputers.
Extra-disciplinary curriculum: analysis of the presentation of legal materials to computer science students
Authors: Rigler Joseph W.
Published: July 2004

An experimental course entitled Computers and the Law was offered to graduating Computer Science seniors at the University of Missouri-Rolla. This paper briefly reviews the purposes, content, and organization of the course; and presents the author's views on the results of the course and his suggestions for subsequent offerings.
A computer science/mathematics major for liberal arts colleges
Authors: Hagelhans Nancy L.
Published: July 2004

The concepts of the model curriculum for computer science in a liberal arts college [3] and a traditional mathematics major are combined to form a computer science/mathematics major. This major is particularly suited to the mathematics faculty retrained in computer science, and it provides the students with strong preparation for graduate study or employment in computer science. The major's requirements include six computer science courses (the model's introductory and core courses), six mathematics courses, one advanced computer science elective and a year of introductory physics.
Laboratories for an undergraduate course in data communications and networks
Authors: Greenfield Robert H. , Parr John H.
Published: July 2004

An undergraduate course in data communications and networks has been offered at the University of Regina. We have developed a series of laboratory exercises to accompany this course [1, 2]. These labs originally focused on the Stallings text [3]. They have been expanded and redesigned to complement Tanenbaum's text [4] and to take advantage of the facilities at the University of Regina.
An application to support a course in numerical analysis
Authors: Temte Mark
Published: July 2004

An original numerical method is presented which is suitable for use in a course in numerical analysis. It combines numerical differentiation with numerical integration to extend the solution of a particular kind of partial differential equation throughout a rectangular grid. An implementation of the method together with a friendly user interface is available from the author for instructional use.
Defining ethical and unethical student behaviors using departmental regulations and sanctions
Authors: Cook Janet M.
Published: July 2004

College students do not automatically possess basic standards of acceptable and unacceptable behavior with regard to computer hardware, software, and data sets. For their sake and our own we need to spell out what is expected of them.

Universities like mine have stated that students cannot be penalized or dismissed for theft or for damage to equipment/software/records unless they have received a copy of a written policy describing proscribed activities and their penalties.

This paper includes two sample policies. One considers only the use of software in microcomputer laboratories. The other covers mainframe, minicomputer and microcomputer facilities, use of resources in a chargeback system, penalties for plagiarism and illegal copying of software, and individual responsibilities with regard to group projects.
An updated information systems curriculum: first revision
Authors: Laurido-Santos Osvaldo
Published: July 2004

Our original proposal for “An Updated Information Systems Curriculus” was presented on March 15, 1985 at the ACM SIGCSE Symposium (2). This paper presents our first revision of the original proposal. It includes two new courses and a redistribution of some of the topics covered on some courses.
Spreadsheets and databases—alternatives to programming for non-computer science majors
Authors: Bailey M. Gene
Published: July 2004

Microcomputers have become easier and easier to use an emphasis is placed on software design for users with little or no experience. With a minimal amount of training, students or employees can become productive. Yet, academic programs still teach programming as a fundamental part of computer literacy. This paper proposes that the programming portion of the class be eliminated and replaced with a study of spreadsheets and databases. The paper discusses the manner in which spreadsheet and database design can be approached to maximize learning.

An important concept that is learned in any programming class is algorithm development. Students learn how to analyze the problem and to set up the step-by-step solution. This process must be done before any coding can begin. Spreadsheets offer the same type of learning and are much more appropriate for non-computer science majors. Students must formulate the problem, determine the equations and formulas necessary to solve it, and then set up the worksheet. Spreadsheet applications are found in every discipline and their design requires a minimal amount of computer knowledge and mathematics.

Learning to set up a database and design the queries necessary to obtain information from the database is a concept important to computer literacy. Once again, students learn to “program” by learning to construct their questions in a manner that is meaningful to the software package.
Beyond traditional computer literacy
Authors: Dyck V. Arnie , Black James P. , Fenton Shirley L.
Published: July 2004

A new approach to computer literacy is emerging, an approach that de-emphasizes the traditional overview of hardware and software and minimizes the teaching of traditional programming methodology. This paper describes the design and implementation of a literacy course intended to develop effective users of common applications software, including word processing, spreadsheets, graphics and database management. The paper continues by demonstrating how many academic computer science concepts can be effectively introduced using this approach.
A Monte Carlo comparison of the binary and interpolation search algorithms
Authors: Archer Clark B.
Published: July 2004

This paper provides performance comparisons of the traditional binary search and the interpolation search for nearly uniformly distributed ordered arrays of keys. The algorithms for the search routines are given along with performance statistics.
Components and generative programming (invited paper)
Authors: Czarnecki Krzysztof , Eisenecker Ulrich W.
Published: July 2004

This paper is about a paradigm shift from the current practice of manually searching for and adapting components and their manual assembly to Generative Programming, which is the automatic selection and assembly of components on demand. First, we argue that the current OO technology does not support reuse and configurability in an effective way. Then we show how a system family approach can aid in defining reusable components. Finally, we describe how automate the assembly of components based on configuration knowledge. We compare this paradigm shift to the introduction of interchangeable parts and automated assembly lines in the automobile industry.

We also illustrate the steps necessary to develop a product line using a simple example of a car product line. We present the feature model of the product line, develop a layered architecture for it, and automate the assembly of the components using a generator. We also discuss some design issues, applicability of the approach, and future development.
Robots
Authors: Gafni Vered
Published: July 2004

This paper presents an architectural style for real-time systems, and an associated formal architectural description language, called Robots. A basic specification in Robots consists of a synchronous control task that is responsible for the dynamic reconfiguration of the system controller as a set of asynchronous
observer
and
process
tasks. The controller architecture evolves by hierarchical refinement of observers and processes into lower level control tasks each dominating a new set of observers and processes. Robots is given operational semantics by statecharts. Also, the architectural style is embedded in Robots by semantic rules that allow formal checking of the consistency and completeness of architectural specifications.
A probabilistic model for software projects
Authors: Padberg Frank
Published: July 2004

A probabilistic model for software development projects is constructed. The model can be applied to compute an estimate for the development time of a project. The chances of succeeding with a given amount of time and the risk of deviating from the estimate can be computed as well. Examples show that the model behaves as expected when the input data are changed.
Designing specification languages for process control systems
Authors: Leveson Nancy G. , Heimdahl Mats P. E. , Reese Jon Damon
Published: July 2004

Previously, we defined a blackbox formal system modeling language called RSML (Requirements State Machine Language). The language was developed over several years while specifying the system requirements for a collision avoidance system for commercial passenger aircraft. During the language development, we received continual feedback and evaluation by FAA employees and industry representatives, which helped us to produce a specification language that is easily learned and used by application experts.

Since the completion of the RSML project, we have continued our research on specification languages. This research is part of a larger effort to investigate the more general problem of providing tools to assist in developing embedded systems. Our latest experimental toolset is called SpecTRM (Specification Tools and Requirements Methodology), and the formal specification language is SpecTRM-RL (SpecTRM Requirements Language).

This paper describes what we have learned from our use of RSML and how those lessons were applied to the design of SpecTRM-RL. We discuss our goals for SpecTRM-RL and the design features that support each of these goals.