Wordyard

Hand-forged posts since 2002

Scott Rosenberg

  • About
  • Greatest hits

Archives

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

June 12, 2007 by Scott Rosenberg 13 Comments

Code ReadsThis is the tenth edition of Code Reads, a series of discussions of some of the central essays, documents and texts in the history of software. You can go straight to the comments and post something if you like. Here’s the full Code Reads archive.

You don’t have to read too far into Guy Steele’s “Growing a Language” to figure out what he’s up to. In this 1998 talk on the nature of programming-language design, Steele writes under a set of constraints: he may use any word of one syllable, but if he wishes to use longer words, he must define them first — using only words of one syllable.

Steele aimed to illustrate how awkward and confining it can be to try to express yourself when you don’t have access to an extensive vocabulary: “I wanted to show you want it is like to use a language that is much too small.” (By this point in the talk, he has already defined “language.”) His larger purpose is to advocate a philosophy of programming-language development that aims for neither a small nor a large language, but rather for one that is “designed to grow.”

Such growth is to be propelled not by a closed cadre of gurus but by the language’s users, who have been given an appropriate set of tools to extend the language. The shape of the language is such that these user-generated additions do not look or behave any differently from the “original” elements of the language provided by its initial creators. Nearly a decade later, this argument — which parallels similar ideas that have become popular in the open-source software community as well as in the “user-generated” enthusiasms of Web 2.0 — sounds neither arcane nor controversial.
[Read more…]

Filed Under: Code Reads, Dreaming in Code, Software

Code Reads: Next up — Guy Steele

May 24, 2007 by Scott Rosenberg 9 Comments

I’m extremely pleased to see how many of you persevered through the long Code Reads drought and returned for the Backus discussion. Thank you all for sticking around. I am learning a lot from the comments, and you’ve renewed my determination to get Code Reads back on a reasonable schedule.

For the next installment, I’m going to suggest that we read (or re-read!) Guy Steele’s paper, “Growing a Language.” It’s a famous piece of writing that I skimmed ages ago but always wanted to take a closer look at. It is also, I think, considerably more accessible than the Backus. Here’s a PDF link to the Steele paper. And here’s an interview with Steele from Sun.

Filed Under: Code Reads

Code Reads #9: John Backus, “Can Programming Be Liberated…?”

May 21, 2007 by Scott Rosenberg 18 Comments

Code ReadsThis is the ninth edition of Code Reads, a series of discussions of some of the central essays, documents and texts in the history of software. You can go straight to the comments and post something if you like. Here’s the full Code Reads archive.

The annals of programming include a small but significant number of radical thinkers who propose total overhauls of our basic techniques for making computers perform useful tasks. One of them is the late John Backus. Backus was the central figure in the creation of FORTRAN — the archetypal first-generation “higher level” programming language — and the devising of the BNF (“Backus Naur Form” or “Backus Normal Form”), a formal method for specifying programming-language syntax.

In his 1977 Turing Award lecture, however, Backus stepped away from the world he’d helped shape and asked, “Can Programming Be Liberated from the Von Neumann Style?” It’s a question that gets at fundamentals, at breaking free of founding constraints. It’s like asking whether psychology could be liberated from Freud, or physics from Einstein.

Backus describes the prevalent Von Neumann paradigm of computing:

In its simplest form a von Neumann computer has three parts: a central processing unit (or CPU), a store, and a connecting tube that can tramsit a single word between the CPU and the store (and send an address to the store). I propose to call this tube the von Neumann bottleneck. The task of a program is to change the contents of the store in some major way; when one considers that this task must be accomplished entirely by pumping single words back and forth through the von Neumann bottleneck, the reason for its name becomes clear….

Surely there must be a less primitive way of making big changes in the store than by pushing vast numbers of words nback and forth through the von Neumann bottleneck. Not only is this tube a literal bottleneck for the data traffic of a problem, but, more importantly, it is an intellectual bottleneck that has kept us tied to word-at-a-time thinking instead of encouraging us to think in terms of the larger conceptual units of the task at hand.

(I will pause here to note the presence of that word “tube.” Perhaps Senator Ted Stevens, far from being a techno-rube, was actually a student of Backus.)
[Read more…]

Filed Under: Code Reads, Dreaming in Code, Software

John Backus, RIP, and up next in Code Reads

March 20, 2007 by Scott Rosenberg 9 Comments

