bluuebunny/crossref_metadata_2025 huggingface dataset:
A declarative language approach to device configuration
Authors: Schüpbach Adrian , Baumann Andrew , Roscoe Timothy , Peter Simon
Published: October 2012

C remains the language of choice for hardware programming (device drivers, bus configuration, etc.): it is fast, allows low-level access, and is trusted by OS developers. However, the algorithms required to configure and reconfigure hardware devices and interconnects are becoming more complex and diverse, with the added burden of legacy support, quirks, and hardware bugs to work around. Even programming PCI bridges in a modern PC is a surprisingly complex problem, and is getting worse as new functionality such as hotplug appears. Existing approaches use relatively simple algorithms, hard-coded in C and closely coupled with low-level register access code, generally leading to suboptimal configurations.

We investigate the merits and drawbacks of a new approach: separating hardware configuration logic (algorithms to determine configuration parameter values) from mechanism (programming device registers). The latter we keep in C, and the former we encode in a declarative programming language with constraint-satisfaction extensions. As a test case, we have implemented full PCI configuration, resource allocation, and interrupt assignment in the Barrelfish research operating system, using a concise expression of efficient algorithms in constraint logic programming. We show that the approach is tractable, and can successfully configure a wide range of PCs with competitive runtime cost. Moreover, it requires about half the code of the C-based approach in Linux while offering considerably more functionality. Additionally it easily accommodates adaptations such as hotplug, fixed regions, and quirks.
Pocket cloudlets
Authors: Koukoumidis Emmanouil , Lymberopoulos Dimitrios , Strauss Karin , Liu Jie , Burger Doug
Published: October 2012

Cloud services accessed through mobile devices suffer from high network access latencies and are constrained by energy budgets dictated by the devices' batteries. Radio and battery technologies will improve over time, but are still expected to be the bottlenecks in future systems. Non-volatile memories (NVM), however, may continue experiencing significant and steady improvements in density for at least ten more years. In this paper, we propose to leverage the abundance in memory capacity of mobile devices to mitigate latency and energy issues when accessing cloud services.

We first analyze NVM technology scaling trends, and then propose a cloud service cache architecture that resides on the mobile device's NVM (pocket cloudlet). This architecture utilizes both individual user and community access models to maximize its hit rate, and subsequently reduce overall service latency and energy consumption.

As a showcase we present the design, implementation and evaluation of PocketSearch, a search and advertisement pocket cloudlet. We perform mobile search characterization to guide the design of PocketSearch and evaluate it with 200 million mobile queries from the search logs of
m.bing.com
. We show that PocketSearch can serve, on average, 66% of the web search queries submitted by an individual user without having to use the slow 3G link, leading to 16x service access speedup. Finally, based on experience with PocketSearch we provide additional insight and guidelines on how future pocket cloudlets should be organized, from both an architectural and an operating system perspective.
Dynamic knobs for responsive power-aware computing
Authors: Hoffmann Henry , Sidiroglou Stelios , Carbin Michael , Misailovic Sasa , Agarwal Anant , Rinard Martin
Published: October 2012

We present PowerDial, a system for dynamically adapting application behavior to execute successfully in the face of load and power fluctuations. PowerDial transforms static configuration parameters into dynamic knobs that the PowerDial control system can manipulate to dynamically trade off the accuracy of the computation in return for reductions in the computational resources that the application requires to produce its results. These reductions translate directly into performance improvements and power savings.

Our experimental results show that PowerDial can enable our benchmark applications to execute responsively in the face of power caps that would otherwise significantly impair responsiveness. They also show that PowerDial can significantly reduce the number of machines required to service intermittent load spikes, enabling reductions in power and capital costs.
Faults in linux
Authors: Palix Nicolas , Thomas Gaël , Saha Suman , Calvès Christophe , Lawall Julia , Muller Gilles
Published: October 2012

In 2001, Chou et al. published a study of faults found by applying a static analyzer to Linux versions 1.0 through 2.4.1. A major result of their work was that the drivers directory contained up to 7 times more of certain kinds of faults than other directories. This result inspired a number of development and research efforts on improving the reliability of driver code. Today Linux is used in a much wider range of environments, provides a much wider range of services, and has adopted a new development and release model. What has been the impact of these changes on code quality? Are drivers still a major problem?

To answer these questions, we have transported the experiments of Chou et al. to Linux versions 2.6.0 to 2.6.33, released between late 2003 and early 2010. We find that Linux has more than doubled in size during this period, but that the number of faults per line of code has been decreasing. And, even though drivers still accounts for a large part of the kernel code and contains the most faults, its fault rate is now below that of other directories, such as arch (HAL) and fs (file systems). These results can guide further development and research efforts. To enable others to continually update these results as Linux evolves, we define our experimental protocol and make our checkers and results available in a public archive.
Inter-core prefetching for multicore processors using migrating helper threads
Authors: Kamruzzaman Md , Swanson Steven , Tullsen Dean M.
Published: October 2012

