bluuebunny/crossref_metadata_2025 huggingface dataset:
Practical dynamic software updating for C
Authors: Neamtiu Iulian , Hicks Michael , Stoyle Gareth , Oriol Manuel
Published: July 2006

Software updates typically require stopping and restarting an application, but many systems cannot afford to halt service, or would prefer not to.
Dynamic software updating
(DSU) addresses this difficulty by permitting programs to be updated while they run. DSU is appealing compared to other approaches for on-line upgrades because it is quite general and requires no redundant hardware. The challenge is in making DSU
practical
: it should be flexible, and yet safe, efficient, and easy to use.In this paper, we present Ginseng, a DSU implementation for C that aims to meet this challenge. We compile programs specially so that they can be dynamically patched, and generate most of a dynamic patch automatically. Ginseng performs a series of analyses that when combined with some simple runtime support ensure that an update will not violate type-safety while guaranteeing that data is kept up-to-date. We have used Ginseng to construct and dynamically apply patches to three substantial open-source server programs---
Very Secure FTP daemon
,
OpenSSH sshd daemon
, and
GNU Zebra
. In total, we dynamically patched each program with three years' worth of releases. Though the programs changed substantially, the majority of updates were easy to generate. Performance experiments show that all patches could be applied in less than 5
ms
, and that the overhead on application throughput due to updating support ranged from 0 to at most 32%.
Artemis
Authors: Fei Long , Midkiff Samuel P.
Published: July 2006

A number of hardware and software techniques have been proposed to detect dynamic program behaviors that may indicate a bug in a program. Because these techniques suffer from high overheads they are useful in finding bugs in programs before they are released, but are significantly less useful in finding bugs in long-running programs on production systems -- the same bugs that are the most difficult to find using traditional techniques. In this paper we propose the Artemis
1
is the Greek goddess of the hunt and wild animals. Our framework guides the hunt for wild bugs. compiler-based instrumentation framework that complements many pre-existing runtime monitoring techniques. The Artemis framework guides baseline monitoring techniques toward regions of the program where bugs are likely to occur, yielding a low asymptotic monitoring overhead. Artemis also facilitates system-load aware runtime monitoring that allows the monitoring coverage to be dynamically scaled up to take advantage of extra cycles when the system load is low, and dynamically scaled down to monitor only the most suspicious regions when the system load is high. Our experiments show that Artemis' asymptotic overhead can outperform the performance floor overhead of random sampling for many tools, and that Artemis can effectively guide a monitoring tool to the buggy regions of a program. Our experimental results show that Artemis applied to a hardware-based PC-invariance monitoring scheme and a value-based invariance detection and checking scheme significantly improves their runtime monitoring overhead (by up to 4.6 times) with moderate impact on their bug-detecting capabilities.
Optimizing data permutations for SIMD devices
Authors: Ren Gang , Wu Peng , Padua David
Published: July 2006

The widespread presence of SIMD devices in today's microprocessors has made compiler techniques for these devices tremendously important. One of the most important and difficult issues that must be addressed by these techniques is the generation of the data permutation instructions needed for non-contiguous and misaligned memory references. These instructions are expensive and, therefore, it is of crucial importance to minimize their number to improve performance and, in many cases, enable speedups over scalar code.Although it is often difficult to optimize an isolated data reorganization operation, a collection of related data permutations can often be manipulated to reduce the number of operations. This paper presents a strategy to optimize all forms of data permutations. The strategy is organized into three steps. First, all data permutations in the source program are converted into a generic representation. These permutations can originate from vector accesses to non-contiguous and misaligned memory locations or result from compiler transformations. Second, an optimization algorithm is applied to reduce the number of data permutations in a basic block. By propagating permutations across statements and merging consecutive permutations whenever possible, the algorithm can significantly reduce the number of data permutations. Finally, a code generation algorithm translates generic permutation operations into native permutation instructions for the target platform. Experiments were conducted on various kinds of applications. The results show that up to 77% of the permutation instructions are eliminated and, as a result, the average performance improvement is 48% on VMX and 68% on SSE2. For several applications, near perfect speedups have been achieved on both platforms.
DieHard
Authors: Berger Emery D. , Zorn Benjamin G.
Published: July 2006

