Go back to the yabbs homepage
Yabbs was conceived during my winter break in 1991 (my freshman year of college at Carnegie Mellon University). I wrote it because I was bored and because I wanted to run a BBS on the internet, but didn't know of any good software to do that at the time.
I started out being written under MS-DOS as a console program (I was going to add networking code later). My intentions were to get a system up that allowed for simple sending and receiving of public messages (no email, no talk, no g-files). It was only going to allow one user on a time (since MS-DOS doesn't have any good multitasking abilities). My plan was to merge in some MS-DOS networking code that I had hacked together for another earlier project (wall, which allowed users to telnet to a MS-DOS machine running PC/TCP and scribble one-liners). Once this was done I figured I'd have something online and hack it out from there.
I never did get the MS-DOS networking stuff merged in. When I got back to school I decided that Unix was the way to go with this stuff (MS-DOS is really braindead). I didn't personally have a machine that I could use to develop it, but a friend of a friend offered me an account on his NeXT workstation. I hacked in some unix networking code and got it running on that.
The original networking code was a mess (it heavily tied up the CPU, only allowed one user, and basically sucked). It worked though. I started to advertise what I had done on IRC in #hack and got some people to play around with it.
A little later another friend (Sam Helwig) set up i386-mach on his 386dx/25. I thought this would be a better place to test yabbs, so I set it up on there. I also decided that the networking code was pretty bad and went back to using stdin/stdout and running it as a shell. I also decided that multiuser stuff would be nice, and talk would be a bonus too. At this point yabbs was basically up fulltime on thompsontown.pc.cc.cmu.edu, Sam's 386. It was buggy though, and I only told friends about it unless I was feeling daring and then I would ask people on #hack to try it out.
At this point I decided to do the multiuser hacks. They were real hacks. Since each copy of yabbs was running as a seperate process they kept track of each other through a file called utmp.dat, which basically had the PID, user name, and some other info for each user online. When you wanted to say something in talk the program read that file, figured out who was in talk, and wrote a file with the talk message in it (one file for each of the other users on yabbs) and sent a SIGUSR1 to the other yabbs processes. The other processes then opened their files, read the message, and displayed it on the screen. Not pretty, but it worked. Soon support for private messages came as well (using a similar system) and paging too (by sending SIGUSR2 to the yabbs processes).
There were a lot of problems with this method for multiuser support. File locking never quite worked right, so two yabbs programs writing to utmp.dat or a message file at the same time would squash the file. Sometimes clients died without cleaning up utmp.dat, so users would appear to be online who weren't. And it was just slow.
Lots of other hacks went into yabbs as well because I was spending a lot of time on it, instead of spending a lot of time on school. I don't reccommend this to people :).
Over the summer I set up Linux on my machine and worked on yabbs a lot more. I got a lot of the bugs worked out and added a simple g-files system to yabbs (I think this was then, I might be wrong).
Yabbs was released to the general public when I got back. I also set it up on my machine (phred.pc.cc.cmu.edu) now that it was on the net running 386bsd. I started to get more users, and thus find more bugs. Not as much work was going into new advancements, just fixing bugs. I also realized that school was more important than yabbs and started to spend lots more time on school and lots less time on yabbs.
Yabbs basically remained the same (bad talk and all) until that summer (1993). I had been hoping to rewrite yabbs to use a client/server architecture. The main reason for this was to fix talk, but I also thought that it would be a better overall design for the system. I spent a lot of time that summer writing an ad-hoc protocol for yabbs and moving the functionality into the new client/server model. The system was designed so that the server was mostly stateless (it knew about users and what they had access too, but not about stuff like their current message base). It was done this way so that cool graphical clients could be written someday. The client basically looked like the old yabbs program, so previous users could easily figure it all out.
The system went back online that fall. It quickly became obvious that the new design was much better. The system could handle more users and was a lot more stable. There were some bugs that needed to be worked out, but that happened pretty quickly.
Around October of 1993 I made my first big change to yabbs since the summer, I switched to gopher as my g-files system. G-files were previously implemented in a bizzare manner that was a pain to setup and maintain. When I switched to gopher I also setup a gopher server on my machine (phred) and put some information about yabbs there. This really caught the attention of a lot of people and yabbs took off (something that I never thought it would do). In November of 1993 I also added support for multiple channels to the protocol.
Lots more changes came the next spring. The multichannel stuff was redone to support one user in many channels. Lots of logging stuff was added to the server so I could figure out what people were doing with it. I also cleaned up the protocol a lot so that I could start distributing the software. The yabbs system running on phred was very popular at the time which helped me to get a lot of the bugs out. By the end of that Spring yabbs was a fairly robust system and became rather stable.
It stayed up over the summer. However, in mid-August I decided that there wasn't time for me to run the system anymore. On September 4th 1994 the system was taken down. Work on the yabbs software itself is still going on however. The current system is better than ever and work on an X-based client is underway. The latest changes to the system handle email a lot better (its much faster), deal well with talk, and have a pretty strong email system.
In the future I'd like to finish the X client (its been put on hold for the time being), add support for usenet news to the yabbs server, and fix a lot of bugs in the client. One of the biggest problems with the current client is that it can only deal with 26 message bases at a time, even though the yabbs protocol does no specify a limit. With a yabbs server that can serve usenet news support for thousands of message bases will become necessary. The current client can't deal with messages longer than 99 lines either, which will also need to change. I'm not sure when any of these changes will be made, but hopefully the project will move on. Currently there are no fulltime yabbs systems running on the internet, but hopefully this will change in the future as well.
- alex wetmore
alex@phred.org