🚀 go-pugleaf

In article <INFO-M2%90061222191839@UCF1VM.BITNET>, ROSS@UCF1VM.BITNET (Bri)
says:
[ asking about JPI vs. Logitech ]
>The main goal is to decide which is better for EDUCATIONAL reasons
>and not programming reasons (teaching concepts of programming and proper
>style) but i am interested in personal reason for true systems programming
>and other major projects.
>
>Now, off the bat I know everyone complains that Logitech is slow compared
>to TS and code is smaller and faster. To this I say: of course it is.
[ explanation of typical press hype ]

Although I must admit that I haven't worked with Logitech for over 2 years,
the speed issue stands under any conditions I used when I switched to JPI.
What was lost?  JPI requires FORWARD declarations, which I have never had to
use yet.  I will admit, though, that speed is not necessarily going to be
an issue in an educational environment.  (Although I can still remember
taking a dinner break when compiling 40-line Ada programs on IBM mainframes
when I was in school--ouch!)

>Other complaints I have about JPI is they are the BORLAND of Pascal.
[ expansion on this idea ]

This is true enough as it stands, but is this an educational issue?  I assume
that JPI is involved in the standardization (I know, never assume, but it
makes sense given their involvement in Modula-2).  It may be that they have
provided enough of a de-facto base to allow them strong input into the process.
I haven't followed the draft standard; how far does JPI actually deviate from
their efforts?  Considering how few M2 implementations there are out there,
portability is a problem under nearly any environment.

>Another thing I noticed is their documentation sucks (putting it nicely).
>It is very anemic and leaves a lot to be desired, especially in the
>library listing section. Logitech's setup is much nicer when compared to
>this.

Could this simply be an example of the baby-duck syndrome?  It's always
difficult to overcome the inertia of working with a system that you have
come to understand deeply.  I prefer to think of JPI's docs as "lean."
I always felt like I was wading through a lot of prose to find the info I
needed from Logitech; whereas I can usually quickly find answers in the JPI
docs.  Are they perfect?  Flatly, no.  But they provided enough info for me
to get up and writing code in hours.  (I will admit that I already knew
Modula-2, so I may be biased toward the more fluent.)

I can think of one strong argument in favor of JPI--their libraries.  After
working with Logitech, and dealing with a couple meg of libraries, I nearly
felt like I had been ripped off by JPI when I first got it.  I soon began to
realize however, that JPI practised what Modula-2 preached: code reusability.
Their libraries are lean because they used the power of Modula-2 to reuse
redundant code, and allow simple extensions without rewriting whole modules.
As a simple example, consider their IO module.  Write your own string
output PROCEDURE, assign it to WrStrRedirect, and the whole library (including
all the WrInt, WrCard, etc.) are yours without any redundancy.  In fact,
you can have several kinds of I/O processing in the same program all using IO
while using only one IO module (simply keep reassigning WrStrRedirect).  Their
Window module takes full advantage of this fact.  Similar PROCs and modules
bear similar names, use common types and don't overlap.  This is something
that Logitech did not take advantage of (at least up to 3.0) and their
libraries showed it.  What does this have to do with education?  Simply this,
when you are teaching about information hiding, code reuse, modularity, and
so on, you have something concrete to show your students.  Have them write an
IO library in graphics modes.  All they have to solve is how to get a CHAR
up on the screen, the rest of the library is there for them to test it.  Let
them write a self-logging IO module.  Can this all be done in Logitech?  Of
course it can--but JPI already did it for you.

I'm not going to convince those who have made up their minds, but for me,
JPI opened up Modula-2 as something grander than a "fixed-up" Pascal.  I
learned more from studying their libraries than I learned from the half-dozen
reference books I keep around.

BTW: the book by K.N. King that JPI provides is a gem, too.  Worth a look
even if you use Logitech.

Posted apologetically by
-Tim Larson
trl3@psuvm.bitnet
(Sorry, that is, about the length.  %) )