bluuebunny/crossref_metadata_2025 huggingface dataset:
ETV
Authors: Terada Minoru
Published: October 2006

Although it is important for students to understand the behavior of programs they have written, it is not easy for novice students. We have designed and implemented a software tool to help such students by presenting a graphical representation of the execution trace data from their programs.ETV (Execution Trace Viewer), the tool, has the following characteristics: (1) Trace generation is automatic, (2) It is language-independent, (3) Visualizes source code as is (not in diagrams, figures etc.), (4) Offers random access along the execution, and (5) Source code is presented in overlapping windows which reflect the nesting nature of function calls (Paper-Slide-Show).
Teaching data modeling
Authors: Wagner Paul
Published: October 2006

While competition for scarce space in a Database Systems course curriculum increases, the amount of time spent in many such courses on data modeling decreases. We instead recommend increasing the amount of time spent in the study of data modeling and encourage data model study beyond formalism syntax. We do this in an attempt to help computer science students better understand complex data domains and to help develop higher-level skills that serve them well in a job market threatened by the increased outsourcing of lower level programming jobs. We further recommend the study of process skills as part of data modeling, and develop the idea of data patterns to assist students in the development of advanced data modeling skills.
The linguistics of object-oriented design
Authors: Holmboe Christian
Published: October 2006

This paper describes object-oriented (OO) design as a complex linguistic activity. Emphasis is made on the distinction between natural and artificial languages and its implication on the alleged naturalness of OO design. The difference between top-down and bottom-up approaches to system design is considered as a further aspect of great importance, which needs attention in teaching. Based on results from a large empirical research work, brief examples of student performance are offered as background for a more extensive discussion of implications for teaching.
Teaching networking hardware
Authors: Casado Martin , Watson Gregory , McKeown Nick
Published: October 2006

We present our experience with the design and teaching of a graduate-level networking hardware course in which students design and build an Internet router. Each team of two students (one proficient in hardware and one proficient in software) design and develop a fully functional router that routes live Internet traffic and inter-operates with other students' routers via a simple routing protocol. Hardware is designed in Verilog using an industry-standard design flow on a specially designed platform, called NetFPGA. Software is written in user-space using a high-level language. Software and hardware are combined and tested using real network traffic over arbitrary private topologies using a custom tool, called VNS. Our approach is distinguished in that both hardware and software can be designed, tested and deployed remotely over the Internet. Our goal is to give students experience in the design of complex networking systems. In our initial course offering in Spring 2004, all teams successfully implemented fully functional routers in less than ten weeks. We will pilot courses outside of Stanford using the remote teaching infrastructure presented in this paper.
The pedagogic opportunities of touch-screen voting
Authors: Jones Mark
Published: October 2006

Touch-screen systems have been used to count votes in a growing number of precincts across the United States. These controversial systems provide an opportunity for valuable classroom discussions both for service courses and courses for computer science majors.This paper begins with an overview of touch-screen voting systems in the United States. It describes ways to productively address this issue with university classes at various levels in the curriculum. It is hoped that this paper will be a useful resource to professors looking to bring this important issue into their classroom, perhaps as a partial requirement of an ethics and social implications module of a course's coverage.
Engaging students to work with self-assessment questions
Authors: Brusilovsky Peter , Sosnovsky Sergey
Published: October 2006

We explored two approaches for encouraging introductory programming students to use the web-based, self-assessment system, QuizPACK. An "organizational" approach applied specially constructed classroom quizzes, while the "technical" approach introduced adaptive guidance. Our studies demonstrated that each of these caused a dramatic increase in system use. This approach could be useful in many other contexts, when an educationally beneficial system is underused by students.
Student-built algorithm visualizations for assessment
Authors: Krebs Markus , Lauer Tobias , Ottmann Thomas , Trahasch Stephan
Published: October 2006

Students' understanding of algorithms and data structures can be assessed with the help of construction tasks where students have to build their own visualizations. It has been claimed that active construction of visualizations results in better learning outcomes than passive viewing or merely changing the input of a visualized algorithm. This paper presents a system for the generation, execution, and evaluation of construction tasks. Its key feature is the flexibility in all three stages, ranging from fully automated to fully manual generation and evaluation as well as several different types of automatic feedback during the execution phase. Besides its use in daily teaching, the system can serve as a test bed for evaluations regarding the effectiveness of visualizations in the learning process.
Computing curricula overview project
Authors: Impagliazzo John
Published: October 2006

This poster describes a work in progress regarding the Overview Computing Project formerly known as Computing Curricula 2004 (CC2004). It will demonstrate the status of this work and highlight its salient features. These features include the scope of the computing areas of computer engineering, computer science, information systems, information technology, and software engineering. It will illustrate their commonalities and differences, and show some of the outcome expectancies of the graduates from these programs.
Distributed team performance in software development
Authors: Hause Martha L.
Published: October 2006

