bluuebunny/crossref_metadata_2025 huggingface dataset:
Application of particle swarm optimization-based least square support vector machine in quantitative analysis of extraction solution of yangxinshi tablet using near infrared spectroscopy
Authors: Lou Weijian , Yang Kai , Zhu Miaoqin , Wu Yongjiang , Liu Xuesong , Jin Ye
Published: November 2013

A particle swarm optimization (PSO)-based least square support vector machine (LS-SVM) method was investigated for quantitative analysis of extraction solution of Yangxinshi tablet using near infrared (NIR) spectroscopy. The usable spectral region (5400–6200 cm-1) was identified, then the first derivative spectra smoothed using a Savitzky–Golay filter were employed to establish calibration models. The PSO algorithm was applied to select the LS-SVM hyperparameters (including the regularization and kernel parameters). The calibration models of total flavonoids, puerarin, salvianolic acid B and icariin were established using the optimum hyperparameters of LS-SVM. The performance of LS-SVM models were compared with partial least squares (PLS) regression, feed-forward back-propagation network (BPANN) and support vector machine (SVM). Experimental results showed that both the calibration results and prediction accuracy of the PSO-based LS-SVM method were superior to PLS, BP-ANN and SVM. For PSO-based LS-SVM models, the determination coefficients (R2) for the calibration set were above 0.9881, and the RSEP values were controlled within 5.772%. For the validation set, the RMSEP values were close to RMSEC and less than 0.042, the RSEP values were under 8.778%, which were much lower than the PLS, BP-ANN and SVM models. The PSO-based LS-SVM algorithm employed in this study exhibited excellent calibration performance and prediction accuracy, which has definite practice significance and application value.
Sinai hinge belt: a major crustal boundary in NE Africa
Authors: Moustafa A. R. , Salama M. E. , Khalil S. M. , Fouda H. G. A.
Published: November 2013

The Sinai hinge belt is a major crustal boundary in northern Sinai separating different tectonic terranes. This boundary started as a number of ENE–WSW-oriented faults of Precambrian or Palaeozoic age and played a major role in the Mesozoic and Cenozoic tectonic evolution of NE Africa. The Sinai hinge belt was reactivated by normal faulting during Early Mesozoic opening of Neotethys and was later reactivated by dextral transpression during Late Cretaceous–Early Tertiary closure of Neotethys and dextral transtension in the Miocene. This study highlights the structural characteristics of the hinge belt and the nature of deformation of its fault segments. It also highlights the role of this basement structure as a crustal boundary between terranes of different tectonic settings as well as its relationship to the structural development of the nearby areas in NE Africa.

Supplementary material:

A Google Earth image and structural form-line map of Rishat Saada Fault, Google Earth image and Landsat TM image of Rishat Lehman Fault and G. Ras Ebeid, geological map of El Risha El Hamra Fault, Landsat TM image and structural form-line map of the Burqa–Riash Fault, and Google Earth image and geological map of El Bruk Fault are available at
www.geolsoc.org.uk/SUP18697
.
Consequences of open-system melting in tectonics
Authors: Yakymchuk Chris , Brown Michael
Published: November 2013

Partial melting and melt drainage from deep suprasolidus crust in orogens has important consequences for tectonics. Melt extraction along prograde segments of clockwise
P
–
T
paths reduces fertility and increases the density and strength of residual crust, which has implications for further melt production during decompression. Using calculated
P
–
T
phase diagrams, implications of stepwise melt loss along clockwise
P
–
T
paths for pelite and greywacke are assessed, and density of the progressively more residual source and the potential role of buoyancy in the exhumation of deep crustal rocks are evaluated. Two model
P
–
T
paths are considered: isobaric heating at 1.2 GPa followed by decompression to 0.4 GPa at 750, 820 and 890 °C, and prograde heating from the fluid-present solidus at 1.2 GPa to 860 °C at 1.8 GPa followed by isothermal decompression to 0.4 GPa. Both closed-system (undrained) and conditionally open-system (drained by intermittent melt loss) conditions are assessed. If melt is drained along clockwise
P
–
T
paths in suprasolidus crust then lower quantities of melt will be generated during decompression than sometimes inferred in tectonic models. Instead, the role of melt transfer through suprasolidus crust and melt accumulation at shallow levels in the anatectic zone should be considered rather than simply invoking the generation of large volumes of melt in decompressing crust.
Impacts of arc collision on small orogens: new insights from the Coastal Range detrital record, Taiwan
Authors: Kirstein Linda A. , Carter Andrew , Chen Yue-Gau
Published: November 2013

Taiwan is considered the archetypical orogen in the development of critical wedge models of mountain building; however, the issue of how arc collision progressed along the margin remains poorly understood. To resolve this, the detrital archive of orogenesis preserved in Coastal Range rocks of eastern Taiwan was used to reconstruct the erosional response of arc collision. The spatial and temporal distribution of exhumation recorded in this detrital record is consistent with southwards progression of arc–continent collision in a punctuated rather than sequential manner with deposition confined to segmented foredeep basins. Apparent increases in sedimentation rates in Taiwan during the Pleistocene may not reflect increased erosion, but instead may be due to the collisional margin architecture.