Applications written in unsafe languages like C and C++ are vulnerable to memory errors such as buffer overflows, dangling pointers, and reads of uninitialized data. Such errors can lead to program crashes, security vulnerabilities, and unpredictable behavior. We present DieHard, a runtime system that tolerates these errors while probabilistically maintaining soundness. DieHard uses randomization and replication to achieve probabilistic memory safety by approximating an infinite-sized heap. DieHard's memory manager randomizes the location of objects in a heap that is at least twice as large as required. This algorithm prevents heap corruption and provides a probabilistic guarantee of avoiding memory errors. For additional safety, DieHard can operate in a replicated mode where multiple replicas of the same application are run simultaneously. By initializing each replica with a different random seed and requiring agreement on output, the replicated version of Die-Hard increases the likelihood of correct execution because errors are unlikely to have the same effect across all replicas. We present analytical and experimental results that show DieHard's resilience to a wide range of memory errors, including a heap-based buffer overflow in an actual application.
Reducing NoC energy consumption through compiler-directed channel voltage scaling
Authors: Chen Guangyu , Li Feihui , Kandemir Mahmut , Irwin Mary Jane
Published: July 2006

While scalable NoC (Network-on-Chip) based communication architectures have clear advantages over long point-to-point communication channels, their power consumption can be very high. In contrast to most of the existing hardware-based efforts on NoC power optimization, this paper proposes a compiler-directed approach where the compiler decides the appropriate voltage/frequency levels to be used for each communication channel in the NoC. Our approach builds and operates on a novel graph based representation of a parallel program and has been implemented within an optimizing compiler and tested using 12 embedded benchmarks. Our experiments indicate that the proposed approach behaves better - from both performance and power perspectives - than a hardwarebased scheme and the energy savings it achieves are very close to the savings that could be obtained from an optimal, but hypothetical voltage/frequency scaling scheme.
Cache-conscious coallocation of hot data streams
Authors: Chilimbi Trishul M. , Shaham Ran
Published: July 2006

The memory system performance of many programs can be improved by coallocating contemporaneously accessed heap objects in the same cache block. We present a novel profile-based analysis for producing such a layout. The analysis achieves cacheconscious coallocation of a hot data stream
H
(i.e., a regular data access pattern that frequently repeats) by isolating and combining allocation sites of object instances that appear in
H
such that intervening allocations coming from other sites are separated. The coallocation solution produced by the analysis is enforced by an automatic tool,
cminstr
, that redirects a program's heap allocations to a run-time coallocation library
comalloc
. We also extend the analysis to coallocation at object field granularity. The resulting field coallocation solution generalizes common data restructuring techniques, such as field reordering, object splitting, and object merging, and allows their combination. Furthermore, it provides insight into object restructuring by breaking down the coallocation benefit on a per-technique basis, which provides the opportunity to pick the "sweet spot" for each program. Experimental results using a set of memory-performance-limited benchmarks, including a few SPECInt2000 programs, and Microsoft VisualFoxPro, indicate that programs possess significant coallocation opportunities. Automatic object coallocation improves execution time by 13% on average in the presence of hardware prefetching. Hand-implemented field coallocation solutions for two of the benchmarks produced additional improvements (12% and 22%) but the effort involved suggests implementing an automated version for type-safe languages, such as Java and C#.
Algorithm specialization in generic programming
Authors: Järvi Jaakko , Gregor Douglas , Willcock Jeremiah , Lumsdaine Andrew , Siek Jeremy
Published: July 2006

Generic programming has recently emerged as a paradigm for developing highly reusable software libraries, most notably in C++. We have designed and implemented a constrained generics extension for C++ to support modular type checking of generic algorithms and to address other issues associated with unconstrained generics. To be as broadly applicable as possible, generic algorithms are defined with minimal requirements on their inputs. At the same time, to achieve a high degree of efficiency, generic algorithms may have multiple implementations that exploit features of specific classes of inputs. This process of algorithm specialization relies on non-local type information and conflicts directly with the local nature of modular type checking. In this paper, we review the design and implementation of our extensions for generic programming in C++, describe the issues of algorithm specialization and modular type checking in detail, and discuss the important design tradeoffs in trying to accomplish both.We present the particular design that we chose for our implementation, with the goal of hitting the sweet spot in this interesting design space.
Effective static race detection for Java
Authors: Naik Mayur , Aiken Alex , Whaley John
Published: July 2006

We present a novel technique for static race detection in Java programs, comprised of a series of stages that employ a combination of static analyses to successively reduce the pairs of memory accesses potentially involved in a race. We have implemented our technique and applied it to a suite of multi-threaded Java programs. Our experiments show that it is precise, scalable, and useful, reporting tens to hundreds of serious and previously unknown concurrency bugs in large, widely-used programs with few false alarms.
Profile-guided proactive garbage collection for locality optimization
Authors: Chen Wen-ke , Bhansali Sanjay , Chilimbi Trishul , Gao Xiaofeng , Chuang Weihaw
Published: July 2006

