bluuebunny/crossref_metadata_2025 huggingface dataset:
Language-Dependent performance of design patterns
Authors: Billard Edward A.
Published: July 2004

The Gang of Four design patterns represent a catalog of 23 reusable design solutions to classes of problems that arise in a variety of applications. This study examines the execution performance of the patterns, as implemented in C++, Java (native and JDK 1.0 through 1.4), Smalltalk, and Perl 5.0. Each pattern is implemented independent of an application and, hence, represents just the pure object structure. Because the patterns themselves demonstrate a variety of structures, the results represent a good benchmark for how well the object-oriented compilers actually handle object-oriented programming, in particular, object creation and object reference to methods/attributes. The results indicate that the C++ compiler provided the fastest code, Java was second, followed by Smalltalk, and then Perl. However, Java 1.2 and 1.4 held their own against the optimized version of C++ and even did slightly better than non-optimized C++. Optimized C++ code was the best in 11 of the 23 patterns, with Java 1.2 and 1.4 sharing the remaining honors for the other 12 patterns, that is, a "winning" Java compiler can be found for just over half of the design patterns. Smalltalk was an order of magnitude, and Perl two orders of magnitude, slower. Although there is a wide variety of performance among the design patterns, the overall averages are much in-line with the averages of four simple test programs. The results may provide guidelines for future application development.
Using theoretical computer simulators for formal languages and automata theory
Authors: Chesñevar Carlos I. , Cobo María L. , Yurcik William
Published: July 2004

Both formal languages and automata theory (FLAT) are core to the CS curricula but are difficult to teach and to learn. This situation has motivated the development of a number of
theoretical computer simulators
as educational tools to allow students to "bring to life" many topics that traditionally were presented only mathematically. This paper discusses the main features of software tools currently freely available via the Internet for teaching FLAT. Based on our practical experience, the tradeoffs between different FLAT software tools is analyzed and discussed. We conclude with general recommendations for integrating FLAT software tools into an established curriculum.
Application of computer science ideas to the presentation of mathematical theorems and proofs
Authors: Hazzan Orit
Published: July 2004

Based on the analogy between mathematical proofs and computer programs this paper illustrates how it is possible to apply methodologies from computer science, used in the development and presentation of computer programs, for the presentation of mathematical theorems and proofs. The following three methodologies are discussed: stepwise refinement, abstraction, and program verification.
Do the arithmetic operations really execute in constant time?
Authors: Chaudhuri Ranjan
Published: July 2004

The paper emphasizes the need for exposing the undergraduate computer science students to the bit-level analysis of the run-times of certain computer algorithms. These are algorithms where the input(s) consist of one or more integers and only a bit-level analysis yields a more realistic estimate of the run-time behaviors of such algorithms.
Design issues in the visual era
Authors: Moses Louise E.
Published: July 2004

In art, "Design is composition. A design consists of parts arranged into a coherent whole." In computer science, "The design lays out the classes and objects needed in a program and defines how they interact." Are we not saying that software design is parts (classes and objects) arranged into a coherent whole? The paper looks at design principles as expressed in beginning courses in these two seemingly disparate disciplines. The majority of the paper is concerned with the presentation of a minimal working vocabulary for visual design issues. It concludes with some observations about the worldviews from computer science and from art, and the importance of making students aware of the worldview of the typical user of their products.
Globalization and the computing curriculum
Authors: Gabbert Paula
Published: July 2004

One of the guiding principles of
Computing Curriculum 2001
was to ensure that the computing curriculum was international in scope. This article provides a model for achieving this objective by identifying globalization issues that are relevant to computer science. The underlying premise of the model is that technology has enabled globalization while globalization drives technology. The article also proposes three implementation models for integrating the material into the curriculum.
Predictors for success in a discrete math course
Authors: Jamba-Joyner Lisa , Klostermeyer William F.
Published: July 2004

Several factors, including grade-point average, math SAT scores, performance in calculus and programming courses, and results from a short pre-test were used in an effort to predict student grades a discrete mathematics course offered to computing science students. Two factors, SAT and average programming grade, were found to be significantly associated with the final grade for the discrete math course. Additionally, performance in the discrete math course was positively correlated with performance in the automata course required for computer science students.
A comprehensive CMPS II semester project
Authors: White Kent
Published: July 2004

