bluuebunny/crossref_metadata_2025 huggingface dataset:
Source selectable path diversity via routing deflections
Authors: Yang Xiaowei , Wetherall David
Published: October 2006

We present the design of a routing system in which end-systems set tags to select non-shortest path routes as an alternative to explicit source routes. Routers collectively generate these routes by using tags as hints to independently deflect packets to neighbors that lie off the shortest-path. We show how this can be done simply, by local extensions of the shortest path machinery, and safely, so that loops are provably not formed. The result is to provide end-systems with a high-level of path diversity that allows them to bypass unde-sirable locations within the network. Unlike explicit source routing, our scheme is inherently scalable and compatible with ISP policies because it derives from the deployed Internet routing. We also sug-gest an encoding that is compatible with common IP usage, making our scheme incrementally deployable at the granularity of individual routers.
Understanding the network-level behavior of spammers
Authors: Ramachandran Anirudh , Feamster Nick
Published: October 2006

This paper studies the
network-level
behavior of spammers, including: IP address ranges that send the most spam, common spamming modes (e.g., BGP route hijacking, bots), how persistent across time each spamming host is, and characteristics of spamming botnets. We try to answer these questions by analyzing a 17-month trace of over 10 million spam messages collected at an Internet "spam sinkhole", and by correlating this data with the results of IP-based blacklist lookups, passive TCP fingerprinting information, routing information, and botnet "command and control" traces.We find that most spam is being sent from a few regions of IP address space, and that spammers appear to be using transient "bots" that send only a few pieces of email over very short periods of time. Finally, a small, yet non-negligible, amount of spam is received from IP addresses that correspond to short-lived BGP routes, typically for hijacked prefixes. These trends suggest that developing algorithms to identify botnet membership, filtering email messages based on
network-leve
l properties (which are less variable than email content), and improving the security of the Internet routing infrastructure, may prove to be extremely effective for combating spam.
A measurement study on the impact of routing events on end-to-end internet path performance
Authors: Wang Feng , Mao Zhuoqing Morley , Wang Jia , Gao Lixin , Bush Randy
Published: October 2006

Extensive measurement studies have shown that end-to-end Internet path performance degradation is correlated with routing dynamics. However, the root cause of the correlation between routing dynamics and such performance degradation is poorly understood. In particular, how do routing changes result in degraded end-to-end path performance in the first place? How do factors such as topological properties, routing policies, and iBGP configurations affect the extent to which such routing events can cause performance degradation? Answers to these questions are critical for improving network performance.In this paper, we conduct extensive measurement that involves both controlled routing updates through two tier-1 ISPs and active probes of a diverse set of end-to-end paths on the Internet. We find that routing changes contribute to end-to-end packet loss significantly. Specifically, we study failover events in which a link failure leads to a routing change and recovery events in which a link repair causes a routing change. In both cases, it is possible to experience data plane performance degradation in terms of increased long loss burst as well as forwarding loops. Furthermore, we find that common routing policies and iBGP configurations of ISPs can directly affect the end-to-end path performance during routing changes. Our work provides new insights into potential measures that network operators can undertake to enhance network performance.
Energy-aware lossless data compression
Authors: Barr Kenneth C. , Asanović Krste
Published: October 2006

Wireless transmission of a single bit can require over 1000 times more energy than a single computation. It can therefore be beneficial to perform additional computation to reduce the number of bits transmitted. If the energy required to compress data is less than the energy required to send it, there is a net energy savings and an increase in battery life for portable computers. This article presents a study of the energy savings possible by losslessly compressing data prior to transmission. A variety of algorithms were measured on a StrongARM SA-110 processor. This work demonstrates that, with several typical compression algorithms, there is a actually a net energy
increase
when compression is applied before transmission. Reasons for this increase are explained and suggestions are made to avoid it. One such energy-aware suggestion is
asymmetric compression
, the use of one compression algorithm on the transmit side and a different algorithm for the receive path. By choosing the lowest-energy compressor and decompressor on the test platform, overall energy to send and receive data can be reduced by 11% compared with a well-chosen symmetric pair, or up to 57% over the default symmetric
zlib
scheme.
Energy-efficient CPU scheduling for multimedia applications
Authors: Yuan Wanghong , Nahrstedt Klara
Published: October 2006