Many applications written in garbage collected languages have large dynamic working sets and poor data locality. We present a new system for continuously improving program data locality at run time with low overhead. Our system proactively reorganizes the heap by leveraging the garbage collector and uses profile information collected through a low-overhead mechanism to guide the reorganization at run time. The key contributions include making a case that garbage collection should be viewed as a proactive technique for improving data locality by triggering garbage collection for locality optimization independently of normal garbage collection for space, combining page and cache locality optimization in the same system, and demonstrating that sampling provides sufficiently detailed data access information to guide both page and cache locality optimization with low runtime overhead. We present experimental results obtained by modifying a commercial, state-of-the-art garbage collector to support our claims. Independently triggering garbage collection for locality optimization significantly improved optimizations benefits. Combining page and cache locality optimizations in the same system provided larger average execution time improvements (17%) than either alone (page 8%, cache 7%). Finally, using sampling limited profiling overhead to less than 3%, on average.
Correctness-preserving derivation of concurrent garbage collection algorithms
Authors: Vechev Martin T. , Yahav Eran , Bacon David F.
Published: July 2006

Constructing correct concurrent garbage collection algorithms is notoriously hard. Numerous such algorithms have been proposed, implemented, and deployed - and yet the relationship among them in terms of speed and precision is poorly understood, and the validation of one algorithm does not carry over to others.As programs with low latency requirements written in garbagecollected languages become part of society's mission-critical infrastructure, it is imperative that we raise the level of confidence in the correctness of the underlying system, and that we understand the trade-offs inherent in our algorithmic choice.In this paper we present correctness-preserving transformations that can be applied to an initial abstract concurrent garbage collection algorithm which is simpler, more precise, and easier to prove correct than algorithms used in practice--but also more expensive and with less concurrency. We then show how both pre-existing and new algorithms can be synthesized from the abstract algorithm by a series of our transformations. We relate the algorithms formally using a new definition of precision, and informally with respect to overhead and concurrency.This provides many insights about the nature of concurrent collection, allows the direct synthesis of new and useful algorithms, reduces the burden of proof to a single simple algorithm, and lays the groundwork for the automated synthesis of correct concurrent collectors.
Refinement-based context-sensitive points-to analysis for Java
Authors: Sridharan Manu , Bodík Rastislav
Published: July 2006

We present a scalable and precise context-sensitive points-to analysis with three key properties: (1) filtering out of unrealizable paths, (2) a context-sensitive heap abstraction, and (3) a context-sensitive call graph. Previous work [21] has shown that all three properties are important for precisely analyzing large programs, e.g., to show safety of downcasts. Existing analyses typically give up one or more of the properties for scalability. We have developed a refinement-based analysis that succeeds by simultaneously refining handling of method calls and heap accesses, allowing the analysis to precisely analyze important code while entirely skipping irrelevant code. The analysis is demanddriven and client-driven, facilitating refinement specific to each queried variable and increasing scalability. In our experimental evaluation, our analysis proved the safety of 61% more casts than one of the most precise existing analyses across a suite of large benchmarks. The analysis checked the casts in under 13 minutes per benchmark (taking less than 1 second per query) and required only 35MB of memory, far less than previous approaches.
Modular verification of assembly code with stack-based control abstractions
Authors: Feng Xinyu , Shao Zhong , Vaynberg Alexander , Xiang Sen , Ni Zhaozhong
Published: July 2006

Runtime stacks are critical components of any modern software--they are used to implement powerful control structures such as function call/return, stack cutting and unwinding, coroutines, and thread context switch. Stack operations, however, are very hard to reason about: there are no known formal specifications for certifying C-style setjmp/longjmp, stack cutting and unwinding, or weak continuations (in C--). In many proof-carrying code (PCC) systems, return code pointers and exception handlers are treated as general first-class functions (as in continuation-passing style) even though both should have more limited scopes.In this paper we show that stack-based control abstractions follow a much simpler pattern than general first-class code pointers. We present a simple but flexible Hoare-style framework for modular verification of assembly code with all kinds of stackbased control abstractions, including function call/return, tail call, setjmp/longjmp, weak continuation, stack cutting, stack unwinding, multi-return function call, coroutines, and thread context switch. Instead of presenting a specific logic for each control structure, we develop all reasoning systems as instances of a generic framework. This allows program modules and their proofs developed in different PCC systems to be linked together. Our system is fully mechanized. We give the complete soundness proof and a full verification of several examples in the Coq proof assistant.
Indus
Authors: Borah Kallol
Published: July 2006