Supplementary materials:

Analytical details and dating results are available at
www.geolsoc.org.uk/SUP18693
.
Intermediate representation
Authors: Chow Fred
Published: November 2013

The increasing significance of intermediate representations in compilers.
Making the web faster with HTTP 2.0
Authors: Grigorik Ilya
Published: November 2013

HTTP continues to evolve.
A lesson in resource management
Authors: Neville-Neil George V.
Published: November 2013

Waste not memory, want not memory---unless it doesn't matter.
From MOOCs to SPOCs
Authors: Fox Armando
Published: November 2013

Supplementing the classroom experience with small private online courses.
CDSchecker
Authors: Norris Brian , Demsky Brian
Published: November 2013

Writing low-level concurrent software has traditionally required intimate knowledge of the entire toolchain and often has involved coding in assembly. New language standards have extended C and C++ with support for low-level atomic operations and a weak memory model, enabling developers to write portable and efficient multithreaded code.

Developing correct low-level concurrent code is well-known to be especially difficult under a weak memory model, where code behavior can be surprising. Building reliable concurrent software using C/C++ low-level atomic operations will likely require tools that help developers discover unexpected program behaviors.

In this paper we present CDSChecker, a tool for exhaustively exploring the behaviors of concurrent code under the C/C++ memory model. We develop several novel techniques for modeling the relaxed behaviors allowed by the memory model and for minimizing the number of execution behaviors that CDSChecker must explore. We have used CDSChecker to exhaustively unit test several concurrent data structure implementations on specific inputs and have discovered errors in both a recently published C11 implementation of a work-stealing queue and a single producer, single consumer queue implementation.
Empirical analysis of programming language adoption
Authors: Meyerovich Leo A. , Rabkin Ariel S.
Published: November 2013

Some programming languages become widely popular while others fail to grow beyond their niche or disappear altogether. This paper uses survey methodology to identify the factors that lead to language adoption. We analyze large datasets, including over 200,000 SourceForge projects, 590,000 projects tracked by Ohloh, and multiple surveys of 1,000-13,000 programmers.

We report several prominent findings. First, language adoption follows a power law; a small number of languages account for most language use, but the programming market supports many languages with niche user bases. Second, intrinsic features have only secondary importance in adoption. Open source libraries, existing code, and experience strongly influence developers when selecting a language for a project. Language features such as performance, reliability, and simple semantics do not. Third, developers will steadily learn and forget languages. The overall number of languages developers are familiar with is independent of age. Finally, when considering intrinsic aspects of languages, developers prioritize expressivity over correctness. They perceive static types as primarily helping with the latter, hence partly explaining the popularity of dynamic languages.
Online feedback-directed optimizations for parallel Java code
Authors: Noll Albert , Gross Thomas
Published: November 2013

The performance of parallel code significantly depends on the
parallel task granularity
(PTG). If the PTG is too coarse, performance suffers due to load imbalance; if the PTG is too fine, performance suffers from the overhead that is induced by parallel task creation and scheduling.

This paper presents a software platform that
automatically
determines the PTG at
run-time
. Automatic PTG selection is enabled by
concurrent calls
, which are special source language constructs that provide a late decision (at run-time) of whether concurrent calls are executed sequentially or concurrently (as a parallel task). Furthermore, the execution semantics of concurrent calls permits the runtime system to merge two (or more) concurrent calls thereby coarsening the PTG. We present an integration of concurrent calls into the Java programming language, the Java Memory Model, and show how the Java Virtual Machine can adapt the PTG based on dynamic profiling. The performance evaluation shows that our runtime system performs competitively to Java programs for which the PTG is tuned manually. Compared to an unfortunate choice of the PTG, this approach performs up to 3x faster than standard Java code.
Ball-Larus path profiling across multiple loop iterations
Authors: D'Elia Daniele Cono , Demetrescu Camil
Published: November 2013

Identifying the hottest paths in the control flow graph of a routine can direct optimizations to portions of the code where most resources are consumed. This powerful methodology, called
path profiling
, was introduced by Ball and Larus in the mid 90's [4] and has received considerable attention in the last 15 years for its practical relevance. A shortcoming of the Ball-Larus technique was the inability to profile cyclic paths, making it difficult to mine execution patterns that span multiple loop iterations. Previous results, based on rather complex algorithms, have attempted to circumvent this limitation at the price of significant performance losses even for a small number of iterations. In this paper, we present a new approach to multi-iteration path profiling, based on data structures built on top of the original Ball-Larus numbering technique. Our approach allows the profiling of
all executed paths
obtained as a concatenation of up to
k
Ball-Larus acyclic paths, where
k
is a user-defined parameter. We provide examples showing that this method can reveal optimization opportunities that acyclic-path profiling would miss. An extensive experimental investigation on a large variety of Java benchmarks on the Jikes RVM shows that our approach can be even faster than Ball-Larus due to fewer operations on smaller hash tables, producing compact representations of cyclic paths even for large values of
k
.
Detecting API documentation errors
Authors: Zhong Hao , Su Zhendong
Published: November 2013

