On May 13, 2013, at 3:05 PM, Nigel Williams <nigel.d.williams at gmail.com> wrote:
On Tue, May 14, 2013 at 6:59 AM, Guy Sotomayor <ggs
at shiresoft.com> wrote:
Taligent was to be part of the application
framework. The microkernel used by Pink and
the object model were "toys". Much of the consternation over Taligent at IBM
was fighting
over trying to get fundamental issues addressed (which I won't go into here...it
would take
many hours to compose a sane account).
Did some of the Taligent codebase end up in SUN's Java implementation,
perhaps the libraries?
I encourage you to add to the story of Taligent. I remember at the
time Taligent gained a lot of press attention, particularly when Apple
was struggling with what to do with their operating system and Pink
was seen as the answer.
Crap. Now I'm remembering all of the stuff about Taligent that I'd thought
I'd
forgotten.
Here's a few of the "gems":
- Reportedly it was really hard to port to new processors (they were on 68K).
Why? One of the foundation objects was written in 68K assembler. It was
needed to stream and unstream an object. It needed to know the object's
size. A normal person would have said "put the size of the object in the
object".
Did they do that? Noooo. They had to be clever. They wrote a method that
looked up "new" of the object, *diassembled* it and analyzed it to determine
the size that new was allocating.
Clever: yes, product quality: NO
- They were extremely proud of the fact that they were *only* executing 6
(count them six) machine instructions between method calls. No work was getting
done, just setting up for the next method invocation.
- They had a messaging microkernel (just like we did...except theirs was *very*
primitive). As such, messaging was fundamental to both OS's. They had
decided that the fundamental object in a messaging system was a message.
What that meant was that anything you wanted to do involved invoking a
method on the message. So, if you wanted to say create a new task, you'd
say something like msg(task.create) rather than something more sensible
like task.create(msg).
It may sound a bit esoteric but it was fundamental and their code looked
really strange and made adapting it very difficult to situations that they
hadn't originally considered.
- They were based in C++. Everything had to be in C++ (except at the very
bottom which was 68K assembler). This wouldn't fly for a number of reasons.
The most obvious being that not all code that needed to run on this system
was in C++ and wouldn't be re-written in C++. The thing that really nailed
the problem was one of software updates. Because their object model was
C++ it meant that if the object changed from one release to another everything
using that object would have to be re-compiled...the OS, *all* applications,
everything.
- They created a TCP/IP stack. In C++. It was an interesting research project.
I felt pity for the poor folks at IBM who actually had to take that code and
make it work. I think eventually, they (the IBMers) gave up and took a version
of the BSD stack and put the appropriate wrappers around it and called it a day.
I think that's enough for now.
TTFN - Guy