International collaboration gives students the opportunity to use different technologies for collaboration across time and distance as well as problem-solving experience with different cultures in a team-based environment. Results indicate that not only is communication crucial to a team's success but the process and timing of specific actions can have an impact on a team's software development performance.
Computer game arena
Authors: Prakash Edmond C.
Published: October 2006

In this paper, we describe a Game Arena, which serves as a showcase for student projects in game programming and design.
Curricular projects of the ACM two-year college education committee
Authors: Campbell Robert D. , Hawthorne Elizabeth K. , Klee Karl J.
Published: October 2006

This poster presentation showcases the curricular guidelines developed by the Two-Year College Education Committee (TYCEC), a standing committee of the ACM Education Board.
Implicit functions lab
Authors: Prakash Edmond C.
Published: October 2006

This paper presents the design and development of a web-based collaboratory to teach computer graphics and to enhance peer-to-peer learning.
Bridging media breaks in presence presentations
Authors: Turban Georg , Rößling Guido , Trompler Christoph
Published: October 2006

The integration and fusion of different media input streams into one unique presentation stream is very important for maintaining the live aspect in recordings. The described core component of the
Digital Lecture Hall
[2] handles these requirements. It also supports annotating any content, as well as database storage for further processing of all collected materials.
TCgen 2.0
Authors: Burtscher Martin
Published: October 2006

This tutorial explains the usage of TCgen, a tool for generating portable lossless trace compressors based on user-provided trace format descriptions. TCgen automatically translates these descriptions into optimized C source code. In many cases, the synthesized code is faster and compresses better than BZIP2, GZIP, MACHE, PDATS II, SBC, SEQUITUR, and VPC3, making it ideal for trace-based research and teaching environments as well as for trace archives. Version 2 includes several improvements and simplifies the integration of the generated code with other code through a streamlined API.
Exploiting reference idempotency to reduce speculative storage overflow
Authors: Kim Seon Wook , Ooi Chong-Liang , Eigenmann Rudolf , Falsafi Babak , Vijaykumar T. N.
Published: October 2006

Recent proposals for multithreaded architectures employ speculative execution to allow threads with unknown dependences to execute speculatively in parallel. The architectures use hardware speculative storage to buffer speculative data, track data dependences and correct incorrect executions through roll-backs. Because
all
memory references access the speculative storage, current proposals implement speculative storage using small memory structures to achieve fast access. The limited capacity of the speculative storage causes considerable performance loss due to
speculative storage overflow
whenever a thread's speculative state exceeds the speculative storage capacity. Larger threads exacerbate the overflow problem but are preferable to smaller threads, as larger threads uncover more parallelism.In this article, we discover a new program property called
memory reference idempotency
. Idempotent references are guaranteed to be eventually corrected, though the references may be temporarily incorrect in the process of speculation. Therefore, idempotent references, even from nonparallelizable program sections, need not be tracked in the speculative storage, and instead can directly access nonspeculative storage (i.e., conventional memory hierarchy). Thus, we reduce the demand for speculative storage space in large threads. We define a formal framework for reference idempotency and present a novel compiler-assisted speculative execution model. We prove the necessary and sufficient conditions for reference idempotency using our model. We present a compiler algorithm to label idempotent memory references for the hardware. Experimental results show that for our benchmarks, over 60% of the references in nonparallelizable program sections are idempotent.
The NP-completeness column
Authors: Johnson David S.
Published: October 2006

This is the 25th edition of a column that covers new developments in the theory of NP-completeness. The presentation is modeled on that which M. R. Garey and I used in our book
Computers and Intractability: A Guide to the Theory of NP-Completeness
, W. H. Freeman & Co., New York, 1979, hereinafter referred to as “[G&J].” Previous columns, the first 23 of which appeared in
Journal of Algorithms
, will be referred to by a combination of their sequence number and year of appearance, for example, [Col 1, 1981]. Full bibliographic details on the previous columns as well as downloadable unofficial versions of them can be found at http://www.reseach.att.com/~dsj/columns/. This edition of the column discusses the wide range of lower bounds on approximation guarantees for NP-hard optimization problems both in their functional forms and in the hypotheses on which they depend.
Storing a persistent transactional object heap on flash memory
Authors: Spivak Michal , Toledo Sivan
Published: October 2006