When programmers encounter an unfamiliar API library, they often need to refer to its documentations, tutorials, or discussions on development forums to learn its proper usage. These API documents contain valuable information, but may also mislead programmers as they may contain errors (
e.g.
, broken code names and obsolete code samples). Although most API documents are actively maintained and updated, studies show that many new and latent errors do exist. It is tedious and error-prone to find such errors manually as API documents can be enormous with thousands of pages. Existing tools are ineffective in locating documentation errors because traditional natural language (NL) tools do not understand code names and code samples, and traditional code analysis tools do not understand NL sentences. In this paper, we propose the first approach, DOCREF, specifically designed and developed to detect API documentation errors. We formulate a class of inconsistencies to indicate potential documentation errors, and combine NL and code analysis techniques to detect and report such inconsistencies. We have implemented DOCREF and evaluated its effectiveness on the latest documentations of five widely-used API libraries. DOCREF has detected more than 1,000 new documentation errors, which we have reported to the authors. Many of the errors have already been confirmed and fixed, after we reported them.
Multiverse
Authors: Ravichandran Kaushik , Pande Santosh
Published: November 2013

Algorithmic speculation or high-level speculation is a promising programming paradigm which allows programmers to speculatively branch an execution into multiple independent parallel sections and then choose the best (perhaps fastest) amongst them. The continuing execution after the speculatively branched section sees only the modifications made by the best one. This programming paradigm allows programmers to harness parallelism and can provide dramatic performance improvements.

In this paper we present the Multiverse speculative programming model. Multiverse allows programmers to exploit parallelism through high-level speculation. It can effectively harness large amounts of parallelism by speculating across an entire cluster and is not bound by the parallelism available in a single machine. We present abstractions and a runtime which allow programmers to introduce large scale high-level speculative parallelism into applications with minimal effort. We introduce a novel on-demand address space sharing mechanism which provide speculations efficient transparent access to the original address space of the application (including the use of pointers) across machine boundaries. Multiverse provides single commit semantics across speculations while guaranteeing isolation between them. We also introduce novel mechanisms to deal with scalability bottlenecks when there are a large number of speculations.

We demonstrate that for several benchmarks, Multiverse achieves impressive speedups and good scalability across entire clusters. We study the overheads of the runtime and demonstrate how our special scalability mechanisms are crucial in scaling cluster wide.
On-the-fly detection of instability problems in floating-point program execution
Authors: Bao Tao , Zhang Xiangyu
Published: November 2013

The machine representation of floating point values has limited precision such that errors may be introduced during execution. These errors may get propagated and magnified by the following operations, leading to instability problems, e.g., control flow path may be undesirably altered and faulty output may be emitted. In this paper, we develop an on-the-fly efficient monitoring technique that can predict if an execution is stable. The technique does not explicitly compute errors as doing so incurs high overhead. Instead, it detects possible places where an error becomes substantially inflated regarding the corresponding value, and then tags the value with one bit to denote that it has an inflated error. It then tracks inflation bit propagation, taking care of operations that may cut off such propagation. It reports instability if any inflation bit reaches a critical execution point, such as a predicate, where the inflated error may induce substantial execution difference, such as different execution paths. Our experiment shows that with appropriate thresholds, the technique can correctly detect that over 99.999996% of the inputs of all the programs we studied are stable while a traditional technique relying solely on inflation detection mistakenly classifies majority of the inputs as unstable for some of the programs. Compared to the state of the art technique that is based on high precision computation and causes several hundred times slowdown, our technique only causes 7.91 times slowdown on average and can report all the true unstable executions with the appropriate thresholds.
Relaxed separation logic
Authors: Vafeiadis Viktor , Narayan Chinmay
Published: November 2013

We introduce
relaxed separation logic
(RSL), the first program logic for reasoning about concurrent programs running under the C11 relaxed memory model. From a user's perspective, RSL is an extension of concurrent separation logic (CSL) with proof rules for the various kinds of C11 atomic accesses. As in CSL, individual threads are allowed to access non-atomically only the memory that they own, thus preventing data races. Ownership can, however, be transferred via certain atomic accesses. For SC-atomic accesses, we permit arbitrary ownership transfer; for acquire/release atomic accesses, we allow ownership transfer only in one direction; whereas for relaxed atomic accesses, we rule out ownership transfer completely. We illustrate RSL with a few simple examples and prove its soundness directly over the axiomatic C11 weak memory model.
Turning nondeterminism into parallelism
Authors: Tripp Omer , Koskinen Eric , Sagiv Mooly
Published: November 2013

