GRWL

GRWL is a procedural language for producing formatted printed output. Its statements set type sizes, choose ink colours, define running page headers and break text into paragraphs, and they mix all of this with ordinary loops, conditionals and procedures. The one surviving expansion of the name is Graphic Report Writing Language. Almost everything else about it has been lost. No manual, implementation, vendor, or named designer could be found. The language is known from a single artifact: a 99 Bottles of Beer program submitted to 99-bottles-of-beer.net in 2006. That program says more about the language than any catalog entry. This page describes what the program shows, labels inferences as inferences, and corrects the parts of the catalog record that the program contradicts.

What the record says

The encyclopedia catalog that lists GRWL records the following:

The “Robotics” label is the clearest problem. Nothing in the one known GRWL program has anything to do with robots or machine control. Its vocabulary is that of typesetting and report generation: pointsize, ink, page head, fill, para. That fits the “Graphic Report Writing Language” expansion. Where the robotics classification came from is unknown. It may be confusion with one of the robot programming languages of the 1980s, many of which had similar short acronyms. The 1985 date may also be approximate. The catalog cites no source for it.

History & Origins

The name

The only source that expands “GRWL” is the acronym dictionary AcronymFinder. Its entry reads “Graphic Report Writing Language” and is flagged as a definition that “appears very rarely”. The Wayback Machine first captured it on 17 November 2011. It cites no source and gives no date, vendor, or platform. It matches the surviving program closely, but it is a single unsourced dictionary entry, and this page treats it as probable, not proven.

The phrase “report writer” had a specific meaning in the 1970s and 1980s. A report writer was a tool or sub-language for turning records into formatted printed pages, with headings, page breaks, totals and column layout. COBOL had a Report Writer module, and many database and fourth-generation products shipped their own report languages. A graphic report writing language would plausibly have added control over typefaces, sizes and colours. That became newly practical in the mid-1980s, when laser printers and page-description languages brought typeset-quality output to office computers. This context fits the recorded 1985 date, but it does not confirm it.

The 99 Bottles program

The program was published on 99-bottles-of-beer.net, the long-running collection of programs that print the “99 Bottles of Beer” song in as many languages as possible. It was entry 1039, dated 02/01/06, credited to the user “antonyclark”, and filed under the site’s “real language” category rather than “esoteric language”. The page gives no description of the language, no link to an implementation, and no information about its origin. Wayback captures from April 2006 to December 2023 show the same program with no reader comments.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

for N = 99
for $b = "bottle"
for $d = "beer"
 page head
 (for pointsize 16 N " " $b " of " $d if continued " continued.. " fi
  fill*1
 )
 for b = N to 0 by -1
 for ink(if b eq 0 red else black fi)
  ss(b,1) " of " $d " on the wall, " ss(b,0) " of " $d "."
  fill*.1
  if b eq 0 "Go to the store and buy some more, "
  else  "Take one down and pass it around, " fi
  ss(b-1,0) " of " $d " on the wall."
  fill*1
  para
 next next
next next next

procedure ss(n,i)
(
 if n ge 1 n
 elif n eq 0 if i "N" else "n" fi "o more"
 else N fi
 " " $b
 if n eq 1 else "s" fi
)

GRWL “99 Bottles of Beer”, 99-bottles-of-beer.net entry 1039 (2006), as preserved by the Wayback Machine.

The submitter’s user name is the only person connected to GRWL anywhere in the public record. Whether “antonyclark” designed the language, worked with it in a job, or simply remembered it is not stated.

Design Philosophy

Without documentation, GRWL’s design goals have to be read from the program. One idea stands out: output is the default action. A string literal, a number, or a procedure call standing alone in the code does not need a print statement. It is written straight onto the page. Typographic settings are just more statements in the same stream. The program reads less like code that produces a report and more like a description of the report itself, with control flow inserted where the content repeats or varies.

The same approach underlies template and report languages from troff macros to later web templating systems, where the document is the program. GRWL applies it with the full set of procedural tools: variables, counted loops, multi-way conditionals and parameterised procedures.

Key Features

Everything in this section is inferred from the single surviving program. The program was not run, because no implementation exists. These readings are interpretations of how the code must behave to print the song correctly, not documented semantics.

for and next as a general scoping pair

The most unusual feature is how the program uses for. In most languages that have it, for only introduces a loop. In this program, the five for statements do three different things:

• three bind variables (N, $b, $d),
• one sets an ink colour,
• one is a counted loop.

There are also exactly five nexts: next next after the verse closes the loop and the ink setting, and next next next closes the three bindings. This suggests that GRWL treats for as a general “with this in effect, do the following” construct, closed by next, and treats a loop as just one kind of scope. The ink setting is a good example. It is re-evaluated on every pass of the loop, turning the final “No more bottles” verse red while the others stay black.

Conditionals with empty branches

The procedure ss ends with if n eq 1 else "s" fi. The then branch is empty, so the procedure emits nothing when there is exactly one bottle and an “s” otherwise. The same procedure handles the song’s other irregular cases. Its second parameter switches between “No more” at the start of a line and “no more” mid-line. When the count goes negative after the last verse, it falls through to else N fi and prints 99 again, for “99 bottles of beer on the wall”.

Evolution

No versions, releases, or changes to GRWL are documented. Even the language’s lifespan is uncertain. It is recorded as appearing around 1985, and the catalog that lists it gives 1995 as its last commercial year. Neither date has been confirmed. The only firm point is that the language was still remembered well enough in early 2006 (the entry is dated “02/01/06”, which could be read as either 1 February or 2 January) for someone to write a correct, idiomatic program in it.

Current Relevance

GRWL has no known implementation, users, or documentation. 99-bottles-of-beer.net, which held the language’s only public trace, no longer resolves, and entry 1039 now exists only in the Wayback Machine. Searches for this article covered:

• the general web and DuckDuckGo,
• FOLDOC and the HOPL online history of programming languages,
• the Google Books API,
• the Internet Archive’s metadata and full-text search over scanned magazines and books.

None of them found a manual, a product listing, an advertisement, or a mention of the language. Searches for “GRWL” mostly return the unrelated Global River Widths from Landsat database, an earth-science dataset that shares the acronym.

Not to be confused with

Why It Matters

GRWL is a reminder of how much of computing history lived inside products and workplaces and was never written down where the public could find it. Report languages like it were once common. Many database systems, accounting packages and minicomputer environments had their own. They were learned on the job, documented in manuals that shipped in binders, and abandoned when the product was. Few were ever described in a paper, and fewer still reached the language catalogs.

In GRWL’s case, a single person submitting one program to a hobby website in 2006 preserved more of the language than any other source. That program is complete enough to show a distinctive design: for as a general scoping construct, implicit output, and typographic settings as ordinary statements. It also shows that a catalog entry with a date, a paradigm and a category can still be wrong about what a language was for. If the original manual or software turns up, the 99 Bottles program will be the way to check it.

Sources

• 99-bottles-of-beer.net, “Language GRWL”, entry 1039 (dated 02/01/06), via the Wayback Machine, April 2006 capture and December 2023 capture
• AcronymFinder, “GRWL - Graphic Report Writing Language”, via the Wayback Machine, November 2011 capture
• Northwestern University Autonomous Mobile Robot Group, GRL project description