The goal of this project was to help students tie together the various concepts learned throughout the Computer Science II class. The students were required to use abstract classes for matrices and singly linked list and provide a graphical solution to a maze solver. The first step of the project had the students construct a solution for a given maze. The solution was kept simple by using the right hand rule for solving mazes: always keep your right hand on a wall and you will find a solution if it exists. After the students had solved the problem of creating a solution the next part of the project required them to create an actual random maze. Using a matrix and a stack, the students kept track of the path of a random solution. After a solution path was generated the program was required to generate a number of dead-ends. This project was very challenging for the students. They enjoyed completing it partially because it was graphical in nature and they could visualize their solution.
Enabling XML storage from Java applets in a GUI programming course
Authors: Heines Jesse M.
Published: July 2004

XML, the Extensible Markup Language, is widely used in graphical user interface (GUI) programming today to both specify user interfaces and to hold the data displayed in visual components. It is relatively straightforward for Java applets to read and process XML documents over the Web, but security restrictions make it complex to store those documents back on the server after they have been modified. This paper describes a set of cooperating programs and their underlying algorithms that allow Java applets to read XML documents from - and, more importantly, to store those documents back to - a Java-enabled Web server. The author uses this approach in a GUI programming course to provide students who implement their projects as Java applets with the ability to use the full power of XML and its related technologies.
'Laurel and Hardy' model for analyzing process synchronization algorithms and primitives
Authors: Acharya Mithun , Funderlic Robert
Published: July 2004

The initial software solutions to solve the Process Synchronization problems, which ultimately led to the use of Semaphores are usually hard for a beginner to understand and appreciate. The reason is that one has to do lots of book keeping in tracing these algorithms, which involve multiple processes and variable instances. In order to prove the correctness of any synchronization problem, it has to be tested over the Critical Section conditions which again might be a tough exercise. In this paper we propose a model called "Laurel and Hardy" to understand and prove the (in)completeness of the software solutions to the Process Synchronization problem. A series of dramas is enacted between the two comedians Laurel and Hardy which makes understanding of synchronization problem solutions and testing it over Critical Section conditions very simple. We attempt to convince the readers that Laurel and Hardy model can be used as a potential tool for the analysis of any synchronization algorithms and also in assessing the (in)completeness of it. In addition, Laurel and Hardy model can be used as a teaching aid in beginner's Operating System course.
Comments considered harmful
Authors: Mason John
Published: July 2004

Many beginning computer science students are reluctant to comment their work. They see comments as a waste of time at best. This paper examines how this attitude arises and presents some strategies to change this attitude before it's too late.
Panel on the development, maintenance, and use of course web sites
Authors: Heines Jesse , Börner Katy , Ivory Melody Y. , Gehringer Edward F.
Published: July 2004

Course Web sites are fast becoming standard features of college courses. Some students expect all their courses to have such sites, just like they expect them to have syllabi. Course Web sites help professors communicate with students and students communicate with each other. They might summarize lectures, present assignments, serve as repositories of examples developed by students as well as the professor, and provide links to additional related information on the Web.This panel will discuss various aspects of course Web sites, focusing on their development, maintenance, and use. We will share experiences by presenting examples, highlighting successes and failures, and describing our hopes and concerns for the future. The panel will welcome comments from those in the audience with similar and even contradictory experiences. Our intention is to broaden participants' thinking on the implementation and use of course Web sites and spawn insights that might lead to more effective use of this important course component.
Constructive and collaborative learning of algorithms
Authors: Hübscher-Younger Teresa , Narayanan N. Hari
Published: July 2004

This research began by investigating the literature on student learning from algorithm animations and conducting experimental studies of an algorithm visualization system. The results led us to develop CAROUSEL (Collaborative Algorithm Representations Of Undergraduates for Self-Enhanced Learning), using which students created expository representations of algorithms, shared their representations with others, evaluated each other's representations and discussed them. The system and the activities of representation creation, sharing, evaluation and discussion that it supports were then studied in three experiments, which are summarized. They show a significant positive relationship between these constructive and collaborative activities and algorithm learning, which suggests that this is a beneficial pedagogical approach for introductory courses on algorithms.
Using UML class diagrams for a comparative analysis of relational, object-oriented, and object-relational database mappings
Authors: Urban Susan D. , Dietrich Suzanne W.
Published: July 2004

This paper illustrates the manner in which UML can be used to study mappings to different types of database systems. After introducing UML through a comparison to the EER model, UML diagrams are used to teach different approaches for mapping conceptual designs to the relational model. As we cover object-oriented and object-relational database systems, different features of UML are used over the same enterprise example to help students understand mapping alternatives for each model. Students are required to compare and contrast the mappings in each model as part of the learning process. For object-oriented and object-relational database systems, we address mappings to the ODMG and SQL99 standards in addition to specific commercial implementations.
Five easy but effective assessment methods
Authors: Blandford Dick K. , Hwang Deborah J.
Published: July 2004