Nondeterminism is a useful and prevalent concept in the design and implementation of software systems. An important property of nondeterminism is its latent parallelism: A nondeterministic action can evaluate to multiple behaviors. If at least one of these behaviors does not conflict with concurrent tasks, then there is an admissible execution of the action in parallel with these tasks. Unfortunately, existing implementations of the atomic paradigm - optimistic as well as pessimistic - are unable to fully exhaust the parallelism potential of nondeterministic actions, lacking the means to guide concurrent tasks toward nondeterministic choices that minimize interference.

This paper investigates the problem of utilizing parallelism due to nondeterminism. We observe that nondeterminism occurs in many real-world codes. We motivate the need for devising coordination mechanisms that can utilize available nondeterminism. We have developed a system featuring such mechanisms, which leverages nondeterminism in a wide class of query operations, allowing a task to look into the future of concurrent tasks that mutate the shared state during query evaluation and reduce conflict accordingly. We evaluate our system on a suite of 12 algorithmic benchmarks of wide applicability, as well as an industrial application. The results are encouraging.
Isolation for nested task parallelism
Authors: Zhao Jisheng , Lublinerman Roberto , Budimlić Zoran , Chaudhuri Swarat , Sarkar Vivek
Published: November 2013

Isolation--the property that a task can access shared data without interference from other tasks--is one of the most basic concerns in parallel programming. Whilethere is a large body of past work on isolated task-parallelism, the integration of isolation, task-parallelism, and nesting of tasks has been a difficult and unresolved challenge. In this pa- per, we present a programming and execution model called Otello where isolation is extended to arbitrarily nested parallel tasks with irregular accesses to heap data. At the same time, no additional burden is imposed on the programmer, who only exposes parallelism by creating and synchronizing parallel tasks, leaving the job of ensuring isolation to the underlying compiler and runtime system.

Otello extends our past work on Aida execution model and the delegated isolation mechanism [22] to the setting of nested parallelism. The basic runtime construct in Aida and Otello is an assembly: a task equipped with a region in the shared heap that it owns. When an assembly A conflicts with an assembly B, A transfers--or delegates--its code and owned region to a carefully selected assembly C in a way that will ensure isolation with B, leaving the responsibility of re-executing task A to C. The choice of C depends on the nesting relationship between A and B.We have implemented Otello on top of the Habanero Java (HJ) parallel programming language [8], and used this implementation to evaluate Otello on collections of nested task-parallel benchmarks and non-nested transactional benchmarks from past work. On the nested task-parallel benchmarks, Otello achieves scalability comparable to HJ programs without built-in isolation, and the relative overhead of Otello is lower than that of many published data-race detection algorithms that detect the isolation violations (but do not enforce isolation). For the transactional benchmarks, Otello incurs lower overhead than a state-of-the-art software transactional memory system (Deuce STM).
Python
Authors: Politz Joe Gibbs , Martinez Alejandro , Milano Mae , Warren Sumner , Patterson Daniel , Li Junsong , Chitipothu Anand , Krishnamurthi Shriram
Published: November 2013

We present a small-step operational semantics for the Python programming language. We present both a core language for Python, suitable for tools and proofs, and a translation process for converting Python source to this core. We have tested the composition of translation and evaluation of the core for conformance with the primary Python implementation, thereby giving confidence in the fidelity of the semantics. We briefly report on the engineering of these components. Finally, we examine subtle aspects of the language, identifying scope as a pervasive concern that even impacts features that might be considered orthogonal.
Refactoring with synthesis
Authors: Raychev Veselin , Schäfer Max , Sridharan Manu , Vechev Martin
Published: November 2013

Refactoring has become an integral part of modern software development, with wide support in popular integrated development environments (IDEs). Modern IDEs provide a fixed set of supported refactorings, listed in a refactoring menu. But with IDEs supporting more and more refactorings, it is becoming increasingly difficult for programmers to discover and memorize all their names and meanings. Also, since the set of refactorings is hard-coded, if a programmer wants to achieve a slightly different code transformation, she has to either apply a (possibly non-obvious) sequence of several built-in refactorings, or just perform the transformation by hand.

We propose a novel approach to refactoring, based on synthesis from examples, which addresses these limitations. With our system, the programmer need not worry how to invoke individual refactorings or the order in which to apply them. Instead, a transformation is achieved via three simple steps: the programmer first indicates the start of a code refactoring phase; then she performs some of the desired code changes manually; and finally, she asks the tool to complete the refactoring.

Our system completes the refactoring by first extracting the difference between the starting program and the modified version, and then synthesizing a
sequence
of refactorings that achieves (at least) the desired changes. To enable scalable synthesis, we introduce
local refactorings
, which allow for first discovering a refactoring sequence on small program fragments and then extrapolating it to a full refactoring sequence.

We implemented our approach as an Eclipse plug-in, with an architecture that is easily extendable with new refactorings. The experimental results are encouraging: with only minimal user input, the synthesizer was able to quickly discover complex refactoring sequences for several challenging realistic examples.
Language support for dynamic, hierarchical data partitioning
Authors: Treichler Sean , Bauer Michael , Aiken Alex
Published: November 2013

