MBrace 1.0

My dearest friends at Nessos have just announced their v1.0 release of MBrace, the open source, big-data, cloud programming model (& runtime) for F# and C#.

We are delighted to announce the release of MBrace 1.0! Big thanks to everyone that made this possible #fsharp #csharp #azure #aws

— MBrace (@mbracethecloud) November 11, 2015

Learn more about it: http://mbrace.io

List of PL-related Summer Schools in 2015

I've put together a list with PL-related summer schools. Some deadlines may have passed, but nevertheless I'm putting that here as a placeholder to keep track of summer schools in our field.

Object Algebras Resources

Object algebras is a really cool solution to the expression problem. We have recently used them as a device for implementing extensible stream pipelines (described in the previous post, Streams à la carte).

A good place that someone can start from, to understand object algebras, is the definition of the Expression Problem. The de-facto reference for that is Philip Wadler's 1998 e-mail:

"The expression problem is a new name for an old problem. The goal is to define a datatype by cases, where one can add new cases to the datatype and new functions over the datatype, without recompiling existing code, and while retaining static type safety (e.g., no casts)".

After that, the reader should be able to answer the question: What does the Visitor pattern allow and what does it prevent?. Afterwards, one should read the original paper by Bruno C. d. S. Oliveira and William R. Cook and become familiarize with the idea, via the solutions to the expression problem in various languages. Pick one that you like the most and explore the structure! If the reader is more functional-oriented, a good place to start is from Tagless Interpreters.

In the following, I give some links that provide ample information on object algebras. Let me know if you found a resource useful on the internet and I am going to update the post here for future reference.
 

Bloggers/Discussions/Videos

• Oleksandr Manzyuk's From Object Algebras to Finally Tagless Interpreters
• A reddit discussion in r/haskell/, Solving the expression problem with Object Algebras and Tagless Interpreters.
• A HN discussion, From Object Algebras to Finally Tagless Interpreters
• A Lambda The Ultimate discussion Object Algebras.
• The Expression Problem solved, finally! and DSLs with fold algebras by Eric Torreborre.
• Who's Afraid of Object Algebras? a very good talk (with video) by Tijs van der Storm that goes through object algebras step by step coding live a working example.

Papers

• Extensibility for the Masses: Practical Extensibility with Object Algebras: the original paper by Bruno C. d. S. Oliveira and William R. Cook.
• Feature-Oriented Programming with Object Algebras: in which, Bruno C.d.S. Oliveira, Tijs van der Storm, Alex Loh and William R. Cook. explore composition mechanisms of object algebras using intersection types and type-constructor polymorphism.
• Extensible Language Implementation with Object Algebras by Maria Gouseti, Chiel Peters and Tijs van der Storm.
• From Object Algebras to Attribute Grammars by Tillmann Rendel, Jonathan Immanuel Brachthauser and Klaus Ostermann.
• Streams à la carte: Extensible Pipelines with Object Algebras.

Streams à la carte: Extensible Pipelines with Object Algebras

The final version of our ECOOP15 paper for extensible streams is up!

Streams à la carte: Extensible Pipelines with Object Algebras

We address extensibility shortcomings in libraries for lazy-streaming queries with a new design. The architecture underlying this design borrows heavily from Oliveira and Cook's object algebra solution to the expression problem, extended with a design that exposes the push/pull character of the iteration, and an encoding of higher-kinded polymorphism.

In biboudis/streamalg you can examine closely how a stream library can be extended in multiple ways. The repository contains all stream implementations discussed in the paper alongside with benchmarks and tests. This is a joint work with Nick Palladinos (@NickPalladinos), George Fourtounis (@gf0ur) and Yannis Smaragdakis (@YSmaragdakis).

Clash of the Lambdas, updated

We would like to provide a revised version for our Clash of the Lambdas paper that was accepted in ICOOOLPS'14. We would also like to thank the reviewers, the conversations on our Github repo and other readers that have sent comments via email and strengthened this paper.

In the revised version:

