🚀 go-pugleaf

In article <147@heaven.woodside.ca.us> glenn@heaven.UUCP (Glenn Reid) writes:

> No, I think PostScript succeeded mainly because it is ASCII.  People
> can understand something that they can see.  People like that.  A lot
> of the software in the world is screwed up in one way or another, and
> people love to be able to fix things that are broken.  And they can
> fix them if they are expressed in ASCII.  Or at least they can see
> them and know that there is something broken in there that they can't
> quite understand, so they want to know more about it.  So they learn
> it, and have fun with it, and tell somebody else about it.

> A hell of a lot more people know how to work text editors than
> know how to read octal dumps.  You can drag graphic designers
> and sales people (not to slight them, of course, but to pick some folks
> who probably have never written any programs) into a classroom and
> get them to print their names on a sheet of paper in 100 point Times
> Roman in about 15 minutes.  Try to do that with a binary-encoded
> token stream with packed arrays, 0-padded bytes, run-length
> encoded bits, checksums, and end-of-file indicators.

> Anyway, PostScript is great because you can see it, edit it, write
> more of it, and even complain about it.  Most of us couldn't do any of
> these things if it weren't ASCII.  So what if it takes a little longer
> to get where it's going?  Besides, there are more MIPS and megabytes
> every time you wake up.

People are very inconsistent and silly, and so the things they create tend
to be the same way.  One of the really nice things about PostScript is that
you can explain the Show operator and the Translate operator and even let
them write some toy programs (like those in the Blue Book) that really do
some amazing things.  They fool themselves into thinking they know the silly
language, but that's just fine, because when they finally buy the printer
and look at the work involved in writing their next book in Postscript (:-)
they fall back to TEK or Runoff or whatever, which could just as easily
emit Interpress or Impress or Linotron Cora as Postscript, maybe even easier.
So their fantasy that they know the language is never tested against reality.

I wrote a program that printed Linotron Binary Byte out in readable format,
and I wrote a program that printed Imagen Impress out in readable format,
and these satisfied my need to read and debug output from Real Programs just
fine, thank you.  Agreed that expressing PS in readable ASCII allows people
not capable of doing this the ability to debug program output.  Maybe.
You read a Macintosh control-f dump sometime.

This is akin to buying a new computer based on its array of fancy CISC
instructions like "Insert in Balanced Binary Tree and Balance" then when you
get the damn thing using only higher level language compilers like C that
never generate an instruction more complicated than "Move Register to Memory".
Typical Human inconsistency.

Oops, jumped track to the RISC diatribe -- back to the PS diatribe.  IMHO
PS was successful because it became a de-facto standard at a time when a
standard was desparately needed but the existing standards organizations were
piddling around with CGM/GKS versus (well, insert your own acronyms here).
People needed a standard, PS was 90% of what they needed and it was here
(i.e. people thought Apple would produce LW for a reasonably long time) and
they couldn't afford to wait for GKS or something like it to give them that
last 10%.

-- 
Sig     DS.L    ('ZBen')       ; Ben Cranston <zben@Trantor.UMD.EDU>
* Network Infrastructures Group, Computer Science Center
* University of Maryland at College Park
* of Ulm