We present the design and implementation of T
iny
S
tore
, a persistent, transactional, garbage-collected memory-management system, designed to be called from the Java virtual machine of a Java Card. The system is designed for flash-based implementations of Java Card, a variant of the Java platform for smart cards. In the Java Card platform, objects are persistent by default. The platform supports transactions: a sequence of accesses to objects can be explicitly declared to constitute a transaction. T
iny
S
tore
supports explicit transactions and atomically executes individual accesses that are not part of transactions; it also supports garbage collection, even on systems with a small constant amount of
ram
. T
iny
S
tore
uses a novel approach and specialized data structures to efficiently manage flash memory. We demonstrate its effectiveness by comparing it to a traditional
eeprom
-based memory management system for Java Cards.
Deriving abstract transfer functions for analyzing embedded software
Authors: Regehr John , Duongsaa Usit
Published: October 2006

This paper addresses the problem of creating abstract transfer functions supporting dataflow analyses. Writing these functions by hand is problematic: transfer functions are difficult to understand, difficult to make precise, and difficult to debug. Bugs in transfer functions are particularly serious since they defeat the soundness of any program analysis running on top of them. Furthermore, implementing transfer functions by hand is wasteful because the resulting code is often difficult to reuse in new analyzers and to analyze new languages. We have developed algorithms and tools for deriving transfer functions for the bitwise and unsigned interval abstract domains. The interval domain is standard; in the bitwise domain, values are vectors of three-valued bits. For both domains, important challenges are to derive transfer functions that are sound in the presence of integer overflow, and to derive precise transfer functions for operations whose semantics are a mismatch for the domain (i.e., bit-vector operations in the interval domain and arithmetic operations in the bitwise domain). We can derive transfer functions, and execute them, in time linear in the bitwidth of the operands. These functions are maximally precise in most cases. Our generated transfer functions are parameterized by a bitwidth and are independent of the language being analyzed, and also of the language in which the analyzer is written. Currently, we generate interval and bitwise transfer functions in C and OCaml for analyzing C source code, ARM object code, and AVR object code. We evaluate our derived functions by using them in an interprocedural dataflow analyzer.
Pluggable abstract domains for analyzing embedded software
Authors: Cooprider Nathan , Regehr John
Published: October 2006

Many abstract value domains such as intervals, bitwise, constants, and value-sets have been developed to support dataflow analysis. Different domains offer alternative tradeoffs between analysis speed and precision. Furthermore, some domains are a better match for certain kinds of code than others. This paper presents the design and implementation of cXprop, an analysis and transformation tool for C that implements "conditional X propagation," a generalization of the well-known conditional constant propagation algorithm where X is an abstract value domain supplied by the user. cXprop is interprocedural, context-insensitive, and achieves reasonable precision on pointer-rich codes. We have applied cXprop to sensor network programs running on TinyOS, in order to reduce code size through interprocedural dead code elimination, and to find limited-bitwidth global variables. Our analysis of global variables is supported by a novel concurrency model for interrupt-driven software. cXprop reduces TinyOS application code size by an average of 9.2% and predicts an average data size reduction of 8.2% through RAM compression.
Effective compiler generation by architecture description
Authors: Farfeleder Stefan , Krall Andreas , Steiner Edwin , Brandner Florian
Published: October 2006

Embedded systems have an extremely short time to market and therefore require easily retargetable compilers. Architecture description languages (ADLs) provide a single concise architecture specification for the generation of hardware, instruction set simulators and compilers. In this article, we present an ADL for compiler generation. From a specification, we can derive an optimized tree pattern matching instruction selector, a register allocator and an instruction scheduler. Compared to a hand-crafted back end, the generated compiler produces smaller and faster code.The ADL is rich enough that other tools, such as assemblers, linkers, simulators and documentation, can all be obtained from a single specification.
Procrastination for leakage-aware rate-monotonic scheduling on a dynamic voltage scaling processor
Authors: Chen Jian-Jia , Kuo Tei-Wei
Published: October 2006

As the dynamic voltage scaling (DVS) technique provides system engineers the flexibility to trade-off the performance and the energy consumption, DVS has been adopted in many computing systems. However, the longer a job executes, the more energy in the leakage current the device/processor consumes for the job. To reduce the energy consumption resulting from the leakage current, a system might enter the dormant mode. This paper targets energy-efficient rate-monotonic scheduling for periodic real-time tasks on a uniprocessor DVS system with non-negligible leakage power consumption. An on-line simulated scheduling strategy and a virtually blocking time strategy are developed for procrastination scheduling to reduce energy consumption. The proposed algorithms derive a feasible schedule for real-time tasks with worst-case guarantees for any input instance. Experimental results show that our proposed algorithms could derive energy-efficient solutions.
Bypass aware instruction scheduling for register file power reduction
Authors: Park Sanghyun , Shrivastava Aviral , Dutt Nikil , Nicolau Alex , Paek Yunheung , Earlie Eugene
Published: October 2006