Multicore processors have become ubiquitous in today's systems, but exploiting the parallelism they offer remains difficult, especially for legacy application and applications with large serial components. The challenge, then, is to develop techniques that allow multiple cores to work in concert to accelerate a single thread. This paper describes inter-core prefetching, a technique to exploit multiple cores to accelerate a single thread. Inter-core prefetching extends existing work on helper threads for SMT machines to multicore machines.

Inter-core prefetching uses one compute thread and one or more prefetching threads. The prefetching threads execute on cores that would otherwise be idle, prefetching the data that the compute thread will need. The compute thread then migrates between cores, following the path of the prefetch threads, and finds the data already waiting for it. Inter-core prefetching works with existing hardware and existing instruction set architectures. Using a range of state-of-the-art multiprocessors, this paper characterizes the potential benefits of the technique with microbenchmarks and then measures its impact on a range of memory intensive applications. The results show that inter-core prefetching improves performance by an average of 31 to 63%, depending on the architecture, and speeds up some applications by as much as 2.8×. It also demonstrates that inter-core prefetching reduces energy consumption by between 11 and 26% on average.
Improving the performance of trace-based systems by false loop filtering
Authors: Hayashizaki Hiroshige , Wu Peng , Inoue Hiroshi , Serrano Mauricio J. , Nakatani Toshio
Published: October 2012

Trace-based compilation is a promising technique for language compilers and binary translators. It offers the potential to expand the compilation scopes that have traditionally been limited by method boundaries.

Detecting repeating cyclic execution paths and capturing the detected repetitions into traces is a key requirement for trace selection algorithms to achieve good optimization and performance with small amounts of code. One important class of repetition detection is cyclic-path-based repetition detection, where a cyclic execution path (a path that starts and ends at the same instruction address) is detected as a repeating cyclic execution path.

However, we found many cyclic paths that are not repeating cyclic execution paths, which we call false loops. A common class of false loops occurs when a method is invoked from multiple call-sites. A cycle is formed between two invocations of the method from different call-sites, but which does not represent loops or recursion. False loops can result in shorter traces and smaller compilation scopes, and degrade the performance.

We propose false loop filtering, an approach to reject false loops in the repetition detection step of trace selection, and a technique called false loop filtering by call-stack-comparison, which rejects a cyclic path as a false loop if the call stacks at the beginning and the end of the cycle are different.

We applied false loop filtering to our trace-based Java™ JIT compiler that is based on IBM's J9 JVM. We found that false loop filtering achieved an average improvement of 16% and 10% for the DaCapo benchmark when applied to two baseline trace selection algorithms, respectively, with up to 37% improvement for individual benchmarks. In the end, with false loop filtering, our trace-based JIT achieves a performance comparable to that of the method-based J9 JVM/JIT using the corresponding optimization level.
Improved device driver reliability through hardware verification reuse
Authors: Ryzhyk Leonid , Keys John , Mirla Balachandra , Raghunath Arun , Vij Mona , Heiser Gernot
Published: October 2012

Faulty device drivers are a major source of operating system failures. We argue that the underlying cause of many driver faults is the separation of two highly-related tasks: device verification and driver development. These two tasks have a lot in common, and result in software that is conceptually and functionally similar, yet kept totally separate. The result is a particularly bad case of duplication of effort: the verification code is correct, but is discarded after the device has been manufactured; the driver code is inferior, but used in actual device operation. We claim that the two tasks, and the software they produce, can and should be unified, and this will result in drastic improvement of device-driver quality and reduction in the development cost and time to market.

In this paper we propose a device driver design and verification workflow that achieves such unification. We apply this workflow to develop and test drivers for four different I/O devices and demonstrate that it improves the driver test coverage and allows detecting driver defects that are extremely hard to find using conventional testing techniques.
Synthesizing concurrent schedulers for irregular algorithms
Authors: Nguyen Donald , Pingali Keshav
Published: October 2012

Scheduling is the assignment of tasks or activities to processors for execution, and it is an important concern in parallel programming. Most prior work on scheduling has focused either on static scheduling of applications in which the dependence graph is known at compile-time or on dynamic scheduling of independent loop iterations such as in OpenMP.

In irregular algorithms, dependences between activities are complex functions of runtime values so these algorithms are not amenable to compile-time analysis nor do they consist of independent activities. Moreover, the amount of work can vary dramatically with the scheduling policy. To handle these complexities, implementations of irregular algorithms employ carefully handcrafted, algorithm-specific schedulers but these schedulers are themselves parallel programs, complicating the parallel programming problem further.

