OOPSLA 2009, Day 5: Thursday

Today was nearly all research talks for me. I skipped the keynote by the director of engineering at Facebook, which I guess turned out to be a bad idea, since most people seemed to think it was interesting. The first session was on static analysis and types. I finally got to see the presentation on Doop, after reading the paper on it awhile ago. Doop is a pointer analysis tool written in Datalog, which is a subset of Prolog. Since I was interested in pointer analysis for SCJ annotation verification, the Doop paper was one of the few that I read, since it particularly targets Java.

I opted out of the second morning session and spent the time between the Thorn demo and the student volunteer room instead. The Thorn demo was amusingly, heavily dominated by Purdue representatives (there was a demo yesterday that I suppose satisfied most people). It was nice to see example code. Thorn seems to have a ridiculously large amount of operators at this point, and I made remark about comparing its operator count to Perl's.

The first afternoon session was on memory. The first two presentations were rather difficult to understand, partly due to language barrier. The last paper was on object graph versioning, which is the paper that I'll be presenting at the Purdue PL seminar. The system is basically object version control. It sounds like they store each changed variable in a list when a snapshot is requested, which means constant time for most operations, but logarithmic time for snapshot retrieval. David Ungar said implementing in this into a debugger would be of great use, which reminded me of historical debugging, which will ship in Visual Studio 2010. I think having this for other languages would be great, but not at all relevant to me if implemented in Smalltalk, as they did for the initial system. A Java implementation would be ideal, but I don't actually ever use JDB (I use Eclipse for most of my work, so I use whatever Eclipse uses — don't think it's JDB).

The last research session was on language implementation. I didn't find any of the three terribly exciting, but it was cool to see Bjarne Stroustrup do a presentation. The third presentation on error recovery in parsing was semi-interesting, but I'm not familiar with SGLR parsers.

There was an ice cream social at the end to celebrate the upcoming change from OOPSLA to SPLASH. Or at least, the overall title will become SPLASH, which is Systems, Programming, Languages, and Applications: Software for Humanity. What a crazy title. Apparently OOPSLA has shifted away quite a bit from the OO, which is why the name changed. The research track remains as OOPSLA, but I guess to satisfy the other events hosted under OOPSLA, they changed the name.

It's been a fun week, albeit ridiculously tiring. I'm definitely ready to leave so I can sleep more, but I suspect things will get somewhat mundane again. After all, corn fields can't compete with Mickey Mouse. I didn't really meet anyone new, which is unfortunate, since OOPSLA is a great opportunity for that. The large Purdue presence ended up clustered together most of the time, making the most ridiculous comments about everything, as well as laughing at anything and everything, so I guess people may have thought of us as a clique. I'm also not very good at picking people's brains on their research topics, so I find it hard to approach anyone. I should probably read more papers to expand my horizon a bit more, since most of my computer knowledge seems to be industrial (and not related to programming languages), rather than academic.

OOPSLA 2009, Day 4: Wednesday

Today's session began with a keynote from Jeannette Wing. It was a kind of pep talk to encourage collaboration with other fields, as well as high-risk, high-yield research topics. It was moderately interesting to hear things about NSF, since she's currently the assistant director of the CISE directorate, but otherwise, I'm not entirely affected by speeches that are calls to arms and whatnot. The presentation itself wasn't all that bad, though someone commented to me that the higher level position you are, the more vague your answers get. Totally amusing, yet totally true.

Following the keynote was the morning research track, which focused on reliability and monitoring. None of the papers really stood out to me, so I won't go into it, but you can see the research track papers here.

After lunch was another invited talk by Gerard Holzmann, who discussed the use of formal methods in software development (particularly in spacecraft, where correct software is obviously vital). For some reason, all of the larger rooms have their lights dimmed, so I was dozing off, but the basic idea was that after the initial setup, formal verification software is easy to use and helps a lot, but people are scared to use it for some reason, when they shouldn't be. When asked about the tradeoff between testing and formal methods for non-safety-critical software (such as GNOME desktop), I don't think he gave a very straight answer. He of course knows that the answer defaults to testing, but as to whether or not formal methods are truly beneficial and worth the time to understand, that was left unanswered.

The research track in the afternoon was on software tools and libraries. The sound of that to me just doesn't sound particularly researchy, but I was one of the volunteers assigned to it, so it didn't really matter what I thought.

The first talk was on IMP, a project from IBM to greatly simplify IDE development. Extending Eclipse is supposed to be comparatively complex, which is why the project was born. Essentially, you must implement a lexer/parser at minimum, and then add IDE services in at will. I know little about either project, but it sounds somewhat like Visual Studio Shell, which was released with Visual Studio 2008. It was an interesting talk, but not really from a research perspective.

