zia

Now that it's been out a week, I printed it out and read it, I have comments on Tim Bray's essay "Language Fermentation" ...

Silly comment: There should be a programming language called "Mead". Google doesn't find one at the moment.

Quibble: C scoping blocks Tim writes:

... the only thing that really irritates me about C at a deep level is having to declare all the variables at the front of the routine, rather than when they're needed.

which of course is not true at all. Simple scoping blocks are woefully underused in C. Some people complain that they push the indentation too far to the right. If that happens, then your function is too long and it's time to refactor it. TDD helps there.

Substantial omission: No mention of type inference. Anyone interested in these issues would also likely be interested in reading the Lambda weblog and the MIT Lightweight Languages List. Both of these fora have frequent and lengthy discussions about static typing versus dynamic typing. Nearly all of those who favor the advantages of static typing consider the type systems of C, C++, Java, and C# to be hopelessly primitive.

[Static typing] does cut off a lot of stupid errors at the pass.
But, it turns out, Test-Driven Development cuts them off better; much better. And there is no doubt whatever that you can create software a lot faster, maybe an order of magnitude faster, in high-level dynamic languages.

I agree that TDD does better than the current popular low-level statically typed languages that lack type inference. But of course there is major doubt that everyone can create software faster at all (let alone an order of magnitude) in high-level dynamic languages versus statically typed languages. LISP fans have been claiming this for decades, but I have heard of no real studies of any significance. I guess that real studies of programmer productivity have been too expensive. Maybe now that the dot-com boom has busted and programmers are a dime a dozen, we might start to see a few such studies. Even then, they'll only be studies valid for "dime-a-dozen programmers" :-).

And once the typing systems from the functional programming languages (like OCaml, Clean and Haskell) are brought to cleaner syntaxes than OCaml's and more efficient compilers than the current crop of Haskell compilers, my guess is that we'll see static (or hybrid) type systems that allow programmers to be much more productive than dynamic languages do. (Disclaimer: Despite this belief, I still do most of my hobby programming in Python.) Of course, functional programming languages have been "the language of the future" for at least two decades now...

Relief: at least people have mostly stopped calling dynamic typing "weak".

Idle thought: Dynamic typing fans often say that programmers just tend not to make the kinds of errors that static typing catches. Perhaps this might be because they have mostly been trained for years on strict, statically typed systems, and they have learned not to make those kinds of errors.

Related stuff: Tim Bray is good at coming up with short phrases that are unique on the web. "Language Fermentation" is a great one. (Even today, Google gets ZERO hits for the phrase "language fermentation"! That won't be true for very long...)

Searching for that phrase on Feedster, or within Tim's Technorati cosmos will bring up quite an array of interesting weblogs.

A few of them:

• http://www.brockerhoff.net/bb/viewtopic.php
  
• http://minutillo.com/steve/weblog/
  
• http://falsepositives.blogspot.com/
  
• http://www.cddc.vt.edu/jeremy/blog/
  
• http://www.blueskyonmars.com/
  
• http://www.thomasbarker.com/
  
• http://radio.weblogs.com/0123037/
  
• http://radio.weblogs.com/0100544/
  
• http://radio.weblogs.com/0116883/
  
• http://www.have-at-it.net/
  
• http://weblog.bluepenguin.us/
  
• http://www.dellah.com/orient/
  
• http://www.frogware.com/
  

And then there's this:

http://flyingmoose.org/tolksarc/theories/theories.htm, seen mentioned on one of the above pages.

That search also gave me an idea for a small application for the new API that technorati just released and for which two Python wrappers (Mark Pilgrim's and Phil Pearson's) have already appeared: A text search within a given technorati cosmos.

Also related: Paul Graham's Hackers and Painters essay.