In this paper, we present a flexible and efficient approach for specifying and synthesizing scheduling policies for irregular algorithms. We develop a simple compositional specification language and show how it can concisely encode scheduling policies in the literature. Then, we show how to synthesize efficient parallel schedulers from these specifications. We evaluate our approach for five irregular algorithms on three multicore architectures and show that (1) the performance of some algorithms can improve by orders of magnitude with the right scheduling policy, and (2) for the same policy, the overheads of our synthesized schedulers are comparable to those of fixed-function schedulers.
Stable matching with couples
Authors: Biró Péter , Irving Robert W. , Schlotter Ildikó
Published: October 2012

In practical applications, algorithms for the classic version of the hospitals residents problem (the many-one version of the stable marriage problem) may have to be extended to accommodate the needs of couples who wish to be allocated to (geographically) compatible places. Such an extension has been in operation in the National Resident Matching Problem (NRMP) matching scheme in the United States for a number of years. In this setting, a stable matching need not exist, and it is an NP-complete problem to decide if one does. However, the only previous empirical study in this context (focused on the NRMP algorithm), together with information from NRMP, suggest that, in practice, stable matchings do exist and that an appropriate heuristic can be used to find such a matching.

The study presented here was motivated by the recent decision to accommodate couples in the Scottish Foundation Allocation Scheme (SFAS), the Scottish equivalent of the NRMP. Here, the problem is a special case, since hospital preferences are derived from a “master list” of resident scores, but we show that the existence problem remains NP-complete in this case. We describe the algorithm used in SFAS and contrast it with a version of the algorithm that forms the basis of the NRMP approach. We also propose a third simpler algorithm based on satisfying blocking pairs, and an FPT algorithm when the number of couples is viewed as a parameter. We present an empirical study of the performance of a number of variants of these algorithms using a range of datasets. The results indicate that, not surprisingly, increasing the ratio of couples to single applicants typically makes it harder to find a stable matching (and, by inference, less likely that a stable matching exists). However, the likelihood of finding a stable matching is very high for realistic values of this ratio, and especially so for particular variants of the algorithms.
psort
, yet another fast stable sorting software
Authors: Bertasi Paolo , Bressan Marco , Peserico Enoch
Published: October 2012

psort
is the fastest sorting software according to the PennySort benchmark, sorting 181GB of data in 2008 and 224GB in 2009 for $0.01 of computer time. This article details its internals, and the careful fitting of its architecture to the structure of modern PC-class platforms, allowing it to outperform state-of-the-art sorting software such as
STXXL sort
.
Limited discrepancy search revisited
Authors: Prosser Patrick , Unsworth Chris
Published: October 2012

Harvey and Ginsberg's limited discrepancy search (LDS) is based on the assumption that costly heuristic mistakes are made early in the search process. Consequently, LDS repeatedly probes the state space, going against the heuristic (i.e., taking discrepancies) a specified number of times in all possible ways and attempts to take those discrepancies as early as possible. LDS was improved by Richard Korf, to become improved LDS (ILDS), but in doing so, discrepancies were taken as late as possible, going against the original assumption. Many subsequent algorithms have faithfully inherited Korf's interpretation of LDS, and take discrepancies late. This then raises the question: Should we take our discrepancies late or early? We repeat the original experiments performed by Harvey and Ginsberg and those by Korf in an attempt to answer this question. We also investigate the early stopping condition of the YIELDS algorithm, demonstrating that it is simple, elegant and efficient.
Quasirandom rumor spreading
Authors: Doerr Benjamin , Friedrich Tobias , Künnemann Marvin , Sauerwald Thomas
Published: October 2012

We empirically analyze two versions of the well-known “randomized rumor spreading” protocol to disseminate a piece of information in networks. In the classical model, in each round, each informed node informs a random neighbor. In the recently proposed quasirandom variant, each node has a (cyclic) list of its neighbors. Once informed, it starts at a random position of the list, but from then on informs its neighbors in the order of the list.

While for sparse random graphs a better performance of the quasirandom model could be proven, all other results show that, independent of the structure of the lists, the same asymptotic performance guarantees hold as for the classical model.

In this work, we compare the two models experimentally. Not only does this show that the quasirandom model generally is faster, but it also shows that the runtime is more concentrated around the mean. This is surprising given that much fewer random bits are used in the quasirandom process.

These advantages are also observed in a lossy communication model, where each transmission does not reach its target with a certain probability, and in an asynchronous model, where nodes send at random times drawn from an exponential distribution. We also show that typically the particular structure of the lists has little influence on the efficiency.
Generating constrained random graphs using multiple edge switches
Authors: Tabourier Lionel , Roth Camille , Cointet Jean-Philippe
Published: October 2012

The generation of random graphs using edge swaps provides a reliable method to draw uniformly random samples of sets of graphs respecting some simple constraints (e.g., degree distributions). However, in general, it is not necessarily possible to access all graphs obeying some given constraints through a classical switching procedure calling on pairs of edges. Therefore, we propose to get around this issue by generalizing this classical approach through the use of higher-order edge switches. This method, which we denote by “
k
-edge switching,” makes it possible to progressively improve the covered portion of a set of constrained graphs, thereby providing an increasing, asymptotically certain confidence on the statistical representativeness of the obtained sample.
When to inherit a type
Authors: Hu Chenglie
Published: October 2012