Applications written for distributed-memory parallel architectures must partition their data to enable parallel execution. As memory hierarchies become deeper, it is increasingly necessary that the data partitioning also be hierarchical to match. Current language proposals perform this hierarchical partitioning statically, which excludes many important applications where the appropriate partitioning is itself data dependent and so must be computed dynamically. We describe Legion, a region-based programming system, where each region may be partitioned into subregions. Partitions are computed dynamically and are fully programmable. The division of data need not be disjoint and subregions of a region may overlap, or alias one another. Computations use regions with certain privileges (e.g., expressing that a computation uses a region read-only) and data coherence (e.g., expressing that the computation need only be atomic with respect to other operations on the region), which can be controlled on a per-region (or subregion) basis.

We present the novel aspects of the Legion design, in particular the combination of static and dynamic checks used to enforce soundness. We give an extended example illustrating how Legion can express computations with dynamically determined relationships between computations and data partitions. We prove the soundness of Legion's type system, and show Legion type checking improves performance by up to 71% by eliding provably safe memory checks. In particular, we show that the dynamic checks to detect aliasing at runtime at the region granularity have negligible overhead. We report results for three real-world applications running on distributed memory machines, achieving up to 62.5X speedup on 96 GPUs on the Keeneland supercomputer.
Verifying quantitative reliability for programs that execute on unreliable hardware
Authors: Carbin Michael , Misailovic Sasa , Rinard Martin C.
Published: November 2013

Emerging high-performance architectures are anticipated to contain unreliable components that may exhibit
soft errors
, which silently corrupt the results of computations. Full detection and masking of soft errors is challenging, expensive, and, for some applications, unnecessary. For example, approximate computing applications (such as multimedia processing, machine learning, and big data analytics) can often naturally tolerate soft errors.

We present Rely a programming language that enables developers to reason about the quantitative reliability of an application -- namely, the probability that it produces the correct result when executed on unreliable hardware. Rely allows developers to specify the reliability requirements for each value that a function produces.

We present a static quantitative reliability analysis that verifies quantitative requirements on the reliability of an application, enabling a developer to perform sound and verified reliability engineering. The analysis takes a Rely program with a reliability specification and a hardware specification that characterizes the reliability of the underlying hardware components and verifies that the program satisfies its reliability specification when executed on the underlying unreliable hardware platform. We demonstrate the application of quantitative reliability analysis on six computations implemented in Rely.
Targeted and depth-first exploration for systematic testing of android apps
Authors: Azim Tanzirul , Neamtiu Iulian
Published: November 2013

Systematic exploration of Android apps is an enabler for a variety of app analysis and testing tasks. Performing the exploration while apps run on actual phones is essential for exploring the full range of app capabilities. However, exploring real-world apps on real phones is challenging due to non-determinism, non-standard control flow, scalability and overhead constraints. Relying on end-users to conduct the exploration might not be very effective: we performed a 7-use study on popular Android apps, and found that the combined 7-use coverage was 30.08% of the app screens and 6.46% of the app methods. Prior approaches for automated exploration of Android apps have run apps in an emulator or focused on small apps whose source code was available. To address these problems, we present A
3
E, an approach and tool that allows substantial Android apps to be explored systematically while running on actual phones, yet without requiring access to the app's source code. The key insight of our approach is to use a static, taint-style, dataflow analysis on the app bytecode in a novel way, to construct a high-level control flow graph that captures legal transitions among activities (app screens). We then use this graph to develop an exploration strategy named
Targeted Exploration
that permits fast, direct exploration of activities, including activities that would be difficult to reach during normal use. We also developed a strategy named
Depth-first Exploration
that mimics user actions for exploring activities and their constituents in a slower, but more systematic way. To measure the effectiveness of our techniques, we use two metrics: activity coverage (number of screens explored) and method coverage. Experiments with using our approach on 25 popular Android apps including BBC News, Gas Buddy, Amazon Mobile, YouTube, Shazam Encore, and CNN, show that our exploration techniques achieve 59.39--64.11% activity coverage and 29.53--36.46% method coverage.
Injecting mechanical faults to localize developer faults for evolving software
Authors: Zhang Lingming , Zhang Lu , Khurshid Sarfraz
Published: November 2013

