>
>  This “rule” was used to express an opinion and with no backing arguments,
> should be disregarded as irrelevant.


I'm pretty sure this was just a joke. No need to back it with arguments or
determine its relevance. You are free to agree or disagree all you
like. Nobody is trying to argue with you.

Personally, I think there's a *grain *of truth to it, which is why it's
funny to me. (A colleague implemented a relatively complex parameter file
syntax, which ended up containing implicit function calls with a syntax
surprisingly close to Lisp, so it hit close to home. lol)

From the Wikipedia page:

Both Greenspun's rule and Morris's corollary are examples of a
> characteristic style of hacker 
> humor<http://en.wikipedia.org/wiki/Computer_humor> known
> as "ha ha only 
> serious".[6]<http://en.wikipedia.org/wiki/Greenspun's_tenth_rule#cite_note-6>




On Fri, Jan 25, 2013 at 1:25 PM, David Clark <[email protected]>wrote:

> I looked up the Wiki link and it said that Greenspun never had rule 1-9
> and came up with the name “the tenth rule” because it sounded impressive.
> This “rule” was used to express an opinion and with no backing arguments,
> should be disregarded as irrelevant.****
>
> ** **
>
> I presume that the “slow implementation of half of Common Lisp” is in
> reference to Lisp using Polish Prefix Notation (PPN) and the fact that all
> interpreters that compile to byte code also use PPN.****
>
> ** **
>
> **1.       **Lisp was created in 1958 and was the second (Fortran was
> first) higher level language invented for commercial computers.  If Lisp
> was so good then why do we have literally thousands of computer languages
> and at the very least a few dozen that are currently used by thousands of
> programmers?****
>
> **2.       **The instructions of all modern CPUs are in PPN.  The only
> other way they could be created is with a fixed size instruction set that
> would be much less efficient.  Is PPN Lisp or does Lisp also use PPN?****
>
> **3.       **The question is “is using PPN in a byte code interpreter
> running a subset of Lisp”?  My answer is obviously NO!****
>
> **4.       **Lisp was very slow for decades and I would argue that Lisp
> is still slow except for the benchmarks that some implementers have
> optimized to try to sell their wares.  Benchmarks are an art rather than a
> science.****
>
> **5.       **All  interpreters aren’t “slow” and some like Java and C#
> have included JIT compiling to machine code to make their speed approach
> that of assembler.****
>
> ** **
>
> I have many complains about Lisp as a computer language but my biggest
> complaint is that PPN is good for machines but lousy for humans.  My
> internal byte code is “surprise” PPN but I can’t imagine why anyone would
> ever write code at that level when they can use a much more human friendly
> source code.  The answer is that they wouldn’t use that low level PPN as
> source code and that more than anything else is why Lisp is essentially a
> dead language.  It is extremely difficult to see the shape of the nested
> loops and control structures as they blend in to all the other function
> calls.  The ability to extend the language (the biggest reason people say
> you should use Lisp) is very useful but has no direct connection to using
> “S expressions” or PPN as source code.****
>
> ** **
>
> David****
>
> ** **
>
> PS I have included my comments on “rule 11” in another post.****
>
> ** **
>
> *From:* Juan Carlos Kuri Pinto [mailto:[email protected]]
> *Sent:* January-23-13 3:37 PM
> *To:* AGI
> *Subject:* [agi] Greenspun's tenth rule and eleventh rule ^_^****
>
> ** **
>
> Greenspun's tenth rule: Any sufficiently complicated C or Fortran program
> contains an ad hoc, informally-specified, bug-ridden, slow implementation
> of half of Common Lisp.****
>
> ** **
>
> http://en.wikipedia.org/wiki/Greenspun's_tenth_rule****
>
> ** **
>
> Greenspun's eleventh rule: Any sufficiently parallel program written in a
> non-purely functional programming language, like C, Assembler, Java, Lisp,
> Scheme, and OCaml, contains an ad hoc, informally-specified, bug-ridden,
> slow implementation of half of Haskell.****
>
> *AGI* | Archives <https://www.listbox.com/member/archive/303/=now> [image:
> Image removed by 
> sender.]<https://www.listbox.com/member/archive/rss/303/1652298-7c98969f>|
> Modify <https://www.listbox.com/member/?&;> Your Subscription****
>
> [image: Image removed by sender.] <http://www.listbox.com>****
>
> ** **
>   *AGI* | Archives <https://www.listbox.com/member/archive/303/=now>
> <https://www.listbox.com/member/archive/rss/303/23050605-2da819ff> |
> Modify<https://www.listbox.com/member/?&;>Your Subscription
> <http://www.listbox.com>
>



-------------------------------------------
AGI
Archives: https://www.listbox.com/member/archive/303/=now
RSS Feed: https://www.listbox.com/member/archive/rss/303/21088071-f452e424
Modify Your Subscription: 
https://www.listbox.com/member/?member_id=21088071&id_secret=21088071-58d57657
Powered by Listbox: http://www.listbox.com

<<~WRD000.jpg>>

Reply via email to