Assessment of ABET/CAC accredited programs can become a burdensome task that generates lots of paper, takes hours of faculty time, and produces little in the way of meaningful results that can be used as a basis for improving a program. The result is often lack of active participation by faculty and an increase in negative attitudes that tend to further erode assessment effectiveness. This is a serious problem at small schools that cannot afford the luxury of full time assessment personnel and are totally dependent on faculty for the assessment process. This paper presents five assessment methods that require a minimum of paper-work and faculty time but are nevertheless effective in presenting an accurate assessment of a program's objectives. The five methods presented are: 1. the Assessment Day concept; 2. personal class assessment; 3. sampled student work; 4. faculty interview groups; and 5. student focus groups.
The game of go
Authors: Huang Timothy
Published: July 2004

In this paper, we discuss how Go, a strategy game widely played in Asia and other parts of the world, provides a rich, challenging environment for capstone and undergraduate research projects. We first describe the game itself and the characteristics that make it appropriate for more advanced undergraduate projects. We then discuss several projects that our students have pursued over the last three years, and we share observations that may be helpful to other computer science educators.
Laptops in the classroom
Authors: Campbell Andrea Beth , Pargas Roy P.
Published: July 2004

This paper focuses on a rapidly growing population on many college and university campuses today: students equipped with laptop computers capable of wireless connection to the Internet. More and more departments are requiring that students enrolling in certain courses bring laptop computers to class. The course instructor is sometimes overwhelmed by the prospect, asking "How should I change my lesson plan in order to integrate the laptop in my daily lecture?" This paper first describes the effort to bring the laptop to campus at a number of colleges and universities around the country. It then offers concrete suggestions based on the experiences of several professors who either have taught, or are now teaching, laptop-required courses. The paper concludes with a summary and a look toward the future.
Faculty turnover in CS departments
Authors: Cohoon J McGrath , Shwalb Rebecca , Chen Lih-Yuan
Published: July 2004

The rapid growth of computer science in both academia and industry creates a special problem with faculty turnover. This paper examines data from a national study of computer science departments to describe the circumstances surrounding faculty turnover in computer science and identify the major factors related to faculty departure. It concludes with suggested approaches for addressing the situation.
An introductory course in network administration
Authors: Cigas John
Published: July 2004

This paper describes a sophomore/junior-level laboratory course on network administration. The course aims to introduce networking concepts while emphasizing observation and measurement of network traffic. It utilizes an isolated laboratory of PCs running Linux along with numerous hubs, switches, and routers that can be rewired into multiple configurations. Being isolated from the campus network allows students complete administrative access without compromising campus security. Groups of students assemble their own LAN, attach it to the lab's "internet" backbone via a router, and then provide numerous common services like HTTP, DNS, and remote access to the rest of the lab. Once the room has a functioning internet, students examine various issues like encryption with TLS and ssh, as well as caching and load issues in retrieving different types of data from a web server. This paper covers the goals of the course, the laboratory setup, the exercises used in the course, and our experiences teaching the course.
The effectiveness of simulation in a hybrid and on-line networking course
Authors: Cameron Brian H. , Wijekumar Kay
Published: July 2004

Simulations are an important part of many traditional classes in Computer Networking. As web-based learning environments grow in popularity the need for simulations has become pronounced. This paper reports on a study to compare the performance of students enrolled in two web-based learning environments, one with a simulation package and the second with graphics and text only. Analysis shows statistically significant improvements in performance in the simulation group compared to the other group.
Using Java to teach networking concepts with a programmable network sniffer
Authors: Jipping Michael J. , Bugaj Agata , Mihalkova Liliyana , Porter Donald E.
Published: July 2004

A crucial part of the Networking course is the examination of and experimentation with network traffic data. Most standalone network traffic sniffers are quite expensive and those freely available on general purpose platforms (e.g., Linux or Windows) are quite cryptic. Because of this, we have developed NetSpy: a Java-based network sniffer that allows plug-in Java modules to analyze network data. These modules are written by students as part of their experimentation with traffic data. This paper describes the NetSpy system and the way we use this in Networking class.
Introductory programming, criterion-referencing, and bloom
Authors: Lister Raymond , Leaney John
Published: July 2004

