Meetup August 11th, 2010 @ Pivotal Labs

[Charlie Robbins]

So it's been a while and I hope you haven't forgotten about us. The Google Group is up to 179 members now :)

We'll be having our inaugural meetup tomorrow at Pivotal Labs from 6:30 - 8:30pm. The format is going to be very open, I'd invite anyone who would like to do a lightning talk or demo to reach out to me directly. The goal here is to gauge the level of expertise in the community so that we can have bigger talks in the future. Also so everyone can get to know each other and learn about various esoteric things we might be hacking on. 

12 West 27th Street 18th floor (the label is not going to say Pivotal Labs but it's still right)

New York, NY (NYCFTW)

Hope to see you all there, and if you've got a minute just drop an RSVP on the Anyvite. It's not required, but could help determine the level of beverages / snacks we need.

http://anyvite.com/events/home/jyubcwexye

Cheers,

Charlie

[Douglas Finke]

Tomorrow is Lab49's picnic in Harriman. I am happy to blast it out to NYStaff though if you'd like.

Otherwise next meetup.

Doug

---

Date: Tue, 10 Aug 2010 17:50:08 -0400
Subject: Meetup August 11th, 2010 @ Pivotal Labs
From: charlie...@gmail.com
To: nyc-co...@googlegroups.com

[Kalani Thielen]

Hi everybody,

 

I'd like to thank Charlie for setting up a fun night of conversation about my (and I'm sure many others') favorite topic.  I learned a few things about some interesting work, like OMeta, that I probably wouldn't have looked into on my own.

The subject of parsers and parser-generators came up and was talked about quite a bit.  The PEG/packrat angle was explored in some detail.  For folks who are more old-fashioned (like me) and are happy with LALR(1) -- I just wanted to point out what's arguably the absolute best treatment of the LA-set determination algorithm (with apologies to Al Aho and the dragon book's awkward pumping technique).  I've written a few parser generators based on this relational technique, and it's the same one used in the GNU Bison tool (and presumably Jison): http://www.win.tue.nl/~wsinswan/softwaretools/material/DeRemer_Pennello.pdf

 

Parsing aside (moving on to, you know, compilers) I was hoping to talk a little bit about some of the things I'm toying with in my little compiler project.  So far, it's a fairly typical division with a monomorphically-typed lambda calculus on top, compiling to an abstract machine code, and finally to x86 machine code (and I've already written all of the tedious packaging code to generate PE files for Windows, and ELF files for Linux).  I had to dust off my Intel processor manuals to get the code generator out, but I think that it's worth it to know how the whole thing works bottom to top.

 

So right now I'm messing around with the partial evaluation phase of the top level language.  I'm not sure how familiar you all are with PE and the magical Futamura Projections (http://en.wikipedia.org/wiki/Partial_evaluation) but I'm not aiming for anything especially ambitious as far as that goes.  I just want to eliminate needless tagging and other intermediate data structures as much as possible.  I've found this book to be very helpful (http://books.google.com/books?id=B1UTK2j8rksC&dq=%22projection+factorisations%22+partial+evaluation&printsec=frontcover&source=bn&hl=en&ei=5VxnTJHzLsKC8gbEq5izBA&sa=X&oi=book_result&ct=result&resnum=4&ved=0CCMQ6AEwAw#v=onepage&q&f=false), especially its analysis of the *dependent type* of the partial evaluation function.  If any of you aren't familiar with the magical Futamura Projections, by the way, you might like this very entertaining high-level writeup by sigfpe a few years ago: http://blog.sigfpe.com/2009/05/three-projections-of-doctor-futamura.html

 

Also, maybe a more mundane compiler topic, I've come to the conclusion, after the last few years of writing compilers for functional languages, that function application rightly ought to be treated as a case of overloading within compilers.  Qualified types (http://www.amazon.com/Qualified-Types-Practice-Distinguished-Dissertations/dp/0521543266) and type classes give us a principled approach to overloading, and the traditional problems of so-called "lambda lifting" and "defunctionalization" ought to be recast in those terms.  I've found that reworking my compiler in this way has made the introduction and elimination of closures (and their optimization) much more natural.  As well, making the overloading of function application primitive makes it easier to support other, less common, reasonable interpretations (like arrays as functions from their indexes to their elements, likewise for hash maps, etc).

Finally, after a couple of conversations with fellow attendees, I wonder if others are familiar with the application of algebra and calculus at the level of datatypes (http://blog.lab49.com/archives/3011).  There's some fertile ground here for designers of programming languages (let's all at least agree to start with algebraic data types).

 

I look forward to talking with you all at the next meetup.

 

-Kalani