When we want to share information on the web today, we typically pick up our smartphones and tap out a few words. Almost magically, our knowledge bits get hurled into the ether for the entire Internet to read.
Twenty years ago, publishing on the web felt less like slinging knowledge and more like building a house, brick by brick. It reminds me of my school days, when I walked uphill both ways in the snow–only the hills looked like HTML files and the snow resembled a gnarly FTP client. Mind you, web publishing was easier than printing up and distributing 10,000 pamphlets, but the process wasn’t trivial.
In early 1995, when I was on the cusp of turning 14 years old, I decided I wanted to be part of World Wide Web (the web) on the Information Superhighway (the Internet) by creating my own web page (website). (Even the jargon is old.) To do that, I had to obtain an Internet connection, then I had to rent web space, learn how to write HTML, and actually upload it to that space, then figure out how to view it in a graphical web browser.
It wasn’t easy, but I found the result exhilarating. Here’s how I–and lots of other folks–did it.
On the afternoon of Sunday, February 26, 1995, my father walked into a software store named Babbage’s in Raleigh, North Carolina, and bought a copy of Plug-n-Play Mosaic for Windows. The product came in a software-style box, but it was essentially a large book with two bundled floppy disks from SAMS Publishing. Tech journalist Angela Gunn wrote the book, which served as a novice’s introduction to the World Wide Web, in 1994.
Only six months prior, I had first discovered the Internet through a friend who introduced me to a local university dial-up line that allowed students to access the school’s servers remotely to read email or check the school library’s card catalog. It was called the NCSU Dataswitch after the local university’s name.
To access it, I needed a computer, a dial-up modem, and a terminal emulator program. Once connected, if I typed “library” as my login name, I could gain access as a member of the public, and I would be presented with the N.C. State library’s Gopher menu (effectively a menu-based precursor to the web). From there, I could navigate to other Gophers and access quite a bit of stuff, like web pages (in text) or online games (also in text) or free.
I and my best friend, aged 13 and 16 respectively, abused the heck out of that service, although we didn’t know it at the time. I thought the Dataswitch worked like CompuServe, which could handle thousands of users at a time. But no: it turns out there were only two lines. And guess what? My friend always called one, while I called the other. One time I stayed online playing a MUSH (a multiplayer text game) for 20 hours straight. That was fairly typical.
As the Internet became more than just a way to access MUDs or look up the occasional novelty on text-based Gophers or web browsers, both of us sought a more robust way of accessing it. One of the first ISPs in our city was called NandO.net. Our local newspaper, the News and Observer, ran it as an extension of its efforts to pioneer online newsmaking processes.
On some day in late 1994, my father signed my family up for NandO.net. What we got in exchange for about $20 a month was an account on an Internet-enabled BBS, which had its own local message board and games, but would allow us to use text-only Internet email, web browsing, FTP, and Gopher. My dad paid extra for a “shell account” so I could log in and get a Unix command prompt. From there I could upload and download files from a terminal program, telnet to other servers, and push stuff from my shell account to remote machines via FTP.
If all this sounds complicated, that’s because it was.
Over a year prior, in early 1993, the National Center for Supercomputing Applications (NCSA) had released Mosaic, a high quality web browser that displayed images in-line with text–that is, pictures appeared on the page at the same time as the words. Its popularity grew until, by late 1994, many people sought a graphical portal to the Web. I became one of them.
To get there, you needed more than text-based access to the web. You needed to make your local machine effectively look like a node on the Internet itself. And to do that, you needed a way to translate the TCP/IP protocol that the Internet used into a form that could be used over a dial-up telephone modem connection.
The solution to that arrived as Point-to-Point Protocol (PPP), which wrapped TCP/IP into yet another protocol that suited itself to dial-up connections. In 1995, NandO.net added PPP support, and my dad signed us up for PPP access. Through Internet-savvy friends and NandO.net, my father received instructions on how to set up a PPP connection that looked like this (these are his actual notes).
Frankly, it boggled my young mind. I had previously connected to BBSes, run my own BBS since 1992, and connected to Prodigy, CompuServe, and AOL, but I had never seen weird numbers like this.
In retrospect, I can see that my father’s first hope at simplifying this process was the purchase of the Plug-N-Play Mosaic book. While the book was a wonderful explanatory resource, unfortunately, the software that came with it was fairly horrible. It shipped with Spyglass Mosaic, a commercial browser related to NCSA Mosaic in name and design only, and some deficient PPP tools. (The second disk shipped with the book was occupied entirely by Win32s, and if I have to explain that too, my brain will explode.)
Connecting graphical applications to the web proved complicated in the era between early 1993 and mid to late 1995 because, at the time, TCP/IP networking was not a native part of Windows 3.11. Users had to provide their own TCP/IP stack, the software that allowed your local computer to speak TCP/IP. On top of that, you needed a PPP utility.
In the early days, buying a TCP/IP stack for Windows cost anywhere between hundreds and thousands of dollars. And when any piece of software cost that much, shareware authors usually stepped in with a lower-priced alternative. In the case of the software I used, Trumpet Winsock, the price was $0, because I never registered it.
Trumpet Winsock was a shareware TCP/IP and PPP solution created by Australian programmer Peter Tattam for Windows 3.x. It found widespread distribution on BBSes and other online services in the early days of the graphical Web. As a result, a whole generation of freeloaders like myself used it to get on the Internet with Windows for the first time.
But like everything else those days, setting up Trumpet Winsock wasn’t a simple process. My early Internet buddy–the one I mentioned earlier–likes to bring up a special string-of-curse words epithet I coined at age 14 to describe the torturous process of setting up TCP/IP in Windows. It has become an inside joke between us that persists two decades later. I’ll spare you the gory details, but you get the idea.
Here is the setup screen for Trumpet Winsock. The hardest part was trying to figure out which numbers went where; simultaneously, you had to figure out which spaces to leave blank. The whole setup was incredibly fickle when it came to exactness–any slight error in input would bring the whole thing down into an anticlimactic pile of dull, non-working software. No explosions, no crashes; just nothing.
That’s when I’d use the epithet.
If you wanted to automate the process of logging in through Trumpet Winsock, you not only had to get all those numbers right, but also create or edit a custom login script that had to exactly match what your ISP expected you to type while logging in (it needed to incorporate your user login and password information as well). Here’s a snippet from a script I set up two days after the book purchase, on February 28, 1995:
// set new timeout for logging in
// Wait for login prompt
// Send user name
// Send password
// Wait for PPP prompt from the PPP server
ABORTONFAILURE (“Login authentication failure”)
//PROGTEXT (“PPP connection established.”)
(Yes, my password was “teeth”–go figure.)
When it worked, and you managed to connect, it wasn’t much more satisfying than when it failed. You’d still be presented with a non-user friendly scroll of status messages. Coming from a BBS and shell account background, I was used to this, but I can only imagine how intimidating it must have seemed to computer novices (if they ever managed to get it to work). Connecting looked exactly like this.
According to my records, the first time I got my PPP connection working was Tuesday, February 28, 1995, around 11:33 a.m. I remember the scene: I was home sick from school, sitting in my room. My silver Intel 14,400 bits-per-second modem, which was unbearably slow for the task, screeched as I connected and the script executed successfully. I typed in a URL and watched in amazement as a color photo of a cat unfolded into my browser window over the next five minutes. It was a different world back then–but not so different.
The second website I looked at was the Trojan Room Coffee Pot website, which let you check the status of a coffee maker on the campus of the University of Cambridge in the U.K. It was the world’s first webcam, and it blew my mind.
Less than an hour later, I was creating my own web page, using Gunn’s Mosaic book as a guide.
Following Gunn’s examples, I began to experiment with HTML. The first HTML file I ever wrote was titled (surprise!) BENJ.HTM, dated 12:37 p.m. on Feb 28, 1995. Here is the code:
Not exactly standards-compliant, but it did display an accurate vanity message. I attempted to incorporate a hand-scanned grayscale photo of myself (8th-grade class photo), but it looks like I forgot to put the equal sign in the tag.
I tinkered around the rest of that day until I got my first “home page” squared away–with a working Benj image, list of fun links, and all. But at that point, I was only viewing the HTML file of my page on my local computer. It wasn’t until August 1995 that I created an actual website that was accessible through the Internet.
My dad worked with a guy at work named Doug who was ahead of the curve on all things computer-related. It was Doug who happened to give my family our first modem, a Zoom 2400-bps model that got me BBSing for the first time in 1992. He was, and is, a good friend.
Doug knew about a web host called Hurricane Electric that rented out limited web space on the cheap. $1 a month got you one megabyte of space–which, at the time, was enough to build a site–and 100 megabytes of bandwidth. Each additional megabyte cost $2.95, and each additional megabyte of traffic cost 10¢.
My dad signed me up for a Hurricane Electic account, and I got to work crafting my web masterpiece, which I titled “The Schmeli Caborgan,” a name I made up from thin air to sound silly and faux-Scandinavian. (It’s pronounced Schmee-lye Ca-borgan, by the way.) Remember: I was 14, and I thought I was funny.
The first step was to start building an HTML file. As you may know, an HTML file is just an ASCII text file with a fancy name that one fills with special formatting tags that tell a browser how to display the page. Back in the day, I used Windows Notepad, which shipped with Windows 3.11, to write my HTML. Here is how it looked:
After I wrote the file, I would save it with a .HTM extension (MS-DOS, and thus Windows, only supported “8+3” file names at the time–eight character file name plus a three character extension). I would then load it up locally in my web browser to test it out.
You may recall that the Mosaic book came with a copy of the Spyglass Mosaic browser. Well, it wasn’t long before I switched to a beta version of Netscape Navigator, which was just then emerging as the most promising and popular Web browser for PCs. Netscape gained popularity quickly for its nice interface, stable nature, and the fact that it had more useful features than its competitors. It was also distributed for free, which is a feature that is hard to beat in any era.
Here is how my first website, the Schmeli Caborgan, as it looked in Netscape 1.0–before I added any images.
At that time, Netscape 1.0 did not support background images (all pages had a grey background), did not display JPEG images at all, or allow HTML-selectable font faces–among other limitations. But we liked it anyway.
It did, however, support displaying GIF files inline with text. So to make a snazzy logo for my new website, I fired up Microsoft Paintbrush and sketched out a geometrical wonder.
Since Netscape couldn’t display the BMP files that Painbrush produced, I had to use a program called Jasc Paint Shop to convert my SCHMELI.BMP file into GIF format. Jasc went on to upgrade Paint Shop with editing tools, calling it Paint Shop Pro, and expanding on it until the company was acquired by Corel in 2004. I remain a Jasc-era Paint Shop Pro loyalist to this day–but don’t tell anybody, because people think I use Photoshop.
After that, it was time to add the image tag to my HTML file, then upload it to my web space and check it out online for the first time. Getting my files in the right spot to see on the Internet, however, required a bit of tricky file and program juggling.
First of all, at that time, I didn’t have a Windows FTP client. Such a client would have used the PPP connection with my ISP to directly connect to Hurricane Electic’s servers, and from there, I would have uploaded the files. But no, that would be too easy, wouldn’t it?
I’ve checked my log files from the time, and it turns out that I did this: 1) First, I ran Telix, a popular MS-DOS terminal emulation program, and used it to dial into my ISP’s Unix shell account. 2) After logging into my shell account, I uploaded my files one at a time using the Unix command line “rz” command, which received a Zmodem protocol file upload. 3) After that, my files were on my ISP’s machine. From there, I needed to move the files to my web host’s remote machine, so I ran the command-line FTP client in Unix to connect to Hurricane Electric servers. 4) Once connected to that remote web server, I uploaded the files from my shell account to the web space.
Phew. Here is exactly what that process looked like. This is a transcript taken directly from one of my log files from 1995, and it is displayed in Telix exactly as it would have appeared at the time:
Remember what I said about publishing to the web being like walking uphill both ways in the snow? More like uphill both ways on the ice. Now I can see why I didn’t update my website very often in the 1990s. It’s rather amazing to my 34 year-old self that I figured out how to do all this at the age of 14.
At the end of that long August day of editing and typing and uploading, I finally got a chance to take a look at my first website on the real Internet. I started Windows 3.11 again, dialed in with Trumpet Winsock, loaded up Netscape, typed in http://www.he.tdl.net/~schmeli, and this is what I saw:
Beautiful nonsense. And of course it was “under construction”–every website was back then.
Not long after that, I added a separate page on my site with a nice list of links to classic video game and vintage computer sites on the Web–there were about five total at the time. Then I added a list of paranormal phenomena links (again, I was 14) and my site suddenly had meaningful content.
To exploit that content, I submitted my computer and paranormal pages to Yahoo, the premier web directory that listed pretty much every site on the WWW. At the time, Yahoo’s directory included just over 31,000 entires. In other words, there were only about 31,000 web pages on the entire Internet (Today? Around 4.6 billion).
In that climate, it was easy to stand out, so my pages quickly became part of Yahoo’s directory. And it wasn’t a complete given–they had to pass through a human editor too. That was one of my proudest achievements at the time.
So that’s what it was like to get online and publish on the Web 20 years ago. Think about this process next time you hit “Send” on the touch screen of your wireless pocket Internet terminal–and be grateful, as I am, that there is no longer any meaningful impediment to sharing your cat pictures with the entire world instantaneously.