I was all set to dive into “No Silver Bullet” for the next Code Reads, but given last night’s news of the passing away of John Backus, father of FORTRAN, I thought I would do a quick revision of the plan.

The next Code Reads will focus on Backus’s 1977 Turing lecture, “Can Programming Be Liberated from the von Neumann Style?” It’s full of equations and math notation that, superficially at least, look daunting to this reader — but I will give it a try, and perhaps the collective expertise of all of you will help bolster me in those areas where I falter!

Filed Under: Code Reads, Software, Technology

Code Reads #8: The Cathedral and the Bazaar

March 3, 2007 by Scott Rosenberg 8 Comments

Code ReadsThis is the eighth edition of Code Reads, a series of discussions of some of the central essays, documents and texts in the history of software. You can go straight to the comments and post something if you like. Here’s the full Code Reads archive.

The Cathedral and the Bazaar, Eric Raymond’s classic essay on open-source software development, is now 10 years old. I first read it soon after its publication. At that time the term “open source” was newly minted, and the movement was in the news chiefly because (a) it seemed to offer a threat to Microsoft, and (b) Netscape, at a late stage of its war with Microsoft, had decided to release its browser code under open-source license. I was editing Salon’s technology section in those days, and one of our central projects was Andrew Leonard’s thorough coverage of the open-source phenomenon. (He interviewed Raymond in early 1998.)

I think it’s fair to say that today CatB (as Raymond and others now call the essay) has proved its importance independent of its place in the long-concluded browser-war saga. I’ve reread it several times over the years since, and each time find something new and valuable.

[Read more…]

Filed Under: Code Reads, Dreaming in Code, Software

Code Reads #7: Parnas’s “Star Wars” paper

January 5, 2007 by Scott Rosenberg 36 Comments

Code ReadsThis is the seventh edition of Code Reads, an aspiring-to-weekly discussion of some of the central essays, documents and texts in the history of software. You can go straight to the comments and post something if you like. Here’s the full Code Reads archive.

In the early 1980s, president Ronald Reagan proposed the missile-defense program known formally as the Strategic Defense Initiative (SDI) — and informally as “Star Wars.” Then the Pentagon and its contractors began trying to build the thing. They’re still at it today.

In 1985, David Lorge Parnas — a well-reputed computer scientist best known for elucidating the principle of “information hiding” that underlies modern object-oriented techniques — publicly resigned from a government computing panel that had been convened to advise the Star Wars effort. Star Wars couldn’t be built according to the government’s requirements, Parnas declared, because the software simply couldn’t be built. Unlike many who weighed in on Star Wars, Parnas didn’t express opposition on moral or political grounds; he was, he said, a longtime toiler in the field of defense software engineering, and had no “political or policy judgments” to offer. He just thought that SDI’s engineering aspirations lay impossibly far outside the bounds of real-world capabilities.

In support of this judgment Parnas composed a series of eight short essays that the American Scientist — and later the Communications of the ACM — published together under the title, “Software Aspects of Strategic Defense Systems.” It’s a magnificently forthright piece of writing — it encapsulates the best of the engineering mindset in prose. And it explains some fairly complicated notions in terms anyone can follow.

For instance, it wasn’t until I read Parnas’s paper that I fully understood why digital systems are so much harder to prove reliable than analog ones. [Read more…]

Filed Under: Code Reads, Dreaming in Code, Software

Code Reads update and schedule

January 3, 2007 by Scott Rosenberg 2 Comments

I’m sorry that I wasn’t able to keep up a rigorous weekly schedule for Code Reads through the fall — too many conflicting demands. I’m getting serious now, though, and setting some dates down here. (Public commitments to deadlines always concentrate the mind.)

January will be something of an all-star month full of well-known classics in the field, in honor of the forthcoming publication of Dreaming in Code.

Later this week I’ll be posting the next Code Reads installment on David Parnas’s “Software Aspects of Strategic Defense Systems,” his 1985 essay about the Reagan-era Star Wars program, and why its software needs would doom it.

Next week (Jan. 8), we’ll look at Eric Raymond’s manifesto, The Cathedral and the Bazaar. Sure, you’ve heard of it, you know all about it — but when’s the last time you actually read it?

Then, the following week (Jan. 15), to mark the official launch of Dreaming in Code, we’ll take a look at the essay that I view as, if not the cornerstone of the entire field of software development, then certainly the distillation of the questions my book centers on: Frederick Brooks’ “No Silver Bullet.” We touched on some of the issues back when we started with “The Mythical Man-Month,” but “No Silver Bullet” spins quite a separate argument that’s worth grappling with on its own.
[tags]code reads, no silver bullet, david parnas, cathedral and bazaar, eric raymond[/tags]

