bluuebunny/crossref_metadata_2025 huggingface dataset:
Evaluating individuals in team projects
Authors: Wilkins Dawn E. , Lawhead Pamela B.
Published: July 2004

In 1999, most computer science students participate in at least one group project in some class prior to graduation. However, assessing individual student contributions to a group project is a difficult task faced by instructors of these classes. In this paper, we have compiled a wide range of assessment instruments, and identified situations where they can be effective. This paper is a compilation of potential evaluation strategies. No comparison is made among the many strategies nor are particular techniques ranked above or below others. The goal is simply to provide a wide range of potential team evaluation techniques. Since each technique evaluates a particular characteristic and different team project courses have different goals it is up to the instructor to choose the techniques that best evaluate the individual in light of the course goals.
Programming in Java
Authors: Fleury Ann E.
Published: July 2004

Java is becoming a popular first programming language for university students. One reason for its popularity is its power as an object-oriented language. This study examined beginning students' understanding of the construction and use of objects in Java. During tape-recorded interviews, students were asked to predict which programs from a collection of similar programs would work according to specification and which would not. This paper will discuss those interviews, including the most common false assumptions or “student-constructed rules” invoked by the students and the implications of the interviews for instruction.
Evaluating programming ability in an introductory computer science course
Authors: Chamillard A. T. , Braun Kim A.
Published: July 2004

There are numerous ways to evaluate student programming ability, all of which have benefits and drawbacks. In this paper we discuss how we have combined a number of those evaluation techniques to assess student programming ability in an introductory computer science course and statistically analyze the relationships of student performance using the different evaluation techniques.
Video resources for use in teaching ethics and computing
Authors: Bowyer Kevin
Published: July 2004

Workshops on the theme of “Teaching Ethics and Computing” were sponsored by the National Science Foundation's Undergraduate Faculty Enhancement program. This paper outlines the results of the workshops, available at marathon. csee.usf.edu/~kwb/naf-ufe/. Preparation for the workshops included a survey of videos that are potentially useful in teaching ethics and computing. This paper reviews some of the “best of” these videos.
Instrumentation
Authors: Tesser Herbert , Al-Haddad Hisham , Anderson Gary
Published: July 2004

A new method of teaching traditional concepts of CS1-CS2 is discussed. The new method uses real-time data acquisition, teaming, and interdisciplinary courseware to illustrate basic computer science concepts. We present a series of experiments and the corresponding software engineering elements. These experiments have proved to be motivating for a broad spectrum of students.
Design and implementation of computer games
Authors: Jones Randolph M.
Published: July 2004

This paper presents a course in the design and implementation of computer games, offered as an upper-division computer science course at Colby College during the winter semester, 1999. The paper describes the material, topics, and projects included in the course. More generally, I argue that this course provides an ideal environment for students to integrate a wide base of computer knowledge and skills. The paper supports this argument by presenting the variety of computer science concepts covered in the course, as well as pointing out potential areas of variation in future courses, depending on the tastes and priorities of the instructor.
A capstone course for a computer information systems major
Authors: Tuttle Sharon M.
Published: July 2004

This paper describes the current form and organization of Humboldt State University's CIS 492: Systems Design and Implementation, the capstone course for the Computer Information Systems (CIS) major. Since Spring 1998, this course has combined a team programming experience on a large-scale database project with discussions of a software engineering classic, Frederick Brooks Jr.'s “The Mythical Man Month”[1]. Students seem to find this combination valuable, and it is hoped that this paper can impart some useful ideas to others in designing a CIS/MIS capstone course.
Implementing an IT concentration in a CS department
Authors: Countermine Terry , Pfeiffer Phil
Published: July 2004

The increasing use of commercial off-the-shelf (COTS) software has created a demand for
IT professionals
—people that build and manage systems assembled from COTS components. In Fall 1999, the ETSU Dept. of CIS started a program of study for training IT professionals. This IT concentration differs from existing concentrations in four key ways:

The IT concentration emphasizes VB instead of C++.

It emphasizes web, database, and networking applications instead of systems software;

It puts more emphasis on human issues in computing: ethics, computer-assisted instruction, and systems analysis and specification;

It deemphasizes science and math, giving students more opportunity to complete a minor of their choosing.

Key design criteria for the concentration included making the content practical and attractive; teaching short-term and long-term skills; and minimizing the need for additional faculty. This final concern was addressed by reworking selected courses in computer organization, databases, networking, and software engineering for the concentration.

