From: drm@esl.com (Don McGregor)
Newsgroups: comp.sys.mac.advocacy
Subject: Re: Mac multitasking/Taligent stuff
Date: 30 Dec 92 18:04:13 GMT
Reply-To: drm@esl.com

> >     [first quoting someone else who wrote:]
> > >>*******I have never, ever, heard a single argument as to why a
> > >>*kernel* that Larry Rosenstein would call "Object-Oriented" (i.e.
> > >>written in smalltalk or obj-c or whatever) is better, either in
> > >>functionality or usuability, to the user or the vast majority
> > >>application developers, than a modern kernel like Mach.*******

Taligent vs. NeXT seems to have been coming up a lot lately.  I dug up a  
quickie meeting report I did for a users group on a Taligent talk last  
Oct; this might fuel the flames further on the need for an OOP kernel.  

There's a bunch of other stuff in here relating to the need for OOP  
development environments.

--------
ACM Meeting 10/8/92

				
Michael Potel of Taligent spoke about Pink, the new OOP environment from  
the Apple/IBM consortium.  I thought you guys might be interested in  
what's coming up in the OOP world.  He was light on the technical stuff  
because this was an open audience, but he did mention a few things.

1. He started off with a list of danger signals for the current PC  
software world:

*Fewer 1.0 apps.  Not enough people are doing really new software; just  
reworking existing applicaitons in progressively higher rev numbers.

*Creeping featuritis.  More and more apps are doing things like spell  
checking, grammar checking, etc.  This adds to the bit count of new  
software, and users pay for all those bits--programmers have to write  
them, testers have to test them, etc.  The menus start bouncing off the  
bottom of the screen and no one can find the feature they really need in  
the mass of extraneous features. 

*The upgrade price is approaching that of new software.

*Long time to market.  Powerpoint went 3+ years between major upgrades.   
Adobe Illustrator 88 was about the same.

*Big engineering teams to figure out all the nuances of the system and  
write all this stuff.  Two guys in a garage can't write the killer app  
anymore; it takes a cast of thousands and big money to bring it to market.   
A small or corporate developer can't get together the talent to do a Real  
Application.  The gurus are off doing shrink-wrap; as soon as you train  
some guys to do corporate applications they jump ship.  If you have a good  
idea and want to implement it, you need to get together a networking guy,  
an OS guy, a graphics guy, and so on.

*The tester headcounts are exceeding the developer headcounts.  (Happened  
in Mac Sys 7.0, which Michael managed). 

*Applications are doing OS work.  Too many programmers are having to throw  
away the imaging model and do their own, or write their own text objects,  
to get the functionality they need.  But to do the OS stuff you need  
gurus,which are in notoriously short supply.

*Economics are stifling innovation. Bill Gates has been quoted as saying  
it takes $50 million to bring a new product to market.  Two guys with a  
good idea can't do that.  The need for a big payoff also forces the  
company to write for the broadest possible market and sell a million  
copies to recoup their investment.  Too many 100,000 unit and 10,000 unit  
markets are being ignored because it isn't economically feasable to write  
software for them.

*Users are not upgrading. 

*There are fewer profitable software companies as the economies of scale  
force the small players out.

In the limit, there will be one software company selling WordSheet 22.0,  
which costs $10,000, required 50 gurus to write, and had 500 testers.

2. The software industry has been going through some phases.  Originally  
everyone wrote to the bare iron in assembler.  In phase 2, everyone called  
software libraries, like the Mac toolbox.  In phase 3, everyone is using  
objects. 

3. The technical goals of Pink are:

Rich Functionality		   (Software innovation)
Open and Expandable at ALL levels  (Including the OS)
OOP				   (Faster Technology curve)
Portable, scalable, adaptable	   (Supports HW innovation)
Integrated Developer Environment   (a Good Thing).

The system is intended to be open at ALL levels--hardware, the OS  
software, and the application software.  If a developer doesn't like  
something about the OS, he can rip it out, or subclass off the existing  
stuff and add his own functionality.  So it should be possible to put in a  
new graphics engine, etc.

He was not pleased by what clones had done to the hardware world, and saw  
the replacable portions of the OS as one plus for the business side of  
things.  If you put your own stuff into the OS to plug it together with  
the hardware, it makes it more difficult for cloners to copy the hardware,  
drop their margins to nil, and drive out the R&D investment.  The OS  
interface has changed in subtle ways. (He didn't quite put it that  
explicitly, but that was his train of thought.)

