[comp.sys.amiga.advocacy] Clueless Mac people speaking in the Amiga area. :-)

lrg7030@uxa.cso.uiuc.edu (Loren J. Rittle) (01/21/91)

jsd@wahoo.rice.edu (Shawn Joel Dube) writes:
<Silly diagram deleted, not by Shawn, BTW>
>Seriously, I think cooperative is better. Take the following for example:
>Two task are running.  One is waiting on a keypress (via OS subroutine)
>and the other is doing some serious number-crunching.  With the Amiga, valuable
>time is being spent doing nothing (waiting for a keypress).  With co-op
>multitasking, almost all of the cpu time is spent with the number cruncher.

Sir, you have no clue what you are talking about.  If the process waiting
for the keypress uses the standard AmigaOS mechanism, then the task will
be removed from the ready queue, making the other more CPU intensive
task the only task in the ready to run queue!  Only the apporiate
interrupt/signal will bring the waiting task back into the ready
queue.  While a task is in the waiting queue, no CPU time whatsoever
is wasted on the task!  So, no valuable time (as you claim) is spent
``doing nothing.''  See any good book on the Amiga Exec for how this works.
Or any good book on OS design, should give you general information.

>Yes, I agree it would make the system somewhat unstable but I don't consider
>this a problem except when playing games or doing animation.


>|>   Can Mac programs talk to each other? send signals, semaphores? 

NO, not in an OS supported way.

>
>If programmed to do so, yes.  I believe in the next release of the Mac OS,
>the ability to have something like Window's Dynamic Data Link will exist
>that the Amiga (correct if I'm wrong) doesn't have.
>

First things first:
The Amiga does not have DDL per se, but the low level functionality
is in the AmigaOS to support it.  I think most people would agree that
with FS update notification (in 2.0) and/or ARexx (had since 1987)
you can do the same sorts of things as you can with DDL.  Of course,
the Amiga has supported message passing between applications since
day one! And DDL is just a high level service layer on message passing.
There is a high level IPC language for the Amiga (besides ARexx...),
whose name is PPIPC.  It has many of the high level features of DDL.
To be quite honest, this is one area, where the Amiga is quite
strong, I'm suprised you didn't know.  For more information, see
ARexx documentation or FTP PPIPC from a fish disk site.
I'm sure Pete Goodeve or Peter da Silva would be more than happy
to fill in more details of PPIPC, since they wrote the specs and
the first implementation.  (Both fine people are on the net, BTW)


``If programmed to do so, yes''  Well of course, *anything* can be programmed,
I believe the important point is that the MacOS does not support these
sorts of things like AmigaOS, UNIX, VMS, etc do at the OS level.  And like
most things under the MacOS, if you want it *you*, the programmer, 
must recreate it for every program.  The Applications must deal with
such things as resizing windows for Christ's sake.  They, the MacApps and
not the OS, are responsible for checking where mouse clicks land in their
windows and then taking the ``Apple'' approved actions.  Yes its true,
every Mac App that looks like a Mac App has the same pile of code at the
core to handle all sorts of thing that one would expect the OS to handle
(the AmigaOS does at least ;-).  Buddy, remember where you are next
time you make such bold claims.  Sheesh (not an English word, BTW).

We're not even talking about the brain dead file system Apple uses,
what a kludge --- they thought that a flat file system would be enough,
then later, when they saw otherwise, *tried* to add a hierarchical
file system.  It's really the most (current day, in use) pitiful
file system I have ever seen.  The workings of the guts of the
file system are not hidden from the applications at all.  They have
to `know' about everything.  Even MS-DOS has a cleaner break between
what services applications request and what the OS does. (I can't
believe that I'm claiming MS-DOS provides services to applications...)

>-- 
>rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
>r     ___     _                                          r
>r    /__     | \           N U K E   I R A Q ! ! !       r
			    ^^^^^^^^^^^^^^^^^^^^^^^
>r   ___/hawn |__\ube       -----------------------       r
>r  jsd@owlnet.rice.edu                                   r
>rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
Well, at least there is one thing we can agree upon.  I'm glad
you limited distribution to the usa!  I kept it that way!
Actually, I hope we don't NUKE them per se, if you meant bomb the
Hell out of them, then I concur whole heartily.

Loren J. Rittle
--
``In short, this is the absolute coolest computer device ever invented!''
                   -Tom Denbo speaking about The VideoToaster by NewTek
``your pathetic architectures won't support it'' - Kent Paul Dolan
``Think about NewTek's VideoToaster!  Now think about the Amiga!''
Loren J. Rittle lrg7030@uxa.cso.uiuc.edu

torrie@cs.stanford.edu (Evan J Torrie) (01/22/91)

lrg7030@uxa.cso.uiuc.edu (Loren J. Rittle) writes:
>``If programmed to do so, yes''  Well of course, *anything* can be programmed,
>I believe the important point is that the MacOS does not support these
>sorts of things like AmigaOS, UNIX, VMS, etc do at the OS level.  And like
>most things under the MacOS, if you want it *you*, the programmer, 
>must recreate it for every program.  

  Hmm.  I just use a class library for most of the "common" actions.
Takes no work at all on my part.


>We're not even talking about the brain dead file system Apple uses,
>what a kludge --- they thought that a flat file system would be enough,
>then later, when they saw otherwise, *tried* to add a hierarchical
>file system.  It's really the most (current day, in use) pitiful
>file system I have ever seen.  The workings of the guts of the
>file system are not hidden from the applications at all.  They have
>to `know' about everything.  

 Depends on what level you're programming at...  The standard FSOpen,
and FSRead etc calls, work fine if you're just reading and writing
files.  Navigating around directories, I agree, is a lot more
difficult.

-- 
------------------------------------------------------------------------------
Evan Torrie.  Stanford University, Class of 199?       torrie@cs.stanford.edu   
"She's got a tongue like an electric eel, and she likes the taste of a 
 man's tonsils!"  - Rik Flashheart

peter@sugar.hackercorp.com (Peter da Silva) (01/23/91)

In article <1991Jan21.085309.10664@ux1.cso.uiuc.edu> lrg7030@uxa.cso.uiuc.edu (Loren J. Rittle) writes:
> I'm sure Pete Goodeve or Peter da Silva would be more than happy
> to fill in more details of PPIPC, since they wrote the specs and
> the first implementation.  (Both fine people are on the net, BTW)

My blushes, Watson.

I worked with Pete on the design, but personal problems prevented me from
keeping up with PPIPC. Pete did the implementation.
-- 
Peter da Silva.   `-_-'
<peter@sugar.hackercorp.com>.

peter@sugar.hackercorp.com (Peter da Silva) (01/23/91)

In article <1991Jan21.172643.20642@Neon.Stanford.EDU>, torrie@cs.stanford.edu (Evan J Torrie) writes:
> lrg7030@uxa.cso.uiuc.edu (Loren J. Rittle) writes:
> >most things under the MacOS, if you want it *you*, the programmer, 
> >must recreate it for every program.  

>   Hmm.  I just use a class library for most of the "common" actions.
> Takes no work at all on my part.

This is the X-windows solution. Let's load up every program with extra baggage
because the GUI/OS/whatever is inadequate. And the Mac doesn't even have
shared libraries to make this relatively painless.
-- 
Peter da Silva.   `-_-'
<peter@sugar.hackercorp.com>.