From: andrew@cubetech.com
Subject: Re: specifically comparing NeXT with Mac...
Organization: Cube Technologies, Inc.
Date: Thu, 5 Nov 1992 12:05:38 GMT

In article <ewright.720893515@convex.convex.com> ewright@convex.com (Edward V. Wright) writes:
>In <FISCHER.92Nov3013446@steiner.iesd.auc.dk> fischer@iesd.auc.dk (Lars Peter Fischer) writes:
>>Your analogy is hogwash. Renderman with out a display is useless. A
>>monocrome system is useful for many things.
>
>A monochrome monitor is useful for perhaps 20% of the things that
>a computer can do today.  That makes the monochrome NeXTstation 1/5 
>of a computer -- a (much) faster version of the Mac Classic with a
>large screen.

For the vast majority of people who do real work everyday, color is a
luxury and certainly not a necesity.  Furthermore, 98% of the people
who use computers use them for less than 1% of the tasks that a
computer can do (really, document processing and basic office
automation really is a pretty small portion of the gamut of a
computer's capabilities), and certainly those tasks do not require
color.  Color output is still too expensive for it to become
commonplace enough to be taken for granted (as laser printers have
become).

>Renderman, however, is one of the few remaining advantages that NeXT
>has.  Apple will soon negate the advantage of Display Postscript with
>Quickdraw GX.  NeXT has promoted its objected-oriented programming and
>development tools, but those are no longer unique.  You can get MacApp,
>TCL, AppMaker, Marksman, etc. on the Mac -- at a fraction of the cost.
>NeXT programmers say, "there's no comparison, NeXTstep is so much better,"
>but they're never able to say *how*.  Display Renderman, on the other
>hand, is neat.  A very elegant way of creating impressive 3D graphics 
>-- which you then have no way to display on the NeXT.

Not so at all!  Unless I am misinformed, QDGX won't fix the real
problem with drawing on Macintosh.  The real problem isn't the power
of Quickdraw or lack thereof compared to PostScript, but the fact that
with DPS, you have the same imaging model for _all_ output.  Unless
QDGX is a DPS clone, you are still where you used to be: you still
have to write code to draw to the screen, and code to draw to the
printer.  A unified imaging model is the biggest win with DPS.  It
also happens to be really powerful, but the fact that I only have to
write my drawing code once is the biggest win.  The fact that
PostScript is a real industry standard for imaging is also a big win
as well.

You can't get "MacApp, TCL, AppMaker, Marksman, etc on th Mac -- at a
fraction of the cost."  A NeXT computer suitable for development (lots
of ram and a good sized disk) (which comes with the entire development
system for free) costs less than a Quadra suitable for development
with all of the things you mentioned.  Regardless, the cost saved by
developing on NeXTSTEP as opposed to Macintosh totally negates any
kind of cost saving you may or may not get with either machine.

Macintosh, even with MacApp, TCL, AppMaker, Marksman, and whatever
else they've got now, you still aren't getting the same thing that you
get with NeXTSTEP...and I'm going to tell you why.

First of all, with NeXTSTEP, you develop in Objective-C rather than
C++.  C++ does not support the dynamic binding of objects and
messages.  The compiler rather than a run-time system determines which
objects sends what messages to which objects.  This is really
important, and I'll get to why in just a sec.

Interface Builder is one of NeXTSTEP's greatest strengths.  However,
the strength in Interface Builder really comes from obj-c.  Sure,
you've got Prototyper or Marksman, and I guess AppMaker is one as
well.  What do these programs do?  You "paint" your interface, and it
generates a shitload of code.  You take this code and you "flesh it
out."  What happens when you have to change this interface?  You
change it in the InterfacePainter, it generates the code, and you have
to re-hook in your code and recompile the whole mess.

Interface Builder is different.  When you "draw" your interface, you
are really creating the actual objects that will be instantiated when
your application is run.  What you create is saved to a system file
type called "nib" which is readable by an object class called
Application.  No code is generated, and you can create links and
associations that you can reference in your code.  When you make a
change, you don't have to re-integrate your code with the interface,
and you don't have to recompile.  With NeXTSTEP you really spend less
time dealing with interface code whereas with Marksman and similar
products on Macintosh, Windows, and X, you just write less of the code
yourself, but there are additional hassles while at the same time you
aren't fixing the real problem: eliminating code you shouldn't have to
deal with from your app.

