🚀 go-pugleaf

In article <22075@yunexus.YorkU.CA> oz@yunexus.yorku.ca (Ozan Yigit) writes:
> In article <see ref> brnstnd@kramden.acf.nyu.edu (Dan Bernstein) writes:
> | No. A machine is much more than its ``primitive datatypes.'' But Lisp
> | doesn't even provide full access to pointers.
> Imagine that! ;-)

It doesn't. I can't even find a Lisp for the Convex that takes advantage
of array indexing: in C, p[i] runs as fast as *p on that machine, but
since Lisp doesn't truly grok pointers it falls flat.

Or is it heresy in your faith to even conceive of the idea that Lisp
doesn't understand pointers as well as C?

> >			     I need fast compile times and run times so
> >that the machine's turnaround time during testing and debugging doesn't
> >become a significant part of my turnaround time.
> Use the right compiler [and the right machine] for fast compile times,

Oh, what a *useful* suggestion. ``Your programs don't run fast enough?
Buy a Cray.'' Believe it or not, even on the Cray, the compiler takes a
noticeable amount of time, and there do exist programs that run for
longer than a second.

> > I need language power: full access to what the machine can do.
> You seem to be confusing language "power" with language "level".

No. Ada is in some ways more powerful than C: among its primitives, for
example, are tasks. This doesn't make it higher-level or lower-level
than C; it just adds some power, by providing more access to what the
machine (in this case, OS) can do.

> > Lisp doesn't have any of this.
> Is this "have" the same as your previously re-defined "have" to mean
> something in relation to general computability, or is this something
> more meaningful and useful?

Does ``any of this'' refer to some semantic feature of a programming
language? No. Therefore my previously defined ``have'' does not apply
here. You understand overloaded operations; why don't you understand
overloaded words?

> Of course. Just as interesting, the neighbourhood cabbie was telling me
> about how he gave a ride to Elvis, and he had witnesses to prove it. So?

Hey, bud, you started.

> >Would you write a compressor in a dynamically typed language?
> Silly question, despite its answer. 1988, compress.lisp [UN*X compress in
> Common Lisp] by Paul Fuqua, done.

You didn't answer the question. Would you write a compressor in a
dynamically typed language? I wouldn't, because each compile run takes a
noticeable amount of time, and each test run takes a noticeable amount
of time. If I used a dynamically typed language, I'd lose big on either
compile time, run time, or both. That can mean the difference between a
week and a month in project turnaround time, not to mention a slower
final program.

The dynamic-typing people claim that I'll get it all back in
maintenance, because my program will be shorter. I don't believe them:
dynamic typing wouldn't simplify my huptrie.h, for example. They claim
that I won't have as many testing and debugging runs. Sorry, but it just
isn't true: practically every bug I found and behavior I changed would
have been found and changed the same way in most languages, and I have
the project logs to prove it.

Maybe it's a silly question, but for me it exemplifies what's wrong with
dynamically typed languages.

---Dan