Indus is a new object oriented programming language for Ubiquitous computing. The Indus programming language enables implementation of software agents that have the ability to cooperatively execute tasks by coordinating with other agents and composing components using connectors. The Indus programming model tightly integrates a set of run time libraries that automates the management of distributed agents and components across a variety of platforms and networks. Indus also differentiates itself from other general purpose, object oriented programming languages by being able to generate code on a variety of 8/16/32/64 bit platforms, thus making it ideal as a language for implementing pervasive applications.
Some suggestions for the use of tables in compilers
Authors: Murphy Mike
Published: July 2006

It is common practice in compilers to use tables to represent data, and then automatically generate code based on those tables (often known as "table-driven code"). Many compilers use machine description tables from which is automatically generated parts of the code generator, and there are often small pieces of table-driven code within a compiler. Sometimes these tables are very useful, but other times the tables themselves can become a maintenance nightmare. This paper uses examples from several SGI compilers to try and enumerate some guidelines for designing good tables and table-driven code.
Ethics and professionalism for an IT professional in the UAE
Authors: Bilal Sara Saeed , Hassan Fatma , Martin C. Dianne
Published: July 2006

In my last column, I provided my personal reflections on educating women in Dubai. In this column, I have asked two of the fourth-year students, Sara and Fatma, to provide their own views about the role that computer technology now plays in the UAE and the impact it is having on their culture. Their comments appear below.
An application of vector space theory in data transmission
Authors: Shiau LieJune
Published: July 2006

This work illustrates an application of vector spaces to data transmission theory. We show how Hamming code error detection and error correction are done through the tool of various theories in vector space. It is hoped that this article will explain the importance of abstract mathematics, such as vector space and basis, in the application of data transmission, which enlightens mathematics and computer science majors.
What should be visualized?
Authors: Brusilovsky Peter , Grady Jonathan , Spring Michael , Lee Chul-Hwan
Published: July 2006

To guide our work on adaptive explanatory program visualization the authors prepared a questionnaire that was broadly distributed among teachers of programming-related subjects. The questionnaire was designed to collect a list of topics that are considered important, but hard to teach and to solicit suggestions on using visualization for teaching these topics. This paper introduces the questionnaire, explains how it was administered, and presents the results that we consider of interest to the teachers of programming community.
Is CS1 better with the same lecture and lab instructor?
Authors: McCauley Renée , Starr Christopher , Pharr Walter , Stalvey RoxAnn , Pothering George
Published: July 2006

This paper presents results from a four-semester classroom experiment to assess whether the introductory programming lecture and closed-laboratory courses would be more effective if they were taught by the same or different instructors. Using a common final exam and lab practical as dependent variables, we determined there is no statistically significant effect on learning outcomes by having the same instructor for lecture and lab. Results of a qualitative survey, however, showed a statistically significant difference in student satisfaction for the same-instructor group over the different-instructor group.
MasterMind©
Authors: Lorenzen Torben , Chang Hang-Ling
Published: July 2006

For two semesters, the authors have tested CS1 introductory students on their ability to play the MasterMind© game at the beginning of the semester and compared those scores with in class programming test scores. The resulting correlations suggest that this game can be used as part of a computer programming aptitude test. This aptitude test could be used to advise potential students or employees about their probable success as programmers. Our survey of the literature yielded many programming aptitude tests with correlations lower than ours of 0.6; we are unique in using a game as an aptitude test.
Social issues of Computer Science in the "Methods of Teaching Computer Science in the High School" course
Authors: Hazzan Orit , Lapidot Tami
Published: July 2006

This paper discusses social issues of Computer Science in the context of the preparation of high school Computer Science teachers. Specifically, it focuses on the importance of addressing social issues in the Methods of Teaching Computer Science in the High School course and illustrates the actual teaching, in the course, of the following three social issues of Computer Science: ethics, diversity, and history of Computer Science.
Desirable attributes for computing graduates
Authors: Randall Cindy H. , Price Barbara A.
Published: July 2006

Students selecting information-based degree programs such as Information Systems (IS), Computer Science (CS), and Information Technology (IT) are entering into programs comprised of many analytical and technical classes. It would seem that if these programs are meeting their objectives, the skills and attributes these students believe lead to academic success would be viewed as critical by the faculty who teach in these programs or those approved by the Computing Accreditation Commission (CAC) of ABET, Inc. Students and faculty from three universities were surveyed on the importance of skills/attributes.
Experiences teaching a graduate research methods course
Authors: Shaffer Clifford A.
Published: July 2006