This is made possible by obj-c, which dynamically binds objects at
runtime.  But there is a lot more to NeXTSTEP besides interface
builder. Like:

Distributed Objects - IPC done right.  Have you tried using
AppleEvents?  They suck.  They are a pain to implement, you are
limited to sending 32k, and I don't think they work over the network.
DO's let you send messages to objects *exactly* as you send messages
to objects normally, but the recieving object can be in your app, in
anther app on the same machine, another app on another machine down
the hall, or another app on another machine in a different state (I've
personally done this).  The code is identical.  The only difference is
how you instatiate the recieving object. So instead of this:

myObject = [[FooClass alloc] init];

you say:

myObject = [NXConnection connectToName:"myName" onHost:"*"];

That is the only thing that's different, and it's unbelievably
powerful.  myObject is a proxy for the real object that is in an
unknown location.  Dynamic binding makes this possible.

But the biggest thing going for NeXTSTEP is all the free code you get.
That free code is the collection of objects that make up the entire
programming environment.  All of these objects: Responder,
Application, Window, Panel, SavePanel, OpenPanel, PrintPanel,
FontPanel, NXHelpPanel, NXDataLinkPanel, NXColorPanel, Menu,
PopUpList, View, Box, NXSplitView, ScrollView, ClipView, Text,
NXColorWell, NXBrowser, Button, Scroller, Slider, TextField, Matrix,
Form, Pasteboard, Cell, NXBrowserCell, SelectionCell, ActionCell,
FormCell, ButtonCell, MenuCell, TextFieldCell, and SliderCell to name
a few user-interface objects from the AppKit alone (there are more in
that kit, along with 3DKit, IndexingKit, DatabaseKit, MachKit,
NetInfoKit, PhoneKit, plus more objects that aren't in kits).  All of
the objects, protocols, and functions in NeXTSTEP are designed to, and DO
work together.  Does MacApp work seamlessly with TCL, and can you draw
your interface in Marksman using either MacApp or TCL objects?

NeXT objects do most of the drudge work for you when writing an an
app.  The AppKit provides classes - most notably Window and View -
that make drawing on the screen "exquisitely succinct."  Most of the
unromantic work that's involved in drawing - communicating with
hardware devices and screen buffers, clearing areas of the screen
before drawing, coordinating overlapping drawing areas - is taken care
of for you, leaving you to concentrate on supplying code that simply
draws.  Even this is assisted by many of the other classes and a
number of C functions that provide drawing code for you (all of the
interface objects know how and when to draw themselves).  This just
isn't what happens on Macintosh, even if you have every single
development tool that you can get.

Event handling;  this is a joy on Macintosh (O.K. Mouse down.  Now,
was it in a menu? no, was it in a window? etc ad nausium). not.  It's
extremely easy with NeXTSTEP.  The Responder class, which is an
abstract superclass that all interface objects that respond to user
events inherits from, handles all aspects of event handling.  You just
fill in the blanks (like exactly what this object does when it recieve
a mouseDown: message or whatever).  The Application class
automatically delivers the event to the right object without you doing
_anything_.

There's so much more, but I'm tired (gosh, it's 6 a.m. - almost
bedtime!) and I still have stuff to do.

>
>>NeXT has colour, too, but they do not have small screens. 
>
>Yeah, they have NeXTdimension.  "Color for the rest of us" --
>where the rest of us is defined as people like Steve Jobs and
>Ross Perot.  If you can afford to spend $60 million to buy a
>Presidential election for a buddy from Arkansas, you can afford
>a NeXTdimension.  If you can't, you can't. :-)

Who buys NeXTdimensions?  Nobody I know.  They all buy NeXTstation
Color's and NeXTstation Turbo Color's.



andrew
-- 
andrew@cubetech.com     | "Carpe Nocturn - I get more work done after
Andrew Loewenstern      |  2 a.m. than most people do all day."
Cube Technologies, Inc. |                          - Simson Garfinkle