Remembering bulletin boards with MS-DOS
Before TCP/IP and the modern network stack, there was a brief but glorious moment when we would communicate by directly connecting to other computers using ad-hoc protocols. People recognized the power in this sort of communication, and dedicated their computers to publishing news, all sorts of information, even files. To connect to such a system, we would use a dial-up modem: there was no IP address nor port, but a phone number. After dialing, the machine would answer automatically and take over the communication by sending menus, or meticulously crafted text interfaces with which the caller would interact. This was the protocol, completely custom, completely made up by the answering party.
Over the phone we could only send ASCII text, so that was the basis of the communication protocol: the user would phone, the system would answer and send back text, and the user would respond with more text. Any key press would be sent over the phone line, meaning that systems would be able to respond without having the user to press enter, allowing forms of rudimentary interface interactions to take place. Looking for a name, the system we would dial in received the obvious: bulletin board system, or BBS for short. It was the first form of all-purpose global computer communication and interaction.
How did this work?
Again, we need to understand that this was not the Internet, that there was no network card involved, and that there was no TCP/IP. This is important because it goes to show how a completely disorganized mess that allowed any system to respond any way it wanted without following any rules, was able to create a coherent form of communication, where tens of thousands of users would collect news, chat, exchange files, and form communities.
Of course, this could all work because the entry point was so basic: all we needed was a phone line, a computer, and a modem. Since the exchange unit was an ASCII character, the modem didn’t even need to be too fast either. Yes, if you wanted to enjoy overly complex and fancy bulletin boards with text-based interfaces, you had better have a fast modem, but other than that, the processing power of your computer didn’t matter at all. With MS-DOS, the modem didn’t even need a driver. The communication commands were standardized under the Hayes AT set to which all modems adhered, and modem terminal applications usually supported many modems, including generic ones so no extra installation step was required.
Soon people realized they stumbled upon a gold mine. Personal blogs using folders and text files appeared, tutorials with ASCII art diagrams, and the all-time favorite: pirated software. The content complexity, rule systems, sharing features, even the weird connection format, elevated the bulletin boards to cult-status, as unprecedented sharing, communication, and key-based interaction became standard for computer geeks in the eighties.
Is it all lost?
Not all is lost, no. The scale, the modem with its phone lines, the obscure and technology-oriented communities are indeed gone, but bulletin boards still exist. We can still access them from modern operating systems using telnet, or we can try to emulate some of the bygone era’s feeling using MS-DOS. Unfortunately, 86Box is not able to emulate modems directly, and neither is QEMU. What we can do is create a pass-through serial port and install a modem emulation driver, such as ATduck.
Today though, we will choose a simpler way: DOSBox. DOSBox can add a virtual generic modem to the emulated computer’s serial port. We just edit the configuration file and adjust the desired serial port:
We simply pick the serial port, the first one in the above screenshot, and fill in modem. This would be enough, but if we want two-way interaction, we can also specify a listen port, using listenport:5000. The number can be any port we want, which we can use to “call” the virtual modem. With the above configured, we can start DOSBox. In the background status window, we will see the modem being initialized:
Next, we need the software. There was a very versatile modem command application back then, called Telemate. It was built in the late eighties and was able to work with many modem protocols and outputs. There were also many such applications provided by modem vendors, able to use custom and proprietary features built into their modems. For example, BitCOM by Cheyenne, the one I also used back then. For our exercise though, we will use Telemate, which we can download from Vetusware.
DOSBox works a little differently than 86Box, and it requires a folder on the local drive which we will mount as drive C. I created a folder called dosbox in my Downloads folder in Windows, and inside I created another folder called drivec. Next, I added a mount command in the configuration file:
You can see it in the screenshot above, right at the end: mount c c:\users\raduz\downloads\dosbox\drivec. In the drivec folder, I unzipped the Telemate archive downloaded from Vetusware. Then, when started, we can see the mounted C drive:
Above is Telemate 4.1.2. A more usual version would be 3.0, but this will have to do. We start the program using tm, which will initialize the modem and display the user interface:
The main screen was a phone book, an inspired choice allowing you to save bulletin boards or other users phone numbers easily. I remember in the late nineties playing FIFA 98 over dial-up modem with a school friend and chatting using terminal applications such as the above. Remember, there was no protocol, only ASCII text sent over the phone line, meaning after connecting to the other computer, simply typing text and pressing enter would send it to the other party, creating a simple yet effective chat app.
So, let’s connect to a bulletin board then. I don’t know many contemporary bulletin boards, except for one: The Bottomless Abyss. It is available over the web too, but for our purposes we will connect to it using Telemate. The second disclaimer is that normally, a modem would connect to another system using a phone number. Our emulated modem in DOSBox knows how to connect to other systems using TCP/IP and URLs. So, let’s go to the Terminal by pressing alt+T:
And now we can “call” the bulletin board using the ATDT call command:
Note the command: ATDT bbs.bottomlessabyss.net:2023. As we said above, this is just a reinterpretation of the original ATDT command which would only accept a phone number. Above we provide the web address and the TCP port number, connecting us to the modern-day bulletin board:
Normally this would take a while and enchant us with a very well-known modem connection sound. I cannot explain the connection sound. It was a sort of random mess of quickly pressed dial tones, which would begin to succeed at such wondrous speeds that it would resemble white noise.
Note that the screen above is already the bulletin board’s interface, which shows a “boot” screen which relates to itself configuring and negotiating client features. This is what we meant by admins creating their own protocols and interfaces and note the Abyss Operating System mentioned at the beginning. Of course, it’s not a real operating system, but it’s the bulletin board operating system, built from scratch by the administrator.
Next, we are prompted to press the # key twice, to prove that we are human: a sort of CAPTCHA human identification system. We configure next the code page, a sort of character set if you will, that ensured that both server and client have the same understanding of a given character code:
Next, we are brought to an ASCII-art Earth map, showing our approximate location (if possible):
And then we are finally dropped at the login screen:
We can create a new account by leaving both fields empty, or we can enter our user identifier and password and press enter. Again, note how we already established the communication protocol with this server. It is not a system that communicates with machines, requiring APIs and pre-defined contracts. It’s a system created exclusively for humans, for which text and key presses are enough. From here on, we can browse and interact with the bulletin board system, and I invite you to continue yourself using DOSBox.
They were indeed contrasting times, and we moved on since then. We may ask ourselves on to…what? Mainly on to formalized communications which allow computers to talk freely among themselves. After all, this is wat APIs are, and this is what REST promotes. We moved on to centralized services that offer everything bulletin boards did, but at a much larger scale and heavily automated by curation, selection, and advertisement algorithms.
We moved on to platforms instead of servers. Facebook is a platform that offers everything: news, chat, sharing, a whole experience without leaving its walled garden. Automated generic cloud systems instead of singular and faulty human operated servers. All this means more users, more content, and less work. All this means generic web sites that all look the same, that are all made to be read by machines.
Either way, thank you for following me on this short nostalgic journey back to bulletin boards era. I hope you had a fun time, and I hope you will try to connect yourself to a bulletin board using DOSBox. Thank you again and see you next time!
