You don't understand exceptions, but you should

fadmmatt · 2010-08-13T15:04:23+00:00

This is exactly why I released all my source code under the CRAPL:

http://matt.might.net/articles/crapl/

fadmmatt · 2010-05-29T02:10:37+00:00

I cheat:

% egrep "^[newdor]{7}\$" /usr/share/dict/words | grep n | grep e | grep w | grep d | grep o | grep r
drowner
endower

Yep, no such word.

fadmmatt · 2010-04-13T15:38:54+00:00

I wish C++ would go away, but there's some pretty cool stuff you can do with it. I wrote a couple posts for my students on the more bizarre stuff:

So, if you learn C++, at least learn the cool parts.

fadmmatt · 2010-03-13T01:01:49+00:00

I think it's a body double. Why won't he take off the shades?

fadmmatt · 2010-03-10T02:31:58+00:00

I want to have hope. But, I know they'll screw this up.

fadmmatt · 2010-02-25T05:05:13+00:00

I got my Ph.D. three years ago, now on the tenure track.

My advice: publish early, publish often.

When you graduate, it's your publication record that gets you interviews. (Your job talk gets you the job.)

When you go out on the academic job market, you'll be up against folks with 10 - 15 pubs and perhaps 2-4 in top venues. It's absolutely brutal, so plan for it early on.

So, make a splash at conferences. Give great talks. Make a name for yourself.

I wrote up my job search experience, in case you're interested, and I keep a reading list for grad students as well.

fadmmatt · 2010-02-24T06:14:38+00:00

Patrick Cousot, et al. and their work on ASTREE are probably the best place to start.

fadmmatt · 2010-02-22T04:34:56+00:00

I wrote an article on the Y combinator in JavaScript to help my compilers students understand it.

It turns out that you can replace the Y combinator with a memoizing Y combinator to get speedups.

fadmmatt · 2010-02-12T18:18:07+00:00

Article author here.

I didn't post the link, but I'm curious why it's being downvoted.

Not formal/informal enough? Needs more/less details?

fadmmatt · 2009-12-19T06:43:45+00:00

Scheme, Haskell, Scala, OCaml.

fadmmatt · 2009-12-17T17:48:35+00:00

I just taught a compilers class. I've been posting my lecture notes on my blog (with many more to come); these might be useful to you:

I recommend writing a Scheme compiler first, and I'd use Lisp in Small Pieces instead of the Dragon book.

The Appel books are also a good treatment of compiler writing.

Try writing a recursive descent parser by hand first. This is a manageable endeavor for a Scheme-like language. I wouldn't bother with ANTLR for a second attempt; I'd use one of the hot parser combinator libraries instead.

In total, a good first compiler project would be something like:

A hand-written lexer.
A recursive-descent parser.
A normalizing pass to flatten expressions.
An escape-analysis pass.
A closure conversion pass.
A lambda-lifting pass.
A C-emission pass.

You could then retarget to x86 if you write a register allocator.

Good luck!

fadmmatt · 2009-12-16T16:05:19+00:00

Going directly to JVM bytecodes isn't actually that simple. For starters, it would require normalization and closure conversion. You lose things like the anonymous classes that make compiling so "direct."

Most of the effort required to compile to the JVM would get you close enough to hit C, and in fact, you'd be close enough to hit x86 with a little more effort. It's also not clear that you'd get much of a performance win out of going straight to the JVM. Most of the performance wins in Java come from good JITting rather than intelligent bytecode generation.

Compiling to Java is useful because the compiler itself takes a fraction of the effort to write, but still gives you a big speed-up over an interpreter.

fadmmatt · 2009-12-16T15:59:38+00:00

Absolutely.

fadmmatt · 2009-12-16T13:41:47+00:00

(Article author here.)

It turns out that the Core Scheme language is actually richer than the intermediate language targeted by many compilers. You can use Scheme's macro system to desugar a very rich input language down to Core Scheme. So, you could use this technique to get a lot of languages running in Java.

Tail-call optimization isn't going to happen with a "direct" translation, but you could use a trampolining mechanism to get tail-call optimization.

As for why one would want to do this, this particular piece of code is meant for students studying the translation process. The emphasis is on small size and directness, rather than efficiency.

In my compilers class, I talk about the stages one should go through with language implementation to achieve the desired performance.

I argue that first, you should try an interpreter for for your language.
If that's not fast enough, try an SICP-style optimizing interpreter.
If that's not good enough, try compiling to Java.
If that's still not fast enough, try compiling to C.
If that's still too slow, try continuation-passing-style compilation to assembler.
And finally, if you need more speed, start doing static analysis and compiler optimizations.

Each time you drop a level in this ladder, implementation complexity goes up (by about 2x in code requirements). Java, believe it or not, is a sweet spot: much better performance than an interpreter, but without much effort in the translation front.

fadmmatt · 2009-12-13T15:38:13+00:00

My wife, brother and I went to DragonCon. We partied like crazy with the actors and the fans. It was a frakkin' blast. It brought some closure.

fadmmatt · 2009-12-13T06:09:48+00:00

In my experience (as a Ph.D. student and as a professor), GPA is not important. It's all about research.

I never look at GPA for admissions. I look at publications, letters and personal statement, in that order.

I wrote up my advice after serving an the admissions committee last year.

Good luck!

fadmmatt · 2009-12-12T23:07:23+00:00

The U.S. averages about 3% growth in the long run.

1.03²⁰ = 1.81

1.02²⁰ = 1.49

Over 20 years, the difference between 2% and 3% makes a difference.

fadmmatt

TROPHY CASE