The second talk was about bridging the gap between Java and C debuggers in order to debug JNI code, which essentially provides a unified stack in order to get a full stack trace when debugging problems that occur in JNI code. The content was mildly interesting, but I don't exactly deal with JNI, so it wasn't all that applicable to me. On top of that, the presenter was a little overbearing, and I'm certainly not the only one who thought the same.

The last presentation was presenting C#'s task parallel library. Even if my research is mostly in Java and I otherwise mostly try to use Python, I still consider C# to be a good language (and it's unfortunate that most researchers opt for the JVM). I never really read into the parallelism that is shipping with C# 4.0, so it was interesting, but again, it didn't feel very research-like to me. Seeing Parallel.For and futures in C# is nice, but I can't imagine it being very complex, conceptually. Rather, it was somewhat like Sunday's tutorial, where they were implementing already-known techniques in a pure OOP language.

This evening was the big, Hawaiian OOPSLA dinner. Unfortunately, I think Disney got their ethnicities mixed, because about half of the food was Chinese and the other half was American. Oops. For the curious: pork dumplings, crab rangoon, fried rice, vegetable stir fry, pulled pork, lemon chicken. Yeah, what part of that is from Hawaii? Apparently there's dancing at every OOPSLA, which was a pretty amusing thing to see. Other than that, the evening wasn't all that exciting. Since it was difficult to find a table, all the Purdue people ended up at the same tiny table with Tyler, from Iowa State, whom I met at the summer school. Not being a social butterfly and all, I feel awkward just walking up to strangers to talk to them, so I guess I missed out on a good opportunity. In fact, I haven't really met many new people at all at OOPSLA, just talked to some Purdue people more than I had at campus and meeting several of the summer school attendees that made it to OOPSLA.

Takeaways: from the research program, not much. I've had more interesting days. The formal methods talk leaves questions opened to be answered, but I have no real desire to enter that field, so I guess someone else will have to answer them. Though things like model checking are fairly interesting, I am certainly not one who indulges in formal methods and verification.

Tomorrow is the last day. It's been a tiring, but overall fun experience.

OOPSLA 2009, Day 3: Tuesday

Tuesday is when the research track began. The morning started off with a keynote from Barbara Liskov, this year's winner of the ACM Turing Award. I think it was quite an interesting talk, since I don't often hear historical perspective on the earlier days of computing. She gave the same speech as the one when she accepted the award; essentially how she came up with the ideas that she did that led to her impact on our field, and subsequently a Turing award. I skimped on the morning research papers, since it didn't look entirely interesting to me, in favor of getting more work done.

Tuesday's volunteer duties consisted of working at an info booth for 2 hours. I think in most cases, the info booth is just for people who don't feel like pulling out their programs to find where things are, or can't look behind them to find registration/the bathroom. The last half hour overlapped with the Onward! keynote speaker, so I skipped it as well, after seeing slides that didn't look too exciting and people leaving early. Turns out, it was probably a good choice.

The afternoon research track was on concurrency. I highlight two of the papers:

Grace, a safe, multi-threaded programming system for C/C++ was an excellent presentation, with a good chunk of humor that all people knowledgeable of concurrency know about. The idea was something like spawning processes to perform "fork-join" parallel computations, using mmap to share computations. Interestingly, they actually get initially better performance from spawning processes instead of threads. The Linux scheduler doesn't migrate threads to separate cores on a processor for some amount of time, while processes are migrated instantly, taking advantage of available cores much more quickly. The reason for this is related to caching/processor state, from what I understand. Since threads are part of a larger process, this typically means that they share data with other parts of the program. Processes, on the other hand, are typically isolated from each other, which means that immediately dumping it to another core doesn't affect cache performance.

The other highlighted presentation was on Thorn. Thorn is a collaboration, mainly between Purdue and IBM, to design a robust, concurrent scripting language. Unfortunately, the presentation was more about robustness than concurrency, even though it was in the concurrency track, but it was nice to see slides on the language, rather than guessing through the "documentation" that I saw in Thorn as an undergrad.

I think today's lesson is that computing history, unlike national history, is actually interesting. Hearing Barbara's perspective on things was very cool, since I think it's the first person who I've actually seen present their view on computing history, while actually having lived in and participated in that era. Most historical perspectives I hear seem to be peers that just know a lot more about history than I do.

OOPSLA 2009, Day 2: Monday

