bluuebunny/crossref_metadata_2025 huggingface dataset:
Aha! an illuminating perspective
Authors: Ginat David , Garcia Dan , Gasarch William
Published: July 2004

The 'Aha!' phenomenon is familiar to us in many domains including computer science and mathematics (e.g., [2,3,6]). It often stems from an unexpected point of view that illuminates an appealing solution path. The 'Aha' reaction is common to all. Its occurrence is related to the problem-solvers' common perspectives and solution repertoires. Whether more frequent or less frequent, 'Aha' occurrences enrich and strengthen perspectives and repertoires in a stimulating manner.Consider the following
Ladder Problem:
calculate the number of different ways to climb an N-stage ladder when each step is either one or two stages. One solution perspective may be 'forward reasoning', leading to a systematic accumulation of the possible climbing paths. Another perspective may be combinatorial, leading to the calculation of all the combinations of 1 and 2 that sum to N. A third perspective may be 'backward reasoning', yielding recursive decomposition of the N
th
case into the N-1 and N-2 cases.Some problem-solvers may fairly quickly invoke the third perspective and elegantly obtain the N
th
Fibonacci number. Others may first follow one of the other perspectives and later realize the illuminating third perspective. The 'Aha' reactions among the solvers may vary. However, both less experienced and more experienced solvers will gain from recognizing the relevance and elegance of the recursive decomposition and enhance their problem-solving repertoires.
Design of a major in software development
Authors: Fekete Alan , Kummerfeld Bob
Published: July 2004

This paper presents a curriculum consisting of a collection of subjects to prepare students for a career in "software development" while remaining within the scope normal for a major in a broad liberal arts degree. We describe the principles behind the construction of the curriculum, and contrast it with the more extensive "Software Engineering Body of Knowledge" appropriate in a professional Engineering degree.
Disequilibration for teaching the scientific method in computer science
Authors: Braught Grant , Reed David
Published: July 2004

We present several introductory computer science laboratory assignments designed to reinforce the use of the scientific method. These assignments require students to make predictions, write simulations, perform experiments, collect data and analyze the results. The assignments are specifically designed to place student predictions in conflict with the observed results, thus producing a disequilibration. As a result, students are motivated to critically examine their simulations, consider their assumptions, and repeat their experiments. These potential benefits of disequilibration are discussed and additional ways to apply disequilibration in computer science education are suggested.
A new instructional operating system
Authors: Holland David A. , Lim Ada T. , Seltzer Margo I.
Published: July 2004

This paper presents a new instructional operating system, OS/161, and simulated execution environment, System/161, for use in teaching an introductory undergraduate operating systems course. We describe the new system, the assignments used in our course, and our experience teaching using the new system.
PortOS
Authors: Atkin Benjamin , Sirer Emin Gün
Published: July 2004

In this paper, we describe PortOS, an educational operating system designed to complement undergraduate and graduate level classes on operating systems. PortOS is a complete user-level operating system project, with phases covering concurrency, synchronization, networking and file systems. It focuses particularly on ad hoc and peer-to-peer distributed computing on mobile devices. This paper discusses alternative approaches to operating system projects, and presents our particular design point along with pedagogical justifications.
Computational science and engineering
Authors: Cunningham Steve , Pulliam Sylvia Clark , Swanson Charles D. , Turner Peter R.
Published: July 2004

The methods of computational science and engineering have been applied to a wide range of problems such as weather forecasting, cosmology, drug design, and car crash simulation. More recently, high performance computers have been applied to problems in biology (e.g., molecular biology, bioinformatics). The development of CSE as an interdisciplinary field has had a profound effect on the way science and engineering is done, both for basic research and product development. Less than ten years ago, these methods required very expensive supercomputers and special software skills to be effective. Today, while supercomputers are still important, the power of widely available PCs and workstations means that many of these methods can be introduced into the undergraduate curriculum. The objectives of this session are, therefore:• To introduce participants to some of the methods of CSE (e.g., modeling, scientific visualization).• To demonstrate the range of software tools that can be utilized.• To provide examples of these tools applied to teaching topics from different scientific disciplines.• To provide participants ideas and resources that they can use in their own courses.
Teaching a Java-based CS1 course in an academically-diverse environment
Authors: Comer James , Roggio Robert
Published: July 2004

