BBS/Gtalk History

From Thu Aug 16 18:59:25 2001
Date: Sun, 19 Aug 2001 14:17:07 -0700
From: David Jeske 
To: Jason Scott 
Subject: Re: BBS Doc
Message-ID: <>
References: <> 
Mime-Version: 1.0
Content-Type: text/plain; charset=us-ascii
X-Mailer: Mutt 1.0pre3i
Status: RO
Content-Length: 19533
Lines: 394

Hey Jason,

Here is a brainstorm of things I remember. I apologize if I included
too many irrelevant details, remembering all this stuff inspired me
quite a bit. Feel free to ask about anything you'd like more
information about.


I grew up in a suburb of Chicago called Glenview, IL. I was about 15
when I first started into the BBS scene. A friend of mine had just got
one of those 'dial yourself' 300 baud modems. I went over to his place
and he and I spent an evening just getting the thing working and
dialing a few systems. I just had to play around more, so I somehow
convinced him to let me borrow the modem. A few days later, I was
giving the modem back after getting completely hooked. 

My parents were a few years divorced at the time and both of them were
against the idea of getting me a modem. My mother because she didn't
know what a modem was, and my father because he did. However, I was
working at a local Taco Bell at the time and that's where I got my
first modem. Not by saving up and buying one, however. It turns out an
old POS system they got rid of long ago made use of an original Hayes
1200 modem. After some badgering, I convinced the store manager to let
me take it home and my BBS career was born.

I spent most of my early days calling Apple II BBSs, and Diversi-Dials
from my Apple //c. Unfortunatly call packs were disbanded right around
the same time I found the BBS scene, so I had to be careful about
where I called. The systems I called most were:

  1) The Flying BBS (later the Flying BBS II)
     Apple II BBS run on GBBS/ACOS 
     Deerfield, IL
     Run by Grant Speakman (Eternal Ponderer)
     last contacted at:   (3/2001)
  2) Point Zer0 
     7 line diversi-dial
     Highland Park, IL
     Run by Sue ?? (Zer0)
  3) Igloo
     public-access UNIX system
     connected to the Internet via UUCP for email/news
  4) Hemisphere
     Apple II/Mac BBS run on GBBS/ACOS
  5) Magnetic Field Elite (MFE)
     Apple II BBS run on heavily modified GBBS/ACOS
     Run by Eddie (The Magnet)
  6) Vortex
     7-line diversi-dial
     Northbrook, IL
     Somewhat short-lived ddial run by Andy Doane and
      Grant Speakman (from Andy's house I think)
  7) ??
     GBBS ACOS, followed by a fancy MACOS system
     Barrington, IL
     Run by Rob Levitsky

Other cohorts of mine at the time were Dan Marks (Disk Cruncher) and
Andy Doane (AgentX).

Grant and I met on his BBS. I bought a 2400 baud USR Courier from him,
and when I visited his house and "the system", I also got to see
several of the Remote Controlled planes his BBS was named for. I also
had an R/C plane so shortly after that we became friends and
occasionally went out to fly RC planes. Once or twice I had the honor
of helping by watching the system while he was on vacation. While
working with the Flying BBS I learned ACOS, the interpreted
programming language that was part of the GBBS Apple II BBS system.

Around the same time, I transitioned from jr. high school to high
school. I was just getting into programming in 6502 assembly on the
Apple II and I needed help. I asked around and school and was
introduced to Daniel Marks (Disk Cruncher), who was the local computer
and Apple II whiz. It turns out Dan was always working on BBSs making
some type of mod or another. One of the ones I remember pretty
distinctly was a typing-speed-test which was installed on MFE. It had
online users type statements like "The quick brown fox jumped over the
fence" as fast as possible, and turned it into a big contest by
showing the top-five fastest typists on the system.

The Hemisphere was loosely connected with a local computer shop, so
they always had hard drives of one type or another for sale. They also
had a table at a local swap-meet where BBS users would occasionally go
to buy computer upgrades of all kinds.

However, while I enjoyed logging onto the local BBSs, checking the
messageboards, and downloading some software. I quickly started
spending the majority of my time on the local ddials, since they
offered a chance to interact with others online in real-time.