This paper presents a novel methodology for localizing faults in code as it evolves. Our insight is that the essence of failure-inducing edits made by the developer can be captured using mechanical program transformations (e.g., mutation changes). Based on the insight, we present the FIFL framework, which uses both the spectrum information of edits (obtained using the existing
FaultTracer
approach) as well as the potential impacts of edits (simulated by mutation changes) to achieve more accurate fault localization. We evaluate FIFL on real-world repositories of nine Java projects ranging from 5.7KLoC to 88.8KLoC. The experimental results show that FIFL is able to outperform the state-of-the-art
FaultTracer
technique for localizing failure-inducing program edits significantly. For example, all 19 FIFL strategies that use both the spectrum information and simulated impact information for each edit outperform the existing
FaultTracer
approach statistically at the significance level of 0.01. In addition, FIFL with its default settings outperforms
FaultTracer
by 2.33% to 86.26% on 16 of the 26 studied version pairs, and is only inferior than
FaultTracer
on one version pair.
MrCrypt
Authors: Tetali Sai Deep , Lesani Mohsen , Majumdar Rupak , Millstein Todd
Published: November 2013

In a common use case for cloud computing, clients upload data and computation to servers that are managed by a third-party infrastructure provider. We describe MrCrypt, a system that provides data confidentiality in this setting by executing client computations on encrypted data. MrCrypt statically analyzes a program to identify the set of operations on each input data column, in order to select an appropriate homomorphic encryption scheme for that column, and then transforms the program to operate over encrypted data. The encrypted data and transformed program are uploaded to the server and executed as usual, and the result of the computation is decrypted on the client side. We have implemented MrCrypt for Java and illustrate its practicality on three standard benchmark suites for the Hadoop MapReduce framework. We have also formalized the approach and proven several soundness and security guarantees.
Synthesis modulo recursive functions
Authors: Kneuss Etienne , Kuraj Ivan , Kuncak Viktor , Suter Philippe
Published: November 2013

We describe techniques for synthesis and verification of recursive functional programs over unbounded domains. Our techniques build on top of an algorithm for satisfiability modulo recursive functions, a framework for deductive synthesis, and complete synthesis procedures for algebraic data types. We present new counterexample-guided algorithms for constructing verified programs. We have implemented these algorithms in an integrated environment for interactive verification and synthesis from relational specifications. Our system was able to synthesize a number of useful recursive functions that manipulate unbounded numbers and data structures.
Bounded partial-order reduction
Authors: Coons Katherine E. , Musuvathi Madan , McKinley Kathryn S.
Published: November 2013

Eliminating concurrency errors is increasingly important as systems rely more on parallelism for performance. Exhaustively exploring the state-space of a program's thread interleavings finds concurrency errors and provides coverage guarantees, but suffers from exponential
state-space explosion
. Two prior approaches alleviate state-space explosion. (1)
Dynamic partial-order reduction
(DPOR) provides
full coverage
and explores only one interleaving of independent transitions. (2)
Bounded search
provides
bounded coverage
by enumerating interleavings that do not exceed a bound. In particular, we focus on preemption-bounding. Combining partial-order reduction with preemption-bounding had remained an open problem.

We show that preemption-bounded search explores the same partial orders repeatedly and consequently explores more executions than unbounded DPOR, even for small bounds. We further show that if DPOR simply uses the preemption bound to prune the state space as it explores new partial orders, it misses parts of the state space reachable in the bound and is therefore unsound. The bound essentially induces dependences between otherwise independent transitions in the DPOR state space. We introduce Bounded Partial Order Reduction (BPOR), a modification of DPOR that compensates for bound dependences. We identify properties that determine how well bounds combine with partial-order reduction. We prove sound coverage and empirically evaluate BPOR with preemption and fairness bounds. We show that by eliminating redundancies, BPOR significantly reduces testing time compared to bounded search. BPOR's faster incremental guarantees will help testers verify larger concurrent programs.
Correctness of an STM Haskell implementation
Authors: Schmidt-Schauß Manfred , Sabel David
Published: November 2013

A concurrent implementation of software transactional memory in Concurrent Haskell using a call-by-need functional language with processes and futures is given. The description of the small-step operational semantics is precise and explicit, and employs an early abort of conflicting transactions. A proof of correctness of the implementation is given for a contextual semantics with may- and should-convergence. This implies that our implementation is a correct evaluator for an abstract specification equipped with a big-step semantics.
Optimising purely functional GPU programs
Authors: McDonell Trevor L. , Chakravarty Manuel M.T. , Keller Gabriele , Lippmeier Ben
Published: November 2013

Purely functional, embedded array programs are a good match for SIMD hardware, such as GPUs. However, the naive compilation of such programs quickly leads to both code explosion and an excessive use of intermediate data structures. The resulting slow-down is not acceptable on target hardware that is usually chosen to achieve high performance.

In this paper, we discuss two optimisation techniques, sharing recovery and array fusion, that tackle code explosion and eliminate superfluous intermediate structures. Both techniques are well known from other contexts, but they present unique challenges for an embedded language compiled for execution on a GPU. We present novel methods for implementing sharing recovery and array fusion, and demonstrate their effectiveness on a set of benchmarks.
Using circular programs for higher-order syntax
Authors: Axelsson Emil , Claessen Koen
Published: November 2013