On Monday, I spent most of the morning trying to get some work done, in order to not completely screw myself over upon return. Since my job that morning was to be a "floater", I couldn't do anything anyway (a floater is someone who just sits around unless the volunteer captains need them to do something). I missed my advisor's keynote at the Dynamic Languages Symposium (DLS) as a result, but I'm pretty sure I've heard the material many times before.

I was able to attend the afternoon session of DLS, which had some interesting talks. A paper on type reconstruction of dynamic languages looked like an idea that had briefly crossed my mind awhile ago, but it was fully explored, so it was interesting to hear about it. There was also a talk on running a VM on a VM (mind blowing, right?) to take advantage of the host VMs JIT, in order to eliminate the need to write a JIT on the guest VM. I find [nearly] all things JIT exciting, so it was a good talk, even if their performance benchmarks were extremely slow.

The Ruby Intermediate Language was presented as an easy-to-analyze intermediate form of Ruby. It was mildly interesting, but personally, I don't find Ruby's hard-to-parse intricacies very interesting, as I ended up ditching Ruby for Python a few years ago. RIL basically eliminates the hard-to-parse syntax from Ruby, converting them to their easier-to-parse equivalents, with the goal of making analysis tools easier to write.

There was a complaint at the end where someone questioned the necessity of RIL instead of just providing a standalone parser (which RIL may have, since none existed at the inception of RIL), which I tend to agree with — even though I think source transformations that simplify the AST are common, I don't think they're usually as game-changing as the ones presented in RIL. For example, the Java compiler collapses concatenation of string literals down to one literal, and it's completely transparent (and irreversible, as far as I can tell) to compiler plugins. However, this isn't the same as eliminating the ambiguities in Ruby that make life "pleasant" or "natural" for Ruby developers. It would be equivalent to a "JIL" that converted Java for-each loops into the ugly for-loop equivalents, for example, only Ruby offers many more conveniences than Java.

The last talk of the day was about object heaps on manycore (56) hardware. David Ungar from IBM presented experimental results using a Smalltalk VM. It's always interesting to hear about VMs and concurrency (and this is both!), since the topics are often at the threshold of my knowledge. However, this presentation was less "controversial" than the RIL paper, so I don't have much to say about it, aside from feel free to read all of the mentioned papers, if they sound interesting.

An interesting day overall. After all, who doesn't like dynamic languages?

OOPSLA 2009, Day 1: Sunday

Sunday's activities for me consisted of going to the VMIL workshop, which was quite interesting, and a tutorial on "realizing the benefits of functional programming in object oriented code." I was only able attend the morning session of VMIL, which was basically their invited talks on the VMIL website. They were all decent talks. It was especially interesting to hear about Maxine, which I had seen briefly mentioned on reddit some time ago.

Unfortunately, though I was looking forward the tutorial (which I was obligated to attend as the student volunteer on duty), it turned out to be somewhat disappointing. The concepts were not new to me, so I was probably not the target audience. C# actually has a Func type that corresponds to the Java version presented in the tutorial, and I'd seen currying in C# from previous investigations. I hadn't seen Java-style continuations before, but after lectures by Olivier Danvy on continuations this summer, the code was not too surprising. Nonetheless, the code was still interesting to see, as I am always fascinated by how other people program.

I think the most disappointing part was how little discussion there was on the benefits of shoving functional-style code (which isn't exactly pretty, in Java) into an OOPL, and deeper case studies into performance/safety benefits, etc. There was the obvious discussion about referential transparency and so on, but I'm looking for more than just some buzzwords.

The presenter was a little bit disorganized and lacking in presenter skills (tangential expositions, extremely small writing), but we all have our faults, and I'm sure he can improve in time. It is clear that he likes the subject, but not immediately clear that he likes talking about it. I am, of course, not being literal, since if he didn't like talking about it, he obviously wouldn't have volunteered to do the tutorial.

Overall, I was satisfied with the first day, since VMIL was nice, and the tutorial wasn't a total waste.

My first conference: OOPSLA 2009

As my professor graciously offered expense coverage to attend OOPSLA, several of my peers and I made it down as student volunteers. This is my first conference experience, hosted at Disney World's Contemporary World Resort. We arrived late Saturday night, and the program began the next morning with a joyfully early meeting at 7. So far it's been a good experience, but it's also been exhausting to continually wake up "early" (regular time for you working folks, I suppose). I ended up sleeping at 9:30 on Sunday, since I was so tired. I'm pretty sure I haven't done that in very many years. Since this post has gotten quite long, I'll be backposting a separate post for each day.