Since register files suffer from some of the highest power densities within processors, designers have investigated several architectural strategies for register file power reduction, including "On Demand RF Read" where the register file is read only if the operand value is not available from the bypasses. However, we show in this paper that significant additional reductions in the register file power consumption can be obtained by scheduling instructions so that they transfer the operands via bypasses, rather than reading from the register file. Such instruction scheduling requires the compiler to be cognizant of the bypasses in the processor pipeline. In this paper, we develop several bypass aware instruction scheduling heuristics varying in time complexity, and study their effectiveness on the Intel XScale processor pipeline running MiBench benchmarks. Our experimental results show additional power consumption reductions of up to 26% and on average 12% over and above the register file power reduction achieved through existing techniques.
Improving flow analyses via ΓCFA
Authors: Might Matthew , Shivers Olin
Published: October 2006

We present two independent and complementary improvements for flow-based analysis of higher-order languages: (1)
abstract garbage collection
and (2)
abstract counting
, collectively titled ΓCFA.Abstract garbage collection is an analog to its concrete counterpart: we determine when an abstract resource has become unreachable, and then reallocate it as fresh. This prevents flow sets from merging in the abstract, which has two immediate effects: (1) the precision of the analysis is increased, and (2) the running time of the analysis is frequently reduced. In some nontrivial cases, we achieve an order of magnitude improvement in precision and time
simultaneously
.In abstract counting, we track how many times an abstract resource has been allocated. A count of one implies that the abstract resource momentarily represents only one concrete resource. This, in turn, allows us to perform environment analysis and to expand the kinds (rather than just the degree) of optimizations available to the compiler.
Recursive modules for programming
Authors: Nakata Keiko , Garrigue Jacques
Published: October 2006

TheML module system is useful for building large-scale programs. The programmer can factor programs into nested and parameterized modules, and can control abstraction with signatures. Yet ML prohibits recursion between modules. As a result of this constraint, the programmer may have to consolidate conceptually separate components into a single module, intruding on modular programming. Introducing recursive modules is a natural way out of this predicament. Existing proposals, however, vary in expressiveness and verbosity. In this paper, we propose a type system for recursive modules, which can infer their signatures. Opaque signatures can also be given explicitly, to provide type abstraction either inside or outside the recursion. The type system is decidable, and is sound for a call-by-value semantics. We also present a solution to the expression problem, in support of our design choices.
The missing link
Authors: Rossberg Andreas
Published: October 2006

Despite its powerful module system, ML has not yet evolved for the modern world of dynamic and open modular programming, to which more primitive languages have adapted better so far. We present the design and semantics of a simple yet expressive firstclass component system for ML. It provides dynamic linking in a type-safe and type-flexible manner, and allows selective execution in sandboxes. The system is defined solely by reduction to higherorder modules plus an extension with simple module-level dynamics, which we call
packages
. To represent components outside processes we employ generic
pickling
. We give a module calculus formalising the semantics of packages and pickling.
Equality of streams is a Π0 over 2-complete problem
Authors: Roşu Grigore
Published: October 2006

This paper gives a precise characterization for the complexity of the problem of proving equal two streams defined with a finite number of equations: Π0 over 2. Since the Π 0 over 2 class includes properly both the reursively enumerable and the corecursively enumerable classes, this result implies that neither the set of pairs of equal streams nor the set of pairs of unequal streams is recursively enumerable. Consequently, one can find no algorithm for determining equality of streams, as well as no algorithm for determining inequality of streams. In particular, there is no complete proof system for equality of streams and no complete system for inequality of streams.
OCaml + XDuce
Authors: Frisch Alain
Published: October 2006

This paper presents the core type system and type inference algorithm of OCamlDuce, a merger between OCaml and XDuce. The challenge was to combine two type checkers of very different natures while preserving the best properties of both (principality and automatic type reconstruction on one side; very precise types and implicit subtyping on the other side). Type inference can be described by two successive passes: the first one is an ML-like unification-based algorithm which also extracts data flow constraints about XML values; the second one is an XDuce-like algorithm which computes XML types in a direct way. An optional preprocessing pass, called strengthening, can be added to allow more implicit use of XML subtyping. This pass is also very similar to an ML type checker.
biXid
Authors: Kawanaka Shinya , Hosoya Haruo
Published: October 2006