Teaching research methods to computer science graduate students presents a number of significant challenges. Of particular concern is the extreme breadth of material that must be covered and the diversity of the students taking the course. This paper describes the implementation of the graduate research methods course at Virginia tech. The primary goal of this course is to improve the ability of research-track students to perform graduate research and more generally to prepare for their professional career (not necessarily in research). A notable feature of our implementation is the use of authentic assignments whenever possible.
Computer literacy
Authors: Gupta Gireesh K.
Published: July 2006

Computer literacy is a fundamental part of undergraduate curriculum today. Computer literacy is as basic to undergraduate students as the course work in core curriculum in today's computer-centric information age [6]. The number of computers-in-use worldwide is growing, especially in the developing countries [3]. Computers affect every facet of our lives and every sector of the global society. Employers prefer workers who are computer literate because they are more productive and efficient at work than those who are not computer literate. This paper focuses on computer literacy and its benefits to people of all ages -- children, teenagers, adults and seniors. I also describe the implementation of computer competency requirement at Belmont Abbey College and the process students follow to satisfy this requirement in order to graduate.
Snobol bulletin no. 1
Authors: Waite William M.
Published: July 2006

It is appropriate to begin the first issue of the SNOBOL Bulletin by giving a brief survey of the SNOBOL processors currently available. This information has been derived from a number of sources, and its accuracy unfortunately cannot be guaranteed. In particular, the list may unintentionally omit a co-author of a SNOBOL implementation which we know of only indirectly. Any additions or corrections supplied by our readers will be greatly appreciated.
A cooperative uplink power control scheme for elastic data services in wireless CDMA systems
Authors: Alyfantis George , Hadjiefthymiades Stathes , Merakos Lazaros
Published: July 2006

We consider the uplink power control problem in a single cell CDMA wireless data system. Each user specifies upper and lower QoS bounds. We formulate the considered problem as a game, and first examine the non-cooperative case. We then compare it to its cooperative counterpart (through the Nash bargaining solution). The use of the cooperative scheme shows significant reduction in the transmission power of the mobile terminals, while the achieved QoS is slightly compromised, compared to the non-cooperative scheme.
Estimating network proximity and latency
Authors: Sharma Puneet , Xu Zhichen , Banerjee Sujata , Lee Sung-Ju
Published: July 2006

Network proximity and latency estimation is an important component in discovering and locating services and applications. With the growing number of services and service providers in the large-scale Internet, accurately estimating network proximity/latency with minimal probing overhead becomes essential for scalable deployment. Although there exist a number of network distance estimation schemes, they either rely on extensive infrastructure support, require the IP address of the potential targets, falsely cluster distant nodes, or perform poorly with even few measurement errors. We propose
Netvigator
, a scalable network proximity and latency estimation tool that uses information obtained from probing a small number of landmark nodes and intermediate routers (termed milestones) that are discovered en route to the landmarks, to identify the closest nodes. With very little additional probing overhead, Netvigator uses distance information to the milestones to accurately locate the closest nodes. We developed a Netvigator prototype and report our performance evaluation on PlanetLab and in the intranet of a large enterprise. Netvigator is a running service on PlanetLab as a part of HP Labs'
S
3
(Scalable Sensing Service).
A passive state-machine approach for accurate analysis of TCP out-of-sequence segments
Authors: Rewaskar Sushant , Kaur Jasleen , Smith F. Donelson
Published: July 2006

In this paper we describe a new tool being made available to the networking research community for passive analysis of TCP segment traces. The purpose of the tool is to provide more complete and accurate classification of out-of-sequence segments than those provided by prior tools. One of the crucial factors that limits the accuracy of prior tools is that these do not incorporate variations across TCP implementations (for different operating systems) that have different parameters (e.g., timer granularity, minimum RTO, duplicate ACK thresholds, etc.) or algorithms that influence what can be inferred about out-of-sequence segments. Our tool explicitly accounts for implementation-specific details in four prominent TCP stacks (Windows, Linux, FreeBSD/Mac OS-X, and Solaris). We validate our tool through several controlled experiments with instances of all four OS-specific implementations used in the analysis. We then run this tool on packet traces of 52 million Internet TCP connections collected from 5 different locations and present the results. We also include comparisons with results from running selected prior tools on the same traces.
Tmix
Authors: Weigle Michele C. , Adurthi Prashanth , Hernández-Campos Félix , Jeffay Kevin , Smith F. Donelson
Published: July 2006