The new concentration should meet the needs of students and employers while improving retention and increasing enrollment. Preliminary indications suggest that the IT will become the department's most popular concentration.
Recursion in gradual steps (is recursion really that difficult?)
Authors: Velázquez-Iturbide J. Ángel
Published: July 2004

We propose a gradual approach to teach recursion. Our main assumption is that the difficulty in learning recursion does not come from the recursion concept itself, but from its interaction with other mechanisms of imperative programming. We use this basic idea to propose a new pedagogical approach. On the one hand, recursion is introduced in a gradual way by means of three fields (grammars, functional programming and imperative programming). On the other hand, each instance of recursion is explained so that all of its accompanying mechanisms are clearly identified.

The approach has three main advantages. First, the teaching of recursion is simplified because it is taught in a gradual way. Second, the concept of recursion is isolated and differentiated from other concepts or mechanisms associated to particular instances of recursion. Last, the student perceives recursion as a recurrent concept in the discipline of computer science.
Operating systems projects built on a simple hardware simulator
Authors: Dickinson John
Published: July 2004

Effective teaching of operating system concepts requires projects. This paper describes a series of operating system projects all based on a simple hardware simulator that have been used to teach operating system concepts at the undergraduate level. A key feature of this approach is the use of a simple but realistic hardware model upon which an operating system is progressively built. The hardware simulator evolves as the operating system evolves.
Combining cooperative learning and peer instruction in introductory computer science
Authors: Chase J. D. , Okie Edward G.
Published: July 2004

CPSC 120, Principles of Computer Science I, is a first semester freshmen level course for computer science majors. Over a three semester comparison period, this course had an average WDF rate of 56% (i.e. percentage of students receiving a grade of “D” or “F”, or withdrawing from the course). In two sections of this course, two strategies, peer instruction and cooperative learning, were combined to lower the WDF rate for both sections to an average of 32.5%. The improvement was even more dramatic for the female students in the classes, who improved from a 53% WDF rate to a WDF rate of only 15%.
The National Science Foundation (seminar session)
Authors: Martin C. Dianne , Reek Margaret
Published: July 2004

A new program in undergraduate education at the National Science Foundation is the Course, Curriculum and Laboratory Improvement (CCLI) program. CCLI has two tracks that are of particular interest to CS faculty members. They are the Educational Materials Development (EMD) and the Adaptation and Implementation (A&I) tracks. The focus of the EMD track is to develop, test and implement new materials or practices for national dissemination. The focus of the A&I track is to adapt and implement existing innovative materials or practices within a particular institution.

Both of these tracks offer opportunities for funding for CS faculty concerned about improving the quality of CS undergraduate education. Projects can encompass a broad range of activities, from individual courses and laboratories through comprehensive projects that impact entire curricula or programs across multiple departments or institutions. Funding can be requested for all items normally supported by NSF, such as equipment and personnel. The next CCLI program deadline date is June 7, 2000, making the seminar very timely for people interested in developing a proposal.
Relational programs
Authors: Bastani Farokh B.
Published: July 2004

The objective of this research is to produce useful, low-cost methods for developing correct concurrent programs from formal specifications. In particular, we address the design and verification of the synchronization and communication portions of such programs. Often, this portion can be implemented using a fixed, finite amount of synchronization related data, i.e., it is "finite-state." Nevertheless, even when each program component contains only one bit of synchronization related data, the number of possible global synchronization states for
K
components is about 2

K

, in general. Because of this "state-explosion" phenomenon, the manual verification of large concurrent programs typically requires lengthy, and therefore error-prone, proofs. Using a theorem prover increases reliability, but requires extensive formal labor to axiomatize and solve verification problems. Automatic verification methods (such as reachability analysis and temporal logic model checking) use state-space exploration to decide if a program satisfies its specification, and are therefore also subject to state-explosion. To date, proposed techniques for ameliorating state-explosion either require significant manual labor, or work well only when the program is highly symmetric and regular (e.g., many functionally similar components connected in similar ways).To overcome these drawbacks, we advocate the
synthesis of programs from specifications.
This approach performs the refinement from specifications to programs automatically. Thus, the amount of formal labor is reduced to writing a formal specification and applying the appropriate synthesis step at each stage of the derivation. While nontrivial, writing a formal specification is necessary in any methodology that guarantees correctness.
A fully capable bidirectional debugger
Authors: Boothe Bob
Published: July 2004

