🚀 go-pugleaf

In article <429@aucs.UUCP> paul@aucs.UUCP (Paul Steele) writes:
>Which is better: the MPW development system from APDA or Lighspeed Pascal
>and C from THINK.  I know MPW comes with 6 inches of documentation, but
>is there anything in it that isn't in Inside Mac.  Comments please.

I've used both MPW C and Lightspeed C.  They are both very good products and
worth the price you pay, but they are very different in their approach.
MPW is a shell based development system much like UNIX, while Lightspeed C
is a programing environment.

Lightspeed C is by far the easiest use and quickist learn.  The metaphor is
that your code is a project and LSC manages that project for you once you
tell it which sources files are included.  This takes all the overhead of
maintaining make files away and always insures that your project is up to
date with all the include files.  Another very nice feature is LSC's
integrated editor.  Like MPW, when the compiler finds an error, it
automatically opens the offending file and places the cursor on the line
where the error was detected.  But unlike MPW, LSC also knows where your
variables and functions are defined, so you can click on an identifier name
and the file in which it is declared is opened and the cursor is placed
on the first occurance (this is not always the actual definition).  LSC
also knows about all your nested include files and they can be listed and
opened with a click of the mouse.  These features combined with a very fast
compiler make code development an enjoyable task.  The drawback to this
environment is that there is no good way to access other useful programming
tools without exiting LSC.  It's also more difficult to port code to and
from LSC to a shell environment.  The main problem here is handling the
Makefile and things that are done in it.  LSC's make only compiles code
and links in a single resource file.  Generic Makefiles can perform a
number of other tasks that may be related to the project.

MPW is quite easy to learn if you're already familiar with a UNIX type
shell.  It comes with many of the common programming tools like make,
diff, and grep, and packages them into a nice window based shell.  You
can alter the menus and access your own tools and shell scripts.  This
provides a very powerful environment for code development.  Another nice
thing about MPW is that the interface remains the same whether you're
programming in C, Pascal, or assembly and all are available.  By the way,
MPW's Pascal is object oriented and Apple is comming out with and an
object oriented version of C soon which should make programming the Mac
much nicer, especially if you get MacApp.  With MPW's power and a bit
of work, I believe it's possible to create some utilities that will
provide a user interface much like LSC, but LSC cannot be made to do
all the things MPW will do.  I have not looked at the code generated
by MPW but I've heard it's pretty good and it seems to run as fast as
LSC's for those things I've used.  However, the compile, link, run loop
is much longer in MPW than in LSC.

All in all, I think both these systems are useful and have their place in
every programmer's tool box.  For most stand alone Mac applications I'd
use LSC because of its quick turn around and ease of use.  For larger,
more complex applications and systems which might be ported to and from
other systems I'd use MPW C.  Both systems lack good symbolic debugger
support as do all Mac C compiler's I've seen.  A debugger like Sun's
dbxtool would be extremely helpful!

These are my opinions, your's may differ, so sue me.

Larry Hattery