In the traditional norm-referencing approach to grading, all students in a CS1 class attempt the same programming tasks, and those attempts are graded "to a curve". The danger is that such tasks are aimed at a hypothetical average student. Weaker students can do little of these tasks, and learn little. Meanwhile, these tasks do not stretch the stronger students, so they too are denied an opportunity to learn. Our solution is two-fold. First, we use a criterion-referenced approach, where fundamentally different tasks are set, according to the ability of the students. Second, the differences in the nature of the tasks reflect the differing levels of Bloom's taxonomy. Weaker CS1 students are simply required to demonstrate knowledge and comprehension; the ability to read and understand programs. Middling students attempt traditional tasks, while the stronger students are set open-ended tasks at the synthesis and evaluation levels.
A preliminary empirical evaluation of the effectiveness of a finite state automaton animator
Authors: Grinder Michael T.
Published: July 2004

The FSA Simulator is a Java program created to allow computer science students to work and experiment with finite state automata (FSAs). One of its unique features is the ability to compare the languages of two FSAs. This FSA comparison feature lets the software give students feedback about the accuracy of their work as they do exercises, guiding them toward a correct solution. This paper discusses some preliminary experiments performed to determine the effect of this feedback mechanism on students' learning. Two experimental labs were conducted, the results of which suggest that this feature improved students' success rate when doing exercises, but did not appear to significantly improve the students' performance when the comparison feature was not available.
Exploring security vulnerabilities by exploiting buffer overflow using the MIPS ISA
Authors: Phillips Andrew T. , Tan Jack S.E.
Published: July 2004

By exploiting a well known security vulnerability in many C library implementations, it is possible for an unprivileged user to gain unrestricted system privileges. With an understanding of how the process execution stack is allocated and managed during process execution, a user can override the return address of a C library routine and thereby resume execution at a different address where a set of malicious functions can be invoked [1]. This is known as the buffer overflow exploit. With buffer overflow as the underlying theme, an example will be described using C and the MIPS assembly language that simultaneously exposes students to issues in computer security, operating systems concepts such as memory management and function invocation/return, and the MIPS instruction set architecture.
A framework approach to teaching data structures
Authors: Tenenberg Josh
Published: July 2004

This paper advocates the incorporation of object oriented framework libraries such as the Standard Template Library (STL) into the first data structures course at the university level. This represents a shift from learning the details of each data structure to an increased emphasis on the use, integration, and extension of these existing frameworks, as well as on the learning of higher-order design and engineering skills.
Using scientific data to teach a database systems course
Authors: Wagner Paul J. , Shoop Elizabeth , Carlis John V.
Published: July 2004

Database systems instructors face an ongoing challenge to develop meaningful assignments for their courses. We have found that instructors can successfully use large scientific datasets in teaching a database systems course to better prepare students for real-world database systems work.
A manageable web software architecture
Authors: Lee Arthur H.
Published: July 2004

Instruction on web programming at an advanced level in computer science has been in high demand in recent years. The topics and technologies in this area are so vast and diverse that designing and teaching a course requires vast knowledge and the ability to select coherent topics and technologies that can be presented in a semester. The students should learn enough of the underlying fundamental concepts along with the selected technologies so that they can practise in the real world setting while being able to adapt and expand beyond what was taught in class. Very few courses of this kind if any have been taught. We describe such a course, called
Web Software Architecture
, that we created and have taught successfully last Spring. It is a junior/senior level computer science elective course that uses Java, Servlets, JavaServer Pages, HTML, JavaScript, JDBC, and the Apache-Tomcat web server as key technologies. Our experience supports the assertion that such a web programming course has a legitimate place in a computer science curriculum.
Implementing CC2001
Authors: Phillips Andrew T. , Stevenson Daniel E. , Wick Michael R.
Published: July 2004

A first course in computer science that loosely follows the Computing Curricula 2001 report is described. This course blends theory and practice, highlights algorithm design, introduces a modest amount of imperative programming, and uses an Internet algorithmics theme to tie the topics together and keep the course both challenging and interesting to those with and without previous computing experience.
Implementing object equivalence in Java using the template method design pattern
Authors: Stevenson Daniel E. , Phillips Andrew T.
Published: July 2004

