GIGO: words unreadable aloud

Saturday 2 February 2008

The Segway Programming Language

On LtU, Koray Can writes about Paul Graham's recent preliminary release of Arc:

It seems to me that the only people who are talking about it are those who have followed Paul Graham's writings over the years and wanted to see what it, the thing, the real deal would look like.

I call it "Segway", due to the difference between the hype and the (current, pre-alpha) reality. Note that the hype mostly did not come from PG. My earlier guess was overoptimistic by three years or so.
3:41:38 PM comment/

Saturday 5 January 2008

It's 2008. Do you know where your projects are?

Mostly stalled, but here's a partial, cryptic list:

weblogs and pix coalescing at l6r (revive zia.pycs, extract data from Radio, etc)
finish out my OCaml version of Danvy's grand tour of SECD-like machines
mangle spj's sudoku solver
weblog engine in scala, including quarkup, my contribution to the babel of wikilike markup syntaxes, and maybe (im)port Pandoc
build the two ubuntu machines
prototype a streaker interface for gmail & reader
scala android experiments

12:18:49 AM comment/

Tuesday 25 December 2007

Scala, conciseness, and higher-order functions

It was nice to see Dan Weinreb's "First Impressions" article about Scala. It's rare to see a programming language evaluation that's so well-informed and free of emotional reactions.

Steve Yegge won't ever be accused of being that impartial, and his impassioned article about code size is entertaining, but could hardly be described as "unemotional". What I found appalling is that in 122 comments to an article about code size, not a single one mentioned the idea of higher order functions. I think that these, and pattern matching, are among the most effective language features for making code more concise while preserving readability.
11:20:38 PM comment/

Tuesday 18 December 2007

PXSL, Scala Android, Giant Rat of Sumatra

Cool stuff this week:

Tom Moertel's PXSL, a Parsimonious XML Shorthand Language, which I'd love to look more deeply into, later. I think I posted something on Pyscerocha about the various XML shorthands, or alternate syntaxes, that people have come up with to ease the pain of using XML directly.
Scala Android — my first thought upon hearing of Android was how long before I could play with it in Scala?
Silliness: The Firesign Theatre had a 1974 album called "The Tale of the Giant Rat of Sumatra". This week, it appears that the animal has been discovered. Well it was on New Guinea, actually, but who can tell the difference from here?

11:00:05 PM comment/

Wednesday 31 October 2007

Knuth's 2003 book tour

About four years ago, I wrote about Knuth's book "tour". Since the subject came up again, I thought I should update the LtU URLs that were mentioned in there:

"TPK algorithm": Pointer to a page of implementations of the "TPK algorithm". The (Florida Institute of Technology) page is still there.
Knuth and the IBM-650: this LtU classic thread mentions a restricted IEEE page.
I remain astounded at the extent to which the IEEE and ACM both still live in the dark ages. I suppose the alternative in both their cases would be for the organization to simply shrivel up and blow away. I have a vague recollection of having written something about this (the gist: using ACM to publish your paper these days is like the *opposite* of publishing -- i.e., it renders your paper *more private* than if you just put it on your own web page) ... but now I can't find it any more.
Knuth's 1974 Turing Award Lecture (PDF) is referenced in this LtU classic thread. It points to this PDF link, but that may have gone missing since 2002. I was able to snag a copy from the Wayback machine, though I haven't read it yet.
Here is a mention that Knuth has an online preview of some segments of Volume 4 of The Art of Computer Programming, and Whoa, it's still there, these 6+ years later! It points to this gzip'd postscript.

1:17:59 AM comment/

Wednesday 11 July 2007

Remarkable static vs dynamic discussion

On Artima, Bill Venners kicked off one of the more interesting discussions I've seen on the subject of static type checking versus dynamically typed languages. Bill's been active on the Scala mailing list lately, and it's nice to see folks mentioning Scala frequently as an example of a well-done statically typed language.

As I read the discussion, I was thinking along the lines of making a translator for a subset of Ruby, into Scala, when I ran into Bill Pyne's suggestion to do just that (except starting with Python). It'd be nice to have such a tool for my work right now, since I have a compiler that I wrote completely in Ruby, but which is large enough now that it would IMHO benefit from a conversion to a language like Scala. Pity that Scala is probably not politically feasible, since my management would prefer that everything were written in C++.
11:37:45 PM comment/

Tuesday 10 July 2007

Stalled SECD Work

Being the ongoing but abridged saga of a translation of a deconstructed abstract machine (interpreter) for a fairly basic lambda calculus, due to Peter Landin (the original 1964 SECD machine) and Olivier Danvy (the 2003 deconstruction), said translation starting with SML, detouring through Ruby, and stalling out for no intrinsic reason with a partially working OCaml version.

In our last episode (May 2007) I wrote: "The machine part compiles; maybe I'll be able to get the test app running later this week."

It being July now, that'd have to be a heck of a week. Fact is, I've been finding precious little time to work on it, with some major deadlines at work and other personal issues intruding.

But I do recall that I never put the OCaml version up anywhere, and since I haven't even touched it in over three weeks, I figured it must be time to put it up here so I can find it later.

Caveats: I've only compiled it on my old Mac at home, with Ocaml version 3.06. And it's not fully debugged yet, either. But it does say helpful stuff like this:

Evaluate 0 ... 
Evaluating     <LIT 7>
      result   7
Evaluating     <LIT 3>
      result   3
Evaluating     (\x -> [succ _ x])
      result   (E:<[ succ =succ
        ]>, V:x, T:[succ _ x]:)
Evaluating     [(\x -> [succ _ x]) _ <LIT 8>]
      result   9
Evaluating     (\x -> (\y -> [succ _ x]))
      result   (E:<[ succ =succ
        ]>, V:x, T:(\y -> [succ _ x]):)
Evaluating     [(\x -> [succ _ x]) _ <LIT 7>]
      result   8
Evaluate 3 ... Evaluating     <LIT 7>
      result   7
Evaluating     <LIT 3>
      result   3
Evaluating     (\x -> [succ _ x])
      result   (E:<[ succ =succ
        ]>, V:x, T:[succ _ x]:)
Evaluating     [(\x -> [succ _ x]) _ <LIT 8>]
      result   9
Evaluating     (x -> (y -> [succ _ x]))
      result   (E:<[ succ =succ
        ]>, V:x, T:(y -> [succ _ x]):)
Evaluating     [(\x -> [succ _ x]) _ <LIT 7>]
      result   8

At any rate, there are just two source files, so I didn't put together a Makefile or anything. They're here:

http://got.net/~landauer/cs/ohdr.ml
http://got.net/~landauer/cs/Danvy_SEC_M.ml

Though the current result is of somewhat questionable utility, I found it to be worth my time, since I did learn:

more OCaml;
how much FP-style pattern matching helps code conciseness; and
how much extra but necessary infrastructure stuff can be glossed over (i.e., omitted) in a technical paper like Danvy's.

11:55:33 PM comment/