Wednesday, January 24, 2007


I was privileged to attend the POPL conference in Nice last week, followed by the FOOL/WOOD workshop on the saturday. I had a great time (especially enjoying the sunny weather, I managed to fall asleep in the sun on the beach at one point), it was my first 'proper' conference experience and once I got into the swing of things a bit, I really enjoyed talking to lots of interesting and reputable people and soaking up all the brain waves floating around.

Most of the talks were excellent and very interesting, even in topics from which I normally run away from screaming. A lot of the subject matter at POPL was a out of my usual scope and went a bit over my head, and that I was still interested in the talks is a real credit to the presenters. FOOL on the other hand was so spot on, topic wise, that I was pretty much in research heaven. Almost every talk was relevant, interesting and well-presented.

I'll go over some of the talks/papers that interested me below. Links to the papers can be found here or here.


  • Invited talk: Advanced Programming Language Design in Enterprise Software: A lambda-calculus theorist wanders into a datacenter

    I thought this was going to be inspiring, but actually it was a bit disappointing. In the end it just made me angry and I'll have a rant on the functional vs imperative (OO, more to the point) thing in another post.

  • Operational Semantics for Multi-Language Programming

    An interesting (and necessary) idea is how to integrate type systems between programming languages or calculi. This seems like the first paper in a series building up to do this properly, but even so, it is well developed and a good solution to this problem.

  • Semantics of Static Pointcuts in AspectJ

    Although I loathe aspects from a software engineering prespective, they seem to be fairly hot right now, and they do allow for some nice programming techniques. This is a formalism of the pointcut language of AspectJ as does just what it says on the tin. The use of Datalog as an 'intermediate language' adds a bit of spice to the mixture. I admit to being surprised that somthing like this has not been before.

  • A typed Intermediate Language for Compiling Multiple Inheritance

    Again, I'm surprised this hasn't been done before, and, in a way, I wasn't sure why this was so important. But, I think to compiler people it is quite cool. Anyway, I really liked the talk and hope one day to be able to understand the paper as it sounded interesting.

  • Cork: Dynamic Memory Leak Detection for Garbage-Collected Languages

    Very cool use of profiling/dynamic analysis of programs. I liked the talk because dynamic analysis is something I've not really come across before and profiling and instrumentation stuff has always interested me. I will go back and try to understand the theory in detail, but the intuitive stuff was quite exciting.

  • Scrap Your Boilerplate with Xpath-like Combinators

    This really got me thinking. XSLT and Xpath are pretty intersting subjects and there has to be a better way to deal with these and XML in programming languages (in fact its getting a lot of attention at the moment). Other than the motivation the talk and paper were pretty heavy going (at least with my lack of knowledge about FPLs), but I'll definitly be reading the paper in some detail.

  • Towards a Mechanized Metatheory of Standard ML

    A 'rather than you than me' bit of research this. It is important and necessarywork, but it looks like really dull stuff to actually do! The talk, though, was far from dull.

  • Extracting Queries by Static Analysis of Transparent Persistence

    Another interesting paper on integrating queries/databases with programming languages, a bit of a hot topic at the moment, me thinks. The idea here is to use transparent persistence, but extract queries during compilation for the sake of efficency. It sounded like a really good idea and the details seem interesting. Another talk, that 'sucked me in'.

  • Assessing Security Threats of Looping Constructs

    I enjoyed this talk as the subject matter was interesting from a non-academic perspective. I always find information theory-style stuff quite cool, I don;t really know well. The talk was really well presented too.

  • Javascript Instrumentation for Browser Security

    Again, an interesting talk due to the subject matter, browser security being relavent to pretty much everyone. The scheme presented here seemed solid and straightforward (in a good way). The complications due to the nature of Javascript were well explained and solutions presented. I was not completely convinced that it dealt with 100% of cases correctly, in the question and answers there seemed a degree of reliance on conservatism and the fact that no legitimate program would use techniques that appeared to be obfuscation. Still, I should read the paper more thoroughly before passing judgement.


  • Generic Universe Types

    Werner gave a really good talk, reminding me that ownership is awsome, and convincing me that universe types are a pretty good idea. The contribution itself (extending universe types to type parameters) seems very nice: a slight extension to generics and universes that produces an elegant system and some real benefits for the programmer.

  • Fine-Grained Api Evolution for Method Deprecation and Anti-Deprecation

    This seemed like one of those really useful things that people have been struggling with for a long time. This solution sounds like a good one, although interface evolution seems to be one of those problems that will never be properly solved. Its part of the Scala project so should get some real world testing, I'll be interested to see how it performs in practice. The talk itself was good, and got me interested in something I'd normally just skip over.

  • Invited talk: Fortress and Object-Oriented Programming

    It was good to hear about Fortress without all the parallelism stuff that (although important) I'm not really intersted in. The syntax thing wasn't too over-played for a change either. Instead Eric focussed on the object model and related elements. The talk was good and it was nice to see some large scale, real world, innovative language design in action (I've been following Fortress for a while now). Fortress has some interesting ideas in the object model, an (almost) class-less system with traits for reuse and some practical
    looking details. Its looking like a fairly innovative and practical system, although not as radical as it sounded at first.

  • Variant Path Types for Scalable Extensibility

    A topic close to my heart, being related to virtual classes and similar mechanisms. The authors have an approach that has classes belonging to classes as opposed to classes belonging to objects (as in Tribe and VC etc.). This approach is attractive because it is simple and does not require a dependent type system, but the loss of flexibilty and expressiveness is considerable. They go someway to addressing that with this paper, the system vastly increases the flexibilty with a simple and low overhead type system (an extension of exact types). It is impressive work, but I can't help thinking that when they work this to its logical conclusion they'll end up with something very similer to the Tribe/VC model....

  • On Decidability of Nominal Subtyping with Variance

    Interesting stuff again, and closely related to my work on wildcards. Andrew Kennedy gave a really good talk on decidabilty for simpler variance systems; starting off with examples that crashed the Java and Scala compilers (good for getting your attention!). The result seemed to be that these systems (pretty much what C# and Scala have) are theoretically undecidable, but are saved by unintentional tweaks in the specifications. How this crosses over to Java remains to be seen.

  • Formalizing and Extending C# Type Inference

    Probably the best talk of the conference, Gavin Bierman had amazing energy and presentation skills. The talk basically went over his exprience in writing a type inference algorithm for C# 3.0, which to be honest sounded like a nightmare. The reasons for the complications were not obvious and it was interesting subject matter. The future work also sounds tricky...

  • Combining Structural Subtyping and External Dispatch

    This is an idea for combining structural and nominal subtyping. The motivation was good and it looks like an interesting concept, I'd be interested to see how it works out in practice (or at least a more fleshed out theory). Although the syntax looks quite similar to standard OO languages, I think the truth is that there is a big difference arising from the typing that would affect how programs are written etc. I'll be going back and reading the paper in
    detail soon.

  • LazyJ: Seamless Lazy Evaluation in Java

    Not coming from a functional background, I don't really know if lazy evaluation is a good idea for OO languages or practical programming. But, it is an interesting concept, and if it were to be a good idea then this is how it should be done! The language was simple and yet seemed to do everything it needed to; the extensions fitted nicely into Java and the details had been thought through (even though there were a lot of ideas from the audience).

Looking forward to next year already...

No comments: