bluuebunny/crossref_metadata_2025_split huggingface dataset:
Predicting sickness during a 2-week soccer camp at 3600 m (ISA3600)
Authors: Buchheit Martin , Simpson Ben M , Schmidt Walter F , Aughey Robert J , Soria Rudy , Hunt Robert A , Garvican-Lewis Laura A , Pyne David B , Gore Christopher J , Bourdon Pitre C 
Published: November 2013

ObjectivesTo examine the time course of changes in wellness and health status markers before and after episodes of sickness in young soccer players during a high-altitude training camp (La Paz, 3600 m).MethodsWellness and fatigue were assessed daily on awakening using specifically-designed questionnaires and resting measures of heart rate and heart rate variability. The rating of perceived exertion and heart rate responses to a submaximal run (9 km/h) were also collected during each training session. Players who missed the morning screening for at least two consecutive days were considered as sick.ResultsFour players met the inclusion criteria. With the exception of submaximal exercise heart rate, which showed an almost certain and large increase before the day of sickness (4%; 90% confidence interval 3 to 6), there was no clear change in any of the other psychometric or physiological variables. There was a very likely moderate increase (79%, 22 to 64) in self-reported training load the day before the heart rate increase in sick players (4 of the 4 players, 100%). In contrast, training load was likely and slightly decreased (−24%, −78 to −11) in players who also showed an increased heart rate but remained healthy.ConclusionsA >4% increased heart rate during submaximal exercise in response to a moderate increase in perceived training load the previous day may be an indicator of sickness the next day. All other variables, that is, resting heart rate, heart rate variability and psychometric questionnaires may be less powerful at predicting sickness.
Methods of the international study on soccer at altitude 3600 m (ISA3600)
Authors: Gore Christopher J , Aughey Robert J , Bourdon Pitre C , Garvican-Lewis Laura A , Soria Rudy , Claros Jesus C Jimenez , Sargent Charli , Roach Gregory D , Buchheit Martin , Simpson Ben M , Hammond Kristal , Kley Marlen , Wachsmuth Nadine , Pepper Mark , Edwards Alistair , Cuenca Douglas , Vidmar Tony , Spielvogel Hilde , Schmidt Walter F 
Published: November 2013

BackgroundWe describe here the 3-year process underpinning a multinational collaboration to investigate soccer played at high altitude—La Paz, Bolivia (3600 m). There were two main aims: first, to quantify the extent to which running performance would be altered at 3600 m compared with near sea level; and second, to characterise the time course of acclimatisation of running performance and underlying physiology to training and playing at 3600 m. In addition, this project was able to measure the physiological changes and the effect on running performance of altitude-adapted soccer players from 3600 m playing at low altitude.MethodsA U20 Bolivian team (‘The Strongest’ from La Paz, n=19) played a series of five games against a U17 team from sea level in Australia (The Joeys, n=20). 2 games were played near sea level (Santa Cruz 430 m) over 5 days and then three games were played in La Paz over the next 12 days. Measures were (1) game and training running performance—including global positioning system (GPS) data on distance travelled and velocity of movement; (2) blood—including haemoglobin mass, blood volume, blood gases and acid–base status; (3) acclimatisation—including resting heart rate variability, perceived altitude sickness, as well as heart rate and perceived exertion responses to a submaximal running test; and (4) sleep patterns.ConclusionsPivotal to the success of the project were the strong professional networks of the collaborators, with most exceeding 10 years, the links of several of the researchers to soccer federations, as well as the interest and support of the two head coaches.
On the use of mobile inflatable hypoxic marquees for sport-specific altitude training in team sports
Authors: Girard Olivier , Brocherie Franck , Millet Grégoire P 
Published: November 2013

Background/aimWith the evolving boundaries of sports science and greater understanding of the driving factors in the human performance physiology, one of the limiting factors has now become the technology. The growing scientific interest on the practical application of hypoxic training for intermittent activities such as team and racket sports legitimises the development of innovative technologies serving athletes in a sport-specific setting.MethodsDescription of a new mobile inflatable simulated hypoxic equipment.ResultsThe system comprises two inflatable units—that is, a tunnel and a rectangular design, each with a 215 m3volume and a hypoxic trailer generating over 3000 Lpm of hypoxic air with FiO2between 0.21 and 0.10 (a simulated altitude up to 5100 m). The inflatable units offer a 45 m running lane (width=1.8 m and height=2.5 m) as well as a 8 m×10 m dome tent. FiO2is stable within a range of 0.1% in normal conditions inside the tunnel. The air supplied is very dry—typically 10–15% relative humidity.ConclusionsThis mobile inflatable simulated hypoxic equipment is a promising technological advance within sport sciences. It offers an opportunity for team-sport players to train under hypoxic conditions, both for repeating sprints (tunnel configuration) or small-side games (rectangular configuration).
The impact of altitude on the sleep of young elite soccer players (ISA3600)
Authors: Sargent Charli , Schmidt Walter F , Aughey Robert J , Bourdon Pitre C , Soria Rudy , Claros Jesus C Jimenez , Garvican-Lewis Laura A , Buchheit Martin , Simpson Ben M , Hammond Kristal , Kley Marlen , Wachsmuth Nadine , Gore Christopher J , Roach Gregory D 
Published: November 2013

BackgroundAltitude training is used by elite athletes to improve sports performance, but it may also disrupt sleep. The aim of this study was to examine the effects of 2 weeks at high altitude on the sleep of young elite athletes.MethodsParticipants (n=10) were members of the Australian under-17 soccer team on an 18-day (19-night) training camp in Bolivia, with six nights at near sea level in Santa Cruz (430 m) and 13 nights at high altitude in La Paz (3600 m). Sleep was monitored using polysomnography during a baseline night at 430 m and three nights at 3600 m (immediately after ascent, 1 week after ascent and 2 weeks after ascent). Data were analysed using effect size statistics.ResultsAll results are reported as comparisons with baseline. Rapid eye movement (REM) sleep was likely lower immediately upon ascent to altitude, possibly lower after 1 week and similar after 2 weeks. On all three nights at altitude, hypopneas and desaturations were almost certainly higher; oxygen saturation was almost certainly lower; and central apnoeas, respiratory arousals and periodic breathing were very likely higher. The effects on REM sleep were common to all but one participant, but the effects on breathing were specific to only half the participants.ConclusionsThe immediate effects of terrestrial altitude of 3600 m are to reduce the amount of REM sleep obtained by young elite athletes, and to cause 50% of them to have impaired breathing during sleep. REM sleep returns to normal after 2 weeks at altitude, but impaired breathing does not improve.
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.
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.
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).
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.
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.
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.