Somewhere in the midst of all this I upgraded my Apple //c to a IIgs
purchased used from Chris Trimble. The IIgs had cooler sound and
games, but overall wasn't that different. I spent most of my time
running ProComm+ to access BBSs. Soonafter, Chris, Dan Marks, Mike
Fleming, and Rob Levitsky formed a small programming group called
Jupiter Systems.

*** The Apple II era ends, and our scene moved to the IBM PC ***

By 1991, the Apple II scene was really starting to die due to Apple's
languishing support and rumors of the dead Apple IIx. Most of the
members of the Apple II scene resented Apple for it's dropping of
their loved Apple II. Furthermore, the Macintosh only provided a very
high-level point and click interface.  Compared to the Apple II's
integrated assembler, the Macintosh was a toy, not a programmer's
computer. Most people I knew from the scene found more of what they
were looking for in the now nearly affordable IBM PC.

I sold off my IIgs and got myself into the PC world with a $2500
386dx25. I was hooked up with a fast new PC. I had a 9600 baud
modem. Ironically, much of the time it was all reduced to a Qmodem Pro
screen talking to a 300 baud ddial system, very similar to those early
days with the //c.

I had found a few new IBM centric BBSs to call. Including:
  1) The Lunatic Phringe
     first running some free BBS and then Gtalk and 
        much later MajorBBS
     Buffalo Grove?? / Barrington??, IL
     Run by Dave Wrisley (Phobos)
     last contacted at:  (7/1998)
  2) ??? one or two local BBSs
     Glenview, IL

*** My programming career gets started ***

Around the same time, my high-school became involved with a
math-education project hosted at Argonne National Laboratory. They
needed a few students, and hopefully one with some programming
experience, to work on the project over the summer. Better still, they
were using these cool black machines, with beautiful 17" screens, made
by the fledling NeXT Computer. I spent the summer after my high-school
Sophomore year in a University of Illinois at Chicago (UIC) grad class
about NeXTStep programming, learning to write graphical applications
for this math education project.

When school started up in the fall, everything had changed. I had gone
from from stuffing Taco's at the local Taco Bell to spending most of
my free-time programming on the NeXT lab at school. About mid-way
through the year, after I had written some useful software for the
project, the project provided a loaner NeXT machine so I could work
from home. When the next summer rolled around, the math-ed project
(who was also connected to UIC) needed someone to teach the NeXTStep
programming class, and so they asked me. I was a bit nervous about
being a high-school almost senior 

As the summer started, my friend Dan Marks came back from his first
year at University of Illinois at Urbana/Champaign. The MathEd project
was hiring, so Dan too became enlisted as a NeXT programmer. It turned
out that the NeXTStep class would be much more work than I had
expected, because NeXT had released a new OS and dev-tools. Dan and I
worked on new programming samples and new course materials for the
class. When the class started up, I was standing at the head of the
room going over slides, and Dan roamed the room helping people with
the programming exercises.

*** The Birth of Gtalk ***

Around the the same time the class started Andy, Dan and I got to
talking about how we wanted to setup a chat system. We didn't want to
use any of the old-300 baud ddial stuff. We wanted it to be fast and
modern. About a year back, Andy had tried to buy a fledgling piece of
chat software for the PC called STS (Synergy Teleconferencing
Software). However, they were in the very early stages and never
shipped him any working software. We checked out STS, and not only was
it expensive, but it didn't strike us as the modern system we were
looking for. For example, email was still a single line "/e### "
type command just like ddial.

We searched further. We found a sytem called Excalibur on the south
side of Chicago which was running a home-grown chat software called
X-Link. We were interseted in it, because it was a bit nicer than STS
and was right in our backdoor. We convinced the author to come up to
the city and meet us one day after our class session at UIC. We wanted
to know what he was up to, so we asked him to bring a printed copy of
the source code that we could take a look at. We chatted with him
about what he was up to and Dan looked over the code.