This article presents the design, implementation, and evaluation of
EScheduler
, an energy-efficient soft real-time CPU scheduler for multimedia applications running on a mobile device. EScheduler seeks to minimize the total energy consumed by the device while meeting multimedia timing requirements. To achieve this goal, EScheduler integrates
dynamic voltage scaling
into the traditional soft real-time CPU scheduling: It decides
at what CPU speed
to execute applications in addition to when to execute what applications. EScheduler makes these scheduling decisions based on the probability distribution of cycle demand of multimedia applications and obtains their demand distribution via online profiling.We have implemented EScheduler in the Linux kernel and evaluated it on a laptop with a variable-speed CPU and typical multimedia codecs. Our experimental results show four findings: first, the cycle demand distribution of our studied codecs is stable or changes slowly. This stability implies the feasibility to perform our proposed energy-efficient scheduling with low overhead. Second, EScheduler delivers soft performance guarantees to these codecs by bounding their deadline miss ratio under the application-specific performance requirements. Third, EScheduler reduces the total energy of the laptop by 14.4% to 37.2% relative to the scheduling algorithm without voltage scaling and by 2% to 10.5% relative to voltage scaling algorithms without considering the demand distribution. Finally, EScheduler saves energy by 2% to 5% by explicitly considering the discrete CPU speeds and the corresponding total power of the whole laptop, rather than assuming continuous speeds and cubic speed-power relationship.
Information in the information society
Authors: Weizenbaum Joseph
Published: October 2006

The title of this talk is deliberately misleading: I really want to talk about misinformation.. Most citizens in what we laughingly call an "information society" derive most of what they know about their world from the mass media, for example from television, newspapers, more recently and increasingly from the World Wide Web and other such sources. But while it is true that the content of the mass media as a whole is from 90 to 95% trash, it is a mistake to blame the media establishment alone for the peoples' miserable state of world knowledge.Where, after all, is information created, where does it come from? The media delivers not "news", not "information", it delivers messages (signals) that, in order to produce information, must first be converted by the work of interpretation. That labor can be done only by (in the present context) the human mind.Information = interpretation ( signals ).Information theory teaches that messages have no information content, their interpretation does. And, what is most important, an interpretation of a message is a function of the state (or, in other words, the expectations) of the receiver! It follows that understanding a message, say the "news" delivered on television, involves the existing state of knowledge of the viewer, hence his or her education, socialization, indeed, in principle his whole life history.For us as educators, also as computer scientists, this implies that we must be attentive to the "state of the receiver". We must be attentive to the forces that influence the ability of our students to make sense of the signals they receive from us, from the media and from the rest of their world. We must teach them to think critically, and this foremost by means of our own example.
Testing first
Authors: Marrero Will , Settle Amber
Published: October 2006

The complexity of languages like Java and C++ can make introductory programming classes in these languages extremely challenging for many students. Part of the complexity comes from the large number of concepts and language features that students are expected to learn while having little time for adequate practice or examples. A second source of difficulty is the emphasis that object-oriented programming places on abstraction. We believe that by placing a larger emphasis on testing in programming assignments in these introductory courses, students have an opportunity for extra practice with the language, and this affords them a gentler transition into the abstract thinking needed for programming. In this paper we describe how we emphasized testing in introductory programming assignments by requiring that students design and implement tests before starting on the program itself. We also provide some preliminary results and student reactions.
The Kaya OS project and the
μ
MPS hardware emulator
Authors: Goldweber Michael , Davoli Renzo , Morsiani Mauro
Published: October 2006

Ideally, the most meaningful learning experience for students in an undergraduate OS course would be to develop fully-functional OS's on their own. This can be accomplished using
μ
mps, a hardware emulator for a pedagogically undergraduate-appropriate hardware architecture, along with Kaya, a specification for a multi-layer OS supporting multiprocessing, VM, thread synchronization, external devices (disks, terminals, tape, printers, and network interfaces) and a file system.Traditional OS projects like Nachos[3] or OS/161[9] provide students with a significant starting code base. Students then modify existing OS modules or add new ones. With
μ
mps/Kaya students undergo an innovative and pedagogically different experience of starting only with a hardware emulator (i.e. no initial OS code base for students to build on/replace) and ending with a completely student written OS capable of running student written C programs.
A new quantitative assessment tool for computer science programs
Authors: Fossum T. V. , Haller S. M.
Published: October 2006

We have designed a quantitative measure using card sorts that we show is statistically significant in distinguishing beginning students (novices) from those who have acquired competency appropriate to graduates of computer science (CS) programs. Using card sorts and applying this quantitative analysis, CS departments can arm themselves with another measure of the effectiveness of their academic programs in achieving their learning outcomes.
Designing CIspace
Authors: Amershi S. , Arksey N. , Carenini G. , Conati C. , Mackworth A. , Maclaren H. , Poole D.
Published: October 2006