The Texas Christian University (TCU) Computer Science Department was established in 1981. From the outset, the Department's CS1 course has presented significant teaching challenges due to the wide diversity of student's taking the class. Traditionally, only 25-35% of the students enrolled in the course are computing science majors, the remaining being students from a wide diversity of disciplines, many of which are non-science based. Despite the diversity, it has been necessary for the course, and its content, to be structured to satisfy essential core requirements for students majoring in computer science and computer information science as well as to meet program requirements for the many non-computer science majors taking the course. This paper discusses some of the unique issues associated with teaching a Java-based CS1 course to a very diverse group of students, the majority of which have very unsophisticated problem solving skills, and little or no programming expertise. A representative set of experiments and programming assignments are included.
Using Java to design and test hardware circuits over a classroom network
Authors: Jipping Michael J , Marlowe Steve , Sherstov Alexander
Published: July 2004

A crucial part of the Computer Organization course is the design and analysis of hardware circuits. To teach this part of the course efficiently and to involve the entire class in the design of circuits, we have designed the SCAN system. Starting with a textual specification of a circuit, SCAN generates Java classes that can be used to simulate the way the circuit works. These circuits can be simulated locally or can join with other circuits to simulate larger machine function over a network. This paper describes the SCAN system, the Java classes it generates, and the way we use this in the Computer Organization class.
Computing Curricula 2001 implementing the recommendations
Authors: Roberts Eric , Cover C. Fay , Davies Gordon , Schneider Michael , Sloan Robert
Published: July 2004

In the fall of 1998, the ACM Education Board and the Educational Activities Board of the IEEE Computer Society appointed representatives to a joint task force to prepare Computing Curricula 2001 (CC2001). The CC2001 report is the current installment in a series of reports on the undergraduate computer science curriculum that began in 1968 and was then updated in 1978 and 1991 [1, 6]. The computer science volume of the CC2001 report was presented to the community in a series of three public drafts, followed by a final report approved by the governing boards of the ACM and the Computer Society. The purpose of this panel is to discuss strategies for implementing the recommendations of the final report in a wide variety of institutions.
Graphical problem solving and visual communication in the beginning computer graphics course
Authors: Cunningham Steve
Published: July 2004

The beginning computer graphics course can teach much more than just computer graphics. It can also provide an excellent introduction to graphical problem solving and visual communication, and in so doing can be an excellent complement to other computer science courses that teach more analytical problem solving. This paper describes the graphical problem-solving and visual communication contexts and discusses how they can be supported by the beginning computer graphics course.
Introducing computer science through animation and virtual worlds
Authors: Rodger Susan H.
Published: July 2004

We describe a course for non-majors that teaches computer science concepts and programming by creating simple animations and building 2D and 3D virtual worlds. Students work with scripting languages, an interactive programming environment, a programmable modeling environment, and finish with a simple programming language. Students work in pairs on computers during class. Each student creates a web portfolio to display their work.
Visual representations for recursive algorithms
Authors: Stern Linda , Naish Lee
Published: July 2004

We have developed a framework for pedagogically-oriented animations, designed to help students learn new algorithms. Recursive sorting and searching algorithms pose a particular challenge, as it can be difficult to find visual representations that help students develop a mental model of how the recursion proceeds. Relatively complex representations, such as thumbnail sketches or explicitly showing the function stack along with the data structure are appropriate for some algorithms, while simpler representations suffice for others. We have found it useful to classify recursive algorithms according to the way they navigate through a data structure and manipulate data items within it, sometimes with further subdivision according to the kind of recursion. Within each category there are common strategies for visual representation. While there may be no single, general way to represent recursive algorithms, classification is a useful guide to picking an appropriate strategy when animating recursive algorithms.
Incorporating Human-Computer Interaction into the undergraduate computer science curriculum
Authors: Douglas Sarah , Tremaine Marilyn , Leventhal Laura , Wills Craig E. , Manaris Bill
Published: July 2004

This special session presents issues, approaches and experiences related to incorporating Human-Computer Interaction (HCI) into the undergraduate CS curriculum. Since the publication of the ACM SIGCHI Curricula for Human-Computer Interaction in 1992 [1], CS educators have tried various implementations of these guidelines. These implementations have been mainly offered as elective courses or modules within other courses, partly because the CS mainstream has been slow to recognize the importance of user interface design and HCI issues in software development.Today at least 50% of the code written for software applications is specific to the user interface. Average end-user expertise is continually dropping due to the proliferation of inexpensive computers available to the general public. Accordingly, user interface effectiveness has become increasingly important in software development, as the user interface has the power to "make or break" a software product. Through its emphasis on user-centered design, task analysis, and usability evaluation among other topics, an HCI course addresses more than 1/3 of the guidelines and imperatives of the ACM Code of Ethics [2]. This includes issues related to professional review, evaluations of computer systems, social responsibility and quality of life, and non-discrimination and dignity of end-users.CS educators have begun realizing the importance of incorporating HCI into the educational experience of students. Approximately 40% of the CAC-accredited degree programs include an HCI course at the upper level; however, this course is offered mostly as an elective (37% of degree programs) as opposed to a required course (3% of degree programs) [3]. Also, HCI is included as a core knowledge area in Computing Curricula 2001 [4, 5, 6]; unfortunately, only six hours have been devoted to it, as opposed to, say, 36 hours for architecture.
JAVA IDEs
Authors: Owens Barbara Boucher , Pattis Rich , Stephenson Chris , Rehder Jack , Sanders Dean
Published: July 2004