After the meeting, Dan declared that we shouldn't run his
software. Apparently, just like STS, and ddial before that, X-link was
written in a model called "state tables". This basically meant that
program flow for a given online user was not-linear. The software
manually iterated through users, figuring out was state the user was
in, and called the right function. The resulting code looked something

  for(int n=0;n< num_lines; n++) {
    struct line_struct *state = &lines[n];
    if (state->main == LOGGING_IN) {
    if (state == CHATTING) {
    if (state == LOGGING_OFF) {   

Each of those handle_* functions ended up with similar if trees,
checking state to figure out what to do. Dan had recently read a book
by Herbert Schlidt called "Born to Code in C". In this book there was
sample code for a stack-based cooperative multi-tasker. With it, we
could write the above program as s simple linear thread:

void start_thread() {

The stack held all of the state for us. Dan was convinced that we
should write our own chat software. He went home and coded up a simple
stack-based multi-tasker based on the examples in the book. A day
later, when we returned from class, Dan presented me with a simple
program. When I ran it, a simple text screen with asterisk's
sporadically moving across the screen came up. He explained that each
was running in it's own thread, the multi-tasker worked. Another day
later, and he had some simple serial port routines worked out. Andy
and I were impressed. Neither of the two of us knew much about talking
to serial ports or writing multi-taskers. However, Andy and I had big
ideas about what we wanted a chat system to do.

Dan kept working at the core features, while I started integrating
those into something which looked like a BBS. First a login prompt,
then a chat room. Little by little the software came together. Andy
and I designed the look of the chat rooms after what we knew best,

Around the same time, Andy got on the phone with Illinois Bell to
complete a far harder task -- Getting 10 phone lines installed into a
residential home with residental pricing. Ten phone lines would
distinguish us from the ddial systems around which were limited to
only 7 lines due to the Apple IIe's 7 available slots. Several phone
calls and one vice president later, Andy had successfully convinced
Illinois Bell that our hobbist cause was noble, and they agreed to
install the lines.

We also needed a name for the software. We enlisted Mike Fleming, who
was enrolled in the NeXTStep programming class so that he could work
for MathEd as well. The three of us were brainstorming after class,
and since we kept talking about how it was going to do everything
under the sun, one of us suggested "GinsuTalk". With Dan's famous line
"It slices, it dices, it could cut a tin can but you wouldn't want it
to", we had named the software.

After three weeks of teaching downtown from 1-4pm, programming every
other waking hour, and watching Illinois Bell trucks run around the
neighborhood to pull more lines in for our install, we were nearly
there. A full-day pizza party with a few friends got us the expertise
and help we needed to route cabling for 10 phone lines into my
bedroom. Randall Swanson, another high-school friend of ours, had
chipped in by purchasing many of the modems we would need to get the
system up. We had opted for all 2400 baud modems, another factor to
distinguish us from ddial. That satisfying afternoon, only three weeks
after we had decided that we wanted to write our own chat software,
GinsuTalk was accepting it's first caller on the system which bore a
name Dan had always wanted to use for a BBS, Nuclear Greenhouse.

However, the featureset was rough, and the system was new and
unstable. It was another few weeks of fast coding before GinsuTalk was
stable enough for the locals to start considering it a home. Over the
following year, the distinct flavor of Gtalk took shape, including a
full BBS style email and newsgroup system, and our nifty ansi-color
and extended IBM character system which allowed colors and funky
characters in people's handles, as well as in their conversations.

*** GinsuTalk becomes Gtalk ***

My first semester down at UIUC, Andy and I roomed together in an
on-campus apartment. We spent quite a bit of time working on
Ginsutalk, and dialing into Nuclear Greenhouse through an Internet
dialing link we had access to. GinsuTalk had been in development (and
in use) for a little over a year. It was then that we found our first
customer. Or perhaps I should say our first customer found us. 

Bill ?? ran a system in Vancouver, B.C. on diversi-dial called
Elusive Deceptions. The local STS system was slowly getting traction
and he needed to combat it. STS, like ddial before it, would only
license one system into an area. He stumbled upon Nuclear Greenhouse,
and simply had to have the software were running. We explained to him
that it was still a beta product and not yet stable. However, he
insisted that, regardless of it's completeness, he would happily pay
us $300 for the software. This was a hobby project for us, $300 seemed
like alot of money for something that we were doing for fun. We jumped
at the chance and immediately started preparing to ship our first
copy. Randall, with a bit of legal knowledge, wrote our licensing
contract. Dan and I made the system so it could be configured and
installed a copy-protection scheme.

There was one other task at hand. We had to change the
name. Previoulsy this was just a fun project. It didn't matter that
the base of the GinsuTalk name was a trademark plastered all over
knife commercials in the US. However, we were talking about serious
business now. We were concerned that if we ever made any real money,
they would come after us. Thus we shortened the name to "Gtalk".

Bill was the first customer of Gtalk, but he was not the last. It
turned out to be more work that we had thought to ready the software
for sale, and still more work to support a customer so we decided we'd
better get something for all this work. 

The chat scene was a remarkably small one. Each major city could only
support a few multi-line chat systems. Chicago was extremely well
represented, because it was so large. At the peak, Chicago had as many
as 7-10 ddial systems running at once. At this point, we had Gtalk
systems in Chicago, Vancouver, and San Jose. We wanted to branch out,
but STS had already taken hold. The cornerstone STS system was in New
York and called "The Jungle". With over 20 lines, it was easily the
largest chat-dedicated system we knew of at the time. We talked to the
sysop, to figure out if he would consider switch to Gtalk. He was open
to the idea, but was concerned about the cost.  

When they got started, STS had decided to help reduce the cost of
installing their software by building their own serial boards. These
boards were bundled with their software and provided an affordable way
to hook up many modems to a PC. They also provided lock-in for
STS. These serial boards were custom, so nobody else supported
them. We, on the other hand, had decided to use off the shelf
multi-port serial hardware. It was slighly more expensive, but allowed
us to keep the chat system a software-only problem. 

We didn't yet have an easy solution for him. 

[[ I'm not sure if this was before or after SynerChat 

Around then, someone I hadn't heard from in quite a while stepped into
the picture. Dave Wrisley, owner of "The Lunatic Phrings", decided
that the IBM BBS scene was old-hat. He wanted to run a chat system, so
Lunatic Phringe became the third Gtalk system. He was a much easier
customer to work with, because he was in Chicago and unlike the rest
of us, had a real job.


*** Competing with STS ***

The next year at UIUC, Dan, Andy, and I were three out of four
roomates in a college style "quad" apartment on campus. Gtalk was in
full swing, getting our non-school spare cycles on a regular basis. In
addition to working on the software, we were now out looking for more

Around that time Joe Cram, the owner of SynerChat in San Jose,
stubmled upon Nuclear Greenhouse and Gtalk. He was running STS, but
preferred the more BBS-like featureset of Gtalk. I happened to be
visiting the San Jose area for NeXTWorld expo in December, so we met
up to chat. He showed me SynerChat, and we talked about Gtalk a
bit. Soonafter, we sold our third copy of Gtalk, and SynerChat was

Joe gave us a foot into the STS world. We wanted to know more about
STS software and this custom hardware. With him running Gtalk, he had
no need for his STS setup. We felt that if we could support STS's
hardware, it would be easy for us to convince others to switch from
STS. They would have no hardware to buy. Just a simple software
license fee from us and they would quickly be a Gtalk
system. Soonafter he switched over to Gtalk, Joe lent us his STS
software and serial board.

As soon as we received the board, Dan set to work. He stripped labels
off the chips to find out what was really in there and sent off for
databooks. After building some customer circuits to figure out how the
chips were connected, he had the first simple driver working. We
worked quickly, and soon Gtalk could support STS's serial boards. 

However, Things were not as good as we had hoped. STS only supported
1200 baud, and because of that, they cut corners by not including
interrupt support in their serial board. Gtalk could run on this
serial board, but our multi-tasking software relied on serial
interrupts to guarantee we didn't lose characters. It was not a
perfect match. Furthermore, even with support for STS's serial board,
the sysop of The Jungle was not interseted in switching. He was happy
with STS, and so were his users.

So we set all that STS stuff aside. We had other problems. Our system
was running 150 miles away from UIUC back in my bedroom in
Glenview. All our work on features over the previous couple years had
rendered the system a bit unstable. DOS just didn't cut it
anymore. Joe Cram had some success running the entire DOS based BBS
under OS/2. After investigating, I decided that it made sense just to
_port_ the software to OS/2. That would give us real threading, and
protected memory. Three weeks later, Gtalk was running under OS/2. The
users didn't know a thing. The software ran largly the same (although
not quite as fast). However, due to the better development environment
and real debugging, I was able to shake quite a few bugs out of the
system. Overall the system was stable. 

( port to Linux, June 1995 )

David Jeske (N9LCA) + +