And so the last and shortest day began. It started with Jonathan Aldrich's invited talk. This was another good talk, describing the research he has been involved in with software architecture. The general gist is that the architecture of software should be part of the code and enforced by the compiler. To this end he talked about ownership, and his variant - ownership domains, and also ArchJava. He motivated ownership domains with the MVC pattern, showing that owners-as-dominators style ownership is too restrictive to be used there. The whole thing sounded very ambitous and also extremely practical, so pretty exciting stuff. Also mentioned existential types in the context of ownership types, which is something I want to look at.
The first talk on friday was MAO: Ownership and Effects for more Effective Reasoning about Aspects - motivated by the difficulty of reasoning about aspects (their greatest drawback in my opinion), the authors used ownership and effects to aid this reasoning and claimed to get good results.
I'm afraid that by friday I was suffering conference fatigue and my notes were getting pretty flakey, but I did manage to write down which talks I found intersting, so I can read the papers:
Joinpoint Inference from Behavioral Specification to Implementation
A Machine Model for Aspect-Oriented Programming
Tracking Linear and Affine Resources with Java(X)
Attribute Grammar-based Language Extensions for Java
And that was the end of ECOOP. Now I have to find some time to read a lot of papers in more detail, I fear the list never gets shorter.
I'm a research engineer at Mozilla working on the Rust compiler. I have history with Firefox layout and graphics, and programming language theory and type systems (mostly of the OO, Featherweight flavour, thus the title of the blog). http://www.ncameron.org @nick_r_cameron
Wednesday, August 08, 2007
ECOOP day 2
The day kicked off with Luca Cardelli's invited talk. This was a personal history of his involvement with OO theory (and practice to some extent) and type theory, which turns out to be a pretty good history indeed. Once again concurrency reared its ugly head as its Luca's current research area and he thinks its the next intersting thing.
Yi Lu - Validity Invariants and Effects - Lu and Potter's annual ECOOP paper was as interesting as expected. This year they extended ownership types with invariants, the idea being it is easier to reason about invariants in the presence of ownership types.
Non-null references by default in Java - was a case study on delarations that could be declared non-null or nullable and found that most could be non-null. They then argued that non-null should be the default, which seems fair, but is unlikely to happen in Java.
Burak Emir - Matching Objects with Patterns - Compares various OO pattern mathcing techniques and suggests a new one. Pattern matching seems like a good idea, but is sometimes criticised for being non-OO, will read the paper and decide...
I liked the talks on DirectFlow: a Domain-Specific Language for Information-Flow Systems and A Relational Model of Object Collaborations and its Use in Reasoning about Relationships, but don't have much to say about them, sorry.
I missed the talk on JavaGI, but I think I read an earlier version of the work (I seem to remember it being very powerful, but complex) and liked it so will go back and read the paper.
Aaron Turon - Metaprogramming with Traits - Uses a flexible version of traits to do metaprogramming (just like it says on the tin). They have an interesting type system that is hybrid structural/nominal. On a side note, I like traits, I think they are cool.
Shan Shan Huang - Morphing: Safely Shaping a Class in the Image of Others - more metaprogramming than morphing (classes do not change during execution), this seems powerful and generic and (relatively) easy to use. I've written "label checking" in my notes, but can't remember why now. An interesting view on this work is that they have a form of type-checked reflection, which is still a big open question at the moment. The claim that the language was more intuitive (has more "synergy" ) than the competition, was unsurprisingly provocative.
A Higher Abstraction Level using First-Class Inheritance Relations - An interesting idea that basically 'does components' by having a complex and novel form of inheritance.
Yi Lu - Validity Invariants and Effects - Lu and Potter's annual ECOOP paper was as interesting as expected. This year they extended ownership types with invariants, the idea being it is easier to reason about invariants in the presence of ownership types.
Non-null references by default in Java - was a case study on delarations that could be declared non-null or nullable and found that most could be non-null. They then argued that non-null should be the default, which seems fair, but is unlikely to happen in Java.
Burak Emir - Matching Objects with Patterns - Compares various OO pattern mathcing techniques and suggests a new one. Pattern matching seems like a good idea, but is sometimes criticised for being non-OO, will read the paper and decide...
I liked the talks on DirectFlow: a Domain-Specific Language for Information-Flow Systems and A Relational Model of Object Collaborations and its Use in Reasoning about Relationships, but don't have much to say about them, sorry.
I missed the talk on JavaGI, but I think I read an earlier version of the work (I seem to remember it being very powerful, but complex) and liked it so will go back and read the paper.
Aaron Turon - Metaprogramming with Traits - Uses a flexible version of traits to do metaprogramming (just like it says on the tin). They have an interesting type system that is hybrid structural/nominal. On a side note, I like traits, I think they are cool.
Shan Shan Huang - Morphing: Safely Shaping a Class in the Image of Others - more metaprogramming than morphing (classes do not change during execution), this seems powerful and generic and (relatively) easy to use. I've written "label checking" in my notes, but can't remember why now. An interesting view on this work is that they have a form of type-checked reflection, which is still a big open question at the moment. The claim that the language was more intuitive (has more "synergy" ) than the competition, was unsurprisingly provocative.
A Higher Abstraction Level using First-Class Inheritance Relations - An interesting idea that basically 'does components' by having a complex and novel form of inheritance.
Tuesday, August 07, 2007
ECOOP day 1
The first day of the conference was probably the most interesting to me and there was loads of good stuff. It all started with the invited talk by Joe Armstrong about Erlang. Apparently he is quite well known as an opponent of OO programming, so was a bit of an odd choice, but a good one. He was an excellent speaker and the talk was not actually very confrontational. He expounded a lot of good design ideas and concepts and evangelised a bit for Erlang (which seems pretty hot right now in PL circles). He has a real thing against mutable state, which, I guess, in its shared incarnation with concurrency around, is fair. I liked the idea that you don't catch expcetions, but let the process fail, but I'm not entirely convinced you can do this in real life, since other processes are going to have to catch the mess at some point. The other controversial point (according to me) is that we 'natively' understand concurrency, but not OO. I think the opposite is true, I think objects and classes are pretty natural, but that we function very sequentially. We only really notice what other people (processes) are doing when we interact occasionaly. But I think this is even more reason to like something like Erlang which really concentrates on concurrency.
The invited talk was also good beccause it seemed to capture a few of the big 'feels' of the conference - that concurrency is hard and fertile ground for research, and that we might be reaching the limits of OO research (although I don't think I agree with the latter, I do with the former).
The first proper talk was on gradual typing, a great idea that is getting some attention recently in various guises, this is another iterative development in the field. The idea is to be able to safely combine dynamically and statically typed program fragments (and some kind of grey area between the two). I really think this is the way forward for programming languages, especially as type systems get more complex.
Next up (in my notes) is Werner again, this time talking about extending universe type systems with generics. This is the continuation of the work at FOOL that I describe below. Surfice to say I like it a lot and its worth reading.
Possibly the most controversial talk of the conference was on object identity and relation types. The authors propose special classes called relations where the equals and hashcode methods are automatically supplied by the compiler by comparing fields marked 'key'. This was the first step towards some kind of heap/database project. A few members of the audience disliked the use of the term object identity in such a context, but I think this is a pretty petty objection, changing things for the better is what we are meant to be doing. I kind of liked this, it addresses a long standing problem (the subtyping/equals mismatch) and does it nice and simply. However, the extra syntax and machinary seems a lot of effort for what is really a fairly small problem.
To round off the day was the panel discussion, discussing the future for OO programming languages. Martin Odersky and Gilad Bracha gave the most interesting and animated opening talks, but the rest of the discussion was a bit too restrained. Popular points were about concurrency and the (allegedly) growing division between expert and casual programmers. Whether reflection was essential for OO programming seemed to get people excited too.
The invited talk was also good beccause it seemed to capture a few of the big 'feels' of the conference - that concurrency is hard and fertile ground for research, and that we might be reaching the limits of OO research (although I don't think I agree with the latter, I do with the former).
The first proper talk was on gradual typing, a great idea that is getting some attention recently in various guises, this is another iterative development in the field. The idea is to be able to safely combine dynamically and statically typed program fragments (and some kind of grey area between the two). I really think this is the way forward for programming languages, especially as type systems get more complex.
Next up (in my notes) is Werner again, this time talking about extending universe type systems with generics. This is the continuation of the work at FOOL that I describe below. Surfice to say I like it a lot and its worth reading.
Possibly the most controversial talk of the conference was on object identity and relation types. The authors propose special classes called relations where the equals and hashcode methods are automatically supplied by the compiler by comparing fields marked 'key'. This was the first step towards some kind of heap/database project. A few members of the audience disliked the use of the term object identity in such a context, but I think this is a pretty petty objection, changing things for the better is what we are meant to be doing. I kind of liked this, it addresses a long standing problem (the subtyping/equals mismatch) and does it nice and simply. However, the extra syntax and machinary seems a lot of effort for what is really a fairly small problem.
To round off the day was the panel discussion, discussing the future for OO programming languages. Martin Odersky and Gilad Bracha gave the most interesting and animated opening talks, but the rest of the discussion was a bit too restrained. Popular points were about concurrency and the (allegedly) growing division between expert and casual programmers. Whether reflection was essential for OO programming seemed to get people excited too.
FTfJP 07 (at ECOOP)
The second day at ECOOP was taken up with the FTfJP workshop. There were lots of interesting talks and I'll only blog about a few of them. I spent all day there, but I really should have been elsewhere at 2 to listen to Gilad Bracha's talk at DyLA, which lots of people were talking about and sounded pretty interesting from chatting to Gilad. The talk was (apparently, I still need to read the paper) about Gilad's new language which he is developing at Cadence. All I really know is that it is dynamically types and involves some kind of virtual class construct, of which I am a big fan!
So onto the talks, the accompanying papers can be found at the FTfJP link above:
First up was a good looking lad talking about some wildcards rubbish. I thought the talk went pretty well and I got interested questions, so at least some people were following and were interested. I also got some useful feedback afterwards, so that is always nice.
Vincent Cremet or Philippe Altherr - Adding Type Constructor Polymorphism to Java - This was a nice idea to make Java generics more expressive by allowing formal type parameters to be parameterised, thus having the power of full type constructors. You get quite a lot of extra expressivity for no extra syntactic constructs and very little syntactic overhead, which is similar to what already exists, so its a winner all round really. However, it does make the declaration of generic classes even more complex and ugly, so I can't see it being in Java 7.
Chieri Saito - The Essence of Lightweight Family Polymorphism - This was really interesting to me, particularly as I think the lightweight family polymorphism idea is great. The idea here was to attempt to translate lightweight family polymorphism programs into Java with generics to discover how much of their system is syntactic sugar and how much is actually new. They found that most could be translated away, but they needed an extra construct, to give a more specialised type to 'this', in order to translate the complete language. This was formally done by translating .FJ to FGJ.
Elena Giachino - Seperating Type, Behaviour and State to Acheive Very Fine-Grained Reuse - this is another neat idea, this takes the ideas behind traits a step further and further breaks up classes, so there are seperate constructs for behaviour, state, object creation and types. This seems to break things down to the bottom level and means reuse levels are really high. This is very elegant and interesting, however, there must be a tradeoff in the real world with practicality, and having so many little 'micro-classes' kicking around must get to be hard work, I think this even came across in the talk as the conceptual divisions were pretty porous and so in the examples bits of state would appear in the behaviour modules and so forth. Still a great idea and intellectually very interesting.
So onto the talks, the accompanying papers can be found at the FTfJP link above:
First up was a good looking lad talking about some wildcards rubbish. I thought the talk went pretty well and I got interested questions, so at least some people were following and were interested. I also got some useful feedback afterwards, so that is always nice.
Vincent Cremet or Philippe Altherr - Adding Type Constructor Polymorphism to Java - This was a nice idea to make Java generics more expressive by allowing formal type parameters to be parameterised, thus having the power of full type constructors. You get quite a lot of extra expressivity for no extra syntactic constructs and very little syntactic overhead, which is similar to what already exists, so its a winner all round really. However, it does make the declaration of generic classes even more complex and ugly, so I can't see it being in Java 7.
Chieri Saito - The Essence of Lightweight Family Polymorphism - This was really interesting to me, particularly as I think the lightweight family polymorphism idea is great. The idea here was to attempt to translate lightweight family polymorphism programs into Java with generics to discover how much of their system is syntactic sugar and how much is actually new. They found that most could be translated away, but they needed an extra construct, to give a more specialised type to 'this', in order to translate the complete language. This was formally done by translating .FJ to FGJ.
Elena Giachino - Seperating Type, Behaviour and State to Acheive Very Fine-Grained Reuse - this is another neat idea, this takes the ideas behind traits a step further and further breaks up classes, so there are seperate constructs for behaviour, state, object creation and types. This seems to break things down to the bottom level and means reuse levels are really high. This is very elegant and interesting, however, there must be a tradeoff in the real world with practicality, and having so many little 'micro-classes' kicking around must get to be hard work, I think this even came across in the talk as the conceptual divisions were pretty porous and so in the examples bits of state would appear in the behaviour modules and so forth. Still a great idea and intellectually very interesting.
Monday, August 06, 2007
ECOOP 07 - Berlin - IWACO
I was in Berlin last week for ECOOP. The conference was really interesting, I got to meet lots of interesting and important people and I got to explore Berlin a bit too - it is, in fact, a wonderful city - I was well impressed! As I have quite a lot to say, I'll go one day at a time:
On the monday I attended the IWACO workshop, there were talks of 5, 10 and 25 minutes (I think) and nearly all were interesting, the ones I found most interesting were (papers available here):
Erik Ernst - Exclusive References (Primitive Associations) - Combining virtual classes and ownership is a great idea, Erik has an alternative that looks interesting and made me want to read the paper, I think its stuff I need to think about...
Matthew Parkinson - Class Invariants - The End of the Road? - Interesting and deliberately contraversial talk about the limitations of class invariants. Class invariants are described as too inflexible beacuse they can not describe the invariants of a group of classes (eg subject-observer). A heavier alternative using predicates is proposed. I don't know much about class invariants, but the argument seemed to make sense. However, class invariants have the advantage that they are easy to understand for the programmer, which seems to be lost by using predicates. I think this is another motivation for family polymorphism/virtual classes, as class invariants over a family should solve the problem - hmm, another research idea...
Invited talk on X10 by Vijay Saraswat - sounds very interesting and I look forward to reading the paper when its finished. He talked about having constraint types in X10 and extending FJ with xonstraint types as a formal version. These constraint types are a form of depedent types and the type system is undecidable, but he argued that this was not a big problem.
Johan Ostland (I think) - On the benefit of adding modes to owners (Ownership, Uniqueness and Immutability) - Extending ownership types with mutability annotations - simple and effective idea, looks good.
James Noble - Ownership meets Java and Peter Muller - State of the universe addess - These two talks were meant to give an overview of the current state of the art in the two 'competing' systems of ownership types and universes. Both were good talks and convincing, and both outlined really exiciting directions for future work. I guess the result is that ownership types are more flexible and powerful and univeses are easier to use and have less overhead, hopefully we'll get the best of both worlds one day...
John Boyland - Iterators can be independent "from" their collections - an intersting, if complex, solution to the iterators/ownership mismatch. I need to read the paper on this one!
??? - Using ownership types to support library aliasing boundaries - good talk on using ownership in a C++ library which their students used to produce a 3d game. The combination of concurrency and ownership was interesting, they adopted a message passing approach and used 'tethers' to communicate back to the message sending process.
Werner Dietl - Runtime Universe Type Inference - a really good presentation, Werner used a live demo with funky animations to demonstrate the inference of unvierse types. All seemed to work nicely.
Mawan Abi-Antoun - Compile-Time Views of Execution Structure Based on Ownership and Ownership Domains in the real world - the first talk presented a system to visually present the runtime structure of objects using ownership domains. The visualisation is produced at compile time but still gives the dynamic structure of the program. The second talk presented an implementation of ownership domains and a case study on how ownership domains can be added to existing programs. Finding that they served as a useful way to identify bad design 'smells'. I thought this is an interesting point, that seems so obvious when you think about it - a mechanism used for enforcing design in the type system, when applied to an existing system, can be used to identify bad design!
In summary - yay for ownership!
More on the rest of the conference to follow...
On the monday I attended the IWACO workshop, there were talks of 5, 10 and 25 minutes (I think) and nearly all were interesting, the ones I found most interesting were (papers available here):
Erik Ernst - Exclusive References (Primitive Associations) - Combining virtual classes and ownership is a great idea, Erik has an alternative that looks interesting and made me want to read the paper, I think its stuff I need to think about...
Matthew Parkinson - Class Invariants - The End of the Road? - Interesting and deliberately contraversial talk about the limitations of class invariants. Class invariants are described as too inflexible beacuse they can not describe the invariants of a group of classes (eg subject-observer). A heavier alternative using predicates is proposed. I don't know much about class invariants, but the argument seemed to make sense. However, class invariants have the advantage that they are easy to understand for the programmer, which seems to be lost by using predicates. I think this is another motivation for family polymorphism/virtual classes, as class invariants over a family should solve the problem - hmm, another research idea...
Invited talk on X10 by Vijay Saraswat - sounds very interesting and I look forward to reading the paper when its finished. He talked about having constraint types in X10 and extending FJ with xonstraint types as a formal version. These constraint types are a form of depedent types and the type system is undecidable, but he argued that this was not a big problem.
Johan Ostland (I think) - On the benefit of adding modes to owners (Ownership, Uniqueness and Immutability) - Extending ownership types with mutability annotations - simple and effective idea, looks good.
James Noble - Ownership meets Java and Peter Muller - State of the universe addess - These two talks were meant to give an overview of the current state of the art in the two 'competing' systems of ownership types and universes. Both were good talks and convincing, and both outlined really exiciting directions for future work. I guess the result is that ownership types are more flexible and powerful and univeses are easier to use and have less overhead, hopefully we'll get the best of both worlds one day...
John Boyland - Iterators can be independent "from" their collections - an intersting, if complex, solution to the iterators/ownership mismatch. I need to read the paper on this one!
??? - Using ownership types to support library aliasing boundaries - good talk on using ownership in a C++ library which their students used to produce a 3d game. The combination of concurrency and ownership was interesting, they adopted a message passing approach and used 'tethers' to communicate back to the message sending process.
Werner Dietl - Runtime Universe Type Inference - a really good presentation, Werner used a live demo with funky animations to demonstrate the inference of unvierse types. All seemed to work nicely.
Mawan Abi-Antoun - Compile-Time Views of Execution Structure Based on Ownership and Ownership Domains in the real world - the first talk presented a system to visually present the runtime structure of objects using ownership domains. The visualisation is produced at compile time but still gives the dynamic structure of the program. The second talk presented an implementation of ownership domains and a case study on how ownership domains can be added to existing programs. Finding that they served as a useful way to identify bad design 'smells'. I thought this is an interesting point, that seems so obvious when you think about it - a mechanism used for enforcing design in the type system, when applied to an existing system, can be used to identify bad design!
In summary - yay for ownership!
More on the rest of the conference to follow...
Subscribe to:
Posts (Atom)