This panel reflects the experiences of several faculty who each use a different Java Interactive Development Environment (IDE). Panelists will discuss the salient features of the IDEs that are used at their particular institutions. Each panelist will discuss system requirements, ease of installation, strengths and weaknesses of each IDE and pointers for successful adaptation to the classroom.
National Science Foundation Graduate Research Fellowship Program
Authors: Johnson Jeffrey
Published: July 2004

The objective of the Graduate Research Fellowship Program (GRFP) of the National Science Foundation (NSF) is to support the vitality of the human resource base of science, mathematics, and engineering in the United States and to reinforce its diversity. Oak Ridge Associated Universities (ORAU) manages the GRFP application and review processes under contract to NSF.
Testing skills and knowledge
Authors: Califf Mary Elaine , Goodwin Mary
Published: July 2004

Testing students' programming skills remains a challenge for courses that teach beginning programming. This paper describes the introduction of a laboratory final examination into a CS1 course. We present our approach to a lab final and present initial evidence indicating the effectiveness of the lab final. We also describe the problems encountered and solutions to those problems, which may benefit others interested in instituting a similar exam.
The software engineering capstone
Authors: Chamillard A. T. , Braun Kim A.
Published: July 2004

One of the largest challenges facing educators teaching undergraduate software engineering courses is providing the students with meaningful experiences they will find useful when they complete their undergraduate education. Those experiences should include all phases of the software development process, and to be as realistic as possible they should also include the uncertainty and continual change present in any real project. In addition, those experiences need to include working with others in a team, which can affect the morale of some students and also poses challenges to the professor when the time to assign grades arrives. In this paper we discuss how we have tailored the software engineering capstone sequence at the U.S. Air Force Academy to address these issues.
Unit testing frameworks
Authors: Noonan Robert E. , Prosl Richard H.
Published: July 2004

In this paper we explore frameworks for performing unit testing in Java. The vehicle for this exploration is a student-written, skeleton program developed for the
Computer Graphics
course. Our analysis of this one experiment leads us to speculate what benefits in program development and design might accrue by requiring students to unit test their own programs.
Using Visual Studio.Net in the classroom
Authors: Krane Roseann , Thompson Alfred , Kisilinsky Harriette , Phillips Pat
Published: July 2004

The exciting promise of Microsoft.NET Technology inspired four teachers from high schools in Florida, New Hampshire, Wisconsin and California to collaborate using the new technology to teach high school programming. Follow their adventures through the school year of implementing a new technology, coordinating curriculum and partnering distant students. Learn from this panel the do's and don't's that lead to success for innovative teachers.
Bringing the enterprise into a database systems course
Authors: Moore Thomas K.
Published: July 2004

Most database systems courses concentrate on teaching the principles of relational databases. An alternative approach is one in which those principles are taught within the context of emerging enterprise systems. A description is given in this paper of a course that has been successfully taught at the undergraduate level that uses the Java 2 Enterprise Edition (J2EE) model, and its services, to illustrate basic database principles.
JDBC demonstration courseware using Servlets and Java Server Pages
Authors: Dietrich Suzanne W. , Urban Susan D. , Kyriakides Ion
Published: July 2004

This paper describes the design and functionality of courseware developed to demonstrate the JDBC API. The courseware is used in an advanced undergraduate database course that emphasizes the use of Web access to database systems. The JDBC courseware is written using Java Servlets and Java Server Pages, allowing the user to view the metadata associated with a database, to view and browse the information in a database according to the database metadata, and to query and/or manipulate data using SQL statements. The advantage of the courseware is that it demonstrates the main functionality of the JDBC API in an application-independent manner. The courseware can access any ODBC-compliant database, emphasizing the generality of the JDBC API and helping students understand how JDBC can be used to query the metadata of the database as well as the database contents.
Using Visual Basic in the CS curriculum
Authors: Hummel Joe , Mehta Jean
Published: July 2004