This paper describes the design of the CIspace interactive visualization tools for teaching and learning Artificial Intelligence. Our approach to design is to iterate through three phases: identifying pedagogical and usability goals for supporting both educators and students, designing to achieve these goals, and then evaluating our system. We believe identifying these goals is essential in confronting the usability deficiencies and mixed results about the pedagogical effectiveness of interactive visualizations reported in the Education literature. The CIspace tools have been used and positively received in undergraduate and graduate classrooms at the University of British Columbia and internationally. We hope that our experiences can inform other developers of interactive visualizations and encourage their use in classrooms and other learning environments.
Using Octave to introduce programming to technical science students
Authors: Marques Nuno C. , Azevedo Francisco , Morgado Carmen , Custódio Jorge F.
Published: October 2006

In this paper we describe a five semester experiment on the introduction of Octave to teach computer programming to technical science students. We discuss the main advantages and disadvantages of this approach relatively to more traditional programming languages. After a qualitative and quantitative analysis of student evaluation results we argue that this kind of programming languages are useful to teach programming to non computer science engineering students.
Teaching about the risks of electronic voting technology
Authors: Armen Chris , Morelli Ralph
Published: October 2006

In these interesting times computer scientists are increasingly called upon to help concerned citizens understand the risks involved in the current generation of electronic voting machines. These risks and the concurrent escalation of legal challenges to the election system in the United States have shaken the confidence of many Americans that a fair and accurate election is even possible. As computer science educators we have an opportunity to add breadth and depth to our curriculum by using these issues to show how existing concepts can be applied to new problems, and how new problems extend our field. In this paper we identify some of the main problems with e-voting machines and vote-counting technology and suggest ways that discussions of the risks and the attendant societal and ethical issues might be incorporated into the computer science curriculum.
Learning styles across the curriculum
Authors: Chamillard A. T. , Sward Ricky E.
Published: October 2006

Recent research has shown that a student's learning style - essentially, the way a student approaches and masters new material - can affect student performance in introductory computer science courses. We show here that a student's learning style can also affect student performance across the courses in the computer science curriculum.This paper presents the results of a case study in which we collected learning style data for students completing the required courses in a typical computer science curriculum. We then used a wide range of statistical analyses to check for bias in the dataset and to examine the relationships between student learning style and student performance in those courses.Our analysis identified a number of statistically significant relationships between student learning style and performance. We examine potential explanations for those relationships and discuss ways in which the results can be used to enhance student learning.
Making compiler construction projects relevant to core curriculums
Authors: Demaille Akim
Published: October 2006

Having 300 students a year implement a compiler is a debatable enterprise, since the industry will certainly not recruit them for this competence. Yet we made that decision five years ago, for reasons
not
related to compiler construction. We detail these motivations, the resulting compiler design, and how we manage the assignment. The project meets its goals, since the majority of former students invariably refer to it as
the
project that taught them the most.
Virtual square (

V
2

) in computer science education
Authors: Davoli Renzo , Goldweber Michael
Published: October 2006

It is common to name as
virtual
the imaginary space that can be created by software using computers and networks. This space is not only a set of processing and communications means and methods but it is also a space where humans can "meet," exchange ideas, leave messages etc. Students in computer science must learn how to design, implement, manage and debug the systems and networks that create this virtual space. Furthermore, CS students need an experimental environment --a playground-- where they can develop their skills at creating and supporting these virtual environments.For this "playground" we propose a virtual world made up of emulated computer systems and emulated networks. This emulated world will be the students' testing environment, where they can run their own services, administer their own machines and set up security attacks without any danger to real networks and systems. It is a virtual space based on virtual machines and virtual networks but it is also a meeting place for computer science students, where they can test the effectiveness of their ideas.This "space" therefore is a
twice
virtual space, which we call virtual to the second power or virtual squared (

V
2

). It is a virtual environment that is a also virtual location (i.e. a town square) where different real computers, virtual systems and people can meet and communicate.
A prolog toolkit for formal languages and automata
Authors: Wermelinger Michel , Dias Artur Miguel
Published: October 2006

This paper describes the first version of PFLAT (read "P flat"), a collection of Prolog predicates that aims to provide a pedagogical implementation of concepts and algorithms taught in Formal Languages and Automata Theory (FLAT) courses. By ``pedagogical implementation'' we mean on the one hand that students should be able to easily map the implementation to the mathematical definitions given in lectures, and on the other hand that the toolkit should provide a library for students to implement further concepts and algorithms. In both cases the goal is to make students more confident in defining and manipulating the various kinds of languages and automata at a level beyond the one provided by visual simulators of automata. As such, PFLAT is not intended to replace but rather complement existing graphical tools. We believe the declarative, non-deterministic, and interactive nature of Prolog helps in building an executable specification of FLAT concepts and definitions that can be actively extended and explored by students, in order to achieve the stated goal.
Difficulties teaching Java in CS1 and how we aim to solve them
Authors: Weir George R. S. , Vilner Tamar , Mendes António José , Nordström Marie
Published: October 2006