A standard practice in object-oriented programming is to implement an operation, called equals in Java, for testing the equality of two objects. The equals method should be defined for every new Java class, but because of the intricacies of inheritance, casting, and dynamic typing, equals is often quite difficult to write correctly. And unfortunately many textbooks present flawed implementations of this operation. In this paper, we present a semantically correct technique for testing object equivalence, a technique that simultaneously brings together important mathematical foundations (equivalence relations), practical programming issues (inheritance, casting, dynamic typing), and sound software design (design patterns) in a natural and compelling way. While Java is used to demonstrate how the semantic flaws are corrected and the design improved using our techniques, the design is general enough that it will be clear how the same ideas could easily be extended to other languages such as C++.
Pre-games
Authors: Giguette Ray
Published: July 2004

Many CS1 and CS2 instructors have been using game-like assignments and manipulatives to increase student understanding of abstract concepts. A related approach described in this paper requires students to play a game-like version of each assignment (referred to as the "pre-game") before designing and coding their own programs. Students complete a prototype of the pre-game that uses simpler I/O but otherwise follows the same specification. By playing the pre-game, students become familiar with lesson principles using a concrete example that combines the advantages of both game-play and manipulatives. Ideally, the pre-game creates an environment that both encourages experimentation, and allows students to use their intuition when designing algorithms and data structures.
Pilot study
Authors: Bouvier Dennis J.
Published: July 2004

Previous Computer Science Education research incorporating Common Learning Experiences (CLEs) into freshman level breadth-first Computer Science course inspired the author to undertake similar work for a depth-first course. This paper presents a set of CLEs developed for this purpose, namely the 'Living Flowcharts CLEs', along with a discussion of the pilot study and the preliminary results.
Hands-on labs without computers
Authors: Pollard Shannon , Forbes Jeffrey
Published: July 2004

Often in teaching an introductory computer science course for non-majors, a primary focus on building programming skills is neither practical nor effective. Many instructors choose a breadth-first approach focusing on building problem solving skills and surveying computer science. This paper argues that conducting hands-on labs where students work together to physically implement algorithms is an effective supplement for programming labs on the computer. We present lab examples and summarize our experiences.
Measuring the effectiveness of robots in teaching computer science
Authors: Fagin Barry , Merkle Laurence
Published: July 2004

We report the results of a year-long experiment in the use of robots to teach computer science. Our data set compares results from over 800 students on identical tests from both robotics and non-robotics based laboratory sessions. We also examine the effectiveness of robots in encouraging students to select computer science or computer engineering as a field of study.Our results are negative: test scores were lower in the robotics sections than in the non-robotics ones, nor did the use of robots have any measurable effect on students choice of discipline. We believe the most significant factor that accounts for this is the lack of a simulator for our robotics programming system. Students in robotics sections must run and debug their programs on robots during assigned lab times, and are therefore deprived of both reflective time and the rapid compile-run-debug cycle outside of class that is an important part of the learning process. We discuss this and other issues, and suggest directions for future work.
Teaching neural networks using LEGO handy board robots in an artificial intelligence course
Authors: Imberman Susan P.
Published: July 2004

In this paper we propose a novel method for teaching neural networks with back propagation in an undergraduate Artificial Intelligence course. We use an agent based approach in the course, as outlined in the textbook Artificial Intelligence A Modern Approach by Stuart Russell and Peter Norvig [7]. The students build a robot agent whose task is to learn path-following behavior with a neural network. Robot agents are constructed from standard LEGO pieces and use the MIT Handy Board as a controller.
Python robotics
Authors: Blank Douglas , Meeden Lisa , Kumar Deepak
Published: July 2004

This paper describes Pyro, a robotics programming environment designed to allow inexperienced undergraduates to explore topics in advanced robotics. Pyro, which stands for Python Robotics, runs on a number of advanced robotics platforms. In addition, programs in Pyro can abstract away low-level details such that individual programs can work unchanged across very different robotics hardware. Results of using Pyro in an undergraduate course are discussed.
Introducing middle school girls to fault tolerant computing
Authors: Sivilotti Paolo A. G. , Demirbas Murat
Published: July 2004

During summer 2002, we ran a workshop module for a group of 28 eighth-grade girls. Our aim was ambitious: to introduce these students, ages 12 and 13, to computer science by focussing on the deep intellectual topic of self-stabilizing distributed algorithms and by imparting an intuitive appreciation for their use in fault tolerance. At the same time, we hoped to dispel some negative stereotypes of computer science. The module was a success according to evaluations and comments from the participants. This paper describes the sequence of exercises we developed as an elementary-level introduction to the graduate-level topics of fault tolerance and self-stabilization. We report them with the hope that others will try them in college classrooms, as we plan to do.
Code warriors and code-a-phobes
Authors: Thomas Lynda , Ratcliffe Mark , Robertson Ann
Published: July 2004