Visual Basic is currently the most popular programming language in the United States. And yet, it is rarely found in traditional Computer Science (and related) curriculums. Perhaps this is due to the fact that VB is not truly object-oriented, but object-based. Or perhaps because VB is not an open language, instead supported only by tools from Microsoft Corporation and available only on the Windows platform. Or perhaps it is simply Microsoft itself, with its monopolistic tendencies.This panel will argue that Visual Basic --- while it should not replace the use of more traditional languages such as C++, Java, or Scheme --- fulfills an important role in modern CS and related curriculums. The panelists will highlight a few of the cases in which they have found VB to be exceedingly useful, and discuss their rationale for choosing VB over other languages.
Using puzzles in teaching algorithms
Authors: Levitin Anany , Papalaskari Mary-Angela
Published: July 2004

This paper advocates a wider use of puzzles and puzzle-like problems in teaching design and analysis of algorithms. It discusses a variety of puzzles and classifies them according to the general algorithm design techniques. Pedagogic issues are explored.
Algorithms and object-oriented programming
Authors: Bucci Paolo , Heym Wayne , Long Timothy J. , Weide Bruce W.
Published: July 2004

Currently there is a serious conceptual and technical gap between ideas emphasized in object-oriented programming and ideas as taught in algorithms courses. We suggest both a paradigm for "re-expressing" algorithms in terms of classes and objects, and a set of criteria relative to which the quality of such re-expressions can be evaluated. A detailed example is provided for re-expressing the algorithmic idea of sorting.
Open source software
Authors: Wolf Marty J. , Bowyer Kevin , Gotterbarn Don , Miller Keith
Published: July 2004

Open source software is making a large impact on many aspects of society including the business community, the computing industry, the entertainment industry and higher education. The computer science education community has been quiet about issues of open source versus closed source and the role of open source code in the advancement of information technology. A survey of recent issues of SIGCSE Bulletin and SIGCSE conference proceedings shows little attention to the role open source software should play in computer science education. We are here to raise the question: "What are the social and ethical responsibilities of computer science faculty regarding open source software?"One set of issues concerns the use of open source software in teaching and the use of open source development models in the teaching of software development. Some basic questions that arise include "Should analysis of open source (and possible contributions to it) be the subject of class assignments?" and "Should open source software development models be taught?"A second set of issues concerns the use of open source software in
support
of teaching (e.g., using Linux as your standard platform). Some basic questions that arise include "Should we use open source software to support teaching?" and "Are these faculty ethically obligated to make contributions to the open source software base?"In this panel we will identify many of the parties involved in the ethical and social issues surrounding the use of open source in teaching and in the support of teaching, and we will identify the rights and responsibilities we, as faculty, have to the various parties. This panel will initiate a discussion that will identify additional parties and our further professional obligations.
On varying perspectives of problem decomposition
Authors: Ginat David
Published: July 2004

The most common decomposition perspective in computer science problem-solving is 'top-down', in which the problem at hand is divided into 'smaller' sub-problems. Yet there are more decomposition perspectives. In this paper we illuminate three additional perspectives and demonstrate their didactic value. The presentation is displayed in an apprenticeship manner, through different approaches for solving an intriguing algorithmic challenge - the problem of finding majority. Each of the three perspectives is tied to a variety of algorithmic problems and solutions, and elaborated as a pedagogical tool for teaching algorithms.
SIGCSE 2002 forum
Authors: Reges Stuart
Published: July 2004