The goal of this research project is to develop a bidirectional program debugger with which one can move as easily backwards as current debuggers move forward. We believe this will be a vastly more useful debugger. A programmer will be able to start at the manifestation of a bug and proceed backwards investigating how the program arrived at the incorrect state, rather than the current and often tedious practice of the user stepping and breakpointing monotonically forward and then being forced to start over from the beginning if they skip past a point of interest.Our experimental debugger has been implemented to work with C and C++ programs on Digital/Compaq Alpha based UNIX workstations.
Adapting programming languages technologies for finite-state verification
Authors: Dwyer Matthew B. , Hatcliff John
Published: July 2004

Program verification and program transformation are two research areas that have different goals. Program verification aims to increase confidence in software through the use of formal methods and systematic testing. Program transformation rearranges the structure of programs to increase their efficiency or to make them more amenable to some other form of processing. Despite being funded under different NSF awards from the Software Engineering and Languages program on the two different areas above the authors are collaborating to apply results from both awards to develop a set of tools, called Bandera, for transforming Java programs into a form that is amenable to verification using existing model checking tools.
Components and program analyses
Authors: Felleisen Matthias
Published: July 2004

Model checking has been applied quite successfully to hardware verification and shows promise for software verification. The key obstacle is the well-known state explosion problem. This report describes work done by the investigator under NSF support, in particular grants CCR 980-4736 and CCR 941-5496, to ameliorate state explosion.
Hidden algebra and concurrent distributed software
Authors: Goguen Joseph
Published: July 2004

Cleverly designed software often fails to strictly satisfy its specifications, but instead satisfies them
behaviorally,
in the sense that they
appear
to be true under all possible experiments.
Hidden algebra
extends prior work on abstract data types and algebraic specification [2, 6] to concurrent distributed systems, in a surprisingly simple way that also handles nondeterminism, internal states, and more [4, 3]. Advantages of an algebraic approach include decidability results for problems that are undecidable for more expressive logics, and powerful algorithms like term rewriting and unification, for implementing equational logic tools. Much work in formal methods has addressed code verification, but since empirical studies show that little of software cost comes from coding errors, our approach focuses on behavioral specification and verification at the design level, thus avoiding the distracting complications of programming language semantics.
Software testing and analysis of object-oriented software
Authors: Offutt Jeff
Published: July 2004

Our work has studied new language mechanisms for accessing message invocations in message passing based concurrent programming languages. Invocation handling mechanisms in many concurrent languages have significant limitations that make it difficult or costly to solve common programming situations encountered in program visualization, debugging, and scheduling scenarios. We have defined and implemented new such mechanisms within the SR concurrent language and have gained some experience with them.This work has led us to want a cleaner, higher-level way of defining mechanisms for message invocation. We are, therefore, now taking an object-oriented approach. As a step toward that goal, we are currently applying our ideas to Java.Below, we briefly summarize these two areas.
Public case-base and tool kit using a validated RRM
Authors: Rine D. , Nada N.
Published: July 2004

Software systems are important, yet poorly understood entities. Users, and at times even developers, do not always understand what is occurring within the software in use. The Exploratory Visualization project attempts to address the technical issues involved in helping users understand running computations, especially long-lived distributed computations. The three facets of this problem that we investigate in our project are 1) creating accurate views of a running execution, 2) providing comprehensive and efficient access to a computation, and 3) responding to the user's interactions to promote understanding and optimize data collection.
Rapid development of dependable applications over Ad hoc networks
Authors: Roman Gruia-Catalin , Murphy Amy L.
Published: July 2004

Advances in wireless communication and network computing technologies make possible new kinds of applications involving transient interactions among physical components that move across a wide range of spaces, from the confines of a room to the airspace across an ocean, and require no fixed networking infrastructure to communicate with one another. Such components may come together to form ad hoc networks for the purpose of exchanging information or in order to engage in cooperative task-oriented behaviors. Ad hoc networks are assembled, reshaped and taken apart as components move in and out of communication range; all interactions are transient; computations become highly decoupled and rely on weak forms of data consistency; disconnections are frequent and unpredictable; and component behavior is sensitive to changes in location, context, quality of service, or administrative domain.Our objective is to develop software engineering methods and an associated software infrastructure that will facilitate rapid development of dependable mobile applications executing over ad hoc networks.
Automated analysis and fine-tuning of timing properties in embedded real-time systems
Authors: Stewart David B.
Published: July 2004

