Comments on: Code Reads #10: Guy Steele, “Growing a Language”

By: Scott Rosenberg’s Wordyard » Blog Archive » Code Reads #11: “Notes on Postmodern Programming”

Wed, 02 Apr 2008 16:36:17 +0000

[...] in writing about programming isn’t always so easy to find. But here it is again. In our last Code Reads we got to enjoy Guy Steele’s words-of-one-syllable language game; this time around, [...]

By: Peteris Krumins

Peteris Krumins — Tue, 01 Apr 2008 14:13:06 +0000

There is also a video lecture available of his talk.

I wrote about it here: Growing a Language by Guy Steele

Peter

By: secretGeek

secretGeek — Mon, 24 Sep 2007 03:53:32 +0000

thank you Scott — I hadn’t seen this essay before.

i’ve just returned from a holiday during which i toyed a lot with the idea of putting out a book that collects remarkable (and classic and humorous) essays on programming.

it turns out your Code Reads series has covered many of the articles i’d like to get my permissive hands on.

nice work
lb

By: Charlie M

Charlie M — Sat, 28 Jul 2007 04:45:40 +0000

I posit that there are, at the bottom of any linear-sequential “language,” only three words: AND, NOT, and STORE. AND and NOT are in the space-domain as well, which further restricts the language. This is a poor vocabulary with which to write any significant program. It is the reason that software production for any dynamic controller is about 50% efficient, with half the time fixing that which was produced in the first half.

By: Scott Rosenberg’s Wordyard » Blog Archive » Next up for Code Reads: “Notes on Postmodern Programming”

Tue, 19 Jun 2007 01:55:45 +0000

[...] Thanks to everyone who weighed in on the Code Reads discussion of Guy Steele’s “Growing a Language.” [...]

By: Andrew Sacamano

Andrew Sacamano — Thu, 14 Jun 2007 16:43:51 +0000

Reading’s Sam’s comments reminds me of my reaction upon learning about design patterns. I immediately wanted a way to formalize the usage of these patterns, so that the larger structure of a program was explicit. I’m not sure such a thing is possible. Would the vocabulary of the larger structure soon become so large and cumbersome that it would create confusion instead of clarity, being the largest of the large languages? Or is is possible to find a set that is “good enough”?

There seems to be a standard process for many technological developments - first everyone does everything their own way, motivated by fulfilling exactly their own needs. As user communities develop, people begin finding ways to standardize, trading flexibility for simplicity until a balance is achieved. As times goes on, particularly around computers, more and more standardization is achieved. So maybe this is where programming languages can evolve - finding larger and larger abstractions which are “good enough”.

By: links for 2007-06-14 « Mike Does Tech

links for 2007-06-14 « Mike Does Tech — Thu, 14 Jun 2007 01:04:16 +0000

[...] Scott Rosenberg’s Wordyard » Blog Archive » Code Reads #10: Guy Steele, “Growing a Language” [...]

By: Cleo Saulnier

Cleo Saulnier — Wed, 13 Jun 2007 22:29:14 +0000

I read the article when it was first posted, but when I reached the end, I felt like I missed the punch line. I found the mono syllable excercise interesting, but I thought the point was to say that it was more difficult this way. Maybe for him, and some sentences did read strangely, but it was always clear. This goes hand in hand with the notion that when people have constraints to work around or with, you always get a better end result than if you could do anything you wished. At the end, I got the feeling that he trumped himself, but like I said, I didn’t get the punch line. Nice article though I thought it made a different point than the author intended. Still, I liked it and am happy it was brought to my attention.

By: Sam Penrose

Sam Penrose — Wed, 13 Jun 2007 16:33:47 +0000

As I said in the earlier thread, I agree with Scott that the paper is a remarkable rhetorical achievment and brain candy of the highest order.

That said, as a working programmer what I tend to miss most in all the C-based languages I am familiar with is not new words but more flexibility and clarity in making higher level structures. We have, (speaking loosely):

- functions
- classes-qua-data-structure
- classes-qua-object (state-behavior bundles)
- class hierarchies
- “modules” / headers which group previous
- packages (i.e. abstracted file system directories) which group modules
- libraries which group packages
- some patterns for creating structure across those boundaries

When it comes to structuring medium and large works of software, we have no real equivalent to the many mature forms that written language can take: forms which constrain and clarify intention the way the research paper, the polemic, the survey-of-current-literature do for their writers and readers. We all know how to pick out the most important sentences and paragraphs from an unfamiliar piece of writing in moments; picking out the most important functions and modules from an unfamiliar piece of code is a treasure hunt. New operators and keywords — statement-level syntax — are useful for a small fraction of working programmers most of the time. Better ways to communicate program structure would be useful for all of us every day.

By: Brian Slesinsky

Brian Slesinsky — Wed, 13 Jun 2007 08:13:48 +0000

Some of the things Steele advocated did make it into Java, such as generic types. Others made it into C#, but not into Java yet.

I think it’s still an open question whether libraries should be allowed everything that can be done in the language itself. It’s useful to be able to reason about a program in which some terms are unfamiliar. Java does a much better job of this than most mainstream languages.