This pearl presents a novel technique for constructing a first-order syntax tree directly from a higher-order interface. We exploit circular programming to generate names for new variables, resulting in a simple yet efficient method. Our motivating application is the design of embedded languages supporting variable binding, where it is convenient to use higher-order syntax when constructing programs, but first-order syntax when processing or transforming programs.
Experience report
Authors: St-Amour Vincent , Toronto Neil
Published: November 2013

As programmers, programming in typed languages increases our confidence in the correctness of our programs. As type system designers, soundness proofs increase our confidence in the correctness of our type systems. There is more to typed languages than their typing rules, however. To be usable, a typed language needs to provide a well-furnished standard library and to specify types for its exports.

As software artifacts, these base type environments can rival typecheckers in complexity. Our experience with the Typed Racket base environment---which accounts for 31% of the code in the Typed Racket implementation---teaches us that writing type environments can be just as error-prone as writing typecheckers.

We report on our experience over the past two years of using random testing to increase our confidence in the correctness of the Typed Racket base environment.
Organizing Principles of Mammalian Nonsense-Mediated mRNA Decay
Authors: Popp Maximilian Wei-Lin , Maquat Lynne E.
Published: November 2013

Cells use messenger RNAs (mRNAs) to ensure the accurate dissemination of genetic information encoded by DNA. Given that mRNAs largely direct the synthesis of a critical effector of cellular phenotype, i.e., proteins, tight regulation of both the quality and quantity of mRNA is a prerequisite for effective cellular homeostasis. Here, we review nonsense-mediated mRNA decay (NMD), which is the best-characterized posttranscriptional quality control mechanism that cells have evolved in their cytoplasm to ensure transcriptome fidelity. We use protein quality control as a conceptual framework to organize what is known about NMD, highlighting overarching similarities between these two polymer quality control pathways, where the protein quality control and NMD pathways intersect, and how protein quality control can suggest new avenues for research into mRNA quality control.
Generation of Leukemia Inhibitory Factor-Dependent Induced Pluripotent Stem Cells from the Massachusetts General Hospital Miniature Pig
Authors: Kwon Dae-Jin , Jeon Hyelena , Oh Keon Bong , Ock Sun-A , Im Gi-Sun , Lee Sung-Soo , Im Seok Ki , Lee Jeong-Woong , Oh Sung-Jong , Park Jin-Ki , Hwang Seongsoo
Published: November 2013

The generation and application of porcine induced pluripotent stem cells (iPSCs) may enable the testing for safety and efficacy of therapy in the field of human regenerative medicine. Here, the generation of iPSCs from the Massachusetts General Hospital miniature pig (MGH minipig) established for organ transplantation studies is reported. Fibroblasts were isolated from the skin of the ear of a 10-day-old MGH minipig and transduced with a cocktail of six human factors:POU5F1, NANOG, SOX2, C-MYC, KLF4,andLIN28. Two distinct types of iPSCs were generated that were positive for alkaline phosphatase activity, as well as the classical pluripotency markers:Oct4, Nanog, Sox2, and the surface marker Ssea-1. Only one of two porcine iPSC lines differentiated into three germ layers bothin vitroandin vivo. Western blot analysis showed that the porcine iPSCs were dependent on LIF or BMP-4 to sustain self-renewal and pluripotency. In conclusion, the results showed that human pluripotent factors could reprogram porcine ear fibroblasts into the pluripotent state. These cells may provide a useful source of cells that could be used for the treatment of degenerative and genetic diseases and agricultural research and application.
PXR-Mediated Upregulation of CYP3A Expression by Herb Compound Praeruptorin C fromPeucedanum praeruptorumDunn
Authors: Huang Ling , Wu Qian , Li Yu-Hua , Wang Yi-Tao , Bi Hui-Chang
Published: November 2013

We recently reported that Praeruptorin C effectively transactivated the mRNA, protein expression, and catalytic activity of CYP3A4 via the CAR-mediated pathway, but whether and how PC could affect the expression and catalytic activity of CYP3A4 via PXR pathway remains unknown. Therefore, in this study, the effect of PC on theCYP3Agene expression was investigated in mice primary hepatocytes after knockdown of PXR by transient transfection of PXR siRNA, and the gene expression, protein expression, and catalytic activity of CYP3A4 in the LS174T cells with PXR overexpression were determined by real-time PCR, western blot analysis, and LC-MS/MS-based CYP3A4 substrate assay, respectively. We found that the level ofCYP3a11gene expression in mouse primary hepatocytes was significantly increased by praeruptorin C, but such an induction was suppressed after knockdown of pregnane X receptor by its siRNA. In PXR-overexpressed LS174T cells, PC significantly enhanced CYP3A4 mRNA, protein expression, and functional activity through PXR-mediated pathway; conversely, no such increase was found in the untransfected cells. These findings suggest that PC can significantly upregulate CYP3A level via the PXR-mediated pathway, and this should be taken into consideration to predict any potential herb-drug interactions between PC, Qianhu, and the other coadministered drugs.
Dynamic Analysis of Traffic State and Congestion Propagation on Bidirectional Grid Network
Authors: Li Shu-bin , Fu Bai-bai , Zheng Jian-feng
Published: November 2013

