Lasp: A language for distributed, coordination-free programming

August 17, 2015 ~ Adrian Colyer ~ 4 Comments

Lasp: A language for distributed, coordination-free programming - Meiklejohn & Van Roy 2015 * Update: fixed typo in Chris' surname above. * With thanks to Colin Barrett for suggesting today's choice, and to Chris Meiklejohn for providing a link to a paywall-free preprint of the paper. Christopher Meiklejohn recently announced he is leaving Basho to ... Continue Reading

PerfBlower: Quickly Detecting Memory-Related Performance Problems via Amplification

August 14, 2015 ~ Adrian Colyer ~ 1 Comment

PerfBlower: Quickly Detecting Memory-Related Performance Problems via Amplification - Fang et al. 2015 Another ECOOP '15 paper, and definitely something with immediate pragmatic utility. PerfBlower finds heap-related performance problems during regular test runs (not exhaustive performance tests) by amplifying the effects of small issues to make them visible. The user provides details of classes of ... Continue Reading

Streams à la carte: Extensible pipelines with object algebras

August 13, 2015 ~ Adrian Colyer ~ 5 Comments

Streams à la carte: Extensible pipelines with object algebras - Biboudis et al. 2015 Streaming APIs are popping up everywhere, allowing the programmer to express streaming computations such as: int sum = IntStream.of(v) .filter(x -> x % 2 == 0) .map(x -> x * x) .sum(); On examining the streaming libraries in Java, Scala, and ... Continue Reading

Global Sequence Protocol

August 12, 2015 ~ Adrian Colyer ~ 3 Comments

Global Sequence Protocol: A Robust Abstraction for Replicated Shared State - Burckhardt et al. 2015 This is the ECOOP '15 paper that we've been building up to so far this week. The problem domain is the familiar desire to support replicated shared data across nodes (mobile devices here) with eventual consistency. In the mobile context, ... Continue Reading

Cloud Types for Eventual Consistency

August 11, 2015 ~ Adrian Colyer ~ 3 Comments

Cloud Types for Eventual Consistency - Burckhardt et al. 2012 Providing good programming abstractions for cloud storage, synchronization, and disconnected operation appears crucial to accelerate the production of useful and novel applications on today’s and tomorrow’s mobile devices. This paper proposes a model based on cloud types (which may be integrated with a programming language). ... Continue Reading

Eventually Consistent Transactions

August 10, 2015 ~ Adrian Colyer ~ 1 Comment

Eventually Consistent Transactions - Burckhardt et al. 2012 There's another ECOOP'15 paper I'd like to cover this week - Burckhardt et al.'s "Global Sequence Protocol." But that paper builds on the notion of Cloud Types (similar in spirit to CRDTs, and not something I've personally come across before), which in turn builds on work on ... Continue Reading

Access Rights Analysis in the Presence of Subjects

August 7, 2015 ~ Adrian Colyer ~ Leave a comment

Access Rights Analysis in the Presence of Subjects - Centonze et al. 2015 Security in application code is a cross-cutting concern and hence very difficult to get right since the analysis often depends on non-local effects. Java and the .NET CLR both have a declarative permissions model that can grant permissions both to code, and ... Continue Reading

Cooking the Books: Formalizing the JMM Implementation Recipes

August 6, 2015 ~ Adrian Colyer ~ Leave a comment

Cooking the Books: Formalizing the JMM Implementation Recipes - Petri et al. 2015 A decade ago, the semantics of concurrent Java programs, the Java Memory Model (JMM), was revised and redefined... ... this refinement introduced a formalization called the Data-Race Free (DRF) guarantee. Programs that do not have data races (DRF) in their sequentially consistent ... Continue Reading

Optimization Coaching for JavaScript

August 5, 2015 ~ Adrian Colyer ~ 3 Comments

Optimization Coaching for JavaScript - St-Amour & Guo, 2015 Because modern programming languages heavily rely on compiler optimizations for performance, failure to apply certain key optimizations is often the source of performance issues. To diagnose these performance issues, programmers need insight about what happens during the optimization process. Consider the following program snippet from the ... Continue Reading

The Good, the Bad, and the Ugly: An Empirical Study of Implicit Type Conversions in JavaScript

August 4, 2015 ~ Adrian Colyer ~ 2 Comments

The Good, the Bad, and the Ugly: An Empirical Study of Implicit Type Conversions in JavaScript - Pradel and Sen, 2015 Updated to fix conditional coercion example: "0" == "false" is false, but "0" == false is true. "JavaScript is notorious for its heavy use of implicit type coercions" - and many of those are ... Continue Reading

the morning paper

a random walk through Computer Science research, by Adrian Colyer
Made delightfully fast by strattic

Month: August 2015