An extremely time-consuming task of producing an embedded real-time system is the final analysis and fine-tuning of the system's timing. Existing CASE tools focus on the software specification and design of embedded systems. They provide little, if any, support after the software has been implemented. Even if the developer uses a CASE tool to design their system, it likely does not meet the timing specifications on the first try. This happens because the CASE tool's software design and real-time analysis is based only on estimated data and idealized models. The tools do not take into account practical concerns such as operatin system overhead, interrupt handling, limitations of the programming language or processor, inaccuracies in estimating worst-case execution time of each process, and software errors introduced at the implementation phase by the programmers.Performance monitoring tools allow developers to obtain raw data from the underlying embedded system in real-time. These tools provide most, if not all, of the data needed to pinpoint the problem. Such data, however, is not provided in a symbolic fashion, and thus could be very difficult to understand. The monitors only show what happened during run-time, without correlating those results to the original specifications. Performance monitors also do not perform any analysis on the data that is collected. As a result, there is no means to easily differentiate between parts of the execution that are "normal" versus those parts thathave difficult-to-detect timing errors. Only an expert's eye can quickly spot the differences.We are investigating tools that can help embedded system designers analyze, debug, and fine-tune the timing characteristics of their embedded implementations. Such a tool can have a major impact, by allowing designers whose expertise is in an area other than real-time system analysis, such as communications, controls, or hardware design, to use the tool and obtain valuable information on how to fix their code that is not performing according to specifications.
The software component market on the internet current status and conditions for growth
Authors: Traas Vincent , van Hillegersberg Jos
Published: July 2004

Component Based Development (CBD) promises a large step forward in the quest for maximizing reuse in software development. Although a variety of definitions of CBD exists, key to CBD is the process of building systems by way of combination and integration of pre-engineered and pre-tested software components. For CBD to be the long awaited breakthrough in software development, the efficient reuse of software components has to be organized by a market system;
"Components develop their full potential only in a component market"
[5]. Organizations may benefit from organizing an internal component market. Software components can then be reused over multiple projects saving valuable resources. However, the most appropriate marketplace to buy and sell components would be the Internet: an international, freely accessible network, which is perfectly suited for offering, promoting and distributing components. A flourishing component market on the Internet would really allow organizations to buy and reuse against low-costs. Developers would only need to focus on functionality specific to the project, and on locating and integrating available components.Industry watchers have predicted huge growth figures for the software component market. Gartner predicts the component market will grow to $7 billion in 2001, of which $2 billion directly comes from component sales [1]. Giga information group predicts an
off-the-shelf
component market of $3,3 billion in 2001 [6]. Ovum goes further by estimating the size of the software component market to be $64 billion in 2002 [3].But does a component market on the Internet already exist, and if so, what is its status? Also, if a component market is so important for CBD to fulfil its promises, what are the conditions for growth towards maturity? Apart from rough estimations of the future size of the market, little research has been done to investigate the current component market and its growth. It is the objective of the research reported on in this paper to gain insight into these questions.The research described in this article contained two phases: First, an overview of the current status of the component market on the Internet was created. Next, based on this overview and a literature study, conditions for growth of the market were developed. An email-survey was held in which experts were asked to rate these conditions by importance and comment on them. Section two and three describe the results of these research phases respectively.
Towards generative components
Authors: Pulvermüller Elke , Speck Andreas
Published: July 2004