Meaningful applications of inheritance are critical in devising good object-oriented solutions. Yet, not being able to use effectively and correctly inheritance in problem solving is perhaps the most significant impediment for students to become competitive object-oriented thinkers. This article provides a summary of common uses of type inheritance. It also describes the situations where type inheritance can be inappropriate or, at least, subject to reevaluation. More importantly, it brings an attention to the distinction between the mechanics and the semantics of inheritance. The article closes with an example that illustrates the use of inheritance in light of other alternatives. Finally, the article briefly discusses the implications.
ICT literacy education
Authors: Lavy Ilana , Or-Bach Rachel
Published: October 2012

As higher education opens up to a wider population, we witness more incoming students that lack necessary skills for using information and communication tools effectively. We suggest various ways to define, assess, and develop such skills. In this study, we concentrate on another facet; we examined students' retrospective subjective perceptions regarding various effects of an ICT-literacy course. Analysis of the research data revealed that the students believe the ICT-literacy course raised their self-confidence in their ability to cope with further learning. We also present comparative results with relation to age and gender for examining effects of the ICT literacy course.
Tools for "contributing student learning"
Authors: Hamer John , Luxton-Reilly Andrew , Purchase Helen C. , Sheard Judithe
Published: October 2012

Activities that require students to collaborate, share solutions, review each others' work, or create materials explicitly for the use of other students have been shown to be beneficial not only to students' learning of the material, but to their reflective, critical and creative skills. This paper presents a snap-shot of tools currently reported as being used to support such collaborative activities in Computer Science education. Basing our analysis on an extensive review of recent Computer Science Education literature, we categorize these tools according to both their form and use while identifying gaps, limitations and opportunities.
If You Have Too Much Data, then "Good Enough" Is Good Enough
Authors: Helland Pat
Published: October 2012

Classic database systems offer crisp answers for a relatively small amount of data. These systems hold their data in one or a relatively small number of computers. With a tightly defined schema and transactional consistency, the results returned from queries are crisp and accurate. New systems have humongous amounts of data content, change rates, and querying rates and take lots of computers to hold and process. The data quality and meaning are fuzzy. The schema, if present, is likely to vary across the data. The origin of the data may be suspect, and its staleness may vary.
Steno
Authors: Murray Derek Gordon , Isard Michael , Yu Yuan
Published: October 2012

Declarative queries enable programmers to write data manipulation code without being aware of the underlying data structure implementation. By increasing the level of abstraction over imperative code, they improve program readability and, crucially, create opportunities for automatic parallelization and optimization. For example, the Language Integrated Query (LINQ) extensions to C# allow the same declarative query to process in-memory collections, and datasets that are distributed across a compute cluster. However, our experiments show that the
serial
performance of declarative code is several times slower than the equivalent hand-optimized code, because it is implemented using run-time abstractions---such as iterators---that incur overhead due to virtual function calls and superfluous instructions.

To address this problem, we have developed Steno, which uses a combination of novel and well-known techniques to generate code for declarative queries that is almost as efficient as hand-optimized code. Steno translates a declarative LINQ query into type-specialized, inlined and loop-based imperative code. It eliminates chains of iterators from query execution, and optimizes nested queries. We have implemented Steno for uniprocessor, multiprocessor and distributed computing platforms, and show that, for a real-world distributed job, it can almost double the speed of end-to-end execution.
Languages as libraries
Authors: Tobin-Hochstadt Sam , St-Amour Vincent , Culpepper Ryan , Flatt Matthew , Felleisen Matthias
Published: October 2012

Programming language design benefits from constructs for extending the syntax and semantics of a host language. While C's string-based macros empower programmers to introduce notational shorthands, the parser-level macros of Lisp encourage experimentation with domain-specific languages. The Scheme programming language improves on Lisp with macros that respect lexical scope.

The design of Racket---a descendant of Scheme---goes even further with the introduction of a full-fledged interface to the static semantics of the language. A Racket extension programmer can thus add constructs that are indistinguishable from "native" notation, large and complex embedded domain-specific languages, and even optimizing transformations for the compiler backend. This power to experiment with language design has been used to create a series of sub-languages for programming with first-class classes and modules, numerous languages for implementing the Racket system, and the creation of a complete and fully integrated typed sister language to Racket's untyped base language.

This paper explains Racket's language extension API via an implementation of a small typed sister language. The new language provides a rich type system that accommodates the idioms of untyped Racket. Furthermore, modules in this typed language can safely exchange values with untyped modules. Last but not least, the implementation includes a type-based optimizer that achieves promising speedups. Although these extensions are complex, their Racket implementation is just a library, like any other library, requiring no changes to the Racket implementation.
Automatic CPU-GPU communication management and optimization
Authors: Jablin Thomas B. , Prabhu Prakash , Jablin James A. , Johnson Nick P. , Beard Stephen R. , August David I.
Published: October 2012