This paper reports on how first-year students who have programmed before see their programming interest and ability and how this self-perception relates to their performance in the introductory programming course. In particular we examine how this self-perception is reflected in their reactions to the pair-programming technique for developing software.Students who had programming experience before University were given a survey that placed them on a scale that we have called Code Warrior to Code-a-phobe. We then placed them in 'opposite' and 'similar' pairs for a pair programming exercise and surveyed their reactions. There was evidence that students who have considerable self-confidence do not enjoy the experience of pair programming as much as other students and that students produce their best work when placed in pairs with students of similar self-confidence levels.
Group dynamics and collaborative group performance
Authors: Joseph Anthony , Payne Mabel
Published: July 2004

This work resulted from an investigation of the activities component of group dynamics in collaborative (or cooperative) groups for two undergraduate sections of computer architecture taught in spring 2002. A cooperative group is a special type of small group consisting of two to four persons. Collaborative learning as used here is a central component of the author devised integrative cooperative learning teaching technique. The hypothesis for this study is that the greater a student's level of within group course related activities for the imposed course assignments, the higher the student's relative course outcomes. To examine this hypothesis, an analysis of the relationship between a student's group activity and course outcomes was done. The sources of data were the student coordinator assessments and student journals compiled throughout the semester. The results of the analyses of the 63 students in the two sections of the undergraduate computer architecture course substantiated the hypothesis that the more a student participates in out-of-class collaborative academic group activity, the greater the student's achievement.
Computer graphics in undergraduate computational science education
Authors: Cunningham Steve , Shiflet Angela B.
Published: July 2004

Computer graphics is an important part of a working scientist's toolkit. The graphics may be provided by resources with the scientist's group or by capabilities of the toolkits that the scientist uses directly in his or her work. However, in order for the scientist to understand how computer graphics images represent models and what possibilities there are for this representation, and for the occasional time when the scientist may want to create a presentation that is beyond the capability of standard tools, it is important for the science student to understand the basic capabilities and processes of computer graphics. This paper outlines how a computational science program can give students the background they need to have this understanding.
Distributed visualization of graph algorithms
Authors: Sherstov Alexander A.
Published: July 2004

DisViz is a visualization tool designed to assist students in learning graph algorithms, an important topic in the undergraduate curriculum. DisViz is intended for collaborative use by a group of students over a classroom network. This visualization system views network hosts as graph nodes and the socket connections among them, as graph edges. In typical usage, every student runs a copy of DisViz on his/her local machine. These applications detect each other's presence on the network and coordinate their actions to execute the graph algorithm in question and to deliver identical animations to every terminal.
Exploiting value-added content in an online course
Authors: Zachary Joseph L. , Jensen Peter A.
Published: July 2004

Online courses have proliferated across all disciplines in recent years. One commonly-used approach for creating an online course is to build a web site containing as much course information---assignments, solutions, lecture notes, streaming videos, and the like---as possible. The goal of this type of course is to replicate online, to the maximum extent possible, the classroom experience. Online courses built this way exploit the
communications
capabilities of networked computers. We believe, however, that online courses should also strive to exploit the
computational
capabilities of computers. That is, online courses should provide value-added components that make possible learning experiences beyond what is feasible in the traditional classroom. We describe such an online course, called
Creating Interactive Web Content
, that we created and have taught successfully for the last three years. It is a general enrollment course that uses HTML and JavaScript as a vehicle for teaching elementary programming concepts.
Changing a computer science curriculum in light of computing curricula 2001
Authors: Samaka Mohammed
Published: July 2004

The present paper describes the process of changing the curriculum of the computer science degree in the college of science of the UAE University. This process was initiated to keep up with the fast pace of development in the computer science discipline. The process of changing the curriculum involved two tasks. The first task was to construct new core and selective courses, while the second task involved reviewing the existing courses to incorporate into their contents the recent developments in the computer science discipline. During this process, the department searched several computing curricula, in particular, the model of the computing curricula CC2001 of the ACM and IEEE/CS, which it used as a guiding reference.
Computer science with the sciences
Authors: Shiflet Angela B.
Published: July 2004

