16525
Reasoning about the Node.js Event Loop using Async Graphs - IEEE Conference Publication
With the popularity of Node.js, asynchronous, event-driven programming has become widespread in server-side applications. While conceptually simple, event-based programming can be tedious and error-prone. The complex semantics of the Node.js event loop, coupled with the different flavors of asynchronous execution in JavaScript, easily leads to bugs. This paper introduces a new model called Async Graph to reason about the runtime behavior of applications and their interactions with the Node.js event loop. Based on the model, we have developed AsyncG, a tool to automatically build and analyze the Async Graph of a running application, and to identify bugs related to all sources of asynchronous execution in Node.js. AsyncG is compatible with the latest ECMAScript language features and can be (de)activated at runtime. In our evaluation, we show how AsyncG can be used to identify bugs in real-world Node.js applications.
paper  node  node.js  asynchronous  debugging  tools 
6 days ago
A fork() in the road
The received wisdom suggests that Unix’s unusual combination of fork() and exec() for process creation was an
inspired design. In this paper, we argue that fork was a clever
hack for machines and programs of the 1970s that has long
outlived its usefulness and is now a liability. We catalog the
ways in which fork is a terrible abstraction for the modern programmer to use, describe how it compromises OS
implementations, and propose alternatives.
As the designers and implementers of operating systems,
we should acknowledge that fork’s continued existence as
a first-class OS primitive holds back systems research, and
deprecate it. As educators, we should teach fork as a historical artifact, and not the first process creation mechanism
students encounter.
filetype:pdf  unix  os  design  fork  memory  safety  performance 
5 weeks ago
Fast Serializable Multi-Version Concurrency Control for Main-Memory Database Systems
Multi-Version Concurrency Control (MVCC) is a widely employed concurrency control mechanism, as it allows for execution modes where readers never block writers. However,
most systems implement only snapshot isolation (SI) instead
of full serializability. Adding serializability guarantees to existing SI implementations tends to be prohibitively expensive.
We present a novel MVCC implementation for main-memory database systems that has very little overhead compared
to serial execution with single-version concurrency control,
even when maintaining serializability guarantees. Updating
data in-place and storing versions as before-image deltas in
undo buffers not only allows us to retain the high scan performance of single-version systems but also forms the basis of our cheap and fine-grained serializability validation
mechanism. The novel idea is based on an adaptation of
precision locking and verifies that the (extensional) writes
of recently committed transactions do not intersect with the
(intensional) read predicate space of a committing transaction. We experimentally show that our MVCC model allows
very fast processing of transactions with point accesses as
well as read-heavy transactions and that there is little need
to prefer SI over full serializability any longer.
comp-sci  database  mvcc  performance  design  architecture  filetype:pdf  paper  serialisability  linearisability 
7 weeks ago
EIO: Error Handling is Occasionally Correct
The reliability of file systems depends in part on how
well they propagate errors. We develop a static analysis technique, EDP, that analyzes how file systems and
storage device drivers propagate error codes. Running
our EDP analysis on all file systems and 3 major storage
device drivers in Linux 2.6, we find that errors are often
incorrectly propagated; 1153 calls (13%) drop an error
code without handling it.
We perform a set of analyses to rank the robustness
of each subsystem based on the completeness of its error propagation; we find that many popular file systems
are less robust than other available choices. We confirm that write errors are neglected more often than read
errors. We also find that many violations are not cornercase mistakes, but perhaps intentional choices. Finally,
we show that inter-module calls play a part in incorrect
error propagation, but that chained propagations do not.
In conclusion, error propagation appears complex and
hard to perform correctly in modern systems.
filetype:pdf  paper  comp-sci  filesystem  errors  correctness  error-handling 
7 weeks ago
The PlusCal Algorithm Language
Algorithms are different from programs and should not be described with
programming languages. The only simple alternative to programming languages has been pseudo-code. PlusCal is an algorithm language that can be
used right now to replace pseudo-code, for both sequential and concurrent
algorithms. It is based on the TLA+ specification language, and a PlusCal
algorithm is automatically translated to a TLA+ specification that can be
checked with the TLC model checker and reasoned about formally.
filetype:pdf  comp-sci  lamport  formal-methods  correctness 
7 weeks ago
mov is Turing-complete
It is well-known that the x86 instruction set is baroque, overcomplicated, and redundantly redundant. We show just how much fluff
it has by demonstrating that it remains Turing-complete when reduced to just one instruction.
The instruction we choose is mov, which can do both loads
and stores. We use no unusual addressing modes, self-modifying
code, or runtime code generation. Using just this instruction (and
a single unconditional branch at the end of the program to make
nontermination possible), we demonstrate how an arbitrary Turing
machine can be simulated.
computer  x86  comp-sci  filetype:pdf  paper 
7 weeks ago
« earlier      
2011 2012 2016 abuse advertising advice advocacy agile ai algorithms amazon analysis analytics android api apple architecture art article aws benchmark book books brexit browser business career children climatechange clojure cloud code communication community comp-sci comparison compiler concurrency cool cryptography css culture data database debugging deployment design development devops digital distributed diversity docker economics economy education election empathy encryption energy engineering entrepreneurship erlang eu experience facebook failure feminism filetype:pdf finance framework functional funny future gds git github golang google gov.uk government guardian hacking hadoop hardware haskell health history howto html html5 http humour image images infosec innovation inspiration internet interview ios iphone java javascript journalism jquery jruby js jvm language languages law leadership lean learning library life linux management marketing mathematics media memory metrics mobile monitoring mysql netflix network networking news node node.js nodejs nosql nytimes opensource operations optimization paper parenting people performance philosophy physics politics presentation privacy process productivity programming psychology publishing python rails rant reference research rest review ruby satire scala scalability scaling science search security server sexism slides socialmedia software ssl startup startups statistics strategy study sysadmin tech technology testing tips tools trump tutorial twitter twitter:timoreilly ui uk unix usa ux video visualization web webdesign webdev wired women women-in-tech work wpo writing

Copy this bookmark:



description:


tags: