Do You Remember Bob?

GdoL writes: "Do you remember Bob? Byte's editor starts his monthly column talking about Bob the OS Interface from Microsoft in the middle 1990s. And he didn't forget either Bob the programming language from a former technical editor of Dr. Dobbs Journal, David Betz. This OO language is widely use on 'DVD players and set-top boxes produced by the likes of Toshiba, Samsung, and Motorola.' Do you remember any other language long forgotten that is still used in the real world?"

Comments

BOB UI and WinXP

[mESSDan]

While reading the first article, I was struck by something strange:

In the picture of the Bob UI, it shows a little dog who has a caption bubble coming from his mouth. Well, in WinXP if you do a file search (hit F3), you'll see an almost identical dog.
Maybe Microsoft thought that Bob was ahead of its time?
Anyway, it's strange.

SNOBOL4

[geophile]

The greatest string processing language of all time. Blows away Perl. In SNOBOL4, the space was (is!) an unbelievably powerful pattern-matching operator. A single match could break apart a string and assign variables with pieces of it. A single statement could succeed or fail, and then there were up to to transfers of control at the end, one for success and one for failure.

SNOBOL4 was completely flexible on type, (e.g. you could do "5" + 3); had dynamic memory allocation and garbage collection; had the ability to evaluate dynamically generated SNOBOL4 ... the list goes on.

It's probably still in use, and it was bizaare and wonderful. I also have fond memories of two compiler courses taught by RBK Dewar, one of the implementers of the Spitbol implementation of SNOBOL4.

Bob the language

[p3d0]

Just in case anyone is wondering...

It's hard to find any documentation for the Bob language. Having a quick look at some Bob source code, it is a simple OO language without classes, where subclassing is the same as instantiation, much like Self or Cecil. It seems to support only single inheritance, though I gather it's dynamically typed, so there's no need for "interface inheritance".

It's not "purely" object-oriented, since you can define procedures that are not methods of any class. At first glance, there doesn't seem to be any access control: all features of an object are public.

Re:Bob the language

[BlueGecko]

(Disclaimer: I'm not an expert in prototype-based languages, but I'm fairly confident that the description below is quite accurate. Corrections are, therefore, very welcome.)

Languages such as this are called prototype-based languages, and are generally seen as the successor to object-oriented programming. However, no prototype-based language has, to my knowledge, actually gone anywhere (the one that got closest was NewtonScript, which would have made it if it weren't for the fact that the only place to use it was on the Apple Newton), so it's nice to see that at least one actually made some progress towards general acceptance.

For those unfamiliar with the concept of prototype-based programming languages, Bob (and all prototype-based languages, for that matter) are by their very nature single-inheritence. The general idea is to eliminate the whole idea of classes, and instead treat everything as an already existing object. You them modify those objects as necessary, and, if it's an object which is handy, you just make lots of copies of it. I find it much clearer to use the word "copy" instead of "initiate," as you did for this reason. For example, define anObject = new Foo() makes a new copy of the already existing Foo object, that will have all of the same values, etc. as Foo. You can then modify that copy by adding new values as necessary.

The reason I make this distinction is that one of the powerful things you can do in prototype-based languages is give an instance of a class a new function. For an example of when you'd want to do this, let's say you have a Canvas object in a GUI. Now, you, at some point, are going to need a screen, and the screen is going to need some variables and methods you don't need for a standard Canvas (for example, Screen.refreshRate or Screen.setColorDepth()). The normal way to do this in a regular OO language would probably be to declare a subclass of Canvas that had the extra functionality, and then to make a single instance of it, probably called theScreen. This is awkward, however, because, 99.9% of the time, you really only want one screen object, so making a subclass just for a single instance seems odd. In a prototype-based language, however, you'd simply "copy" a new instance of a Canvas (called theScreen) and add your extra methods and functionality specifically to that object. Ultimately decide that you really do need multiple screens? No problem! Probably you'll want to add a monitorNumber attribute directly to the already existing screen object, and then make a copy of that. Similar functionality is also present in Dylan, and, by extension, probably LISP's CLOS, although I'm honestly just not familiar enough to know.

Re:Modula-2

[Anonymous Coward]

There are still currently supported M2 compilers with new versions every year or two. It's popular for some embedded applications. M3 looks to be almost dead, no matter how nice. Only one compiler available, few libraries, add-ons, fancy UI's, etc. Should have been, but it isn't. IDK of any really major apps using it.

Re:How about Fortran

[Mr. Slippery]

Does anyone outside of academia still use Fortran for anything?

It's still used in scientific applications. I know three years ago, when I contracted at Raytheon STX (formerly Hughes STX...reasonably big name in aerospace), the guys who did the number crunching side of things worked with FORTRAN a lot.

Eric Raymond's retrocumputing museum

[wstearns]

For those interested in old languages...
"The Retrocomputing Museum is dedicated to programs that induce sensations that hover somewhere between nostalgia and nausea -- the freaks, jokes, and fossils of computing history. Our exhibits include many languages, some machine emulators, and a few games.

Most are living history -- environments that were once important, but are now merely antiques. A few never previously existed except as thought experiments or pranks. Most, we hope, convey the hacker spirit -- and if not that, then at least a hint of what life was like back when programmers were real men and sheep were nervous."

http://www.tuxedo.org/~esr/retro/

Re:Don't blame Lisp!

[Jobby]

It was Alexander Graham Bell who invented the telephone, by the way...

Re:The disaster that was Bob...

[Maigus]

Not Quite.
Karen Fries was the driving force behind Bob. Melinda was just part of the PM team associated with it.
I was on that team as a contract tester. It was my first job after dropping out of college. I'm terribly surprised I still work in the industry after being associated with that disaster. I did come away with some entertaining memories, however.
The original project codename was "Utopia" (actually, it might have been Utopia Home). I've still got a T-Shirt with the Petie the Parrot character on it and Utopia scrawled across in a kind of abstract architect font.
When the name Bob was revelaed, there was a meeting of all the team members and a bunch of muckety mucks. This incredibly cliche marketing consulting team was the group which came up with the name. They were all up in front of the room in their black turtle necks and black plastic framed glasses.
When they got through their powerpoint presentation to the name and the glasses wearing smiley face icon the room was deathly still except for Karen Fries excited squeal and clapping. She looked out over the crowd assembled and started to look cross - we got the message and started clapping.
Now I've been involved with more than a couple doomed projects since then (perhaps I'm some sort of CS pariah) but I've never seen a group of people so unhappy and depressed about their work.
A little while after that, I believe, Melinda got her engagement ring. There was another big party. The joke I always tell about that event is: "It was a pitty about her arm..." I'm sure, being a geek that Bill felt he had to make up for something there and prove to the world that this relatively attractive woman was indeed taken. The rock on her ring was as large as one of my knuckles. There's no way when wearing that ring she could put her hand in a tight pocket. It was one of the most ridiculous and sad things I've ever seen, yet there I was saying, "Wow, that's... great!"
We knew when we were working on Bob itself that it would be a disaster. At the time, Pentium computers were just coming out in the consumer space. A P90 was reqiured to run Bob with any sort of usability. Most of it was written in VB, back when VB had no chance to rival C in any task and just using the product was painful. These computers were 3-5 thousand dollars and we expected new computer users to buy them just to use a piece of even less functional than MS Works software?
The whole thing would have been unbelievalbe to me if I hadn't lived it myself.

GUI's still aren't good enough

[olevy]

OK, first I have to admit that I was one of the developers for Bob. Don't hold it against me, it has been a long time since I worked for Microsoft. Most of the other Bob developers have long since left as well.

Bob, was one of the very, very few truly creative product attempts for the general market Microsoft has ever made. The first version was deeply flawed, but it also had some very good ideas. Microsoft is not very comfortable with the messiness of creativity and so like a foreign microbe Bob got expelled before these problems could be fixed. Version 2 got cancelled just a week before going into general beta.

The product started out as skunk works, and if it had stayed like that, we might have done a better job. However, I think the biggest curse was that mid-project our Product Unit Manager (PUM) became Melinda French, soon to become Melissa Gates. Melinda never had much direct say in the product, but she was obviously very well connected. We then got showered with money and developers and it went to our heads. It has become a very good object lesson to me on the dangers of over-engineering.

What I find distressing, though is that the good ideas that were in Bob are ignored, and no other product seems to be picking them up.

Here are some of the key ideas:

* Menus are not necessarily the best UI. Think about it; they are passive, they quite often show lots of options that are in appropriate, and the commands are stuffed in all sorts of weird places. Even experienced users have trouble finding some of the options.

* A shockingly high percentage of people are still scared of computers. If you are truly going to create consumer software you have to address this somehow.

* UI is a conversation. GUI's are built on the realization that we are very visual creatures. But what about tapping into our sociability? We are very social creatures. There is a body of evidence that shows that people interact in a social way with their computer (really!). That is where the characters come in -- in extensive usability tests we found a real benefit to them. They helped allay the fear factor and they served as a useful UI metaphor -- UI as a conversation. By the way, the characters were always completely optional -- there was a very easy way to turn them off completely.

*Task basked UI. Most programs are general purpose programs that do quite a number of things. The only problem is that the vast majority of people only use a small fraction of the features. One solution is to take the code for word processing and present it as a family of specialized tasks. So you would end up with a letter writer, a report writer, an e-mail writer, a list maker, etc.

I wrote Bob's Letter Writer. This may sound like a weird specialization, but since we knew that people using this particular program were just writing letters, we could do a great job of making mail merge easy, and also doing neat graphic effects (ala Publisher) that would appeal to someone writing a letter to a friend.

* Files are a low level concept. I mean really -- why should the common user have to care about such a geeky thing as a file? They just want to get their document. They could care less about whatever low level construct the developers have come up with to store this information, and really they shouldn't have to. It is weird that we still do not have an object oriented OS. My biggest disappointment with Linux is that it has done very little to push forward truly new ideas (I'm still rooting for it though).
On a technical side, the reason why Bob performed so poorly was because we tried to create the very first OLE component system that worked just as well for C++ as for Visual Basic. VB was not yet up to the challenge, and yet most of the apps were done in VB. We also used every Microsoft technology (the Jet database engine, the Quill word processing engine, VBA, etc.) and yet machines of that time only had 4 megabytes of memory! We required way too much memory for the time -- probably around 12 MB. The graphics looked bad because we had such a tight memory budget that we did not use any bitmaps at all. Everything was done with meta files (vector objects). On top of that we had to write to Windows 3.1 -- 16 bit programming.