The performance benefits of GPU parallelism can be enormous, but unlocking this performance potential is challenging. The applicability and performance of GPU parallelizations is limited by the complexities of CPU-GPU communication. To address these communications problems, this paper presents the first fully automatic system for managing and optimizing CPU-GPU communcation. This system, called the CPU-GPU Communication Manager (CGCM), consists of a run-time library and a set of compiler transformations that work together to manage and optimize CPU-GPU communication without depending on the strength of static compile-time analyses or on programmer-supplied annotations. CGCM eases manual GPU parallelizations and improves the applicability and performance of automatic GPU parallelizations. For 24 programs, CGCM-enabled automatic GPU parallelization yields a whole program geomean speedup of 5.36x over the best sequential CPU-only execution.
Predicate abstraction and CEGAR for higher-order model checking
Authors: Kobayashi Naoki , Sato Ryosuke , Unno Hiroshi
Published: October 2012

Higher-order model checking (more precisely, the model checking of higher-order recursion schemes) has been extensively studied recently, which can automatically decide properties of programs written in the simply-typed λ-calculus with recursion and
finite
data domains. This paper formalizes predicate abstraction and counterexample-guided abstraction refinement (CEGAR) for higher-order model checking, enabling automatic verification of programs that use
infinite
data domains such as integers. A prototype verifier for higher-order functional programs based on the formalization has been implemented and tested for several programs.
Higher-order test generation
Authors: Godefroid Patrice
Published: October 2012

Symbolic reasoning about large programs is bound to be imprecise. How to deal with this imprecision is a fundamental problem in program analysis. Imprecision forces approximation. Traditional static program verification builds "may" over-approximations of the program behaviors to check universal "for-all-paths" properties, while automatic test generation requires "must" under-approximations to check existential "for-some-path" properties.

In this paper, we introduce a new approach to test generation where tests are derived from
validity proofs
of first-order logic formulas, rather than
satisfying assignments
of quantifier-free first-order logic formulas as usual. Two key ingredients of this
higher-order test generation
are to (1) represent complex/unknown program functions/instructions causing imprecision in symbolic execution by
uninterpreted functions
, and (2) record
uninterpreted function samples
capturing input-output pairs observed at execution time for those functions. We show that higher-order test generation generalizes and is more precise than simplifying complex symbolic expressions using their concrete runtime values. We present several program examples where our approach can exercise program paths and find bugs missed by previous techniques. We discuss the implementability and applications of this approach. We also explain in what sense dynamic test generation is more powerful than static test generation.
Isolating and understanding concurrency errors using reconstructed execution fragments
Authors: Lucia Brandon , Wood Benjamin P. , Ceze Luis
Published: October 2012

In this paper we propose Recon, a new general approach to concurrency debugging. Recon goes beyond just detecting bugs, it also presents to the programmer short fragments of buggy execution schedules that illustrate how and why bugs happened. These fragments, called
reconstructions
, are inferred from inter-thread communication surrounding the root cause of a bug and significantly simplify the process of
understanding
bugs.

The key idea in Recon is to monitor executions and build graphs that encode inter-thread communication with enough context information to build reconstructions. Recon leverages reconstructions built from multiple application executions and uses machine learning to identify which ones illustrate the root cause of a bug. Recon's approach is
general
because it does not rely on heuristics specific to any type of bug, application, or programming model. Therefore, it is able to deal with single- and multiple-variable concurrency bugs regardless of their type (
e.g.
, atomicity violation, ordering, etc). To make graph collection efficient, Recon employs selective monitoring and allows metadata information to be imprecise without compromising accuracy. With these optimizations, Recon's graph collection imposes overheads typically between 5x and 20x for both C/C++ and Java programs, with overheads as low as 13% in our experiments. We evaluate Recon with buggy applications, and show it produces reconstructions that include all code points involved in bugs' causes, and presents them in an accurate order. We include a case study of understanding and fixing a previously unresolved bug to showcase Recon's effectiveness.
LL(*)
Authors: Parr Terence , Fisher Kathleen
Published: October 2012

Despite the power of Parser Expression Grammars (PEGs) and GLR, parsing is not a solved problem. Adding nondeterminism (parser speculation) to traditional
LL
and
LR
parsers can lead to unexpected parse-time behavior and introduces practical issues with error handling, single-step debugging, and side-effecting embedded grammar actions. This paper introduces the
LL
(*) parsing strategy and an associated grammar analysis algorithm that constructs
LL
(*) parsing decisions from ANTLR grammars. At parse-time, decisions gracefully throttle up from conventional fixed k>=1 lookahead to arbitrary lookahead and, finally, fail over to backtracking depending on the complexity of the parsing decision and the input symbols.
LL
(*) parsing strength reaches into the context-sensitive languages, in some cases beyond what GLR and PEGs can express. By statically removing as much speculation as possible,
LL
(*) provides the expressivity of PEGs while retaining
LL
's good error handling and unrestricted grammar actions. Widespread use of ANTLR (over 70,000 downloads/year) shows that it is effective for a wide variety of applications.
Web information retrieval and filtering course to undergraduates using open source programming
Authors: Jung Seikyung , Lawrance Joseph
Published: October 2012