Many traffic problems in China such as traffic jams and air pollutions are mainly caused by the increasing traffic volume. In order to alleviate the traffic congestion and improve the network performance, the analysis of traffic state and congestion propagation has attracted a great interest. In this paper, an improved mesoscopic traffic flow model is proposed to capture the speed-density relationship on segments, the length of queue, the flow on links, and so forth, The self-developed dynamic traffic simulation software (DynaCHINA) is used to reproduce the traffic congestion and propagation in a bidirectional grid network for different demand levels. The simulation results show that the proposed model and method are capable of capturing the real traffic states. Hence, our results can provide decision supports for the urban traffic management and planning.
A Recent Review on Chemiluminescence Reaction, Principle and Application on Pharmaceutical Analysis
Authors: Fereja Tadesse Haile , Hymete Ariaya , Gunasekaran Thirumurugan
Published: November 2013

This paper provides a general review on principle of chemiluminescent reactions and their recent applications in drug analysis. The structural requirements for chemiluminescent reactions and the different factors that affect the efficiency of analysis are included in the review. Chemiluminescence application in immunoassay is the new version for this review. Practical considerations are not included in the review since the main interest is to state, through the aforementioned applications, that chemiluminescence has been, is, and will be a versatile tool for pharmaceutical analysis in future years.
The Cluster-Heads Selection Method considering Energy Balancing for Wireless Sensor Networks
Authors: Nam Choon-Sung , Han Young-Shin , Shin Dong-Ryeol
Published: November 2013

Wireless sensor networks (WSNs) are self-organizing networks in which sensor nodes with limited resource are scattered in an area of interest to gather information. WSNs need to have effective node's energy management methods for stable and seamless communication. As one of a number of good technical solutions, a clustering technique has been issued and proposed among researchers for reducing energy consumption in WSNs. Also, it can prevent the problem of data duplication by the sensor nodes. Generally, to reduce WSNs' energy consumption as much, cluster heads (CHs) are selected dynamically based on cluster rotation mechanism. However, the CH that is already previously selected could not be selected again unless the round process is over even though the node has more energy than others. Following this fact, in WSNs, there is a kind of irregular energy consumption status among sensor nodes because of CHs' overhead energy usages. To solve this problem, in WSN networks, any sensor node should be a candidate to be CH without any exception even if the node is already chosen before. Therefore, in this paper, we will establish and propose an energy balanced CH selection mechanism and the distribution of sensor node's energy consumption in WSNs for equal and stable energy management.
Efficacy and Safety of Iguratimod for the Treatment of Rheumatoid Arthritis
Authors: Li Jiangtao , Mao Hejuan , Liang Yan , Lu Yanrong , Chen Shuo , Yang Nanping , Shi Guixiu
Published: November 2013

All randomized controlled trials (RCTs) of iguratimod for rheumatoid arthritis (RA) to assess its efficacy and safety are included in this paper. The Review Manager software was used for meta-analysis to assess risk bias of the studies included, and GRADE profiler software was used for the evidence quality of the studies included. Four RCTs involving 1407 patients with RA were included. Meta-analyses showed that, after 24-week therapy, ACR20, tender joint count, swollen joint count, rest pain, physician and patient global assessment of disease activity, HAQ score, ESR, and CRP in iguratimod group were better than those in placebo group and that the difference between those of iguratimod group and those of other DMARDs (MTX and SASP) group was not significant. GRADE evidence classification of the studies included was moderate. Iguratimod for RA had few adverse events, and its efficacy and safety were the same as those of MTX and SASP for RA. The results of this systematic review suggest that more high-quality and large-scaled RCTs were needed to determine the efficacy of iguratimod for RA and whether iguratimod is as effective as other DMARDs besides MTX and SASP.
Cortical Plasticity after Cochlear Implantation
Authors: Petersen B. , Gjedde A. , Wallentin M. , Vuust P.
Published: November 2013

The most dramatic progress in the restoration of hearing takes place in the first months after cochlear implantation. To map the brain activity underlying this process, we used positron emission tomography at three time points: within 14 days, three months, and six months after switch-on. Fifteen recently implanted adult implant recipients listened to running speech or speech-like noise in four sequential PET sessions at each milestone. CI listeners with postlingual hearing loss showed differential activation of left superior temporal gyrus during speech and speech-like stimuli, unlike CI listeners with prelingual hearing loss. Furthermore, Broca’s area was activated as an effect of time, but only in CI listeners with postlingual hearing loss. The study demonstrates that adaptation to the cochlear implant is highly related to the history of hearing loss. Speech processing in patients whose hearing loss occurred after the acquisition of language involves brain areas associated with speech comprehension, which is not the case for patients whose hearing loss occurred before the acquisition of language. Finally, the findings confirm the key role of Broca’s area in restoration of speech perception, but only in individuals in whom Broca’s area has been active prior to the loss of hearing.