The intent of this forum is to generate a really lively discussion on the gamut of our relationship - as computer science educators - to industry.How dependent are we/should we be on specific industry software and platforms? (Many examples come to mind - Microsoft Visual Studio.NET, Red Hat Linux, C#, Sun's version of Java.)How obligated are we to jump on board the newest upgraded software version of whatever we might be using?How does our desire for good job placement of our graduates square with our oft-repeated claim that we are educators, not trainers?Pursuing this issue of "where do we fall on the spectrum between training and education," what to do about all these industry certification programs - Cisco, Novell, Oracle, Microsoft. Do we teach these curricula? Do we give credit to students who take it, say at a community college, and then transfer?What about a service course in, say, Photoshop? Is this college-level material?Do opportunities for summer internships or research projects in an industry setting place some special obligations on us with respect to that company?
Teaching a software project course using the team software process
Authors: Cannon Robert , Hilburn Thomas B. , Diaz-Herrera Jorge
Published: July 2004

The tutorial is intended for faculty that will be teaching or have taught a software project course. It provides attendees with ideas, concepts, guidelines and experiences for teaching such a course using the introductory Team Software Process.
Loving to learn theory
Authors: Grinder Michael T. , Kim Seong B. , Lutey Teresa L. , Ross Rockford J. , Walsh Kathleen F.
Published: July 2004

Can students love to learn the theory of computing? This topic is, after all, probably the most challenging in the computer science curriculum. The academic structure in the United States from grade school on is not particularly good at preparing students to deal with mathematical abstractions in any case, and the kinds of abstractions that permeate the theory of computing are unlike any encountered in other math courses: strings, formal languages, and models of computation. Furthermore, there is often little correlation provided in a standard theory textbook between the theory and the real world of software development; students wonder just what the point of the course is. It is no surprise, then, that most students struggle with learning the theory of computing.It is tempting to forego teaching the theory of computing, since students not only struggle with it, but they often retain so little of it. This would be a mistake. Done properly, the theory course puts the "science" into computer science, giving aspiring practitioners a basis for understanding the fundamental laws that govern their discipline: there are problems that cannot be solved, there are intractable problems, there are limitations on the efficiency of the solutions to problems, and so on. Students not only need to know these fundamental truths about their field, but they also need to be able to apply this knowledge to their everyday work of programming.In this paper we describe recent advances in our long-term efforts in the Webworks Laboratory at Montana State University to make the theory of computing accessible to students through active learning modules designed for use on the web. While we won't be so bold as to say that students will actually
love
to learn the theory of computing as a result of having access to these modules, we can confidently say from our own experience that they will find learning the theory to be more
fun.
And that, we would all agree, is a big step towards helping students learn.
Integrating a simulation case study into CS2
Authors: Robbins Kay A. , Key Catherine Sauls , Dickinson Keith
Published: July 2004

Case studies are widely used in business and medicine to help students learn from the successes and failures of practitioners in the field. This paper discusses the potential benefits of case studies in computer science and how case studies differ from projects. We describe our preliminary experience with developing a network simulation case study for an object-oriented CS2 course and present some of ideas for teaching such a case study through close coupling of lectures with laboratories. The teaching materials for this case study are available on the web.
A multiplatform/multilanguage client/server project
Authors: Shay William
Published: July 2004

This paper introduces a more general client/server example than is typically described. Whereas many client/server examples often involve communication between two C programs or two Java programs, this paper describes a program demo containing two clients (one in C and one in Java) and two servers (one in C and one in Java). Furthermore, either client is capable of connecting to and downloading a file from either server using a socket connection over the TCP/IP protocol. None of these programs make any assumptions regarding what language or platform supports the program at the remote end.
To java.net and beyond
Authors: Gagne Greg
Published: July 2004

This paper covers the use of Java and its API for developing networking programs in an undergraduate computer networks class. Through the use of TCP and UDP sockets provided in the java.net package, students are able to write several client-server applications such as web and mail servers and a chat room. Additionally, the java.rmi API provides a library for invoking methods on remote objects, similar to remote procedure calls. Remote method invocation (RMI) is used to write a distributed version of the Producer-Consumer problem.
Evaluating the precision of static reference analysis using profiling
Authors: Liang Donglin , Pennings Maikel , Harrold Mary Jean
Published: July 2004

Program analyses and optimizations of Java programs require reference information that determines the instances that may be accessed through dereferences. Reference information can be computed using reference analysis. This paper presents a set of studies that evaluate the precision of two existing approaches for identifying instances and one approach for computing reference information in a reference analysis. The studies use dynamic reference information collected during run-time as a lower bound approximation to the precise reference information. The studies measure the precision of an existing approach by comparing the information computed using the approach with the lower bound approximation. The paper also presents case studies that attempt to identify the cases under which an existing approach is not effective. The presented studies provide information that may guide the usage of existing reference-analysis techniques and the development of new reference analysis techniques.
Dependence analysis in reduction of requirement based test suites
Authors: Vaysburg Boris , Tahat Luay H. , Korel Bogdan
Published: July 2004

Requirement-based automated test case generation is a model-based technique for generating test suites related to individual requirements. The technique supports test generation from EFSM (Extended Finite State Machine) system models. Several requirement-based selective test generation techniques were proposed. These techniques may significantly reduce a number of test cases with respect to a requirement under test as opposed to a complete system testing. However, the number of test cases may still be very large especially for large systems. In this paper, we present an approach of reduction of requirement based test suites using EFSM dependence analysis. Different types of dependencies are identified between elements of the EFSM system model. These dependencies capture potential interactions between elements of the model and are used to determine parts of the model that affect a requirement under test. This information is used to reduce the test suite by identifying repetitive tests,
i.e.,
tests that exhibit the same pattern of interactions with respect to the requirement under test. Our initial experience shows that this approach may significantly reduce the size of selective test suites.
Projected state machine coverage for software testing
Authors: Friedman G. , Hartman A. , Nagin K. , Shiran T.
Published: July 2004

Our research deals with test generation for software based on finite state machine (FSM) models of the program specification. We describe a set of coverage criteria and testing constraints for use in the automatic generation of test suites. We also describe the algorithms used to generate test suites based on these coverage criteria, and the implementation of these algorithms as an extension of the Murφ model checker[4]. The coverage criteria are simple but powerful in that they generate test suites of high quality and moderate volume, without requiring the user to have a sophisticated grasp of the test generation technology. The testing constraints are used to combat the endemic problem of state explosion, typically encountered in FSM techniques. We illustrate our techniques on several well-known problems from the literature and describe two industrial trials, to demonstrate the validity of our claims.
Conformance test experiments for distributed real-time systems
Authors: Cardell-Oliver Rachel
Published: July 2004

This paper introduces a new technique for testing that a distributed real-time system satisfies a formal timed automata specification. It outlines how to write test specifications in the language of Uppaal timed automata, how to translate those specifications into program code for executing the tests, and describes the results of test experiments on a distributed real-time system with limited hardware and software resources.
Specification, verification, and synthesis of concurrency control components
Authors: Yavuz-Kahveci Tuba , Bultan Tevfik
Published: July 2004

Run-time errors in concurrent programs are generally due to the wrong usage of synchronization primitives such as monitors. Conventional validation techniques such as testing become ineffective for concurrent programs since the state space increases exponentially with the number of concurrent processes. In this paper, we propose an approach in which 1) the concurrency control component of a concurrent program is formally specified, 2) it is verified automatically using model checking, and 3) the code for concurrency control component is automatically generated. We use monitors as the synchronization primitive to control access to a shared resource by multipleconcurrent processes. Since our approach decouples the concurrency control component from the rest of the implementation it is scalable. We demonstrate the usefulness of our approach by applying it to a case study on Airport Ground Traffic Control.We use the Action Language to specify the concurrency control component of a system. Action Language is a specification language for reactive software systems. It is supported by an infinite-state model checker that can verify systems with boolean, enumerated and udbounded integer variables. Our code generation tool automatically translates the verified Action Language specification into a Java monitor. Our translation algorithm employs symbolic manipulation techniques and the specific notification pattern to generate an optimized monitor class by eliminating the context switch overhead introduced as a result of unnecessary thread notification. Using counting abstraction, we show that we can automatically verify the monitor specifications for arbitrary number of threads.
Rescaling reliability bounds for a new operational profile
Authors: Bishop Peter G
Published: July 2004