In order to perform realistic network simulations, one needs a traffic generator that is capable of generating realistic synthetic traffic in a closed-loop fashion that "looks like" traffic found on an actual network. We describe such a traffic generation system for the widely used
ns-2
simulator. The system takes as input a packet header trace taken from a network link of interest. The trace is "reverse compiled" into a source-level characterization of each TCP connection present in the trace. The characterization, called a connection vector, is then used as input to an
ns
module called
tmix
that emulates the socket-level behavior of the source application that created the corresponding connection in the trace. This emulation faithfully reproduces the essential pattern of socket reads and writes that the original application performed without knowledge of what the original application actually was. When combined with a network path emulation component we have constructed called
DelayBox
, the resulting traffic generated in the simulation is statistically representative of the traffic measured on the real link. This approach to synthetic traffic generation allows one to automatically repro-duce in
ns
the full range of TCP connections found on an arbitrary link. Thus with our tools, researchers no longer need make arbitrary decisions on how traffic is generated in simulations and can instead easily generate TCP traffic that represents the use of a net-work by the full mix of applications measured on actual network links of interest. The method is evaluated by applying it to packet header traces taken from campus and wide-area networks and comparing the statistical properties of traffic on the measured links with traffic generated by
tmix
in
ns
.
The windows of pivate DNS updates
Authors: Broido Andre , Hyun Young , Fomenkov Marina , claffy kc
Published: July 2006

This work is motivated by the observation of one particular type of unwanted traffic -- dynamic DNS updates for private (RFC1918) addresses, which leaks to global network. This spurious traffic not only wastes network resources but also jeopardizes security and privacy of users.We first look at the magnitude of these updates on two independent AS112 [1] servers. We then analyze which operating systems are responsible for these updates by using three levels of signature techniques and find that over 97% of updates come from Windows systems. While newer versions of Windows OSes are more stringent in sending private DNS updates, we did not observe an overall decreasing trend due to this evolution. Users, software vendors, and system administrators can take steps to reduce this RFC1918 traffic. However, since most end users are unlikely to interfere with vendor default settings, it should be the responsibility of software vendor and system administrators to take positive action to fix this problem.
You must be joking... dares to ask
Authors: Faloutsos Michalis
Published: July 2006

What is the earliest sign of success for an idea or a trend? If you don't have insider's information like Martha Stewart, the best indication is seeing whether people are trying to associate their names with it. For example, AI has seen some rough patches until Spielberg produced the movie that gave that community credibility. (I wonder if program managers are affected by movie critics and reviews? Oops, there goes my funding for the foreseeable future). Case in point, how many articles have you seen paying tributes to the "father of AI"? How many people do you hear in talks claiming that they were there when the A and the I were separate and they were among the first, but really the very first, to join the two letters together.
An introduction to the WEKA data mining system
Authors: Markov Zdravko , Russell Ingrid
Published: July 2006

This is a proposal for a half day tutorial on Weka, an open source Data Mining software package written in Java and available from www.cs.waikato.ac.nz/~ml/weka/index.html. The goal of the tutorial is to introduce faculty to the package and to the pedagogical possibilities for its use in the undergraduate computer science and engineering curricula. The Weka system provides a rich set of powerful Machine Learning algorithms for Data Mining tasks, some not found in commercial data mining systems. These include basic statistics and visualization tools, as well as tools for pre-processing, classification, and clustering, all available through an easy to use graphical user interface.
Reducing lecture and increasing student activity in large computer science courses
Authors: Pargas Roy P.
Published: July 2006

This paper describes how one instructor uses a web-based tool called
MessageGrid
in a laptop-enhanced computer science course to accomplish five goals: (1) to solicit questions from students regarding pre-lecture reading assignments, (2) to engage the students in classroom activity that supports the lecture material for the day, (3) to conduct short, frequent assessments of student comprehension, (4) to conduct exercises that encourage peer-learning, and (5) to use
Ink
-based software animations to supplement the lecture material for the day. We present

MessageGrid

and explain how the short lecture exercises (called
lexes
) help engage the students in class. We show how the assessment component of
MessageGrid
helps students know whether or not they learning the material as they should, and enables the instructor to identify students who are falling behind. We present four different ways of designing lexes. We end with conclusions and plans for future work.
Combating anonymousness in populous CS1 and CS2 courses
Authors: Guerreiro Pedro , Georgouli Katerina
Published: July 2006

One of the causes for unsatisfactory results in first year programming courses, as we have observed, is anonymousness: individual students mostly follow the course without recognition from their peers and their teachers, and this often discourages them. Therefore, increasing the visibility of what happens in the classroom and in the labs, as well as helping the students to know who their colleagues are and how they are performing can be very helpful. We recommend three complementary educational strategies which include video recording the classes and making the recordings available on the Internet to help students to review the lectures, using a web-based learning management system to foster the communication between teachers and students and among students, and increasing the visibility of student work by adopting an automatic grading system for lab assignments which can in parallel be used for self-assessment purposes.
Experiences with marmoset
Authors: Spacco Jaime , Hovemeyer David , Pugh William , Emad Fawzi , Hollingsworth Jeffrey K. , Padua-Perez Nelson
Published: July 2006