Often, independent organizations define and advocate different XML formats for a similar purpose and, as a result, application programs need to mutually convert between such formats. Existng XML transformation languages, such as XSLT and XDuce, are unsatisfactory for this purpose since we would have to write, e.g., two programs for the forward and the backward transformations in case of two formats, incur high developing and maintenance costs.This paper proposes the
bidirectional
XML transformation language biXid, allowing us to write only one program for both directions of conversion. Our language adopts a common paradigm
programming-by-relation
, where a program defines a relation over documents and transforms a document to another in a way satisfying this relation. Our contributions here are specific language features for facilitating realistic conversions whose target formats are loosely in parallel but have many discrepancies in details. Concretely, we (1) adopt XDuce-style regular expression patterns for describing and analyzing XML structures, (2) fully permit
ambiguity
for treating formats that do not have equivalent expressivenesses, and (3) allow
non-linear
pattern variables for expressing non-trivial transformations that cannot be written only with linear patterns, such as conversion between unordered and ordered data.We further develop an efficient evaluation algorithm for biXid, consisting of the "parsing" phase that transforms the input document to an intermediate "parse tree" structure and the "unparsing" phase that transforms it to an output document. Both phases use a variant of finite tree automata for performing a one-pass scan on the input or the parse tree by using a standard technique that "maintains the set of all transitable states." However, the construction of the "unparsing" phase is challenging since ambiguity causes different ways of consuming the parse tree and thus results in multiple possible outputs that may have different structures.We have implemented a prototype system of biXid and confirmed that it has enough expressiveness and a linear-time performance from experiments with several realistic bidirectional transformations including one between vCard-XML and ContactXML.
Fifteen years of functional pearls
Authors: Bird Richard S.
Published: October 2006

In 1991, when the
Journal of Functional Programming
was inaugurated, the editors, Simon Peyton Jones and Philip Wadler, asked me to contribute a regular column to be called
Functional Pearls
. The idea was to emulate the very successful series of essays that Jon Bentley had written under the title
Programming Pearls
in the
Communications of the ACM
. A possible alternative model for the column was Martin Rem's
Small Programming Exercises
that appeared regularly in the
Science of Computer Programming
in the 1980s. In Rem's articles, various programming tasks were posed in one issue, and solved in the subsequent one. It was felt that similar material could be adapted to a functional style, using equational reasoning rather than the Dijkstra-Hoare framework to derive the final product. After all, one reason that functional programming stimulated the interest of many at that time was that it was good for equational reasoning, a slogan captured in Mark Jone's GOFER system (Good For Equational Reasoning).I agreed to the suggestion, but only under the proviso that other contributors to the column should be sought. Counting to the end of the present year, 2006, about 64 pearls will have appeared in JFP, of which I have written 14. There are also various pearls that have been presented at ICFP and at MPC (
Mathematics of Program Construction
). The pearls range in content, from (hopefully) instructive exercises in program calculation - my own area of interest, to attractive presentations of new functional data structures - of which Ralf Hinze and Chris Okasaki were the main contributors, as well as interesting algorithms in their own right, such as Runciman's
Lazy wheel sieves
, and Huet's
Zipper
.This talk will review a little of the history of Functional Pearls, and tentatively try to suggest what ingredients make a good pearl and how pearls differ from normal research papers. Indeed, my brief from the Program Chair for this talk was expressed as follows: "Well done Functional Pearls are often the highlight of an ICFP conference, but many of the submitted ones somehow miss the mark, by being too trivial, too complicated, or somehow not quite the elegant solution one hopes for. So it would be interesting to hear about your experiences as to what makes a good one and how to go about creating it.Having accepted this daunting commission, and being mindful of Horace's remark that good advice should be short, I am now busily engaged in finding a pearl that is not too trivial, nor too complicated, and is sufficiently elegant to serve as a decent example, both to illustrate the talk and to provide some technical content.
Access control in a core calculus of dependency
Authors: Abadi Martín
Published: October 2006

The Dependency Core Calculus (DCC) is an extension of the computational lambda calculus that was designed in order to capture the notion of dependency that arises in information-flow control, partial evaluation, and other programming-language settings. We show that, unexpectedly, DCC can also be used as a calculus for access control in distributed systems. Initiating the study of DCC from this perspective, we explore some of its appealing properties.
Complying with Compliance
Authors: Allman Eric
Published: October 2006

“Hey, compliance is boring. Really, really boring. And besides, I work neither in the financial industry nor in health care. Why should I care about SOX and HIPAA?” Yep, you’re absolutely right. You write payroll applications, or operating systems, or user interfaces, or (heaven forbid) e-mail servers. Why should you worry about compliance issues?
Extending task technology fit with computer self-efficacy
Authors: Strong Diane M. , Dishaw Mark T. , Bandy D. Brent
Published: October 2006