In 1971 Dijkstra noted that as a teacher of programming he 'feels akin to a teacher of composition at a conservatory. He does not teach his pupils how to compose a particular symphony, he must help his pupils to find their own style and must explain to them what is implied by this' [1]. In similar vein, Don Knuth suggests that 'computer programming is an art, because it applies accumulated knowledge to the world, because it requires skill and ingenuity, and especially because it produces objects of beauty' [2].Traditionally, most Computer Science programs offer an introductory programming methodology course (CS1). In recent years, many institutions have subjected this course to major changes. One common alteration has been a move from a procedural paradigm to an Object Oriented (OO) paradigm. In many cases, this is manifested as a change to programming in Java. Emerging from this transition is the apparent anomaly that many students fail to understand OOP concepts, especially when required to use them in problem solving.Our panel represents researchers from four different countries who have all encountered such problems with a CS1 course. In this light, the panel focuses on CS1 difficulties and aims to address solutions to the 'Java problem'. Although we bring our own insights to the considered issues, we aim to engage the panel audience in discussing the nature of the problem and the propriety of the proposed solutions.
Using the BlueJ IDE in a data structures course
Authors: Paterson James H. , Haddow John , Birch Miriam , Monaghan Alex
Published: October 2006

This poster describes the use of the BlueJ Java IDE in a data structures course. The BlueJ IDE is an excellent tool for teaching programming using an objects-first approach. Learners are able to create, inspect and interact with instances of classes without the requirement to initiate a process with a main method. The ability to inspect 'live' objects can provide insights in specific areas of programming beyond the basic concepts. We have made use of BlueJ in an introductory course on data structures for students who have previously learned object oriented programming using BlueJ. The course deals with stacks, queues, lists, binary trees and graphs.Descriptions, diagrams, animations and simulations can all play a part in understanding the way in which these structures store and provide access to their data. However, interacting directly with actual objects which have been instantiated from code which the student has written can make the data structure much more tangible. The capability in BlueJ to inspect an object and to navigate object references to inspect associated objects allows a direct visual exploration of the internal representation of a data structure.For example, BlueJ allows the student to write a linked list class, create and populate an instance of the class, and visually inspect the nodes of the list. Object references can be followed from node to node to traverse the list. This experiment provides strong contrast with a visualization of the storage in an array list. The point can be emphasized that data structures with the same interface can have completely different internal representations.Similarly, a graph data structure is represented diagrammatically in terms of vertices joined by edges. However, there are a number of ways in which graphs can be represented internally, including adjacency lists and adjacency matrices. An adjacency list representation consists of a list of vertices, each of which is associated with a list of edges originating from that vertex. BlueJ allows visual exploration of such a structure, which can then be related back to the diagrammatic representation.Since BlueJ also allows API class instances to be inspected, the internal representations used by the Java Collections Framework classes can be explored.The poster shows examples of visual exploration of data structures with BlueJ. Further materials will be available at: http://hamilton.bell.ac.uk/datastructures.
Introducing object-oriented analysis and design in lower-level undergraduate courses
Authors: Hamza Haitham S.
Published: October 2006

This research aims at developing a tool-supported method for introducing Object-Oriented Programming (OOP) in undergraduate courses while exposing students to the notion of OO Analysis and Design (OOAD).
Learning repetition structures in programming
Authors: Marcelino M. J.
Published: October 2006

A study conducted at the Universidade de Coimbra with first year students of programming classes of the Electrical Engineering and Computers Degree is described. The main objective of the study was to investigate how students learn the crucial aspect of control structures in programming, namely repetition structures, and if there are patterns of learning behavior that emerge.
Knowledge sharing as an innovative educational practice
Authors: Mikulecky Peter
Published: October 2006

The objective of the poster is to describe an approach to the exploitation of nowadays very popular knowledge management methodology as an innovative educational practice in knowledge technologies teaching. This approach of extensive knowledge sharing can be considered as one of promising contribution to the practice of collaborative learning.
Guidelines for a multiple-goal CS introductory course
Authors: Muller Orna , Haberman Bruria
Published: October 2006

Over the years educators have been debating about the most appropriate paradigm for teaching an introductory course in computer science (CS). Specifically, the pedagogical approach known as "objects early" or "objects first" is controversial [2,3,4]. One important reason for educators to argue against the objects early approach is their concern that starting with objects results in the learning of algorithmic problem-solving to be neglected [4]. In this poster we present a pedagogical framework for an introductory multiple-goal course in OOP based on weaving algorithmic pattern-based problem solving activities into OOD/P instruction [5].
Taking the bus in the information highway system
Authors: Alvim Duarte
Published: October 2006