We developed Marmoset, an automated submission and testing system, to explore techniques to provide improved feedback to both students and instructors as students work on programming assignments, and to collect data to perform detailed research on the development processes of students. To address the issue of feedback, Marmoset provides students with limited access to the results of the instructor's private test cases using a novel token-based incentive system. This both encourages students to start their work early and to think critically about their work. Because students submit early, instructors can monitor all students' progress on test cases, helping identify challenging or ambiguous test cases early in order to update the project specification or devote additional time in lecture or lab sessions to the difficult test cases.To study and better understand the development process of students, Marmoset can be configured to transparently capture snapshots to a central repository everytime students save their files. These detailed development histories offer a unique, detailed perspective of each student's progress on a programming assignment, from the first line of code written and saved all the way through the final edit before the final submission. This type of data has proven extremely valuable many uses, such as mining new bug patterns and evaluating existing bug-finding tools.In this paper, we describe our initial experiences using Marmoset in several introductory computer science courses, from the perspectives of both instructors and students. We also describe some initial research results from analyzing the student snapshot database.
High school computing clubs
Authors: Bennett Andrew , Briggs Joanna , Clark Martyn
Published: July 2006

While classes in IT skills are endemic, high school students in the UK rarely experience computer science. We present a pilot of a scheme that aims to go some way towards addressing this. Specifically, computing clubs were run on high school premises by high school teachers using material prepared by the University of Leeds School of Computing and supported by volunteer undergraduate mentors. Feedback suggests that the clubs were highly successful in their objectives of broadening understanding of the idea of a computer and introducing the concept of a computer program. School students, their teachers and the undergraduate volunteers all report an enjoyable, purposeful experience.
Industrial demand-driven curriculums for computer-software field in Korea
Authors: Pak Suehee , Rho Eunha , Chang Juno
Published: July 2006

In order to meet increasing industrial demand for quality IT experts in the computer-software field, demand-driven undergraduate curriculums have been developed and applied to college education in Korea. The computer-software field has been categorized into several specialized areas, tracks, and educational contents have been designed and constructed for each track. In this paper, a 6-phased curriculum development methodology is suggested and artifacts produced in each phase of the development process are described. By applying iterative and incremental principles of the methodology, all artifacts have been continuously updated.
The role of computer science in digital production arts
Authors: Davis Timothy A. , Kundert-Gibbs John
Published: July 2006

Special effects production is a rapidly expanding field in the film, television, and gaming industries. The educational goals and requirements for digital artists in these fields vary widely, and tend to change dramatically over short spans of time. Several years ago, we began a new graduate program at Clemson University to train students in this field. Though the impetus to develop the program originated in the computer science department, the department was not suited to cover all of the topics necessary, even with the addition of several new courses. Accordingly, the program was established as interdisciplinary, with major components in computer science and art. The computer science portion of the curriculum emphasizes basic computing concepts, especially programming. The program has evolved from a somewhat disparate collection of courses into a tighter, more integrated, educational experience, with a high graduate placement in the industry each year.
EduComponents
Authors: Amelung Mario , Piotrowski Michael , Rösner Dietmar
Published: July 2006

To reduce the workload of teachers and to improve the effectiveness of face-to-face courses, it is desirable to supplement them with Web-based tools. This paper presents our approach for supporting computer science education with software components which support the creation, management, submission, and assessment of assignments and tests, including the automatic assessment of programming exercises. These components are integrated into a general-purpose content management system (CMS) and can combined with other components to create tailor-made learning environments. We describe the design and implementation of these components, and we report on our practical experience with deploying the software in our courses.
Formative computer based assessment in diagram based domains
Authors: Higgins Colin A. , Bligh Brett
Published: July 2006

This paper presents an approach to conducting formative assessment of student coursework within diagram-based domains using Computer Based Assessment (CBA) technology. Formative assessment is perceived as a resource-intensive assessment mode and its usage is in steep decline in higher education. CBA technology developed out of the desire to automate assessment due to the necessity of assessing students with decreasing unit-resource; it can overcome the decline in formative assessment by automating those processes which are considered resource-intensive.The system described is based upon the CourseMarker CBA system (formerly CourseMaster / Ceilidh) and the DATsys object-oriented framework for CBA-oriented diagram editors. This paper outlines requirements for obtaining good formative assessment using CBA software and documents a live system which assessed student Entity Relationship diagrams within an undergraduate Database Systems course. Results are presented and considerable extensions proposed.
Putting threshold concepts into context in computer science education
Authors: Eckerdal Anna , McCartney Robert , Moström Jan Erik , Ratcliffe Mark , Sanders Kate , Zander Carol
Published: July 2006