The interdisciplinary field of computational science combines simulation, visualization, mathematical modeling, programming, data structures, networking, database design, symbolic computation, and high performance computing with various scientific disciplines. Despite the shortage of computational scientists, few programs and computational science textbooks appropriate for undergraduates exist. After extensive discussions on enhancing computer use in the sciences, Wofford College faculty members designed a curriculum for students majoring in science or mathematics, called "Emphasis in Computational Science." A student electing this program completes a Bachelor of Science, three existing courses (Programming in C++, Data Structures, Calculus I), two new computational science courses (Scientific Programming, Data and Visualization), and a summer internship. Application rich course modules that have been developed in collaboration with scientists are employed as the textbooks for the computational science courses. Available through the world wide web, these modules can instruct and provide applications for a variety of courses [4].
Developing and maintaining an effective assessment program
Authors: Hogan Thomas R. , Harrison Patrick R. , Schulze Kay G.
Published: July 2004

The increased emphasis on assessment by regional accrediting bodies and the Computing Accreditation Commission of ABET has caused institutions of higher education and computer science departments to seriously consider the tools and techniques they are using to evaluate their program's effectiveness. The current shortage of computer science professors at many schools has greatly reduced the time available to develop and maintain an effective assessment program. Successful assessment programs require the development of a variety of carefully chosen and properly timed assessment instruments to be effective and yet avoid overburdening faculty. Successful assessment also requires a process model that carefully builds faculty support for the assessment process.
One-time binary search tree balancing
Authors: Rolfe Timothy J.
Published: July 2004

A. Colin Day proposed, and Quentin F. Stout and Bette L. Warren modified, an algorithm (the Day/Stout/Warren or DSW algorithm) that, in O(N) time and O(1) space, transforms an arbitrary binary search tree into a degenerate tree, and from that generates the most balanced possible binary search tree.
Guiding students through programming puzzles
Authors: Ross John Minor
Published: July 2004

Solving puzzles can be a challenging, yet rewarding, experience for novice programmers and experts alike. Furthermore, game examples and assignments that are concise offer many learning opportunities for early programmers. As described herein, such opportunities focus on: array manipulation, random solution searching, object-oriented analysis and design, and general creative problem solving.
ICPL
Authors: Harrison C. J.
Published: July 2004

This paper describes an Initial Concurrent Programming Language (ICPL) used to teach fundamental and general concepts and principles that underpin the concurrent programming language paradigm. ICPL has been specifically designed to be simple to implement yet powerful enough to allow many of the basic properties of concurrent systems to be demonstrated directly. ICPL builds directly on an initial knowledge of a block-structured imperative language and introduces the notion of send and receive operations as a basis for message passing between processes. The message passing properties of ICPL are chosen deliberately to demonstrate a complementary approach to describing concurrent systems in terms of processes accessing shared variables via monitors.
Denormalization guidelines for base and transaction tables
Authors: Bock Douglas B. , Schrage John F.
Published: July 2004

This article outlines heuristic guidelines for denormalizing transaction tables in relational databases. Denormalization as a process seeks to improve the response time for data retrieval while maintaining good system performance for row insertions, updates, and deletions. These guidelines apply especially for client-server environments where response time for on-line, transaction-processing systems is critical to end-user satisfaction and productivity.
Some thoughts on graduate education in computer science
Authors: Wegner Peter
Published: July 2004

Computer science is a rapidly growing discipline which is having an impact not only on computer specialists but also on the wider scientific community. Its development in the next decade will be determined both by specific technical issues internal to the discipline and by the "sociology" of a growing discipline whose great practical utility has tended to overshadow the intrinsic conceptual richness of the subject matter. Educational policy in computer science should be governed in part by practical considerations such as the supply and demand of computer scientists, in part by general considerations of educational purpose and educational policy, and in part by technical considerations concerning specific subject matter, The present discussion is deliberately biased towards an "ideal" world where questions of educational purpose and motivation take precedence over practical considerations. Four aspects of computer science are considered below, each of which is loosely related to graduate education.
Systems analysis in computer science education
Authors: Ein-Dor Phillip , Lyons Norman
Published: July 2004

This paper points out the failure of computer system management to keep pace with the increasing economic importance of computers. The authors see the problem as one of orientation for the field of computer science and, especially, computer science education. Curriculum modifications are suggested which could help alleviate the situation.
Results of the use of a recursive function translator
Authors: Krall Edward J.
Published: July 2004

A recursive function interpreter was used to good effect in an undergraduate course in elementary automata theory. Although the functions were translated into combinations of Turing machines, the interpreter is not to be construed to be a Turing Table processor. The results in this paper reflect both the author's subjective judgment, and the compilation of statistics from a questionnaire given to the students.The primary effect was not the understanding of Turing machines or recursive functions but rather the enthusiasm for such study evidenced by the computer science students taking the course. The evaluation of the interpreter is an on-going process, extending even to students on the sophomore and junior level.This paper describes both the simulator and the effects of its use, as well as some general principles concerning such devices.
Teaching computer design using macromodules
Authors: Ellis Robert A. , Wann Donald F.
Published: July 2004