1. we used a fixed heap with 3GB. The GC throughput was improved and results are more balanced
2. we discussed briefly why we chose not to use targeted JVM flags
3. we discussed @specialized and miniboxing
4. we added a new benchmark that tests a streaming operation that avoids automatic boxing of our input data
5. a subtitle was added

Attended SIGPLAN PLMW and POPL 2014

This year's "Programming Languages Mentoring Workshop" and POPL that took place in San Diego, had been a blast. This was my second time attending PLMW/POPL and I can say that anyone who will be able to attend this conference (and the mentoring workshop day) while being a PhD -or even undergrad- student will get a unique opportunity to explore the field of programming languages. So, go for it, the next time you hear about the PLMW scholarships!

This year's attendance had a little bit of structure in note taking for me, since I had a "battery-autonomy > 2 hours"d laptop this time. The format was in Latex and in the end I had a ten-page pdf-document of raw data with links, listings, citations, summaries of talks, to-do items that will help me or a colleague! Surprisingly, the interest some times doesn't come from the solution to a problem that a paper presents per se, but from the methodology that was followed. Some things/realizations/resolutions/advices to share listified are the following:

• Invariants are calculated, are approximated, are broken, can be temporarily broken and then restored, dependent types are super-related to them, are definitely a key concept of parametricity, to abstraction safety and many more! 
• Look for Peter O’Hearn's and Isil Dillig's talks for abstract interpretation 101 (this will help you a lot for past, current and future POPL papers).
• Study about academic writing, presenting!
• Separation Logic can provide solutions to reasoning of infinitely many problems (like type invariant that holds almost everywhere, like reasoning for C sequence points)
• Study Software Foundations and Certified Programming with Dependent Types, Coq is must nowadays. Mechanically checked proof writing with Coq is already a top-class skill for POPL publishing.

Important papers as prerequisites of several talks I attended. This list features papers that I have either found to be a seminal paper, or a paper of a system that was used for evaluation purposes, or a previous paper of the same author, etc. [1] was mentioned from at least 3 distinct speakers; a Coq implementation of a verified Red Black Tree, [2] to understand a this direction in POR, [3] seminal paper on abstract interpretation, [4] interesting use as a case study from a paper but interesting in general for industrial-strength parser library, [5] for lambda calculus with effects, [6] for Symbolic Finite Automata cases and basics, [7] a super-tutorial for DT PL, [8] for parametricity and "on the point and purpose of types", [9-10] parametricity, [11] a guide/insight of Reynolds-papers.

1. Appel, Andrew W. Efficient verified red-black trees, 2011.
2. Flanagan, Cormac, and Patrice Godefroid. Dynamic partial-order reduction for model checking software, ACM Sigplan Notices. Vol. 40. No. 1. ACM, 2005.
3. Patrick Cousot and Radhia Cousot. 1977. Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints, 1977.
4. Leijen, Daan, and Erik Meijer. Parsec: Direct style monadic parser combinators for the real world, 2001.
5. Felleisen, Matthias, and Daniel P. Friedman. Control Operators, the SECD-Machine, and the Lambda-Calculus, 1986
6. Veanes, Margus. Applications of symbolic finite automata. Implementation and Application of Automata. Springer Berlin Heidelberg, 2013.
7. Löh, Andres, Conor McBride, and Wouter Swierstra. A tutorial implementation of a  dependently typed lambda calculus. Fundamenta informaticae 102.2, 2010.
8. Reynolds, John C. Types, abstraction and parametric polymorphism. (1983):513-523.
9. Mitchell, John C. Representation independence and data abstraction. Proceedings of the 13th ACM SIGACT-SIGPLAN symposium on Principles of programming languages. ACM, 1986.
10. Wadler, Philip. Theorems for free!. Proceedings of the fourth international conference on Functional programming languages and computer architecture. ACM, 1989.
11. [metapaper] Brookes, Stephen, Peter W. O’Hearn, and Uday Reddy. The essence of Reynolds. Proceedings of the 41st annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM, 2014.

