The History of Gopher's "i" Type

Published 2021-05-27

Part 1. What is the "i" type?

The "i" type is probably most pivotal contribution to the gopher protocol made from outside of the original UMN gopher team. The "i" type allows plain text to mingle alongside links to files in gopher directories. It transforms a gopher directory from what was originally a "bag-of-links" style listing ala FTP into a true hypertext document. The "i" type is now ubiquitous in modern gopherspace and is an absolute minimum requirement for any new gopher client.

The argument against "i" - keeping menus and files separate

However, there's a school of thought among gopher purists that the "i" type is an abuse of gopher's original design philosophy. The feeling is that gopher was designed to have menus and documents, and the two should remain separate. So instead of tacking an ASCII banner and a short blurb at the top of your root gopher menu, stick it in a text file named "ABOUT". Instead of tacking a text description above a link in your gopher menu, put that description properly in the link's metadata using the gopher+ abstract field.

The cool thing about the above is that it allows for a whole class of client interaction that's just not possible with hypertext. Like directly mounting a gopher hole as a filesystem using FUSE. Or allowing clients to sort a gopher menu in alphabetical order or hide certain file types. This was no doubt the direction that the UMN gopher team was oriented, and they doubled down on this with the creation of gopher+ and gopherVR. In fact, "i" selectors break the whole concept of gopherVR terribly which is a shame.

None the less...

Regardless, the "i" type became hugely popular with the gopher revival in the 2000's, and that's we're at today. However, I was curious about where this selector came from. Who invented it? It's not mentioned anywhere in RFC 1436. It's listed as an "unofficial" type on the wikipedia page with no further clarification. So I did some digging on my own...

Part 2. Origin of the "i" type

The best resource that I have found for gopher history is old usenet archives:

alt.gopher - the original gopher group that was started

comp.infosystems.gopher - was started later and then became the official group

These were both fairly active from around '92 to '95. After that, there was a dead period in gopher history until the gopher-project mailing list was started up in 2000.

For reference, the gopher protocol was invented in (late?) '91 and RFC 1436 was published in March '93.

RFC 1436 - The Internet Gopher Protocol

The Gopher FAQ - June '92

Here's the alt.gopher FAQ from June '92, which lists all of the known gopher link types. The "i" selector is nowhere to be found yet.

(An interesting aside, the only one of these "experimental" IDs to make it into RFC 1436 is "I")

Gopher FAQ - June '92

The Gopher FAQ - 3 months later

Here's the FAQ from September '92, just 3 months later.

There's the "i" type"! But what the heck is panda???

Gopher FAQ - September '92

Panda - University of Iowa's fork of gopher

So it turns out that Panda was a fork of gopher created by the University of Iowa to provide student internet services. It integrated gopher, usenet, FTP, WWW, and more. I found an announcement email (definitely worth a read!), and in it they describe several changes to their "souped up" gopher client. One of which is...

> Ability to add informational text to the tops of menus. This makes menus look a *lot* nicer and are much more readable than plain menus. See the sample screen later in this note.

The "i" type isn't called out by name, but it's clear that this is what's being referred to here. Later on in the email, there's a screenshot. This is probably the first recorded screenshot showing custom "info" at the top of a gopher menu!

An interesting side-note, they're wrapping at 80 characters instead of the 70 which was later mandated in RFC 1436. The client in this screenshot appears very well designed and intuitive, IMO.

[alt.gopher] Panda Announcement

So it looks like Lee Brintle gets credit for the Panda project and thus inventing the "i" selector.

Panda at GopherCon '92

Panda was also presented by University of Iowa at the very first GopherCon. This was only a couple weeks before the gopher FAQ was updated to include the line about the "i" item type, so the timeline matches up.

> Lee Brintle from the University of Iowa's "panda" project talked about some of their extensive modifications to Gopher: printer selection, remote updating of files by data maintainers, scripting (a forth-based interpreter in the client to allow massaging of input to and output from complex servers such as the geography server), grep-like searching of non-WAISified data, and search by title on the current level (a la rn and elm). Panda has evolved into an entirely different animal from Gopher (for starters, it is written in C++) and it is not clear which of these enhancements may make it back to the mainstream. The one Panda feature which seemed to gain everyone's approval was the ability to put explanatory text at the top and/or bottom of the screen rather than in an "About" file.

Emphasis on...

> The one Panda feature which seemed to gain everyone's approval was the ability to put explanatory text at the top and/or bottom of the screen rather than in an "About" file.

Dope.

GopherCon '92 trip report.

Part 3. Adoption of the "i" type

From what I can tell, not much happened after that. There was no immediate widespread adoption of the "i" type. I suspect this is because the UMN gopher client and server resisted adding the "i" item type to their software, which was the dominant server/client among the community. The gopher team went their separate direction with gopher+ and gopherVR which didn't fit with the "i" type methodology.

I hope to eventually find more information from this time period. How widely was the info type used in '92 and '93? Why was it ignored by the UMN gopher team and later omitted from RFC 1436?

Making it official

Later on, I found a question posed to the gopher newsgroup in '94 about the fate of gopher's experimental i type.

comp.infosystems.gopher - Clients that support type "i"?

> Early on, the University of Iowa devised an extension to the Gopher0 protocol whereby type "i" denotes a piece of inline annotation. I've heard tell that U Mn intends to embrace this extension. Has anyone compiled a list of clients that already support type "i"? Hgopher seems to. Is anything else up to speed?

There was a response from Lee Brintle, the creator of Panda himself.

> After the last FAQ, I mailed the Gopher folks about the still-experimental status of the "i" type, and they indicated that it would be moved into the "official" section.

And then a confirmation from Neophytos Iacovou at the UMN Distributed Computing Services.

> Yup, that's true.

It looks like this corresponds with the UMN gopher client finally accepting the "i" type in their software.

> Since no one else has mentioned it yet, i'll throw in that the last few versions of UMinn's Unix gopher+ client support the "i" type.

Closure

Annoyingly, shortly after the last email in April '94 the gopher team stopped posting updates of the gopher FAQ directly to the newsgroup. Instead, they linked to a copy of the gopher FAQ on a long dead FTP server. This is around the time that the UMN gopher team dissolved and the group traffic started to die down.

Fortunately I found one last version of the gopher FAQ posted by Paul Linden on Dec '94. In this version they dropped the "Official" and "Experimental" labels and posted everything in one big list of "known/used" gopher types.

I have no choice but to interpret this as one last jab by the UMN team to refuse making "i" an official gopher type.

Gopher FAQ - December '94

The end.