One of the main problems with reliability testing and prediction is that the result is specific to a particular operational profile. This paper extends an earlier reliability theory for computing a worst case reliability bound. The extended theory derives a re-scaled reliability bound based on the change in execution rates of the code segments in the program. In some cases it is possible to derive a maximum failure rate bound that applies to
any
change in the profile. It also predicts that (in principle) a "fair" test profile can be derived where the reliability bounds are relatively insensitive to the operational profile. In addition the theory allows unit and module test coverage measures to be incorporated into an operational reliability bound prediction. The implications of the theory are discussed, and the theory is evaluated by applying it to two example programs with known faults.
Isolating failure-inducing thread schedules
Authors: Choi Jong-Deok , Zeller Andreas
Published: July 2004

Consider a multi-threaded application that occasionally fails due to non-determinism. Using the DEJAVU capture/replay tool, it is possible to record the thread schedule and replay the application in a deterministic way. By systematically narrowing down the difference between a thread schedule that makes the program pass and another schedule that makes the program fail, the Delta Debugging approach can pinpoint the error location automatically---namely, the location(s) where a thread switch causes the program to fail. In a case study, Delta Debugging isolated the failure-inducing schedule difference from 3.8 billion differences in only 50 tests.
Automatic generation of program specifications
Authors: Nimmer Jeremy W. , Ernst Michael D.
Published: July 2004