Oculus Rift: First Impression

First Impression

I was very lucky today to experiment with an Oculus Rift Development Kit. By now, I am probably several months late to do an elaborate review of the packaging-installation-performance evaluation; you already know many of that stuff from many other posts from the Oculus community (e.g. r/oculus). However, the experience of playing with a Rift as a user was unprecedented and I believe that some thoughts are worthsharing.

Firstly, the Rift came in a beautiful case that absolutely protects the device and everything was included: from UK, US plugs to HDMI cable, mini-usb and a usb-to-DVI adapter. The professionalism that the Oculus team shows by this "product" presentation with the SDK is amazing. 

Unfortunately I wasn't able to try this out at my Ubuntu laptop, as a displayport-to-HDMI converter was necessary; so our first exploration was made from a Sony Vaio equipped with a mainstream NVidia GeForce 330 that did run the demos, but with the FPS (in Rift) varying from 30 to 40. The installation was seamless. No quirks, no missing dlls (except when I first built a demo with some needed DirectX components that come with the redistributable), no surprises. We used the second pair of lenses that came with the Rift. The package included three pairs, A, B and C and the user is free to use which ever he likes in order to achieve the most focus possible for nearsighted people. The 1280x800 (an HD prototype is already presented) (2 displays with resolution 640x800), 32-bit colour, LCD head-display was ready to have it's gyroscope sensor calibrated.

And then the fun started with the free demos from share.oculusvr.com and www.riftenabled.com. Many hours of "playing" and experimenting with the setup followed. Among the demos, the few that I highly recommend-as a must-are the vr.training (inspired by Metal Gear Solid training levels~nostalgia alert~and highly recommended for low-end graphic systems), VR Cinema (that can load an avi, wmv or mkv and play it as if you watch it in a theater), Titans of Space (educational), Blocked In (just a presentation of a single room for an adventure game), Dreadhalls (an absolute atmospheric/horror game), Fallen Angel's Lair (demonstrating UDK, the Unreal Engine), Oculus Tuscany Demo (101 demo from Oculus), Ocean Rift (watch out for the shark) and the coasters from archivision. What will come next to our evaluation is the heavy artillery of gaming (e.g. Half Life 2 - opting in for beta from its Steam menu and by providing the "-vr" command line argument).

The simulator sickness

Before trying Rift, I was sceptical (as everyone) for the simulator sickness that occurs to the user, that results from slight disorientation as a game progresses. The user builds up discomfort from in-game locomotion, rapid rotations, fast changes in elevation etc., which are all some form of acceleration that the brain perceives but the body doesn't actually feel. Some things regarding this matter can be improved dramatically: 1) technologically (like latency and tracking precision) and 2) some other things must be taken under consideration in the game design - HCI level. The developer.oculusvr.com site has a very informative wiki page with guidelines (e.g., placement of camera, displaying text, speed of elements, flashing, providing static references like a cockpit etc. that limit the sickness effect).

Screen-door effect

 

The most annoying thing in the whole process of evaluation is that due to the low resolution of the displays that are extremely close to your eyes you can really see the black lines between pixels. From what I read at the community-press this effect can be eliminated with both higher resolution and better higher pixel-fill rate (to my understanding).

Packaging

Lenses

USB box (transfers sensor data to pc)

Again a rear view

Side view (controlling the distance of the headset from eyes)

I would really recommend the Step into the Game with Oculus Rift and Unity 4.2 video from Unite 2013 by Peter Giokaris who explains elements of the device and gives a primer on the Unity 3D for Rift.

Conclusion 

(as an end user and not API-wise yet)

Oculus Rift is definitely THE future of Virtual Reality (as a computer science field in general). It can have many applications apart from home entertainment to boost productivity and efficiency, enhance (augment) reality, help people with vision problems (as in this recent project about diplopia) and many more. The final product is expected to benefit from the market growth of smart-phones and the need for better, more complex with live colors, high refresh-rate (and of reduced price) displays.