This paper describes how to engage actively students in web information retrieval and filtering course using open source programming. To teach this course, I utilized hands-on lab projects from various open source projects including the Galago search engine. Projects included, but were not limited to, implementing information retrieval (IR) algorithms, collaborative filtering (CF) algorithms, web-based interfaces, and adding features into an open-source search engine. By practicing with real-world open source programming, students found that they better understood how to connect background knowledge to real-world applications in preparation for industry jobs.
Second Life for Medical Education
Authors: Spooner Nicholas A. , Cregan Patrick C. , Khadra Mohamed
Published: October 2012

Research suggests that virtual learning could considerably augment, if not eventually revolutionize medical education. In this study, medical students were provided with an opportunity to engage in an online, simulated Second Life environment in order to interactively address problem-based presentations of surgical disease within a safe, confidential, realistic and engaging medical educational platform.
Learning In Work: The influence of Julian Orr's 'Talking about Machines'
Authors: Bozarth Jane
Published: October 2012

Julian Orr's "Talking about Machines: An Ethnography of a Modern Job" has been influential in the learning community. In writing about the importance of informal relationships and storytelling as knowledge sharing in the work environment, he astutely redirected the conversation to situated learning and communities of practice.
Storytelling in eLearning: The why and how
Authors: Gable Shelley A.
Published: October 2012

Whether you design classroom training, eLearning, m-learning, or work with another medium entirely, storytelling is a learning tool that possesses the power to motivate, persuade, educate, and even entertain. This article explains how the value of storytelling is supported by adult learning theory, outlines the elements to include when writing a story, and suggests specific methods for incorporating stories into eLearning lessons.
A skit-based approach to teaching web and networking protocols
Authors: Kumar Suthikshn
Published: October 2012

Teaching web protocols is a challenging task. Students find it difficult to visualize the concepts and teachers find it difficult to explain protocols in a classroom environment. In this article, we present an innovative approach to teaching this topic using skits. Students enact skits, which illustrate the concept of web protocol very well. In this article, we discuss several skit examples for interesting web and networking protocols.
Educators' strategies for object-oriented analysis and design
Authors: Nordström Marie
Published: October 2012

Almost all research on the teaching of object orientation focuses on the students and their learning. One important aspect that will affect how object orientation is taught is the educators' personal views on different issues of the paradigm. In this article, we present some results of a qualitative study on educators' views on the teaching of object orientation. We specifically focus on ways teachers address object-oriented design and analysis. Data was collected through interviews with ten educators.
Exploring number bases as tools
Authors: De Vlieger Michael Thomas
Published: October 2012

In computer science and for society in general, there is a tendency to overlook number bases beyond decimal, binary, and hexadecimal. Our mathematical ancestors used the numbers 12, 60, and 360 to organize time and angular measure. This article describes a method of examining number bases at a glance for possible incorporation in information-age ideas. The number-theoretical relationships of digits to number bases serve as a guide toward selection of numbers for such uses.
Digest of ACM educational activities
Authors: McGettrick Andrew , Timanovsky Yan
Published: October 2012

Welcome to the third installment of EduBits, your quarterly pipeline to new and exciting happenings in the world of ACM education. Starting with this March issue of ACM Inroads, we are introducing a new thread that will highlight principal educational activities within ACM and affiliated organizations. Starting with this issue, you'll find a special focus on an ACM Special Interest Group (SIG) engaged in educational activities. News summaries will also include updates from task groups and committees of the ACM Education Council and within the institution itself.

This issue also features a status report from the CS2013 curricula revision task force and highlights of the many educational activities within SIGGRAPH, ACM's Special Interest Group on Computer Graphics and Interactive Techniques. In the spirit of community inclusiveness and broadening participation that permeates the Education Council, these pieces come straight from the people leading these important educational efforts. We trust you'll find their words informative and engaging and welcome your feedback. Enjoy.

We begin with a dedicated group of volunteers guiding a major revision of undergraduate computer science curricula recommendations: CS2013.
Analysis
Authors: Snyder Lawrence , Barnes Tiffany , Garcia Dan , Paul Jody , Simon Beth
Published: October 2012

The five pilots were taught "under a microscope." Extensive surveying, weekly conference calls, instructor summaries and other methods were used to gather data to understand how well the courses were succeeding. The final report on the pilot 1 courses [6] gives complete data. For the purposes on this article, a few selected graphs seem most useful.
Living in a computing world
Authors: Paul Jody
Published: October 2012