Roads are everywhere and if there are those that don't use them directly, we all derive advantage from them. In developed countries, computers and the network infrastructure may very well be comparable to roads. But, as with roads, a computer and/or a network per se do nothing without a means to use them. We must have something equivalent to a car - the software! In this poster we explore whether we can build a public software grid based on free software that brings benefits to the state and to the individual.
The MulE game engine extending online role-playing games
Authors: Boavida Miguel , Santos João Paulo , Assunção Pedro , Soares Luis , Luz João , Viegas Ricardo
Published: October 2006

The work presented in this poster reflects the first results drawn from the implementation of the MulE Game Engine, an open-source architecture implemented to develop realistic MMORPGs.
[4]cite
Authors: Lawrence Richard
Published: October 2006

4cite is a web-based citation package that allows users to store, import, export, and share reference sources. 4cite allows users to access their reference source collection using any internet ready PC. The reference sources can be cited from within word processing packages and bibliographies can be automatically generated. The project is compatible with the Library of Congress Metadata Object Description Schema (MODS). The package is fully extendable allowing users to create new input types at runtime. 4cite allows users to share references among colleagues, which simplifies document writing with multiple authors.
Teaching an introductory course in data mining
Authors: Roiger Richard J.
Published: October 2006

The goal is to supply the participant with the tools to teach a course or unit about data mining and knowledge discovery. A basic understanding of the benefits and limitations of data mining as a problem-solving strategy will be offered. Several data mining techniques will be discussed. Prior knowledge about data mining and the knowledge discovery process is not necessary.
Modeling context in haptic perception, rendering, and visualization
Authors: Kahol Kanav , Tripathi Priyamvada , Mcdaniel Troy , Bratton Laura , Panchanathan Sethuraman
Published: October 2006

Haptic perception refers to the ability of human beings to perceive spatial properties through touch-based sensations. In haptics, contextual clues about material,shape, size, texture, and weight configurations of an object are perceived by individuals leading to recognition of the object and its spatial features. In this paper, we present strategies and algorithms to model context in haptic applications that allow users to haptically explore objects in virtual reality/augmented reality environments. Initial results show significant improvement in accuracy and efficiency of haptic perception in augmented reality environments when compared to conventional approaches that do not model context in haptic rendering.
Controlling garbage collection and heap growth to reduce the execution time of Java applications
Authors: Brecht Tim , Arjomandi Eshrat , Li Chang , Pham Hang
Published: October 2006

In systems that support garbage collection, a tension exists between collecting garbage too frequently and not collecting it frequently enough. Garbage collection that occurs too frequently may introduce unnecessary overheads at the risk of not collecting much garbage during each cycle. On the other hand, collecting garbage too infrequently can result in applications that execute with a large amount of virtual memory (i.e., with a large footprint) and suffer from increased execution times due to paging.In this article, we use a large set of Java applications and the highly tuned and widely used Boehm-Demers-Weiser (BDW) conservative mark-and-sweep garbage collector to experimentally examine the extent to which the frequency of garbage collection impacts an application's execution time, footprint, and pause times. We use these results to devise some guidelines for controlling garbage collection and heap growth in a conservative garbage collector in order to minimize application execution times. Then we describe new strategies for controlling garbage collection and heap growth that impact not only the frequency with which garbage collection occurs but also the points at which it occurs. Experimental results demonstrate that when compared with the existing approach used in the standard BDW collector, our new strategy can significantly reduce application execution times.Our goal is to obtain a better understanding of how to control garbage collection and heap growth for an individual application executing in isolation. These results can be applied in a number of high-performance computing and server environments, in addition to some single-user environments. This work should also provide insights into how to make better decisions that impact garbage collection in multiprogrammed environments.
Feedback linking
Authors: von Platen Carl , Eker Johan
Published: October 2006

Firmware over the air (FOTA) is becoming a standard procedure for maintaining and updating wireless embedded systems. To cope with bandwidth and storage constraints this is facilitated using incremental updates based on delta technology, i.e. only the modifications are transmitted. The performance of a FOTA update is highly dependent on the size of the delta, and the type of modifications. Application of a delta update involves mutating the present version, byte by byte, into the new version. The problem is that even the smallest change in the source code may cause almost every single memory position to be affected, and thus requiring the complete memory to be rewritten. This has two implications: First, the time spent updating memory becomes unnecessary long. Secondly, and much worse, since a large part of the system is affected, the system is not functional during application.This paper introduces the concept of a feedback linker, which uses the object code layout of the previous version, when building a new version. The feedback linker maximizes the similarities between two versions allowing for smaller update packages and faster upgrades. The feedback linker is described in terms of an optimization procedure, an prototype test bed and a set of experimental results.
Reducing the cost of conditional transfers of control by using comparison specifications
Authors: Kreahling William , Hines Stephen , Whalley David , Tyson Gary
Published: October 2006