This study is part of a stream of research that has a goal of understanding software utilization choices of users by extending and testing TTF models in a variety of domains using various methods of model estimation. In particular, this study extends a Task-Technology Fit (TTF) model by including the Computer Self-Efficacy (CSE) construct, a strategy of model extension suggested by Berthon et al. (2002). In this study, the domain is the utilization of modeling tools by business students. The TTF models are estimated using PLS. This study finds that CSE, i.e., users' beliefs in their ability to use a technology, in a TTF model increases the explanatory power of the model over one with only task characteristics, technology functionality, and the fit (interaction) between them. CSE has a direct effect on tool utilization, but no significant interaction, i.e., fit, effects.
An approach toward profit-driven optimization
Authors: Zhao Min , Childers Bruce R. , Soffa Mary Lou
Published: October 2006

Although optimizations have been applied for a number of years to improve the performance of software, problems with respect to the application of optimizations have not been adequately addressed. For example, in certain circumstances, optimizations may degrade performance. However, there is no efficient way to know when a degradation will occur. In this research, we investigate the profitability of optimizations, which is useful for determining the benefit of applying optimizations. We develop a framework that enables us to predict profitability using analytic models. The profitability of an optimization depends on code context, the particular optimization, and machine resources. Thus, our framework has analytic models for each of these components. As part of the framework, there is also a profitability engine that uses models to predict the profit. In this paper, we target scalar optimizations and, in particular, describe the models for partial redundancy elimination (PRE), loop invariant code motion (LICM), and value numbering (VN). We implemented the framework for predicting the profitability of these optimizations. Based on the predictions, we can selectively apply profitable optimizations. We compared the profit-driven approach with an approach that uses a heuristic in deciding when optimizations should be applied. Our experiments demonstrate that the profitability of scalar optimizations can be accurately predicted by using models. That is, without actually applying a scalar optimization, we can determine if an optimization is beneficial and should be applied.
Generation of problems, answers, grade, and feedback---case study of a fully automated tutor
Authors: Kumar Amruth N.
Published: October 2006

Researchers and educators have been developing tutors to help students learn by solving problems. The tutors vary in their ability to generate problems, generate answers, grade student answers, and provide feedback. At one end of the spectrum are tutors that depend on hand-coded problems, answers, and feedback. These tutors can be expected to be pedagogically effective, since all the problem-solving content is carefully hand-crafted by a teacher. However, their repertoire is limited. At the other end of the spectrum are tutors that can automatically generate problems, answers, and feedback. They have an unlimited repertoire, but it is not clear that they are effective in helping students learn. Most extant tutors lie somewhere along this spectrum.In this article we examine the feasibility of developing a tutor that can automatically generate problems, generate answers, grade student answers, and provide feedback. We investigate whether such a tutor can help students learn. For our study, we considered a tutor for our Programming Languages course, which covers static and dynamic scope (i.e., static scope of variables and procedures, dynamic scope of variables, and static and dynamic referencing environment of procedures in the context of a language that permits nested procedure definitions). The tutor generates simple and complex problems on each of these five topics, solves the problems, grades the students' answers, and provides feedback about incorrect and missed answers. Our evaluation over two semesters shows that the feedback provided by the tutor helps improve student learning.
End-to-end routing behavior in the internet
Authors: Paxson Vern
Published: October 2006

The large-scale behavior of routing in the Internet has gone virtually without any formal study, the exception being Chinoy's analysis of the dynamics of Internet routing information [Ch93]. We report on an analysis of 40,000 end-to-end route measurements conducted using repeated "traceroutes" between 37 Internet sites. We analyze the routing behavior for pathological conditions, routing stability, and routing symmetry. For pathologies, we characterize the prevalence of routing loops, erroneous routing, infrastructure failures, and temporary outages. We find that the likelihood of encountering a major routing pathology more than doubled between the end of 1994 and the end of 1995, rising from 1.5% to 3.4%. For routing stability, we define two separate types of stability, "prevalence," meaning the overall likelihood that a particular route is encountered, and "persistence," the likelihood that a route remains unchanged over a long period of time. We find that Internet paths are heavily dominated by a single prevalent route, but that the time periods over which routes persist show wide variation, ranging from seconds up to days. About 2/3's of the Internet paths had routes persisting for either days or weeks. For routing symmetry, we look at the likelihood that a path through the Internet visits at least one different city in the two directions. At the end of 1995, this was the case half the time, and at least one different autonomous system was visited 30% of the time.
N-body simulations
Authors: Sharp Philip W.
Published: October 2006