This paper describes Threshold Concepts, a theory of learning that distinguishes core concepts whose characteristics can make them troublesome in learning. With an eye to applying this theory in computer science, we consider this notion in the context of related topics in computer science education.
A replicated experiment of pair-programming in a 2nd-year software development and design computer science course
Authors: Mendes Emilia , Al-Fakhri Lubna , Luxton-Reilly Andrew
Published: July 2006

This paper presents the results of a replicated pair programming experiment conducted at the University of Auckland (NZ) during the first semester of 2005. It involved 190 second year Computer Science students attending a software design and construction course. We replicated the experiment described in [18], investigating similar issues to those reported in [32] and employing a subset of the questionnaires used in [32]. Our results confirm the use of pair programming as an effective programming/design learning technique.
PNG palette permuter
Authors: Stevenson Daniel E.
Published: July 2006

Developing sophomore-level programming assignments that are both interesting to students and that have a good balance between low-level and high-level concepts is a difficult thing to do. The PNG Palette Permuter is a large assignment that does achieve this balance while still being based on topics such as encryption and image processing which students find interesting and relevant. Specifically, the Permuter involves compression, encryption, and steganography. This paper presents this project and discusses the interesting high and low-level issues that occur.
Building a search engine to drive problem-based learning
Authors: Bird Steven , Curran James R.
Published: July 2006

Search engines pervade the digital world, mediating most access to information instantaneously. We have found that students can build search engine components, and even entire search engines, in the context of problem-based learning in introductory and intermediate computer science courses. The courses cover a broad range of topics in algorithms, data structures, and web design, with a heavy emphasis on programming. Additionally, the internet is coupled with the syllabus at many places, from web design and HTML to graph algorithms and pattern matching. This connection enlivens the discussion of otherwise dry topics like searching, sorting, indexing and hashing. Moreover, the challenge of web-scale computing motivates the continuing students in their later study of formal topics like algorithmic complexity, while non-continuing students acquire transferable analytical skills. We report on the experience in search engine projects for driving problem-based learning in computer science courses, for both high school and university students. Our experience shows that such projects are effective in both introductory and intermediate courses, and readily encompass student groups with diverse programming abilities.
Developing real-world programming assignments for CS1
Authors: Stevenson Daniel E. , Wagner Paul J.
Published: July 2006

Instructors have struggled to generate good programming assignments for the CS1 course. In attempting to deal with this issue ourselves, we have generated two real-world programming assignments that can be solved by most students yet generate challenges for advanced students. We present our overall criteria for a quality programming assignment in CS1, details of the two example assignments, and other issues stemming from the generation and management of these assignments.
Teaching CS1 with graphics and C
Authors: Matzko Sarah , Davis Timothy A.
Published: July 2006

The goal of the τέχνη project is to teach computer science concepts more effectively by infusing large-scale problems in computer graphics into the undergraduate curriculum. Ultimately, this approach would be adopted for all computer science courses in the B.A. curriculum; currently, we are working on the foundational sequence, which includes CS1. For this first course in programming, we present our approach to teaching course concepts using real-world image processing problems in C. The results from our first semester offering are promising, as students produced excellent work and evaluated the class highly.
A web-based service for the automatic detection of roles of variables
Authors: Gerdt Petri , Sajaniemi Jorma
Published: July 2006

Learning elementary programming can be enhanced by introducing the notion of variable roles to students. This paper presents a web-based automatic role detection service that can be utilized in teaching when consolidating role knowledge. The service is based on data flow analysis techniques and uses machine learning to create flow characteristics for roles. The current version recognizes roles with 93% accuracy which is comparable to that of human role assigners.
One step further the ACM K-12 final report
Authors: Bianco Giovanni M. , Tinazzi Simonetta
Published: July 2006

Teaching computer science to children is a major priority in most countries in the world. Nevertheless, Computer Science curricula do not seem to address he children's world, children who need specific languages, models, and presentation methods. In this paper we propose a novel approach of considering a Computer Science Education curriculum based on children's creativity and imagination. The scope is the computer organization (aka Level 1 in he ACM K-12 Final Report). Materials have been designed for children, teachers and parents and take a gender-neutral approach.