A significant portion of a program's execution cycles are typically dedicated to performing conditional transfers of control. Much of the research on reducing the costs of these operations has focused on the branch, while the comparison has been largely ignored. In this paper we investigate reducing the cost of comparisons in conditional transfers of control. We decouple the specification of the values to be compared from the actual comparison itself, which now occurs as part of the branch instruction. The specification of the register or immediate values involved in the comparison is accomplished via a new instruction called a
comparison specification
, which is loop invariant. Decoupling the specification of the comparison from the actual comparison performed before the branch reduces the number of instructions in the loop, which provides performance benefits not possible when using conventional comparison instructions. Results from applying this technique on the ARM processor show that both the number of instructions executed and execution cycles are reduced.
In search of near-optimal optimization phase orderings
Authors: Kulkarni Prasad A. , Whalley David B. , Tyson Gary S. , Davidson Jack W.
Published: October 2006

Phase ordering
is a long standing challenge for traditional optimizing compilers. Varying the order of applying optimization phases to a program can produce different code, with potentially significant performance variation amongst them. A key insight to addressing the phase ordering problem is that many different optimization sequences produce the same code. In an earlier study, we used this observation to restate the phase ordering problem to concentrate on finding all distinct function instances that can be produced due to different phase orderings, instead of attempting to generate code for all possible optimization sequences. Using a novel search algorithm we were able to show that it is possible to exhaustively enumerate the set of all possible function instances that can be produced by different phase orderings in our compiler for most of the functions in our benchmark suite [1]. Finding the optimal function instance within this set for almost any dynamic measure of performance still appears impractical since that would involve execution/simulation of all generated function instances. To find the dynamically optimal function instance we exploit the observation that the enumeration space for a function typically contains a very small number of
distinct control flow paths
. We simulate only one function instance from each group of function instances having the identical control flow, and use that information to estimate the dynamic performance of the remaining functions in that group. We further show that the estimated dynamic frequency counts obtained by using our method correlate extremely well to simulated processor cycle counts. Thus, by using our measure of dynamic frequencies to identify a small number of the best performing function instances we can often find the optimal phase ordering for a function within a reasonable amount of time. Finally, we perform a case study to evaluate how adept our genetic algorithm is for finding optimal phase orderings within our compiler, and demonstrate how the algorithm can be improved.
Optimizing compiler for shared-memory multiple SIMD architecture
Authors: Zhang Weihua , Qian Xinglong , Wang Ye , Zang Binyu , Zhu Chuanqi
Published: October 2006

With the rapid growth of multimedia and game, these applications put more and more pressure on the processing ability of modern processors. Multiple SIMD architecture is widely used in multimedia processing field as a multimedia accelerator.With the consideration of power consumption and chip size, shared memory multiple SIMD architecture is mainly used in embedded SOCs. In order to further fit mobile environment, there is the constraint of limited register number as well. Although shared memory multiple SIMD architecture simplify the chip design, these constraints are the major obstacles to map the real multimedia applications to these architectures. Until now, to our best knowledge, there is little research on the optimizing techniques for shared memory multiple SIMD architecture.In this paper, we present a compiler framework, which aims at automatically generating high performance codes for shared memory multiple SIMD architecture. In this framework, we reduce the competition of shared data bus through increasing the register locality, improve the utilization of data bus by read-only data vector replication and solve the problem of limited register number through a resource allocation algorithm. The framework also handlers the issues concerning on data transformation. As the experimental results shown, this framework is successful in mapping real multimedia applications to shared memory multiple SIMD architecture. It leads to an average speedup by a factor of 3.19 and an average utilization of SM-SIMD architecture with 8 SIMD units by a factor of 52.6%.
From structures and functors to modules and units
Authors: Owens Scott , Flatt Matthew
Published: October 2006

Component programming techniques encourage abstraction and reuse through external linking. Some parts of a program, however, must use concrete, internally specified references, so a pure component system is not a sufficient mechanism for structuring programs. We present the combination of a static, internally-linked module system and a purely abstractive component system. The latter extends our previous model of typed units to properly account for translucency and sharing. We also show how units and modules can express an SML-style system of structures and functors, and we explore the consequences for recursive structures and functors.
Stabilizers
Authors: Ziarek Lukasz , Schatz Philip , Jagannathan Suresh
Published: October 2006