Producing specifications by dynamic (runtime) analysis of program executions is potentially unsound, because the analyzed executions may not fully characterize all possible executions of the program. In practice, how accurate are the results of a dynamic analysis? This paper describes the results of an investigation into this question, determining how much specifications generalized from program runs must be changed in order to be verified by a static checker. Surprisingly, small test suites captured nearly all program behavior required by a specific type of static checking; the static checker guaranteed that the implementations satisfy the generated specifications, and ensured the absence of runtime exceptions. Measured against this verification task, the generated specifications scored over 90% on precision, a measure of soundness, and on recall, a measure of completeness.This is a positive result for testing, because it suggests that dynamic analyses can capture all semantic information of interest for certain applications. The experimental results demonstrate that a specific technique, dynamic invariant detection, is effective at generating consistent, sufficient specifications for use by a static checker. Finally, the research shows that combining static and dynamic analyses over program specifications has benefits for users of each technique, guaranteeing soundness of the dynamic analysis and lessening the annotation burden for users of the static analysis.
Recursive algorithm with C++ program for floating-point arithmetic
Authors: Chung Sei-Jong
Published: July 2004

Floating point Arithmetic is a topic included in virtually all textbooks for Computer Systems (CS 3: ACM's Curriculum Recommendation) or for Computer Organization (CS 4: ACM's Curriculum Recommendation). This paper presents a mathematical optimization model for the topic. The problem of converting real (float) numbers into binary equivalents is first modeled as a Zero-One Integer Programming problem. Then, a Recursive Algorithm is formulated for Floating-Point Formats. Computer programs are written in both C and C++ for a 32-bit floating-point format, using the recursive algorithm. [The computer programs are available at the email
A proposal for a computer security course
Authors: Elorriaga Jon Ander , Gutiérrez Julián , Ibáñez Jesús , Usandizaga Imanol
Published: July 2004

Computer security is a relatively new subject in computer science curricula. We notice this in a moderate academic incidence or in an incomplete syllabus in most of the computer science teaching. The main goal of this article is to share the two years academic experience of the authors in this matter. The article makes a proposal for a first computer security subject. This proposal discusses theoretical and practical contents and the use of a different didactic methodology. Finally, the article refers to the positive results obtained on the students learning and acceptation of the contents taught and the used methodology. Marks and the results of a test made to the student population have confirmed this.
Using spreadsheets as a simple and effective teaching tool for predicting and visualizing parallel program performance
Authors: Juhasz Zoltan
Published: July 2004

This paper describes how we can use a spreadsheet program as an inexpensive and readily available tool to help students understand the execution behavior of parallel programs. Using the proposed method a performance prediction model can be created in a matter of minutes and the performance of the parallel system can be visualized and animated by using standard three-dimensional surface plots and user interface control objects.
Software engineering education
Authors: Návrat Pavol , Bieliková Mária
Published: July 2004

This paper discusses two important aspects of the software engineering related education: the context, both the current one and the historical background of the development and the contents of the education. We concentrate on the situation in Slovakia which has been very similar to other countries in the Central Europe, so it can be considered representative in some sense.
Using the entity-relationship model to teach the relational model
Authors: Apenyo Kofi
Published: July 2004

By far the two most important database models used in data management today are the relational and the entity-relationship models. In the database development cycle, entity-relationship modeling precedes the relational model work. Yet, in most textbooks and therefore in the classroom the relational model is presented before the entity-relationship model. The student is left to retrofit the entity-relationship model to the relational model. This paper advocates reversing this order of presentation so as to be in line with the database development cycle. The major benefit lies in taking advantage of this sequence to improve teaching the relational model. Assuming a prior treatment of conceptual modeling, examples and principles of the entity-relationship model are used to illustrate, elaborate, and even explain relational model concepts.
Teaching computer concepts using virtual machines
Authors: Ågren Ola
Published: July 2004

A set of virtual assemblers and a virtual machine are used as a teaching tool in order to teach students differences and similarities between architectural styles of computer processors. Programs written by the students in the virtual assemblers are compiled using the corresponding virtual assembler. They are then executed on the virtual machine so that students can follow the execution of the programs step by step or at full speed.
Teaching software engineering early
Authors: McCauley Renée , Jackson Ursula
Published: July 2004

In the fall of 1994, we reorganized the content of our three-course computer science introductory sequence in order to introduce software engineering concepts early and provide a consistent software engineering focus from one course to the next. We also established documentation and design standards that would serve as a framework for teaching the software engineering principles and techniques that we considered appropriate and essential to novice software developers. In an attempt to assess the impact of this new teaching process, we compared the performances in upper-level project-oriented courses of students who had been exposed to the new introductory sequence to those of students who had not.This paper describes the documentation and design standards established in 1994, their evolution over the past four years, and how these standards can be used as a framework for teaching software engineering concepts early in the curriculum. It also reports on what we have learned through tracking our students. We found that, in three upper-level courses, project grades for students exposed to software engineering concepts early averaged as much as half a letter grade higher than those of other students.
Open source development and the World Wide Web
Authors: Davis Chad , Bayrak Coskun
Published: July 2004

The development of the World Wide Web over the course of the past ten years has run rampant. The course it has taken has been both swift and unpredictable. The largest distributed system in the world began as a utopian notion of an interconnected and open web of information, the dream of the academic and intellectual alike. Today it is indeed a massive interconnected web of communication and content, but the content, largely on the more popular, if not pornographic, end of the mass media spectrum, is not what the founders intended.Coinciding with the rapid growth of the web has been the equally speedy rise of the open source development community, which can best be understood as a distributed system in its own right. Indeed, the development of the web has been, outside of the Linux project, the largest arena for open source development. And current trends, witnessed by such significant open source projects as Mozilla and Apache, seem to suggest that the open source way of doing things is quickly becoming the web way of doing things. However, there is a certain tension growing between those who would like to control, for economic profit or for the gratification of control itself, the direction of the web's development and those open source developers who are responsible for a large portion of that growth. This paper explores the natural relationship, as well as the growing tension within this relationship, between the open source development community and the World Wide Web.
Invited editorial
Authors: Turner Joe
Published: July 2004

Constant changes in courses and curricula seem to be a fact of life for computing programs. Having participated in several curriculum creation and modification efforts, and in two major curriculum recommendation projects [1,2], and also having observed and reviewed many curriculum development efforts by others during the past 20 years or so, I take this opportunity to offer some observations about computing programs and issues related to their evolution and maintenance. (The term computing is used here to include programs with a wide range of names such as computer science, informatics, information systems, and computer engineering.) Most of the observations and comments that I make have been made before by myself and others, and there is no intention to make this a complete discussion of such issues. Instead, I offer some observations that seem, to me, important and relevant for many of the problems that we face today.
Web-based application development
Authors: Hadjerrouit Said
Published: July 2004

In contrast to the construction of centralised software systems which relies on a well established approach, there is a lack of a proven methodology that guides software engineers in building web-based applications. The focus is still on technology rather than analysis and design issues. However, just as the focus in software engineering shifted from programming to process thirty years ago, the focus with web-based construction must shift from technical issues to the development process. This paper describes a software engineering methodology for developing web-based applications motivated by pedagogical and pragmatic considerations.
Information technology and liberal arts
Authors: Gupta Gireesh K.
Published: July 2004

A college campus without information technology resources is like a human body without the nervous system. Today, information technology is essential to learning and communication. Small liberal arts institutions must provide information technology resources on their campuses and must upgrade them regularly to incorporate technological advancements not only to provide better education, but also for the very survival.
Distributed expertise for teaching computer organization & architecture
Authors: Cassel Lillian (Boots) , Holliday Mark , Kumar Deepak , Impagliazzo John , Bolding Kevin , Pearson Murray , Davies Jim , Wolffe Gregory S. , Yurcik William
Published: July 2004

This report presents preliminary results from our project on creating distributed expertise for teaching computer organization & architecture course(s) in the undergraduate computer science curriculum. We present the details of an online survey designed to gather information from faculty on the current state of teaching this course. The survey also tries to identify specific areas of need for creating distributed expertise as reported by various faculty. We also present several resources that have been identified that are available for use by faculty teaching the course(s). This report represents a mid-point of an ongoing two-year study. Following a discussion of the currently identified needs, we discuss ways to address them and conclude the report with a plan of action that will follow in the next phase of the project.
Using computers in science and technology education
Authors: Lavonen Jari , Meisalo Veijo , Lattu Matti , Leinonen Liisa , Wilusz Tadeusz
Published: July 2004

This working group wishes to promote interaction of computer scientists and educational researchers. Such an interaction would benefit not only educational sciences and computer science education but also contribute to computer science e.g. through behaviour metaphors in robotics. We have initiated an analysis of computer uses in education starting from applications especially in science and technology education. Having analysed various roles of computers in educational processes in the above area we have also identified technological requirements of modern learning environments and defined the concept of a
rich learning environment.
We use the Open Market metaphor to concretise this concept in two different cases. Finally, we present as an outcome of our cooperative analysis basic goals for technological literacy and a description of a technology literate student.