Filed Under: Code Reads

Code Reads #6: Mitch Kapor’s Software Design Manifesto

December 8, 2006 by Scott Rosenberg 16 Comments

Code ReadsThis is the sixth edition of Code Reads, an aspiring-to-weekly discussion of some of the central essays, documents and texts in the history of software. You can go straight to the comments and post something if you like. Here’s thefull Code Reads archive.

Mitch Kapor first presented his Software Design Manifesto at PC Forum in 1990. It got published in Dr. Dobbs’ Journal in 1991, and later appeared as the first chapter of Terry Winograd’s book Bringing Design to Software (much of the book is available in online form now). At a point roughly midway between the start of the personal-computing revolution in the mid-’70s and the present, Kapor threw down a gauntlet: Computers were too hard to work with. “Everyone I know (including me) feels the urge to throw that infuriating machine through the window at least once a week,” Kapor wrote.

The PC revolution’s promises of “personal empowerment” remained unfulfilled because the software that drove the miraculous new machines was simply not well-enough shaped. The people who made it weren’t thinking clearly enough about how their products would be used. Somebody had to do that work; Kapor argued that programmers probably weren’t the best people to take it on, and proposed the creation of a new discipline of “Software Designer” to wear this mantle.
[Read more…]

Filed Under: Code Reads, Dreaming in Code, Software

Code Reads notes

November 27, 2006 by Scott Rosenberg 1 Comment

Within a couple of days I’ll have the next Code Reads installment ready. When I started this series I didn’t want to be rigid about following a pre-chosen list but rather to try to stay flexible — dare I say agile? — and also respond to suggestions. The result has been a longer sojourn in the thickets of somewhat long-in-the-tooth computer-science papers than I initially planned. All worth some attention, to be sure — but my hope is to provide a set of readings and discussions that touches on practice as thoroughly as on theory.

So we’re going to move in that direction for a while. Next up is Mitch Kapor’s Software Design Manifesto.

Also, that book giveaway I mentioned a while back — of five copies of Joel Spolsky’s Best Software Writing — is finally underway. Here’s how I’m doing it: (a) assemble list of people whose comments have substantively contributed to the discussions — and the contributions have almost all been thoughtful, so this means nearly all the people who’ve posted comments; (b) select names randomly from that list. If I have an email address for the lucky winners I will contact them; otherwise I’ll post the name here and ask you to email me. I’m giving away a book a week from now until they run out.

Filed Under: Code Reads

Code Reads #5: Knuth’s “Structured Programming with go to Statements”

November 17, 2006 by Scott Rosenberg 11 Comments

Code ReadsThis is the fifth edition of Code Reads, a weekly discussion of some of the central essays, documents and texts in the history of software. You can go straight to the comments and post something if you like. Here’s the full Code Reads archive.

I have felt for a long time that a talent for programming consists largely of the ability to switch readily from microscopic to macroscopic views of things, i.e., to change levels of abstraction fluently.
— Donald Knuth, “Structured Programming with go to Statements”

We’ve been looking at Edsger Dijkstra’s principles of structured programming for some time now. Today we’ll conclude that phase of this series with a look at Donald Knuth’s “Structured Programming with go to Statements” (1974). Since “Go To Statement Considered Harmful” was the most famous declaration of the structured programming ethos, Knuth’s title itself was a kind of provocative joke — like naming a paper “Judaism with Idols” or “Vegetarianism with Pork Chops.” And that combination of playfulness and attentive humor extends throughout the article, from the epigraphic references to Bob Dylan (and a laxative advertisement!) on. In the middle of a complex analysis of an algorithm in ALGOL, in which Knuth is reviewing ideas for new ways to notate a particular kind of loop, he interjects:

Readers who remember 1967 will also appreciate [this] second suggestion,
turn on begin S; when B drop out; T; end.

The levity’s a good thing, because, I confess, as a non-mathematician and only a rudimentary programmer I approached Knuth’s formula-laden text with trepidation. And there remain parts of “Structured Programming with go to Statements” that are beyond me. But for the most part, this text bears out Knuth’s reputation for brilliant clarity — it’s surprisingly accessible.

[Read more…]

Filed Under: Code Reads, Dreaming in Code, Software

« Previous Page
Next Page »