This paper describes the teaching of computer design using a new and quite unusual hardware aid, macromodules. Of all the new areas emerging in Computer Science the teaching of computer structures, from an engineering viewpoint, has continually challenged the professional educator. This has in a sense presented a dilemma to him: for digital computer system design requires a broad look at a variety of configurations, but also seems to require a comprehensive examination of individual circuit details in order to remain in a practical atmosphere. As is well known, such detailed investigation of many systems is virtually impossible in the time allotted in most cirricula.Introduction of the macromodular concept, however, has permitted individual students, in one or two semesters, to achieve realizable designs of such devices as I/O channels, microprogrammed machines, complete small digital computers, floating point arithmetic systems and list processing hardware.
Space requirements for computer programs
Authors: Zelkowitz Marvin
Published: July 2004

While core is becoming relatively inexpensive, there are applications where program size is important. A project is described using a PDP 8 which demonstrates that significant programs can be written with a minimum of main memory.In learning to program, the students at many universities have access to a large central computer. For the most part, they can ignore time and space requirements in their programs. Usually this is a valid assumption since computing time is becoming less expensive; however, with the proliferation of minicomputers, there are many applications where space is at a premium, and the programmer must consider this limitation in his design.At the University of Maryland a Digital Equipment Corporation PDP 8 computer was made available to graduate students at the Computer Science Center. It was a minimum configuration of 4K 12 bit memory and a teletype. Students were forced to program for a machine with little main memory and no mass storage device. One such exercise, which demonstrated the amount of programming which can be accomplished in a small memory, will now be described.The PDP 8 memory is divided into 32 pages of 128 words each. By convention the top page is not used by any DEC software other than the binary loader, a program which is used to load all other software into the machine. This lead (sic) to the project of having students write debugging programs which fit into this top page. Since a locally written binary loader was written in 74 words, that meant 54 words were available in which the student had to write an interesting program.The results of that assignment clearly demonstrated that significant programs could be written in a minimum of space. Some of the programs which resulted were: a dump program which dumped core onto the teletype at 8 words per line, a modify program which displayed the contents of a memory location onto the teletype and enabled the user to change the contents of a location via the teletype, and a punch program which punched a paper tape of specified core segments in a format which enabled it to be reloaded by the binary loader at a later time. These programs, in a very crude manner, approximated the facilities available in the standard DEC debugging program ODT (1), however, each one was significantly shorter, and only took 10 seconds to load from a teletype - thus it was useful for debugging programs since no high speed I/O device was available.This example has some important consequences. While core is becoming less expensive, there are still applications where size is important. Instructors of programming courses should not completely lose sight of that fact. While one shouldn't stress size over all other considerations, the above exercise shows that small programs can do relatively powerful things, even on a relatively simple PDP 8 computer.
Template for a system design file using OODPM version 5.0
Authors: Drori Offer
Published: July 2004

Object Oriented Design by Prototype Methodology (OODPM) integrates two known technologies: the object approach and the prototype concept. Object oriented methodology is used for internal system design, and prototype methodology is used for external system design. This document is a template for a system design file using OODPM version 5.0 (titles of paragraphs only). For full explanations for each paragraph look at [1].
Agent architecture for agent-based supply chain integration & coordination
Authors: Sanya Liu , Hongwei Wang
Published: July 2004

For agent-based supply chain integration & coordination (SCIC), agent architecture is the foundation and core content. In this paper, agent internal architecture and an infrastructure for SCIC are discussed in detail. For agent internal architecture, generic agent internal architecture reference is given and a concrete agent internal architecture for SCIC is put forward. For infrastructure, agent grid technology is introduced into SCIC. At the same time, agent grid technology and SCIC are bridged, and detail analysis is given. Finally, a case study is showed.
Review of "Dr. Peeling's principles of management
Authors: Tracz Will
Published: July 2004

For agent-based supply chain integration & coordination (SCIC), agent architecture is the foundation and core content. In this paper, agent internal architecture and an infrastructure for SCIC are discussed in detail. For agent internal architecture, generic agent internal architecture reference is given and a concrete agent internal architecture for SCIC is put forward. For infrastructure, agent grid technology is introduced into SCIC. At the same time, agent grid technology and SCIC are bridged, and detail analysis is given. Finally, a case study is showed.