The new CS Principles course provides an opportunity to advance the goal of making knowledge of computing and computer science accessible to every student. A pilot course used to inform the development of the CS Principles curriculum framework enabled its instructor to explore alternative pedagogical practices in pursuit of that goal. This article presents observations and reflections of the instructor with respect to these attempted practices.
QoE-oriented 3D video transcoding for mobile streaming
Authors: Liu Yanwei , Ci Song , Tang Hui , Ye Yun , Liu Jinxia
Published: October 2012

With advance in mobile 3D display, mobile 3D video is already enabled by the wireless multimedia networking, and it will be gradually popular since it can make people enjoy the natural 3D experience anywhere and anytime. In current stage, mobile 3D video is generally delivered over the heterogeneous network combined by wired and wireless channels. How to guarantee the optimal 3D visual quality of experience (QoE) for the mobile 3D video streaming is one of the important topics concerned by the service provider. In this article, we propose a QoE-oriented transcoding approach to enhance the quality of mobile 3D video service. By learning the pre-controlled QoE patterns of 3D contents, the proposed 3D visual QoE inferring model can be utilized to regulate the transcoding configurations in real-time according to the feedbacks of network and user-end device information. In the learning stage, we propose a piecewise linear mean opinion score (MOS) interpolation method to further reduce the cumbersome manual work of preparing QoE patterns. Experimental results show that the proposed transcoding approach can provide the adapted 3D stream to the heterogeneous network, and further provide superior QoE performance to the fixed quantization parameter (QP) transcoding and mean squared error (MSE) optimized transcoding for mobile 3D video streaming.
A real-time remote rendering system for interactive mobile graphics
Authors: Shi Shu , Nahrstedt Klara , Campbell Roy
Published: October 2012

Mobile devices are gradually changing people's computing behaviors. However, due to the limitations of physical size and power consumption, they are not capable of delivering a 3D graphics rendering experience comparable to desktops. Many applications with intensive graphics rendering workloads are unable to run on mobile platforms directly. This issue can be addressed with the idea of remote rendering: the heavy 3D graphics rendering computation runs on a powerful server and the rendering results are transmitted to the mobile client for display. However, the simple remote rendering solution inevitably suffers from the large interaction latency caused by wireless networks, and is not acceptable for many applications that have very strict latency requirements.

In this article, we present an advanced low-latency remote rendering system that assists mobile devices to render interactive 3D graphics in real-time. Our design takes advantage of an image based rendering technique: 3D image warping, to synthesize the mobile display from the depth images generated on the server. The research indicates that the system can successfully reduce the interaction latency while maintaining the high rendering quality by generating multiple depth images at the carefully selected viewpoints. We study the problem of viewpoint selection, propose a real-time reference viewpoint prediction algorithm, and evaluate the algorithm performance with real-device experiments.
Architectural issues in network-centric computing
Authors: Xiaochun Xu , Guanghui Xu , Yongsen Xu
Published: October 2012

The widespread use of the Internet has led to great changes in traditional computational models. The concept of the network-centric computing is becoming more and more popular. Software architecture, as an emerging discipline, focuses on the high-level structures of large complex software systems. With the critical challenges from the new computational model, many open issues of software architectures emerge. In this paper, we present some requisite technologies that are still not completely settled and offer some suggestions based on a survey of relevant study experience to date.
Human transcriptome analysis of acute responses to glucose ingestion reveals the role of leukocytes in hyperglycemia-induced inflammation
Authors: Choi Hyung Jin , Yun Hye Sun , Kang Hyun Ju , Ban Hyo-Jeong , Kim Yeonjung , Nam Hye-Young , Hong Eun-Jung , Jung So-Young , Jung Seung Eun , Jeon Jae-Pil , Han Bok-Ghee
Published: October 2012

Glucose ingestion-induced hyperglycemia has been known to induce inflammation, which is related to the pathogenesis of diabetic complications. To examine acute gene expression responses to physiological oral glucose ingestion in human circulating leukocytes, we conducted a microarray study of human circulating leukocytes sampled before, 1 h after, and 2 h after glucose ingestion in community-based participants without previous histories of diabetes ( n = 60). Ingestion of 75 g glucose successfully induced acute hyperglycemia (glucose concentration 91.6 ± 5.3 mg/dl for fasting and 180.7 ± 48.5 mg/dl for 1 h after glucose ingestion). Oral glucose ingestion significantly increased the expressions of 23 genes and decreased the expressions of 13 genes [false discovery rate (FDR) P value <0.05]. These genes are significantly involved in immunity by way of natural killer cell-mediated immunity, granulocyte-mediated immunity, and the cytokine-mediated signaling pathway (FDR P value <0.05). The present study demonstrated 36 genes that showed acute gene expression change in human leukocytes within 1 h after glucose ingestion, suggesting that leukocytes participate in the inflammatory process induced by acute hyperglycemia. We believe that these results will provide some basic insight into the role of leukocytes in hyperglycemia-induced inflammation and the pathogenesis of diabetic complications.
α-Enolase, a Multifunctional Protein: Its Role on Pathophysiological Situations
Authors: Díaz-Ramos Àngels , Roig-Borrellas Anna , García-Melero Ana , López-Alemany Roser
Published: October 2012