In phase one of the software industry (assembler and bare iron) the OS did  
a little work, the developer did a little work, and the user did a LOT of  
work--trying to integrate applications, typing in commands, etc.  In phase  
2 (software libraries, a la Mac) the OS does some work, the developer does  
a LOT of work, and the user does relatively less work.  In phase 3, more  
of the things are rolled into the OS, which frees the developer of work,  
and still provides the same or more functionality to the user.   
Furthermore, "guru" developers can add even more functionality into the OS  
and provide extra value to their customers.

He mentioned speaking to one of the early Smalltalk developers, who  
observed that what Taligent was doing was recreating the Smalltalk  
environment, back in the days when it didn't run on top of an OS like Unix  
or DOS or Mac.  Everything is an object, and can be replaced.  Nowadays  
the hardware is up to snuff, and the code is compiled and industrial  
strength, and the objects are more useful/better developed/at a higher  
level of integration out of the box.

Obviously, they can't ship the source code.  That places greater emphasis  
on good documentation for the objects and the Frameworks (see below).

4. Frameworks

Pink intends to provide a number of "Frameworks" that developers expand  
upon.  He used the NeXT Application object as an example of one such  
framework, but had in mind many more.  For example, Printer frameworks, or  
Document frameworks, or Network Communication frameworks, or Graphics  
frameworks, or a Desktop framework. A document framework would give you,  
for "free," things like unlimited undo, hot links, etc. 

He said this was one of the most difficult portions of the project;  
writing a good framework that allows flexible extensions is extremely  
difficult.  They usually wound up throwing away two or three first efforts  
and starting over from scratch.  Tounge in cheek company motto: "Taligent:  
It's a lot harder than we thought."

(There will be no PinkTalk, only objects that talk existing protocols such  
as AppleTalk, SNA, whatever.  There are a few impedance problems matching  
non-oop communication concepts within an oop framework.)

5. He said they were using C++, but he didn't seem terribly happy about  
it.  He said it was one of those 2-1/2 generation sort of things...not  
quite all the way to OOP in the promised land, and changing as a language  
still under development does.  But it did give screaming performance, and  
a solid software engineering environment with public, private, and all  
that stuff.  They will support other OOP languages, but things might be a  
little easier in C++ for developers.  He mentioned the "Dylan" language at  
Apple, and said that it was safe to assume that they had been aware of and  
working with the developers of it for some time.

6. Persistent objects.  Lots of people are going to OODMBSes to provide  
the capability for persistent objects.  (I think Sun signed a deal with an  
OODBMS vendor not too long ago, and of course NeXT has signed up with some  
guys.)  He said Taligent found that the file system guys, for example,  
would want some of the functionality of an OODBMS, but really didn't want  
all of it; the same story showed up in other sectors of the effort, but  
with different features needed or dismissed. Their solution was to write  
their own OODBMS, but to break apart the functionality so that, for  
example,  the file system guys could use only the rollback capability and  
ignore the rest of it.

7. Object management.  He envisons object management tools, so that a  
developer can go out and browse the objects that are already written.   
This would include more than just looking at the header file; things like  
the documentation, the bug history report, revision history, specification  
&c would also be included.  An analogy was the system HP uses to track  
hardware pieces; anybody can call up the history of the part, the vendor  
and alternate vendor list, the problem list, quality problems, schedule  
and cost information, and so on, from any workstation at HP.

8. When is it going to be released?  "Taligent: System Software for the  
mid-90's and beyond."  It won't be in the next few months.  Even then it  
won't immediately replace the existing tools, but rather grow into its new  
role.

[It sounds to me a whole lot like a NeXT, particularly in their intended  
initial market, but with a few nice touches.  Making it easy to replace  
pieces of the OS is kind of interesting. The market they're shooting for  
sounds a lot like NeXTs...corporations writing custom applications for  
small markets.  They were talking a lot with CIOs about what they needed  
in new products.  One mentioned that 90% of his $4 billion budget was  
going to maintenance.]

--
Don McGregor | The Revolution will have an alt newsgroup.
drm@esl.com  |