Programming models for building large-scale distributed applications assist the developer in reasoning about consistency and distribution. However, many of the programming models for weak consistency, which promise the largest scalability gains, have little in the way of evaluation to demonstrate the promised scalability. We present an experience report on the implementation and largescale evaluation of one of these models, Lasp, originally presented at PPDP '15, which provides a declarative, functional programming style for distributed applications. We demonstrate the scalability of Lasp's prototype runtime implementation up to 1024 nodes in the Amazon cloud computing environment. It achieves high scalability by uniquely combining hybrid gossip with a programming model based on convergent computation. We report on the engineering challenges of this implementation and its evaluation, specifically related to operating research prototypes in a production cloud environment.
In this extended abstract we survey the most recent developments in code obfuscation and protection from a programming languages perspective. Starting from known impossibility results on universal and general purpose code obfuscation, we show that provably secure obfuscation can be achieved by constraining the attack model. This corresponds to associate attacks with suitable forms of interpretation. In this context it is always possible to systematically making code obscure, making this interpretation failing in extracting (attacking) code. The code transformation can itself be specified as the specialization of a distorted interpreter.
We describe and document our experience from developing an AMD64 backend for the HiPE (High Performance Erlang) native code compiler. We consider implementation alternatives and critically examine design choices for obtaining an efficient AMD64 backend. In particular, we consider in detail how other functional language implementors can migrate their existing x86 backends to the AMD64 architecture, a platform which is becoming increasingly important these days. We mention backend components that can be shared between x86 and AMD64, and those that better be different for achieving high performance on AMD64. Finally, we measure the performance of several different alternatives in the hope that this information can save development effort for others who intend to engage in a similar feat.
Proof Carrying Code is a general principle that supports to transfer code from an untrusted producer over an untrusted channel to a code consumer. The producer generates a safety proof that ensures certain properties of the program and transmits this proof together with the program to the consumer side. The consumer checks that the proof guarantees the required security properties before he executes the code. Two aspects are considered vital for the approach: validity and efficiency. The checking phase at the consumer guarantees that the code is valid with respect to the security properties. That process has to be significantly more efficient than repeating the proof construction. We investigate the application of the Proof Carrying Code principle in a data flow analysis scenario. The producer attaches results of data flow analysis to the code that describe desired properties of the code which are rather costly to compute. The original example is the annotation of type inference information that are needed to type check Java bytecode on resource-constraint devices like mobile phones or even smart cards. We show how the application scenario meets the two vital aspects of validity and efficiency. Furthermore, we state that there is a third vital aspect: the usefulness of the results with respect to the goal the consumer wants to achieve. Results of data flow analysis can often be obtained on different levels of precision. It turns out that there is a trade-off between the usefulness of the results and the costs needed to validate them. ? Condensed Version of the Volume of the Seminar “Proof Carrying Code” held in 2005, Full version to appear as Technical Report of the University Paderborn
