--> BBS/Gtalk History

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: grants@trotts.chi-town.org (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: dwrisley@ivexpackaging.com (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 like:

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

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() {
   handle_login();
   handle_chat();
   handle_logoff();
}

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, ddial.

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.

Glen & 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".

Glen & Bill were the first customers of Gtalk, but they were 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.

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 customers.

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. Soon after, we sold our third copy of Gtalk, and SynerChat was born.

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 )

--> What is Gtalk?

Gtalk is a multi-line teleconferencing package will full email and message base capabilities. It also has the capability to link multiple systems togeather into one large conference.

--> When and how was Gtalk started?

Gtalk was started in July of 1992. It was authored by myself (David W. Jeske) and Daniel L. Marks. The first Gtalk system went online on July 27th,1992. Originally it was written for MS-DOS. It had it's own multitasker to allow it to efficiently handle many users online. Over the next five months, Gtalk was under rapid development. In March of 1993, Magnetic Visions, a chat system in the Vancouver B.C, Canada, area, became our first customer for the Gtalk product. Others followed, but as more systems which were less tolorant of downtime and failures inevitable when running under MS-DOS, the nature of Gtalk needed to change.

It was not until March of 1994 that Gtalk spread wings and flew from the clutches of MS-DOS from which it was born. It was ported to OS/2 in under a week. A testimant to both the modular design of Gtalk, and the powerfull threading capabilities of OS/2. Immediately, systems began to adopt the OS/2 version of Gtalk.

--> Gtalk takes flight once again

In the Summer of '95 Dan and I re-write Gtalk for UNIX. This time everything was rewritten from scratch. The goal was to strike a good balance between integrating native "UNIX" tools (i.e. by using UNIX style mail and news handling) and custom Gtalk functionality. This provides an easy to use system which far surpasses the capabilities of the common UNIX shell script BBS. (or heavily integrated compiled based systems)

--> Who are the authors of Gtalk?

David W. Jeske
Daniel L. Marks

Source taken from: bbsdocumentary.com