Paul Graham also has some pie-in-the-sky thoughts about computer languages; see his articles, Hundred-year language and his work on a new dialect of Lisp, Arc. Arc is a little more down-to-earth than the Tunes HLL, and he appears to have done some work on it.

The Tunes project has some requirements for an unnamed "High Level Language" for their project, which has a lot of good ideas init. As far as I can tell looking at the web page, it's kind of vaporware at this point. And maybe doomed to remain vaporware, since the requirements seem so abstract and idealistic. But anyway, some of their ideas have crossed my mind too, and they might at least server as a thoughtful critique of how current programming langauges feel inadequate to people.

Two good articles by Cory Doctorow (Metacrap) and Clay Shirky (The Semantic Web, Syllogism, and Worldview), expressing skepticism about the Semantic Web.

Shirky says most human thought isn't deduction from syllogisms, it's much more fuzzy and heuristic than that. Doctorow points out lots of good reasons why metadata will be crap in practice.

These ideas relate to better programming languages too. There's an impedance mismatch between human concepts and the way computer software systems tend to classify things. We just don't think as rigidly about things as computers do. We get frustrated with how software will go mindlessly clanking down the wrong path (for example happily cranking out copies of a virus and emailing them to all your friends), but when we try to build smarts into it, we're frustrated by just how dumb those smarts turn out to be.

Human computer interfaces, from GUIs to languages to development and testing environments, need to help our squishy minds navigate the bizarre tinkertoy syllogismatrons we're forced to build. While we frantically look for ways to teach software to think more like we do.

I just stumbled on a weblog about programming languages and their design, called Lambda the Ultimate. Similar to what I want to do here, although I want to focus more specifically on languages that bridge the gap in some interesting way between natural human languages and traditional computer languages.

Apocalypse 12 is out.

In case you live in a cave, the Apocalypses are Larry Wall's occasional manifestos (manifesti?) about how some aspect of Perl 6 will work. I read them with great interest because I like how Wall thinks, and I'm an avid user of Perl, and Perl 6 has some great ideas in it. I like hyperoperators and the new regular expression syntax. That being said, I'm getting kind of worried that Perl 6 is going to be too crufty. Look at what you can do with subroutine signatures. It seems unnecessarily complex and cryptic.

Of course I thought that back when I was learning Old Perl, but now I know it well and can use pretty efficiently, so I'll withhold judgment on Perl 6 until I get a chance to use it.

What this blog is about

The last post was mostly a test. What I want to do here is review computer languages that bridge the gap between computer language and human language in some interesting way.

Lojban is an attempt to make a human language somewhat more approachable by computers -- it has a yacc-parseable grammar that is syntactically unambiguous. In practice so far it has been used for communication between humans, not to specify or constrain a computer's behavior in any way. But it's a good example of an effort to think about some of the differences between the two kinds of language and find halfway points.

I do think that someday computers will be able to cope with human language. For programming I think we'll always need something a little more precise (like the language used in human legal contracts, maybe) to avoid some ambiguity.
But that day could be a ways off; why not meet the machine halfway for now? High-level languages have come a long way from raw machine code in doing this; I'm interested in seeing in what other ways computer languages can be more human without requiring outright artificial intelligence in the computer that uses them.

Kevo was an object-oriented language where classes were derived from objects rather than the other way around: a "family" of objects are ones that have the same signature. Families change dynamically as object properties are changed at runtime.

I haven't been able to find much detail about Kevo; it looks like it emerged around 1993 and its author is Antero Taivalsaari who has since done a lot of work since then on Mobile Java (J2ME). Here's an interesting paper that mentions Kevo:
Psychological criticism of the Prototype-Based OO-Languages