Transient faults that arise in large-scale software systems can often be repaired by re-executing the code in which they occur. Ascribing a meaningful semantics for safe re-execution in multi-threaded code is not obvious, however. For a thread to correctly rexecute a region of code, it must ensure that all other threads which have witnessed its unwanted effects within that region are also reverted to a meaningful earlier state. If not done properly, data inconsistencies and other undesirable behavior may result. however, automatically determining what constitutes a consistent global checkpoint is not straightforward since thread interactions are a dynamic property of the program.In this paper, we present a safe and efficient checkpointing mechanism for Concurrent ML (CML) that can be used to recover from transient faults. We introduce a new linguistic abstraction called
stabilizers
that permits the specification of per-thread monitors and the restoration of globally consistent checkpoints. Safe global states are computed through lightweight monitoring of communication events among threads (e.g. message-passing operations or updates to shared variables).Our experimental results on several realistic, multithreaded, server-style CML applications, including a web server and a windowing toolkit, show that the overheads to use stabilizers are small, and lead us to conclude that they are a viable mechanism for defining safe checkpoints in concurrent functional programs.
Abstraction preservation and subtyping in distributed languages
Authors: Deniélou Pierre-Malo , Leifer James J.
Published: October 2006

In most programming languages, type abstraction is guaranteed by syntactic scoping in a single program, but is not preserved by marshalling during distributed communication. A solution is to generate
hash types
at compile time that consist of a fingerprint of the source code implementing the data type. These hash types can be tupled with a marshalled value and compared efficiently at unmarshall time to guarantee abstraction safety. In this paper, we extend a core calculus of ML-like modules, functions, distributed communication, and hash types, to integrate structural subtyping, user-declared subtyping between abstract types, and bounded existential types. Our semantics makes two contributions: (1) the explicit tracking of the interaction between abstraction boundaries and subtyping; (2) support for user-declared module upgrades with propagation of the resulting subhashing relation throughout the network during communication. We prove type preservation, progress, determinacy, and erasure for our system.
What’s on Your Hard Drive?
Authors: O'Hanlon Charlene
Published: October 2006

Despite the large amount of software available, a few core programs appear again and again.
Rationalizing a Home Terabyte Server
Authors: Creeger Mache
Published: October 2006

With 1 TB of RAID 5 storage, most of my friends believe I have really gone off the deep end with my home server. They may be right, but as in most things in life, I have gotten to this point through a rational set of individual upgrades all perfectly reasonable at the time. Rather than being overly indulgent to my inner geek, am I an early adopter of what will be the inevitable standard for home IT infrastructure? Here is my story; you be the judge.
Keeping Score in the IT Compliance Game
Authors: Ragan Tracy
Published: October 2006

Achieving developer acceptance of standardized procedures for managing applications from development to release is one of the largest hurdles facing organizations today. Establishing a standardized development-to-release workflow, often referred to as the ALM (application lifecycle management) process, is particularly critical for organizations in their efforts to meet tough IT compliance mandates. This is much easier said than done, as different development teams have created their own unique procedures that are undocumented, unclear, and nontraceable.
Review of "Software Security: Building Security In by Gary McGraw," Addison-Wesley Professional, 2006, $49.99, ISBN: 0321356705.
Authors: State Radu
Published: October 2006

Review of "Software Security: Building Security In by Gary McGraw," Addison-Wesley Professional, 2006, $49.99, ISBN: 0321356705.
Perceived system performance
Authors: Liu Liping , Ma Qingxiong
Published: October 2006

In this study, we introduce the notion of perceived system performance (PSP) to extend the technology acceptance model (TAM). We found that PSP explained 46% of the variation in ease of use, a 50% improvement over our current understanding of ease of use while using only one predictor. We also found that, when PSP is absent, TAM was validated as usual. However, when PSP is present, the relationship between ease of use and technology acceptance became insignificant, a phenomenon called
conditional independence
. We provide a causal reasoning-based explanation for our findings.
Moral intensity and ethical decision-making
Authors: Goles Tim , White Gregory B. , Beebe Nicole , Dorantes Carlos A. , Hewitt Barbara
Published: October 2006