On September, 28 - 30, 1999, the First International Symposium on Generative and Component-based Software Engineering (GCSE'1999) took place at Erfurt, Germany. This was the origin of a new international forum bundling the research on all generative techniques within the software development process, especially those focused on components. The next Symposium GCSE'2000 is intended to take place on October, 10 - 12, 2000, Erfurt. This time co-hosted with NET.OBJECTDAYS'2000.
Our experience and learning in ERP implementation
Authors: Agarwal Rakesh , Raha Arup Ratan , Ghosh Bhaskar
Published: July 2004

Information systems developed to support the functional units of a complete enterprise (referred in this paper as "application package") only serve standard industry processes. Very often, the business processes that differentiate an organization from another are the processes that define their competitive edge. This competitive edge can be achieved if the implemented processes are based on the best practices supported by these packages. This requires a strong knowledge of Business Processes, adept IT capability and a sound, tested implementation. This paper describes our experience in using the COTS package application MAC-PAC v10 for TOSHIBA sales & services (a subsidiary of Toshiba Corporation).
A retrospective view of CASE tools adoption
Authors: Albizuri-Romero Miren Begoña
Published: July 2004

This paper provides a retrospective view of the adoption of CASE tools in organizations using some empirical data from various research studies in this field. First, relevant factors that influence the decision to adopt such a tool are discussed. Such factors include elements related to the organization adopting such a technology, as well as other characteristics associated with the application environment and the alternative development methods being used. Then, the advantages and disadvantages of using CASE tools are discussed and some critical success factors are identified. Finally, a taxonomy of CASE tools in the 90's is presented. The paper provides some explanations of why some organizations are successful in adopting CASE tools and gives recommendations for making a better use of such a technology.
Analysis is necessary, but far from sufficient (abstract only)
Authors: Pincus Jon
Published: July 2004

Why are there so few successful "real-world" programming and testing tools based on academic research? This talk focuses on program analysis tools, and proposes a surprisingly simple explanation with interesting ramifications.

For a tool aimed at developers or testers to be successful, people must use it - and must use it to help accomplish their existing tasks, rather than as an end in itself. If the tool does not help them get their job done, or the effort to learn and/or use the tool is too great, users will not perceive enough value; the tool will not get significant usage, even if it is free.

This talk focuses on the often-overlooked consequences of this seemingly basic statement in two major areas: program analysis, and the work beyond core analysis that must be done to make a successful tool. Examples will be drawn from tools that have been successfully used in industry (sold commercially, and developed for internal use).
jRapture
Authors: Steven John , Chandra Pravir , Fleck Bob , Podgurski Andy
Published: July 2004

We describe the design of jRapture: a tool for capturing and replaying Java program executions in the field. jRapture works with Java binaries (byte code) and any compliant implementation of the Java virtual machine. It employs a lightweight, transparent capture process that permits unobtrusive capture of a Java programs executions. jRapture captures interactions between a Java program and the system, including GUI, file, and console inputs, among other types, and on replay it presents each thread with exactly the same input sequence it saw during capture. In addition, jRapture has a profiling interface that permits a Java program to be instrumented for profiling ó after its executions have been captured. Using an XML-based profiling specification language a tester can specify various forms of profiling to be carried out during replay.
Integration of computer ethics into the CS curriculum
Authors: Gotterbarn Don
Published: July 2004

The Impact CS project, described in Dianne Martin's current and previous SIGCSE column, addresses Curriculum 91's mandate "to include the social and ethical implications of computing" in the curriculum. I have two concerns with this mandate. The mandate leaves open
how
to include the material and exactly
what
material to include to satisfy the mandate. For the past ten years the discussion about how to include the material has repeatedly focused on three methods of inclusion: have a separate course---taught by philosophy or CS, have a capstone project course, or integrate ethics into several of the CS courses. Since the initial mandate, the discussion of
what
to include has broadened to include the professional responsibilities of the computing practitioner. This broadening of the subject matter has contributed to favoring the integration approach as a method of inclusion. An approach which (ten years ago) has been empirically proven to be the most effective way to teach ethics.It may seem that we now have a clear path and Impact CS Report 3 provides us with the theoretical underpinnings to "integrate" computer ethics into the curriculum. But I think we still have one further issue to clear up. Material can be "integrated" into a course simply by adding another reading. We can attach the material to a course and treat it much the way ethics was treated in Curriculum 91, as an appendage to the
real
CS curriculum. The material could be "integrated" into the course in another way. We could show the unity of professional, social, and ethical issues with computer science. If professional, social, and ethical concerns are simply treated as an appendage, then teachers will leave these discussion for the last day of class (if there is time left). Teachers will feel that there is no time to include these issues in their classes; students will believe that ethics is included only to minimally meet the requirements of CSAB accreditation and they will not have a clear understanding of their professional responsibilities. On the other hand, we could teach professionalism and ethics as a part of computer science. Good computer science is a combination of the application of technical skill guided by professional responsibility. For example, we could demonstrate that doing good software design involves designing the software in an ethically sensitive way.I am concerned that, because of the use of terms like "units" and "stages" in Impact CS Report 3, some may interpret it as advocating "attaching" ethics units to courses, attaching units that are neatly separable from computer science. The material discussed in the "units" and "stages" of Report 3 can be synthesized with the CS curriculum in some fairly straightforward ways. In what follows I will summarize some of those ways and indicate some of useful resources to help you "demonstrate that ethical computer science is computer science.
The humble fraction
Authors: Perry Nigel
Published: July 2004

In this paper we examine how trends in programming methodology support the definition of value types. We ask the question have we really advanced in the move from traditional to OO methodologies, have we produced square wheels, or have we just changed terminology? We ask this to determine what we should be teaching our students. The work was motivated by a concern that students, through what is, or is not, taught, are missing or rejecting the lessons of history and producing poorer designs because of this.
The Peer Review Process of Teaching Materials
Authors: Knox Deborah , Goelman Don , Fincher Sally , Hightower James , Dale Nell , Loose Ken , Adams Elizabeth , Springsteel Fred
Published: July 2004

When an instructor adopts teaching materials, he/she wants some measure of confidence that the resource is effective, correct, and robust. The measurement of the quality of a resource is an open problem. It is our thesis that the traditional evaluative approach to peer review is not appropriate to insure the quality of teaching materials, which are created with different contextual constraints. This Working Group report focuses on the evaluation process by detailing a variety of review models. The evolution of the development and review of teaching materials is outlined and the contexts for creation, assessment, and transfer are discussed. We present an empirical study of evaluation forms conducted at the ITiCSE 99 conference, and recommend at least one new review model for the validation of the quality of teaching resources.
Lecturelets
Authors: Culwin Fintan
Published: July 2004

The traditional lecture has, for a long time, been subject to significant criticisms regarding its learning effectiveness. Despite this it remains popular and several attempts have been made to transport aspects of its format to the Web. Many of these projects appear to have been ill informed and, like many pedagogic uses of the Web, under evaluated. This paper describes the design, implementation and deployment of
lecturelets,
small low-cost Web hosted lecture like presentations. One design intention was to include effective support for their evaluation and the mechanisms and intentions for this are described.
Students seen flocking in programming assignments
Authors: Greening Tony
Published: July 2004

Programming assignments are typically constructed with great precision, in order to ensure that students traverse the important content areas in the unit. This paper makes a case for an "ill-defined", large programming task by presenting experiences with an assignment based on flocking behavior. Providing students meet the criteria that their artificial life forms clearly exhibit flocking behavior, they become responsible for defining the exact nature of the task. The success of this approach is partly measured by the ability of novice programmers who fully engage with the course material to produce spectacular results. The paper includes a discussion of the philosophical requirements for adopting such an approach within a programming unit.
Team projects in distance education
Authors: Koppleman Herman , van der Mast Charles P. A. G , van Dijk Elisabeth M. A. G , van der Veer Gerrit C.
Published: July 2004

Until recently it was difficult to incorporate team projects in distance education. Nowadays, however, new technology is available which allows for distance teamwork. In this paper we will describe a project-oriented course on human-computer interaction. The course is meant for computer science students in distance education. A serious restriction is caused by the fact that the students study at home, where they usually only have a slow connection to Internet at their disposal. We will focus on the way we structured the course to make distance teamwork possible. Furthermore the tools we offered the students will be discussed. Finally, in the paper we will present the first experiences gained in a pilot project with 12 computer science students.
Has our curriculum become math-phobic? (an American perspective)
Authors: Kelemen Charles , Tucker Allen , Henderson Peter , Astrachan Owen , Bruce Kim
Published: July 2004

We are concerned about a view in undergraduate computer science education, especially in the early courses, that it's okay to be math-phobic and still prepare oneself to become a computer scientist. Our view is the contrary: that any serious study of computer science requires students to achieve mathematical maturity (especially in discrete mathematics) early in their undergraduate studies, thus becoming well-prepared to integrate mathematical ideas, notations, and methodologies throughout their study of computer science. A major curricular implication of this theme is that the prerequisite expectations and conceptual level of the first discrete mathematics course should be the same as it is for the first calculus course --- secondary school pre-calculus and trigonometry. Ultimately, calculus, linear algebra, and statistics are also essential for computer science majors, but none should occur earlier than discrete mathematics. This paper explains our concerns and outlines our response as a series of examples and recommendations for future action.
Restricted universe data structures
Authors: Mäkinen Erkki , Siermala Markku
Published: July 2004

Restricted universe data structures and their algorithms augment our knowledge of the behavior of standard data structures. Understanding the increase in asymptotic efficiency when restricting the universe of possible keys helps us to realize the limits of the common data structures, such as balanced binary trees. This paper first introduces the principles of restricted universe data structures and then empirically compares stratified trees and AVL trees in the connection with a simple algorithmic problem.
An information resource for computer science educators
Authors: McCauley Renée , Manaris Bill
Published: July 2004

This paper describes an information resource for educators in departments offering computer science degree programs. This resource is designed to provide structured, up-to-date information in terms of demographics and statistics related to curricula, faculty, and students in such departments. Additionally, it facilitates the identification of various trends based on these data over several years. This paper presents highlights of the information generated through this project.
Factors affecting performance in first-year computing
Authors: Goold Annagret , Rimmer Russell
Published: July 2004

Performances are analysed over successive semesters for a cohort of first-year students doing computer programming. Attainment is related to performance in other studies. However, many factors have roles. Learning style and problem-solving skills are important in information technology in Semester I. Gender and secondary school outcomes matter in introductory programming, also in Semester I. Dislike of programming influences outcomes in introductory programming and in Data Structures and Algorithms in Semester II. For a number of indicators, influence fluctuates over time and across area of study.
CGTDEMO — educational software for the central limit theorem
Authors: Jovanovic-Dolecek Gordana , Champac Victor H.
Published: July 2004

This paper describes the demo package for teaching and visualizing the Central limit theorem. The topic treated in this paper is of significant interest in undergraduate coverage of non-deterministic systems. Two types of random variables are considered: symmetric, highly concentrated about its mean value and nonsymmetrical random variables. The demo program is developed in MATLAB 5.2. The program gives the user step by step guidance. The user chooses the type of variable, the length of the sum N, and the corresponding parameters of a random variable. Successive plots of the sums of random variables and the estimations of the corresponding probability density functions are obtained. Finally the comparison with a normal variable is given.
The relevance of design in CS1
Authors: Gaona Amparo López
Published: July 2004

Most of the papers on the experiences in teaching the first object-oriented programming course are biased towards the selection of the best programming language. Sometimes we argue the pros and cons of particular languages (C, C++, Java). My point is that teaching a programming methodology is the most important element for such a course.
Experiments with distance learning in software engineering graduate courses
Authors: Jacobsen Michele , Kremer Rob , Shaw Mildred L. G.
Published: July 2004

This article reports on our experience to date with these two distance graduate courses in software engineering. We experimented with several technological tools to facilitate computer mediated communication: WebCT, electronic mail, a list server, and NetMeeting. We briefly discuss the methods used to evaluate the distance learning environments experienced by the graduate students, and make recommendations for future research and educational practice in distance learning environments.
Teaching C++ in a multi-user virtual environment
Authors: Pullen J. Mark , Norris Eugene , Fix Mark
Published: July 2004

The Internet has opened tremendous possibilities for distance education, where teachers and students can be distributed worldwide. However, much of today's Internet-based teaching is limited to student access of Web-based multimedia documents. In this paper we describe new dimensions in distributed education that are possible in synchronous sessions where the students interact with the teacher in real time. We review and elaborate on the nature of the MUVE, a spatially oriented, network-accessed software environment that uses persistent object technology to promote student creativity and allow continuity between online sessions. We describe our experiences in using a MUVE to enable distributed education at the college level in graduate and undergraduate courses, and its use with high school students in the DARPA Computer-Assisted Education and Training Initiative (CAETI).
A WWW-based multimedia center for learning data communications — phase 1
Authors: Elkateeb Ali , Awad Ala
Published: July 2004

The use of multimedia in education has become an important element to improve the quality of education and to reduce the cost of the educational system. In addition, the students got the benefit of learning and understanding the material better than in the conventional way. In this work, a learning package called "Data Communications Learning Center" (DCLC) has been developed and tested. The main objective of this center is to help university students and others to learn data communication concepts, architectures and operations. The center is a world wide web (www) based, and it allows any student that uses a standard modem for the Internet access to use our center. The center has been developed to be easy to use. The initial evaluation of the center examined by a few students have complemented that the center has improved their understanding to some data communication concepts which the center already supports. Although our intention is to support one topic at the first stage of this project, one can easily add other topics to the center. Any professor who is willing to put his course in the center can achieve this without any prior knowledge about the internal design of the center.
Defining computer science
Authors: McGuffee James W.
Published: July 2004

This paper explores the use and purpose of a definition of computer science from the perspective of an undergraduate student. In order to gain access to the topic, the nature and purpose of definitions are explored. Historical examples of computer science definitions are given. The paper concludes with an examination of how students define computer science and how we should use these definitions in computer science education.
Designing robust Java programs with exceptions
Authors: Robillard Martin P. , Murphy Gail C.
Published: July 2004

Exception handling mechanisms are intended to help developers build robust systems. Although an exception handling mechanism provides a basis for structuring source code dealing with unusual situations, little information is available to help guide a developer in the appropriate application of the mechanism. In our experience, this lack of guidance leads to complex exception structures. In this paper, we reflect upon our experiences using the Java exception handling mechanism. Based on these experiences, we discuss two issues we believe underlie the difficulties encountered: exceptions are a global design problem, and exception sources are often difficult to predict in advance. We then describe a design approach, based on work by Litke for Ada programs, which we have used to simplify exception structure in existing Java programs.
Automated test oracles for GUIs
Authors: Memon Atif M. , Pollack Martha E. , Soffa Mary Lou
Published: July 2004

Graphical User Interfaces (GUIs) are critical components of today's software. Because GUIs have different characteristics than traditional software, conventional testing techniques do not apply to GUI software. In previous work, we presented an approach to generate GUI test cases, which take the form of sequences of actions. In this paper we develop a test oracle technique to determine if a GUI behaves as expected for a given test case. Our oracle uses a formal model of a GUI, expressed as sets of objects, object properties, and actions. Given the formal model and a test case, our oracle automatically derives the expected state for every action in the test case. We represent the actual state of an executing GUI in terms of objects and their properties derived from the GUI's execution. Using the actual state acquired from an execution monitor, our oracle automatically compares the expected and actual states after each action to verify the correctness of the GUI for the test case. We implemented the oracle as a component in our GUI testing system, called Planning Assisted Tester for grapHical user interface Systems (PATHS), which is based on AI planning. We experimentally evaluated the practicality and effectiveness of our oracle technique and report on the results of experiments to test and verify the behavior of our version of the Microsoft WordPad's GUI.
Automated systematic testing for constraint-based interactive services
Authors: Godefroid Patrice , Jagadeesan Lalita J. , Jagadeesan Radha , Läufer Konstantin
Published: July 2004

Constraint-based languages can express in a concise way the complex logic of a new generation of interactive services for applications such as banking or stock trading, that must support multiple types of interfaces for accessing the same data. These include automatic speech-recognition interfaces where inputs may be provided in any order by users of the service. We study in this paper how to systematically test event-driven applications developed using such languages. We show how such applications can be tested automatically, without the need for any manually-written test cases, and efficiently, by taking advantage of their capability of taking unordered sets of events as inputs.
Integrating active information delivery and reuse repository systems
Authors: Ye Yunwen , Fischer Gerhard , Reeves Brent
Published: July 2004

Although software reuse can improve both the quality and productivity of software development, it will not do so until software developers stop believing that it is not worth their effort to find a component matching their current problem. In addition, if the developers do not anticipate the existence of a given component, they will not even make an effort to find it in the first place.

Even the most sophisticated and powerful reuse repositories will not be effective if developers don't anticipate a certain component exists, or don't deem it worthwhile to seek for it. We argue that this crucial barrier to reuse is overcome by integratingactive information delivery, which presents information without explicit queries from the user, and reuse repository systems. A prototype system,CodeBroker, illustrates this integration and raises several issues related to software reuse.
Accumulative versioning file system Moraine and its application to metrics environment MAME
Authors: Yamamoto Tetsuo , Matsushita Makoto , Inoue Katsuro
Published: July 2004

It is essential to manage versions of software products created during software development. There are various versioning tools actually used in these days, although most of them require the developers to issue management commands for consistent versioning. In this paper, we present a novel versioning file system Moraine, which accumulatively and automatically collects all files created or modified. Those files are versioned and stored as compressed forms. The older versions are easily retrieved from Moraine by the time-stamps or tags if required.

Using Moraine system, we have developed a metrics (measurement) environment called MAME (Moraine As a Metrics Environment). MAME can collect various metrics data for on-going or past projects, since its basis, Moraine, is able to retrieve all versions of all products (files).

Both Moraine and MAME have been implemented. Using these systems, we have evaluated the performance of Moraine and MAME with various test data and student project data. The result shows that disk space required by this approach is several times larger than ordinary approaches; however, it is acceptable at the current tendency of disk price decrease. By this approach, an ideal metrics environment has been easily established by developing simple data-collection tools for version files.
Coven
Authors: Chu-Carroll Mark C. , Sprenkle Sara
Published: July 2004

Our work focuses on building tools to support collaborative software development. We are building a new programming environment with integrated software configuration management which provides a variety of features to help programming teams coordinate their work.

In this paper, we detail a hierachy-based software configuration management system called
Coven
, which acts as a collaborative medium for allowing teams of programmers to cooperate. By providing a family of inter-related mechanisms, our system provides powerful support for cooperation and coordination in a manner which matches the structure of development teams.