We describe four challenging N-body test problems involving the Sun and planets and use them to compare the performance of nine nonsymplectic and two symplectic integrators. Each problem has a long interval of integration and two have non-Newtonian gravitational interactions. The emphasis in our comparison is on the accuracy of the solution, including the phase information produced by nonsympletic methods; the symplectic methods have been included to provide a contrast. Long intervals of integration necessitate small local error tolerances for the nonsymplectic integrators.Among variable-stepsize integrators, RKNINT requires the least CPU time on the two problems with Newtonian interactions and DIVA the least CPU time on the other two problems for the intervals of integration we used. We find that the error growth on some integrations is noticeably slower than predicted by asymptotic analysis of the truncation and round-off error. Our comparisons suggest that the numerical solutions near the end of a billion year simulation in double precision with variable-stepsize nonsymplectic methods would have poor accuracy.
Globally distributed software development and pair programming
Authors: Flor Nick V.
Published: October 2006

The benefits of pair programming are unquestioned provided the pairs work in close proximity. Globally distributed software development creates opportunities for remote pair programming. What must be done to yield the same benefits?
User-level internet path diagnosis
Authors: Mahajan Ratul , Spring Neil , Wetherall David , Anderson Thomas
Published: October 2006

Diagnosing faults in the Internet is arduous and time-consuming, in part because the network is composed of diverse components spread across many administrative domains. We consider an extreme form of this problem: can end users, with no special privileges, identify and pinpoint faults inside the network that degrade the performance of their applications? To answer this question, we present both an architecture for user-level Internet path diagnosis and a practical tool to diagnose paths in the current Internet. Our architecture requires only a small amount of network support, yet it is nearly as complete as analyzing a packet trace collected at all routers along the path. Our tool, tulip, diagnoses reordering, loss and significant queuing events by leveraging well deployed but little exploited router features that approximate our architecture. Tulip can locate points of reordering and loss to within three hops and queuing to within four hops on most paths that we measured. This granularity is comparable to that of a hypothetical network tomography tool that uses 65 diverse hosts to localize faults on a given path. We conclude by proposing several simple changes to the Internet to further improve its diagnostic capabilities.
Measurement, modeling, and analysis of a peer-to-peer file-sharing workload
Authors: Gummadi Krishna P. , Dunn Richard J. , Saroiu Stefan , Gribble Steven D. , Levy Henry M. , Zahorjan John
Published: October 2006

Peer-to-peer (P2P) file sharing accounts for an astonishing volume of current Internet traffic. This paper probes deeply into modern P2P file sharing systems and the forces that drive them. By doing so, we seek to increase our understanding of P2P file sharing workloads and their implications for future multimedia workloads. Our research uses a three-tiered approach. First, we analyze a 200-day trace of over 20 terabytes of Kazaa P2P traffic collected at the University of Washington. Second, we develop a model of multimedia workloads that lets us isolate, vary, and explore the impact of key system parameters. Our model, which we parameterize with statistics from our trace, lets us confirm various hypotheses about file-sharing behavior observed in the trace. Third, we explore the potential impact of locality-awareness in Kazaa.Our results reveal dramatic differences between P2P file sharing and Web traffic. For example, we show how the immutability of Kazaa's multimedia objects leads clients to fetch objects at most once; in contrast, a World-Wide Web client may fetch a popular page (e.g., CNN or Google) thousands of times. Moreover, we demonstrate that: (1) this "fetch-at-most-once" behavior causes the Kazaa popularity distribution to deviate substantially from Zipf curves we see for the Web, and (2) this deviation has significant implications for the performance of multimedia file-sharing systems. Unlike the Web, whose workload is driven by document change, we demonstrate that clients' fetch-at-most-once behavior, the creation of new objects, and the addition of new clients to the system are the primary forces that drive multimedia workloads such as Kazaa. We also show that there is substantial untapped locality in the Kazaa workload. Finally, we quantify the potential bandwidth savings that locality-aware P2P file-sharing architectures would achieve.
The Long Road to 64 Bits
Authors: Mashey John R.
Published: October 2006

Shakespeare’s words often cover circumstances beyond his wildest dreams. Toil and trouble accompany major computing transitions, even when people plan ahead. To calibrate “tomorrow’s legacy today,” we should study “tomorrow’s legacy yesterday.” Much of tomorrow’s software will still be driven by decades-old decisions. Past decisions have unanticipated side effects that last decades and can be difficult to undo.
The Heart of Eclipse
Authors: Rubel Dan
Published: October 2006

ECLIPSE is both an open, extensible development environment for building software and an open, extensible application framework upon which software can be built. Considered the most popular Java IDE, it provides a common UI model for working with tools and promotes rapid development of modular features based on a plug-in component model. The Eclipse Foundation designed the platform to run natively on multiple operating systems, including Macintosh, Windows, and Linux, providing robust integration with each and providing rich clients that support the GUI interactions everyone is familiar with: drag and drop, cut and paste (clipboard), navigation, and customization. You can think of Eclipse as a “design center” supported by a development team of 300 or more developers whom you can leverage when developing your own software.
The role of domain ontologies in database design
Authors: Sugumaran Vijayan , Storey Veda C.
Published: October 2006