α-Enolase is a key glycolytic enzyme in the cytoplasm of prokaryotic and eukaryotic cells and is considered a multifunctional protein.α-enolase is expressed on the surface of several cell types, where it acts as a plasminogen receptor, concentrating proteolytic plasmin activity on the cell surface. In addition to glycolytic enzyme and plasminogen receptor functions,α-Enolase appears to have other cellular functions and subcellular localizations that are distinct from its well-established function in glycolysis. Furthermore, differential expression ofα-enolase has been related to several pathologies, such as cancer, Alzheimer's disease, and rheumatoid arthritis, among others. We have identifiedα-enolase as a plasminogen receptor in several cell types. In particular, we have analyzed its role in myogenesis, as an example of extracellular remodelling process. We have shown thatα-enolase is expressed on the cell surface of differentiating myocytes, and that inhibitors ofα-enolase/plasminogen binding block myogenic fusionin vitroand skeletal muscle regeneration in mice.α-Enolase could be considered as a marker of pathological stress in a high number of diseases, performing several of its multiple functions, mainly as plasminogen receptor. This paper is focused on the multiple roles of theα-enolase/plasminogen axis, related to several pathologies.
Stochastic Functional Differential Equation under Regime Switching
Authors: Bai Ling , Kai Zhang
Published: October 2012

We discuss stochastic functional differential equation under regime switching dx(t) = f(xt, r(t), t)dt + q(r(t))x(t)dW1(t) + σ(r(t)) | x(t)|βx(t)dW2(t). We obtain unique global solution of this system without the linear growth condition; furthermore, we prove its asymptotic ultimate boundedness. Using the ergodic property of the Markov chain, we give the sufficient condition of almost surely exponentially stable of this system.
Cardiovocal Syndrome (Ortner's Syndrome) Associated with Chronic Thromboembolic Pulmonary Hypertension and Giant Pulmonary Artery Aneurysm: Case Report and Review of the Literature
Authors: Heikkinen Jaakko , Milger Katrin , Alejandre-Lafont Enrique , Woitzik Christian , Litzlbauer Detlef , Vogt Julia-Franziska , Klußmann Jens Peter , Ghofrani Ardeschir , Krombach Gabriele A. , Tiede Henning
Published: October 2012

Cardiovocal syndrome or Ortner's syndrome is hoarseness due to left recurrent laryngeal nerve palsy caused by mechanical affection of the nerve from enlarged cardiovascular structures. Chronic thromboembolic pulmonary hypertension is extremely rarely found to cause this syndrome. We describe a case of a 56-year-old patient with sudden onset of hoarseness. The patient had known long standing severe pulmonary hypertension. Fiberoptic laryngoscopy showed left vocal cord palsy. Computed tomography of the neck and chest revealed extensive enlargement of the pulmonary arteries and excluded a malignant tumor. The diagnosis of cardiovocal syndrome was retained. It is important for the radiologist to be aware of this possible etiology causing left recurrent laryngeal nerve palsy and to understand its mechanism.
Evaluating Surveillance Breast Imaging and Biopsy in Older Breast Cancer Survivors
Authors: Onega Tracy , Weiss Julie , diFlorio Roberta , MacKenzie Todd , Goodrich Martha , Poplack Steven
Published: October 2012

Background. Patterns of surveillance among breast cancer survivors are not well characterized and lack evidence-based practice guidelines, particularly for imaging modalities other than mammography. We characterized breast imaging and related biopsy longitudinally among breast cancer survivors in relation to women’s characteristics.Methods. Using data from a state-wide (New Hampshire) breast cancer screening registry linked to Medicare claims, we examined use of mammography, ultrasound (US), magnetic resonance imaging (MRI), and biopsy among breast cancer survivors. We used generalized estimating equations (GEE) to model associations of breast surveillance with women’s characteristics.Results. The proportion of women with mammography was high over the follow-up period (81.5% at 78 months), but use of US or MRI was much lower (8.0%—first follow-up window, 4.7% by 78 months). Biopsy use was consistent throughout surveillance periods (7.4%–9.4%). Surveillance was lower among older women and for those with a higher stage of diagnosis. Primary therapy was significantly associated with greater likelihood of breast surveillance.Conclusions. Breast cancer surveillance patterns for mammography, US, MRI, and related biopsy seem to be associated with age, stage, and treatment, but need a larger evidence-base for clinical recommendations.