This paper explores the role of an individual's perception of situation-specific issues on decision-making in ethical situations. It does so by examining the influence of moral intensity on a person's perceptions of an ethical problem, and subsequent intentions. Moral intensity (Jones, 1991) is an issue-contingent model of ethical decision-making based on the supposition that situations vary in terms of the moral imperative present in that situation. An individual's decision is guided by his or her assessment of six different components that collectively comprise the moral intensity of the situation. The relationship between the components of moral intensity and the decision-making process is tested through the use of scenarios that present IS-related ethical situations. The results indicate that moral intensity plays a significant role in shaping the perceptions and intentions of individuals faced with IS-related ethical situations. The conclusion drawn from this is that, consistent with prior research, the decision-making process is influenced by an individual's perception of situation-specific issues; that is, the moral intensity of the situation.
Block-aware instruction set architecture
Authors: Zmily Ahmad , Kozyrakis Christos
Published: October 2006

Instruction delivery is a critical component for wide-issue, high-frequency processors since its bandwidth and accuracy place an upper limit on performance. The processor front-end accuracy and bandwidth are limited by instruction-cache misses, multicycle instruction-cache accesses, and target or direction mispredictions for control-flow operations. This paper presents a block-aware instruction set (BLISS) that allows software to assist with front-end challenges. BLISS defines basic block descriptors that are stored separately from the actual instructions in a program. We show that BLISS allows for a decoupled front-end that tolerates instruction-cache latency, facilitates instruction prefetching, and leads to higher prediction accuracy.
Automated assessment and experiences of teaching programming
Authors: Higgins Colin A. , Gray Geoffrey , Symeonidis Pavlos , Tsintsifas Athanasios
Published: October 2006

This article reports on the design, implementation, and usage of the CourseMarker (formerly known as CourseMaster) courseware Computer Based Assessment (CBA) system at the University of Nottingham. Students use CourseMarker to solve (programming) exercises and to submit their solutions. CourseMarker returns immediate results and feedback to the students. Educators author a variety of exercises that benefit the students while offering practical benefits. To date, both educators and students have been hampered by CBA software that has been constructed to assess text-based or multiple-choice answers only. Although there exist a few CBA systems with some capability to automatically assess programming coursework, none assess Java programs and none are as flexible, architecture-neutral, robust, or secure as the CourseMarker CBA system.
3
rd
Intl. ICSE workshop on software engineering for automotive systems
Authors: Rappl Martin , Pretschner Alexander , Salzmann Christian , Stauner Thomas
Published: October 2006

This workshop summary outlines the main results of the one-day International Workshop on Software Engineering for Automotive Systems [5], held in conjunction with the 28th International Conference on Software Engineering (ICSE'06). In the sequel, a brief overview of the presented papers is given and the most interesting discussions are highlighted.
An evaluation of Boolean expression testing techniques
Authors: Singh R. K. , Chandra Pravin , Singh Yogesh
Published: October 2006

Increase in the size and complexity of the software developed has made software testing a challenging exercise. A number of testing techniques are available but they differ in terms of statement coverage, condition coverage and particularly in fault detection capabilities. The size of the test suite also differs from one technique to other. Fault that has propagated into the system inadvertently, especially into the branch statements, have severe effects as they affect the logic of the program. In this paper, an experimental evaluation of the popular branch-testing techniques (Elmendorf's method, Boolean Operator (BOR), Modified Condition/Decision Coverage (MCDC), and Reinforced Criteria/Decision Coverage (RCDC)) is presented. These techniques are evaluated on the basis of types of faults they identify, size of the test suite and their effectiveness in fault detection. For experiments, various branch statements used and referred in literature are selected. Test cases and mutants were prepared for these branch statements. Mutants were prepared by seeding single operator and operand faults into the statements. The results indicate that for a subset of fault types BOR is effective. A variant of MCDC and RCDC demonstrate better performance on the full class of faults and are only slightly worse than Elmendorf's (CEG) method test suite.
Scheme and Functional Programming 2006
Authors: Findler Robert Bruce
Published: October 2006

The Scheme and Functional Programming workshop will be held in Portland, OR on September 17th 2006, in conjunction with ICFP. The purpose of the workshop is to discuss experience with and future developments of the Scheme programming language, as well as general aspects of computer science loosely centered on the general theme of Scheme.Come to hear Manuel Serrano talk about HOP, his new language for programming the web, a status report from the R6RS editors, and presentations of the work below. I look forward to seeing you in Portland!
Algorithm 855
Authors: Alhargan Fayez A.
Published: October 2006

A continued fraction function algorithm is developed to evaluate general-order Mathieu characteristic numbers, and a new technique is presented for evaluating the Mathieu determinant which can be used to compute the order directly. Approximate expressions are developed to estimate the orders and Mathieu characteristic numbers for the root, finding algorithms. The algorithms, with minor modifications, were used for computing Mathieu coefficients of general order. The algorithms can deal with a large range of Mathieu characteristic number
c
, real and complex order ν, and parameter
h
.