Database design is difficult because it involves a database designer understanding an application and translating the design requirements into a conceptual model. However, the designer may have little or no knowledge about the application or task for which the database is being designed. This research presents a methodology for supporting database design creation and evaluation that makes use of domain-specific knowledge about an application stored in the form of domain ontologies. The methodology is implemented in a prototype system, the Ontology Management and Database Design Environment. Initial testing of the prototype illustrates that the incorporation and use of ontologies is effective in creating entity-relationship models.
Effect of T3-induced hyperthyroidism on mitochondrial and cytoplasmic protein synthesis rates in oxidative and glycolytic tissues in rats
Authors: Short Kevin R. , Nygren J. , Nair K. Sreekumaran
Published: October 2006

Hyperthyroidism increases metabolic rate, mitochondrial ATP production, and protein synthesis, but it remains to be determined whether all tissues and synthesis of specific protein pools are equally affected by hyperthyroidism. Previous studies showed that mitochondrial function was less responsive to elevated triiodothyronine (T3) levels in the low-oxidative plantaris muscle compared with other tissues in rats. We tested the hypothesis that in T3-treated animals mitochondrial protein synthesis would increase in oxidative but not glycolytic tissues. Male rats received either T3 (200 μg/day, n = 10) or saline (controls, n = 9) by subcutaneous pump for 14 days, and then in vivo protein synthesis rates were measured using [15N]phenylalanine in liver, heart, plantaris, and red gastrocnemius (Red Gast). Mitochondrial protein synthesis rate in T3-treated rats was higher than in controls by 62% in Red Gast and plantaris and 89 and 115% in liver and heart, respectively ( P < 0.01). Cytoplasmic protein synthesis rates in the T3 group were 107–176% higher than control values ( P < 0.01). There was also indirect evidence that protein breakdown was increased in all tissues of the T3-treated rats. Phosphorylation of selected regulators of protein synthesis in plantaris and Red Gast (mTOR, p70 S6 kinase, 4E-BP1), however, were not significantly affected by T3. We conclude that T3 infusion stimulates a general increase in mitochondrial and cytoplasmic protein synthesis rate among tissues and that this does not appear to explain the tissue-specific responses in mitochondrial oxidative capacity.
Decreased Chicken Ovalbumin Upstream Promoter Transcription Factor II Expression in Tamoxifen-Resistant Breast Cancer Cells
Authors: Riggs Krista A. , Wickramasinghe Nalinie S. , Cochrum Renate K. , Watts Mary Beth , Klinge Carolyn M.
Published: October 2006

Tamoxifen (TAM) is successfully used for the treatment and prevention of breast cancer. However, many patients that are initially TAM responsive develop tumors that are antiestrogen/TAM resistant (TAM-R). The mechanism behind TAM resistance in estrogen receptor α (ERα)–positive tumors is not understood. The orphan nuclear receptor chicken ovalbumin upstream promoter transcription factor (COUP-TF)-I interacts directly with 4-hydroxytamoxifen (4-OHT)- and estradiol (E2)-occupied ERα, corepressors NCoR and SMRT, and inhibit E2-induced gene transcription in breast cancer cells. Here we tested the hypothesis that reduced COUP-TFI and COUP-TFII correlate with TAM resistance. We report for the first time that COUP-TFII, but not COUP-TFI, is reduced in three antiestrogen/TAM-R cell lines derived from TAM-sensitive (TAM-S) MCF-7 human breast cancer cells and in MDA-MB-231 cells compared with MCF-7. ERα and ERβ protein expression was not different between TAM-S and TAM-R cells, but progesterone receptor (PR) was decreased in TAM-R cells. Further, E2 increased COUP-TFII transcription in MCF-7, but not TAM-R, cells. Importantly, reexpression of COUP-TFII in TAM-S cells to levels comparable to those in MCF-7 was shown to increase 4-OHT-mediated growth inhibition and increased apoptosis. Conversely, knockdown of COUP-TFII in TAM-S MCF-7 cells blocked growth inhibitory activity and increased 4-OHT agonist activity. 4-OHT increased COUP-TFII-ERα interaction ∼2-fold in MCF-7 cells. COUP-TFII expression in TAM-R cells also inhibited 4-OHT-induced endogenous PR and pS2 mRNA expression. These data indicate that reduced COUP-TFII expression correlates with acquired TAM resistance in human breast cancer cell lines and that COUP-TFII plays a role in regulating the growth inhibitory activity of TAM in breast cancer cells. (Cancer Res 2006; 66(20): 10188-98)