How Lisp's Nested Notation Limits The Language's Utility
Xah Lee
Xah Lee, 2007-05-03
There is a common complain by programers about lisp's notation, of
nested parenthesis, being unnatural or difficult to read. Long time
lisp programers, often counter, that it is a matter of conditioning,
and or blaming the use of “inferior” text editors that are not
designed to display nested notations. In the following, i describe how
lisp notation is actually a problem, in several levels.
(1) Some 99% of programers are not used to the nested parenthesis
syntax. This is a practical problem. On this aspect along, lisp's
syntax can be considered a problem.
(2) Arguably, the pure nested syntax is not natural for human to read.
Long time lispers may disagree on this point.
(3) Most importantly, a pure nested syntax discourages frequent or
advanced use of function sequencing or compositions. This aspect is
the most devastating.
The first issue, that most programers are not comfortable with nested
notation, is well known. It is not a technical issue. Whether it is
considered a problem of the lisp language is a matter of philosophical
disposition.
The second issue, about nested parenthesis not being natural for human
to read, may be debatable. I do think, that deep nesting is a problem
to the programer. Here's a example of 2 blocks of code that are
syntactically equivalent in the Mathematica language:
vectorAngle[{a1_, a2_}] := Module[{x, y},
{x, y} = {a1, a2}/Sqrt[a1^2 + a2^2] // N;
If[x == 0, If[Sign@y === 1, π/2, -π/2],
If[y == 0, If[Sign@x === 1, 0, π],
If[Sign@y === 1, ArcCos@x, 2 π - ArcCos@x]
]
]
]
SetDelayed[vectorAngle[List[Pattern[a1,Blank[]],Pattern[a2,Blank[]]]],
Module[List[x,y],
CompoundExpression[
Set[List[x,y],
N[Times[List[a1,a2],
Power[Sqrt[Plus[Power[a1,2],Power[a2,2]]],-1]]]],
If[Equal[x,0],
If[SameQ[Sign[y],1],Times[π,Power[2,-1]],
Times[Times[-1,π],Power[2,-1]]],
If[Equal[y,0],If[SameQ[Sign[x],1],0,π],
If[SameQ[Sign[y],1],ArcCos[x],
Plus[Times[2,π],Times[-1,ArcCos[x]]]]]]]]]
In the latter, it uses a full nested form (called FullForm in
Mathematica). This form is isomorphic to lisp's nested parenthesis
syntax, token for token (i.e. lisp's “(f a b)” is Mathematica's
“f[a,b]”). As you can see, this form, by the sheer number of nested
brackets, is in practice problematic to read and type. In Mathematica,
nobody really program using this syntax. (The FullForm syntax is
there, for the same reason of language design principle shared with
lisp of “consistency and simplicity”, or the commonly touted lisp
advantage of “data is program; program is data”.)
The third issue, about how nested syntax seriously discourages
frequent or advanced use of inline function sequencing on the fly, is
the most important and I'll give further explanation below.
One practical way to see how this is so, is by considering unix's
shell syntax. You all know, how convenient and powerful is the unix's
pipes. Here are some practical example: “ls -al | grep xyz”, or “cat a
b c | grep xyz | sort | uniq”.
Now suppose, we get rid of the unix's pipe notation, instead, replace
it with a pure functional notation: e.g. (uniq (sort (grep xyz (cat a
b c)))), or enrich it with a composition function and a pure function
construct (λ), so this example can be written as: ((compose (lambda
(x) (grep xyz x)) sort uniq) (cat a b c)).
You see, how this change, although syntactically equivalent to the
pipe “|” (or semantically equivalent in the example using function
compositions), but due to the cumbersome nested syntax, will force a
change in the nature of the language by the code programer produces.
Namely, the frequency of inline sequencing of functions on the fly
will probably be reduced, instead, there will be more code that define
functions with temp variables and apply it just once as with
traditonal languages.
A language's syntax or notation system, has major impact on what kind
of code or style or thinking pattern on the language's users. This is
a well-known fact for those acquainted with the history of math
notations.
The sequential notation “f@g@h@x”, or “x//h//g//f”, or unixy “x|h|g|
f”, are far more convenient and easier to decipher, than “(f (g (h
x)))” or “((compose h g f) x)”. In actual code, any of the f, g, h
might be a complex pure function (aka lambda construct, full of
parenthesis themselves).
Lisp, by sticking with almost uniform nested parenthesis notation, it
immediately reduces the pattern of sequencing functions, simply
because the syntax does not readily lend the programer to it as in the
unix's “x|h|g|f”. For programers who are aware of the coding pattern
of sequencing functions, now either need to think in terms of a
separate “composition” construct, and or subject to the much
problematic typing and deciphering of nested parenthesis.
(Note: Lisp's sexp is actually not that pure. It has ad hoc syntax
equivalents such as the “quote” construct “ '(a b c) ”, and also “`”,
“#”, “,@” constructs, precisely for the purpose of reducing
parenthesis and increasing readability. Scheme's coming standard the
R6RS ↗, even proposes the introduction of [] and {} and few other
syntax sugars to break the uniformity of nested parenthesis for
legibility. Mathematica's FullForm, is actually a pure nested notation
as can be.)
-------
The above, is part of a 3-part exposition:
“The Concepts and Confusions of Prefix, Infix, Postfix and Fully
Functional Notations”,
“Prefix, Infix, Postfix notations in Mathematica”,
“How Lisp's Nested Notation Limits The Language's Utility”,
archived at:
http://xahlee.org/UnixResource_dir/writ/notations.html
Kaz Kylheku
> How Lisp's Nested Notation Limits The Language's Utility
>
> Xah Lee, 2007-05-03
>
> There is a common complain by programers about lisp's notation, of
> nested parenthesis, being unnatural or difficult to read.
That is false. The complaint does not frequently occur among all of
the complaints occured by the entire population of complaintive
programmers.
> (1) Some 99% of programers are not used to the nested parenthesis
> syntax. This is a practical problem.
Since 99% of programmers don't use Lisp, it's not a practical problem.
> (2) Arguably, the pure nested syntax is not natural for human to read.
> Long time lispers may disagree on this point.
Programming language syntax shouldn't be natural for humans to read.
Or, rather, this shouldn't be a requirement which creates technical
compromises.
> (3) Most importantly, a pure nested syntax discourages frequent or
> advanced use of function sequencing or compositions.
That is an artifact of the way in which function composition is
rendered in nested syntax, and not an artifact of that syntax itself.
There exist macros that provide alternate syntax for function
composition, such as a left-to-right pipeline.
> This aspect is the most devastating.
Compared to issues like global warming and problems in the Middle
East, hardly.
> The first issue, that most programers are not comfortable with nested
> notation, is well known.
Many programmers are also not comfortable in social situations. So
what?
> shell syntax. You all know, how convenient and powerful is the unix's
> pipes. Here are some practical example: “ls -al | grep xyz”, or “cat a
> b c | grep xyz | sort | uniq”.
>
> Now suppose, we get rid of the unix's pipe notation, instead, replace
> it with a pure functional notation: e.g. (uniq (sort (grep xyz (cat a
> b c)))),
When you think about this more deeply (i.e. at all) you run into nasty
details. These programs pass their output to each other, but they also
have a return value (termination status) which isn't passed through
the pipeline. And they take arguments, but the arguments of a pipeline
element are not derived from the previous pipeline element.
Your call (grep xyz (cat ...)) means to pass the output of cat as the
third argument of grep.
In the POSIX shell, this would be coded using guess what, Lisp-like
syntax:
grep xyz $(cat ...)
Taking it further:
uniq $(sort $(grep xyz $(cat a b c)))
or enrich it with a composition function and a pure function
> construct (λ), so this example can be written as: ((compose (lambda
> (x) (grep xyz x)) sort uniq) (cat a b c)).
I posted a filter macro in comp.lang.lisp which expresses function
chaining into a left-to-right notation. Look for it.
In this notation, you might write:
(filter 3 (expt _ 2) (* 4))
which means, start with 3, raise it to the power of 2 to obtain 9, and
then multiply by 4 to get 36.
The underscore indicates the argument position where the output of the
previous pipeline element is to be inserted when calling the next
pipeline element. The default is to add it as a rightmost argument.
The macro has features for dealing with splitting and recombining
lists, and handling multiple values.
This is still the same ``pure nested'' syntax; it merely expresses
function chaining differently.
What was that about notation limiting language utility?
Jon Harrop
> vectorAngle[{a1_, a2_}] := Module[{x, y},
> {x, y} = {a1, a2}/Sqrt[a1^2 + a2^2] // N;
> If[y == 0, If[Sign@x === 1, 0, ?],
> If[Sign@y === 1, ArcCos@x, 2 ? - ArcCos@x]
> ]
> ]
> ]
>
> SetDelayed[vectorAngle[List[Pattern[a1,Blank[]],Pattern[a2,Blank[]]]],
> Module[List[x,y],
> CompoundExpression[
> Set[List[x,y],
> N[Times[List[a1,a2],
> Power[Sqrt[Plus[Power[a1,2],Power[a2,2]]],-1]]]],
> If[Equal[x,0],
> Times[Times[-1,?],Power[2,-1]]],
> If[Equal[y,0],If[SameQ[Sign[x],1],0,?],
> If[SameQ[Sign[y],1],ArcCos[x],
Yes. The Mathematica language really brings home the fact that non-trivial
syntax is good. In particular, it does an excellent job of mimicking
conventional mathematical notation. Arguing in favor of Lisp syntax is like
advocating the use of cave painting...
Also, note that Mathematica provides strictly more in the way of macros.
--
Dr Jon D Harrop, Flying Frog Consultancy
The F#.NET Journal
http://www.ffconsultancy.com/products/fsharp_journal/?usenet
Jon Harrop
> On May 4, 5:11 pm, Xah Lee <x...@xahlee.org> wrote:
>> (1) Some 99% of programers are not used to the nested parenthesis
>> syntax. This is a practical problem.
>
> Since 99% of programmers don't use Lisp, it's not a practical problem.
If you're being pedantic, you may mean "it is an uncommon practical
problem". However, the problem extends beyond Lisp.
Recent discussions have covered the use of pattern matching. In SML, OCaml,
Haskell (I believe) and F# you must write pattern matches over the expr
type in prefix notation. To borrow from Alan's example, the Lisp code:
(destructuring-bind (op1 (op2 n x) y) form
`(* ,n (* ,(simplify x) ,(simplify y)))))
((cons (eql *) *)
(destructuring-bind (op left right) form
(list op
(simplify left)
(simplify right))))
((cons (eql +)
(cons (eql 0)
(cons * null)))
could be written:
| n*x*y -> n*(x*y)
but in ML this must be written as a pattern match over a sum type where the
type constructors must use prefix notation:
| Mul(Mul(n, x), y) -> Mul(n, Mul(x, y))
While this is clearly much better than the Lisp, it would be preferable to
use the mathematical syntax in this case. You can address this in OCaml
using macros and there is a chance that F# will support overloaded
operators in patterns in the future.
Mathematica lets you do:
n x y -> n (x y)
but I don't know of any other languages that do, without forcing you to
reinvent the wheel via macros.
Robert D. Crawford
> How Lisp's Nested Notation Limits The Language's Utility
You know, I am all about keeping one's eyes open so as to see the
limitations of the tools one chooses or is forced to use. If more
people were open to the flaws in their OS, religion, editor, and a
myriad of other things the world would surely be a better and more
peaceful place. However, I have to say that all I ever see from you,
Mr. Lee, is complaints and how you want emacs and lisp to change. For
the love of whatever god you choose to pray to, find a frigging tool
that makes you happy. If it is emacs that makes you happy, then change
the things you don't like and be happy but I fail to see how your
whining diatribes serve any useful purpose. If you don't like lisp then
by all means use something else.
No offense but it does get old after a while.
--
Robert D. Crawford rd...@comcast.net
Marriage is learning about women the hard way.
Pillsy
[...]
> Yes. The Mathematica language really brings home the fact that non-trivial
> syntax is good. In particular, it does an excellent job of mimicking
> conventional mathematical notation.
If I wanted to exhibit the benefits of syntax, Mathematica would be
pretty low on my list of languages to do it with. The combination of C-
ish abreviations (i++, et c.), tricky rules for implicit
multiplication, and a maze of twisty little infix operators make it
very confusing. It's not Perl, but I'd still pick Lisp's syntax any
day of the week and twice on Sundays.
Cheers,
Pillsy
Miles Bader
> If it is emacs that makes you happy, then change the things you don't
> like and be happy but I fail to see how your whining diatribes serve
> any useful purpose. If you don't like lisp then by all means use
> something else.
Xahlee likes to complain. That's the main factor here.
-Miles
--
Run away! Run away!
Ken Tilton
Xah Lee wrote:
> How Lisp's Nested Notation Limits The Language's Utility
>
> Xah Lee, 2007-05-03
>
> There is a common complain by programers about lisp's notation, of
> nested parenthesis, being unnatural or difficult to read. Long time
> lisp programers, often counter, that it is a matter of conditioning,
> and or blaming the use of “inferior” text editors that are not
> designed to display nested notations. In the following, i describe how
> lisp notation is actually a problem, in several levels.
>
> (1) Some 99% of programers are not used to the nested parenthesis
> syntax. This is a practical problem. On this aspect along, lisp's
> syntax can be considered a problem.
Simply wrong. What would be a problem would be if they tried it and
could not quickly get used to it.
>
> (2) Arguably, the pure nested syntax is not natural for human to read.
> Long time lispers may disagree on this point.
No code is natural to read, and yes, I have written a ton of COBOL.
Neither are legal or scholarly natural language texts natural to read.
>
> (3) Most importantly, a pure nested syntax discourages frequent or
> advanced use of function sequencing or compositions. This aspect is
> the most devastating.
The example you chose was a command line, where conciseness rules and
where one is not likely to encounter refactoring or macros. ie, the
syntax for a command-line has nothing to do with the syntax for serious
programming.
sexpr notation provides a hierarchical lexical grouping that maps
isomorphically onto the functional semantics, and the latter is what I
need to rearrange when refactoring, so it kinda helps that the code I
must edit to achieve said rearrangement maps so directly to the semantics.
I think the biggest argument in favor of parens is all the people that
want them to go away. Bad features just die out (see C++ and Java).
kzo
--
http://www.theoryyalgebra.com/
"Algebra is the metaphysics of arithmetic." - John Ray
"As long as algebra is taught in school,
there will be prayer in school." - Cokie Roberts
"Stand firm in your refusal to remain conscious during algebra."
- Fran Lebowitz
"I'm an algebra liar. I figure two good lies make a positive."
- Tim Allen
Rayiner Hashem
> syntax. This is a practical problem. On this aspect along, lisp's
> syntax can be considered a problem.
The first time I saw graph-theory notation, I thought it was
gibberish. I still think most mathematical notation is gibberish, but
I deal with it --- I don't turn in proofs written in prose.
> (2) Arguably, the pure nested syntax is not natural for human to read.
> Long time lispers may disagree on this point.
And mathematical notation is not natural for people to read, at least
not anybody who grew up learning a natural language. But people deal
with it. They're remarkably adaptable this way.
> vectorAngle[{a1_, a2_}] := Module[{x, y},
> {x, y} = {a1, a2}/Sqrt[a1^2 + a2^2] // N;
> If[x == 0, If[Sign@y === 1, π/2, -π/2],
> If[y == 0, If[Sign@x === 1, 0, π],
> If[Sign@y === 1, ArcCos@x, 2 π - ArcCos@x]
> ]
> ]
> ]
Speaking of gibberish. I can't believe anybody would hold up
Mathematica as an example of good programming. Next you'll be telling
me that 99% of Matlab code isn't really crap!
> The third issue, about how nested syntax seriously discourages
> frequent or advanced use of inline function sequencing on the fly, is
> the most important and I'll give further explanation below.
I consider this to be a Good Thing (TM). Unix shell commands read like
line noise.
Edward
> How Lisp's Nested Notation Limits The Language's Utility
>
> Xah Lee, 2007-05-03
>
> There is a common complain by programers about lisp's notation, of
> nested parenthesis, being unnatural or difficult to read. Long time
> lisp programers, often counter, that it is a matter of conditioning,
> and or blaming the use of “inferior” text editors that are not
> designed to display nested notations. In the following, i describe how
> lisp notation is actually a problem, in several levels.
As a practical matter, most LISPers don't even see the parens, but
rather interpret the code according to the indentation.
> (1) Some 99% of programers are not used to the nested parenthesis
> syntax. This is a practical problem. On this aspect along, lisp's
> syntax can be considered a problem.
It's certainly different. Whether it is a problem or not depends on
personal or subjective criteria.
> (2) Arguably, the pure nested syntax is not natural for human to read.
> Long time lispers may disagree on this point.
Harder to read for some things, easier to read for others.
E.G.
1 + 2 + 3 + 4 + 6 - 3 + 32
or
(- (+ 1 2 3 4 6 32) 3)
> (3) Most importantly, a pure nested syntax discourages frequent or
> advanced use of function sequencing or compositions. This aspect is
> the most devastating.
This is one reason LISP has macros. Don't like the syntax? Make your
own. How many languages make this as easy as LISP does?
> The third issue, about how nested syntax seriously discourages
> frequent or advanced use of inline function sequencing on the fly,
> is the most important and I'll give further explanation below.
>
> One practical way to see how this is so, is by considering unix's
> shell syntax. You all know, how convenient and powerful is the
> unix's pipes. Here are some practical example: “ls -al | grep xyz”,
> or “cat a b c | grep xyz | sort | uniq”.
>
> Now suppose, we get rid of the unix's pipe notation, instead,
> replace it with a pure functional notation: e.g. (uniq (sort (grep
> xyz (cat a b c)))), or enrich it with a composition function and a
> pure function construct (λ), so this example can be written as:
> ((compose (lambda (x) (grep xyz x)) sort uniq) (cat a b c)).
(pipe (cat a b c) (grep xyz) (sort) (uniq))
'Nuff said.
UNIX pipe `|' is not just a throw-away syntactic separator, anyone
with LISP experience would see it for what it is: a function that
operates on functions.
> Lisp, by sticking with almost uniform nested parenthesis notation,
> it immediately reduces the pattern of sequencing functions, simply
> because the syntax does not readily...<snip>
I would contend that LISP did not do this. You did.
<snip>
> (Note: Lisp's sexp is actually not that pure. It has ad hoc syntax
> equivalents such as the “quote” construct “ '(a b c) ”, and also
> “`”, “#”, “,@” constructs, precisely for the purpose of reducing
> parenthesis and increasing readability. Scheme's coming standard the
> R6RS ↗, even proposes the introduction of [] and {} and few other
> syntax sugars to break the uniformity of nested parenthesis for
> legibility. Mathematica's FullForm, is actually a pure nested
> notation as can be.)
Some functions are used so often, they have shorthand equivalents.
This is a feature in many languages. But if for some reason one
wanted the sexp to be "pure," nothing's stopping him from using the
fully-parenthesized versions.
> -------
> The above, is part of a 3-part exposition:
> “The Concepts and Confusions of Prefix, Infix, Postfix and Fully
> Functional Notations”,
> “Prefix, Infix, Postfix notations in Mathematica”,
> “How Lisp's Nested Notation Limits The Language's Utility”,
> archived at:
> http://xahlee.org/UnixResource_dir/writ/notations.html
>
> Xah
> x...@xahlee.org
> ∑ http://xahlee.org/
>
I suggest you start to acquaint yourself with LISP before getting too
far into the exposition:
--
Edward
D Herring
> How Lisp's Nested Notation Limits The Language's Utility
I didn't read your thesis, but the general premise is correct.
Caution: late-night ramblings follow. Proceed with caution.
The solution is simple: do something in Lisp that is nearly impossible
in other languages.
Do something that is anathema to the programmer machismo.
Write an interactive, point-and-click interface that lets users edit
Lisp code as block diagrams, seamlessly transforming back and forth
between s-expressions and widgets.
In another project, write macros that convert Basic code into idiomatic
Lisp.
Provide the user with "UI/syntax macros" that can present code in any
number of forms.
With such frameworks in place, the truth will be exposed: All languages
are "preprocessed Lisp"; their only essential difference is the
preferred syntax and the libraries provided.
Definition: Turing-complete, n., an expression of Lisp.
(I should really get some sleep now.)
Seriously, though. The lisp environment is overwhelming to the new
user. Everything is foreign; they should offer a course in the history
department just so people can understand all the thoughts that resulted
in what we have today.
I "learned programming" by typing hex codes from magazines into a VIC20;
when these didn't work, I finally entered the BASIC checksum program to
help identify where things went wrong. This was foreign, but Commodore
basic provided a simple interface for the types of interactive
programming that Lisp excels at. I learned "for loops" by bouncing *'s
across the screen... I can only imagine what it would happen if I were
at that age trying the same experiments today... construct a widget, add
a text panel, oops can't position text, try a blank panel, figure out
which command draws text... 2 years later?
What will future generations learn to program on? The abomination known
as Visual Basic? Perl, Python, and other "scripting languages"? Almost
certainly not Lisp. Dr.Scheme (or whatever had the simple built-in
Windows IDE) was my first introduction to Lisp, and I must say that
Commodore and GRA (? AtariST) basic were much easier to grasp -- largely
due to the linguistic nature of their commands.
Lisp has a full suite of macros for morphing code; but the main efforts
to fix the syntax always seem to result in new compilers being written
(Dylan anyone?). Why can't we have syntax macros?
We need something that new coders can grasp easily. If it runs on a
thin layer over Lisp, then they will learn to see through the facade --
and hopefully avoid the brain damage encoded in restrictive programming
paradigms enforced by inferior language systems. Plus code written in
the "simple" syntax will be translated by these syntax macros into
idiomatic Lisp code, thus providing an interactive lesson in Lisp.
Treat Lisp as the bytecode of a universal "virtual machine".
I've cobbled together a simple framework inspired by Terence Parr's
Antlr and StringTemplate libraries. These (Mr. Parr's libraries) are
excellent libraries that implement a fairly , ignoring their linguistic
implementation. Something like this in Lisp should be just the key to
providing a standardized syntax macro framework...
/end transmission
fireblade
> (o o)
> |~~~~ooO~~(_)~~~~~~~|
> | Please |
> | don't feed the |
> | TROLL! |
> '~~~~~~~~~~~~~~Ooo~~'
> |__|__|
> || ||
> ooO Ooo
>
fireblade
>
> - Show quoted text -
___________________________
/| /| | |
||__|| | Please don't |
/ O O\__ feed |
/ \ the trolls |
/ \ \ |
/ _ \ \ ----------------------
/ |\____\ \ ||
/ | | | |\____/ ||
/ \|_|_|/ | __||
/ / \ |____| ||
/ | | /| | --|
| | |// |____ --|
* _ | |_|_|_| | \-/
*-- _--\ _ \ // |
/ _ \\ _ // | /
* / \_ /- | - | |
* ___ c_c_c_C/ \C_c_c_c____________
Sorry for double posting but I'm getting sick of Xah Lee and Jon
Harrop.
We all get their message :COMMON LISP SUCKS so please let us leave in
our misery
while you make all the great programms in F#, Mathematica or
whatever ...
>From now on I'll ignore both of them for good .
cheers
bobi
Xah Lee
«(1) Some 99% of programers are not used to the nested parenthesis
syntax. This is a practical problem. On this aspect along, lisp's
Ken Tilton wrote:
«Simply wrong. What would be a problem would be if they tried it and
could not quickly get used to it.»
I think what you said is part of what i said. But let me elaborate.
Lisp's nested parenthesis certainly is a problem, if you want to
attract programers to lisp and programers are not attracted by sexp in
the first place.
What you expressed, is to consider the question of whether people can
get used to sexp. If programers cannot adapt sexp and find it
comfortable as a syntax of a programing language, then, you consider
THAT, to be a problem of the lisp syntax. Otherwise no problemo.
I think you vantage point is not so goody. But if we consider the
question itself, i think yes, people can adapt and use sexp reasonable
well for programing. Actually, this has been already done i guess by
lispers for 40+ years right? But if we really focus on this point of
view, namely: whether sexp can be suitable as a syntax for computing
language. Then, that is rather not a interesting question i thinky.
Because, in general, people can adapt to all kind of wierd shits,
really depending how pressing the matter is. If it is life
threatening, or they have no other choice, human animals can adapt.
Imagine, compare, the technology today are far advanced than 40 years
ago. Computers are what? a thousand, ten thousand times faster? And
there's no Perl, Python, Java, Internet 40 years ago. But People went
to the Moon! Imagine, what kind of torturous pain these people have
to go thru in software and hardware or the computation of mathematics
to do this. BASIC with GOTO and FORTRAN? What? no structured
constructs? No code blocks? No libraries? No symbols? No macros? Not
even Eval()? No USB and DVDs but punchcards?
You know about Chinese characters right? To a European, Chinese
characters looks torturous. But in fact it is. Just consider the
number of strokes. But i think Chinese people of 13 billion are
surviving.
Sure. I certainly agree human animals can get used to sexp. Under
some conditions, human animals can get used to a lot of things, and
loving it too.
See:
• “Body and Mind Modification”
http://xahlee.org/Periodic_dosage_dir/20031129_body_mod.html
• “Difficulty Perceptions in Human Feats”
http://xahlee.org/vofli_bolci/juggling.html
The interesting question would be, to what degree of botchedness of
computer language syntax can be, until programers will not be able to
adapt it and code it fruitfully? Suppose, for each paren in lisp, we
double it. So, “(+ 3 4)” will be written as “((+ 3 4))”. And suppose
we force this to be the new syntax for lisp. I will bet you one
hundred bucks, that all lispers will find in exactly as easy to read
as before.
How many level of parens do you think we can add till all lispers
abandon ship?
How many?
----------------------------
Xah Lee wrote:
«(2) Arguably, the pure nested syntax is not natural for human to
read. Long time lispers may disagree on this point.»
Kenny wrote:
«No code is natural to read, and yes, I have written a ton of COBOL.
Neither are legal or scholarly natural language texts natural to
read.»
Huh? surely you agree that there is at least some qualification as to
some written language being more natural or easier to read?
For example, compare language A and B, where A is just lisp's sexp,
and B is sexp with every paren replaced by double parens. Now, which
is more “natural” or easy to read?
So, likewise, compare Perl and Python. Which is easier to read in
general? You can't wax philosophy on this can you?
Imagine a philosophical scenario, where a devil killed off all
pythoners on earth. Therefore perl code is easier to read, because
nobody would understand a fuck when shown a python code. So, the
question of whether Perl or Python code is easier to read, depends.
Also, i mean, it depends on the programer!! Because, if i write Perl
code versus a moron writing in Python, then my Perl code will sure be
easier to read. So, it also depends on me.
What a great tough undecidability!
----------------------------
Xah Wrote:
«(3) Most importantly, a pure nested syntax discourages frequent or
advanced use of function sequencing or compositions. This aspect is
the most devastating.»
Kenny wrote:
«The example you chose was a command line, where conciseness rules and
where one is not likely to encounter refactoring or macros. ie, the
syntax for a command-line has nothing to do with the syntax for
serious programming.»
Yes the example i gave was unix's shell. It is chosen because it is
simple to illustrate and widely known.
I could give Mathematica examples with explanations... but its not
suitable as the simple unix pipe example because then i'll have to
spend great space explaining Mathematica.
(if anyone is interested in Mathematica syntax, i explained some here
http://xahlee.org/UnixResource_dir/writ/notations.html
)
But anyway, here's a few mathematica example from my Plane Tiling
package.
Here's one line that's the most simple to understand:
Reflect2DGraphics[{a1_, a2_}, {n1_, n2_}][gra_] :=
(Translate2DGraphics[{n1, n2}])@
(Reflect2DGraphics[{a1,a2}])@
(Translate2DGraphics[-{n1, n2}][gra]);
Basically, you'll see on the right side are 3 sequence of functions.
The left side is a function applied to a function. i.e.
Reflect2DGraphics takes 2 vectors and “returns” a function that takes
one graphics argument. (it doesn't actually return a function since
it's written as pattern matching... but you can think of it as a
function generator)
Here's the lispy form some lisper believe is easier to read:
CompoundExpression[
SetDelayed[
Reflect2DGraphics[List[Pattern[a1, Blank[]], Pattern[a2,
Blank[]]],
List[Pattern[n1, Blank[]], Pattern[n2, Blank[]]]][
Pattern[gra, Blank[]]],
Translate2DGraphics[List[n1, n2]][
Reflect2DGraphics[List[a1, a2]][
Translate2DGraphics[Times[-1, List[n1, n2]]][gra]]]], Null]
The following are more code. They involve pure functions, function
application, function mapping, function generator applied to
functions... and basically all done with flat sequencing of functions
when possible. (aka function chaining sans nesting). Whenever you see
the ampersand sign &, its a pure function (aka lambda). Some pure
function has pure function as its innards.
These are written in 1997, by yours truely. I would say, if you have
not been coding lisp or Mathematica for, say, 40 hours a week for 4
years, you wouldn't understand these code when explained. (not
considering the math it is doing)
Okie, here's a good one. Lots of sequencing of pure functions on the
fly:
cycledMatrix[{m_Integer, n_Integer}, cycleLists : {_List ..}] :=
Module[{}, (Flatten[({Table[#1, {Quotient[#2, #3]}],
Take[#1, Mod[#2, #3]]} &) @@ ({#, m,
Length@#} &)@#] &) /@
Flatten[(({(Flatten[#, 1] &)@Table[#1, {Quotient[#2, #3]}],
Take[#1, Mod[#2, #3]]} &) @@ ({#, n, Length@#} &)@
cycleLists), 1]];
Btw, the “f@@g” you see is shortcut syntax for “Apply[f,g]”.
Here's the equivalent lispy form, lispers think its easier to read:
CompoundExpression[
SetDelayed[
cycledMatrix[
List[Pattern[m, Blank[Integer]], Pattern[n, Blank[Integer]]],
Pattern[cycleLists, List[Repeated[Blank[List]]]]],
Module[List[],
Map[Function[
Flatten[Apply[
Function[
List[Table[Slot[1], List[Quotient[Slot[2],
Slot[3]]]],
Take[Slot[1], Mod[Slot[2], Slot[3]]]]],
Function[List[Slot[1], m, Length[Slot[1]]]]
[Slot[1]]]]],
Flatten[Apply[
Function[
List[Function[Flatten[Slot[1], 1]][
Table[Slot[1], List[Quotient[Slot[2],
Slot[3]]]]],
Take[Slot[1], Mod[Slot[2], Slot[3]]]]],
Function[List[Slot[1], n, Length[Slot[1]]]]
[cycleLists]], 1]]]],
Null]
----------------------------------------
Okie, another one, wee!
ColoredLatticeNetwork[n:(4 | 3), m_Integer,
colors:{_List..}, s_, a_, {x_, y_}] :=
Module[{lines, gp}, lines = (Map[Line, #1, {2}] & )[
(Partition[#1, 2, 1] & ) /@
N[Table[{1, 0}*s*i + ({Cos[#1], Sin[#1]} & )[
(2*Pi)/n]*s*j, {j, -m, m}, {i, -m, m}]]];
gp = (Transpose[#1, {3, 1, 2}] & )[
{cycledMatrix[{m*2, m*2 + 1}, (RotateRight[#1, m] & )[
(RotateRight[#1, m] & ) /@ colors]], lines}];
Translate2DGraphics[{x, y}][
Table[Rotate2DGraphics[{0, 0}, ((2*Pi)*i)/n + a][
gp], {i, 0, n - 1}]]];
Here's the equivalent lispy form lisp morons insist it is easier to
read:
CompoundExpression[
SetDelayed[
ColoredLatticeNetwork[Pattern[n, Alternatives[4, 3]],
Pattern[m, Blank[Integer]],
Pattern[colors, List[Repeated[Blank[List]]]], Pattern[s,
Blank[]],
Pattern[a, Blank[]], List[Pattern[x, Blank[]], Pattern[y,
Blank[]]]],
Module[List[lines, gp],
CompoundExpression[
Set[lines,
Function[Map[Line, Slot[1], List[2]]][
Map[Function[Partition[Slot[1], 2, 1]],
N[Table[
Plus[Times[List[1, 0], s, i],
Times[Function[List[Cos[Slot[1]], Sin[Slot[1]]]]
[
Times[Times[2, Pi], Power[n, -1]]], s, j]],
List[j, Times[-1, m], m], List[i, Times[-1, m],
m]]]]]],
Set[gp, Function[Transpose[Slot[1], List[3, 1, 2]]][
List[cycledMatrix[List[Times[m, 2], Plus[Times[m, 2],
1]],
Function[RotateRight[Slot[1], m]][
Map[Function[RotateRight[Slot[1], m]], colors]]],
lines]]],
Translate2DGraphics[List[x, y]][
Table[Rotate2DGraphics[List[0, 0],
Plus[Times[Times[Times[2, Pi], i], Power[n, -1]], a]]
[gp],
List[i, 0, Plus[n, -1]]]]]]], Null]
--------------------------------
Okie, this one is a simple one.
StarMotif[n_Integer, coords_?MatrixQ, s_, α_, {x_, y_}] :=
Polygon@(Flatten[#, 1] &)@
Transpose@
Map[Table[{Cos[t + Last@#], Sin[t + Last@#]}*First[#]*s +
{x,
y}, {t, α, 2*Pi + α - 2*Pi/n/2, 2*Pi/n}] &,
coords];
Now, the easier-to-read lisp form follows:
CompoundExpression[
SetDelayed[
StarMotif[Pattern[n, Blank[Integer]],
PatternTest[Pattern[coords, Blank[]], MatrixQ], Pattern[s,
Blank[]],
Pattern[α, Blank[]],
List[Pattern[x, Blank[]], Pattern[y, Blank[]]]],
Polygon[Function[Flatten[Slot[1], 1]][
Transpose[
Map[Function[
Table[Plus[
Times[List[Cos[Plus[t, Last[Slot[1]]]],
Sin[Plus[t, Last[Slot[1]]]]], First[Slot[1]],
s],
List[x, y]],
List[t, α,
Plus[Times[2, Pi], α,
Times[-1,
Times[2,
Times[Times[Pi, Power[n, -1]], Power[2,
-1]]]]],
Times[2, Times[Pi, Power[n, -1]]]]]], coords]]]]],
Null]
--------------
This one is semantically and geometrically complex!
SlitLine[Line[pts_List /; (Length@pts > 2)], cuttingLine : {{_, _},
{_, _}}] :=
Module[{temp},
If[SameQ @@ (temp = PointOnLeftSideQ[#, cuttingLine] & /@ pts),
Return@List@Line@pts];
temp = MapThread[
And[#1, #2] &, {(UnsameQ @@ # &) /@
Partition[temp, 2,
1], (PointOnLeftSideQ[First@cuttingLine, #] =!=
PointOnLeftSideQ[Last@cuttingLine, #] &) /@
Partition[pts, 2, 1]}];
temp = Append[#, Null] &@
MapThread[
If[#2, 0@LineIntersectionPoint[#1, cuttingLine],
Null] &, {Partition[pts, 2, 1], temp}];
temp = (DeleteCases[#, Null, {1}] &)@Flatten[Transpose@{pts, temp},
1];
(Line /@
ReplaceRepeated[
List@temp, {a__, 0[pt_], b__} :> Sequence[{a, pt}, {pt,
b}]])]
Now, the spectacular lisp form:
SetDelayed[
SlitLine[Line[
Condition[Pattern[pts, Blank[List]], Greater[Length[pts],
2]]],
Pattern[cuttingLine,
List[List[Blank[], Blank[]], List[Blank[], Blank[]]]]],
Module[List[temp],
CompoundExpression[
If[Apply[SameQ,
Set[temp,
Map[Function[PointOnLeftSideQ[Slot[1], cuttingLine]],
pts]]],
Return[List[Line[pts]]]],
Set[temp,
MapThread[Function[And[Slot[1], Slot[2]]],
List[Map[Function[Apply[UnsameQ, Slot[1]]],
Partition[temp, 2, 1]],
Map[Function[
UnsameQ[PointOnLeftSideQ[First[cuttingLine],
Slot[1]],
PointOnLeftSideQ[Last[cuttingLine], Slot[1]]]],
Partition[pts, 2, 1]]]]],
Set[temp,
Function[Append[Slot[1], Null]][
MapThread[
Function[
If[Slot[2], 0[LineIntersectionPoint[Slot[1],
cuttingLine]],
Null]], List[Partition[pts, 2, 1], temp]]]],
Set[temp,
Function[DeleteCases[Slot[1], Null, List[1]]][
Flatten[Transpose[List[pts, temp]], 1]]],
Map[Line,
ReplaceRepeated[List[temp],
RuleDelayed[
List[Pattern[a, BlankSequence[]], 0[Pattern[pt,
Blank[]]],
Pattern[b, BlankSequence[]]],
Sequence[List[a, pt], List[pt, b]]]]]]]]
If you want to see more, you can download my package at
http://xahlee.org/MathGraphicsGallery_dir/PlaneTilingPackageDemo_dir/planeTilingPackageDemo.html
Free of charge.
Malcolm McLean
"Miles Bader" <mi...@gnu.org> wrote in message
news:873b2cx...@catnip.gol.com...
in both the good and the bad sense of the term, and rather eccentric.
--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm
Malcolm McLean
"Kaz Kylheku" <kkyl...@gmail.com> wrote in message
news:1178325041....@w5g2000hsg.googlegroups.com...
On May 4, 5:11 pm, Xah Lee <x...@xahlee.org> wrote:
>> How Lisp's Nested Notation Limits The Language's Utility
>> Long time lispers may disagree on this point.
>
>Programming language syntax shouldn't be natural for humans to read.
>Or, rather, this shouldn't be a requirement which creates technical
>compromises.
>
technical compromises whatsoever - pure assembly or machine code - but only
rarely. Most of the time we accept some limitations for the sake of making
things easier for the human programmer. That includes run-time efficiency,
but also restrictions in the "power" of the language.
You might be interested in the page 10 Rules of Computer Programming on my
website which deals with psychological issues in programming. Lisp breaks
the rule of three in spades.
Rainer Joswig
fireblade <slobodan...@gmail.com> wrote:
I fully agree. Neither of them as any (!) clue about Lisp and programming in Lisp.
Neither of them has written any significant or even non-significant Lisp program.
Their postings are full of (wrong) assumptions and are mostly based on
no experience and no knowledge of Lisp programming. Both are only trolling
in comp.lang.lisp. Best to post a warning sign and other to ignore them...
Pascal Costanza
> How Lisp's Nested Notation Limits The Language's Utility
>
> Xah Lee, 2007-05-03
>
> There is a common complain by programers about lisp's notation, of
> nested parenthesis, being unnatural or difficult to read. Long time
> lisp programers, often counter, that it is a matter of conditioning,
> and or blaming the use of “inferior” text editors that are not
> designed to display nested notations. In the following, i describe how
> lisp notation is actually a problem, in several levels.
>
> (1) Some 99% of programers are not used to the nested parenthesis
> syntax. This is a practical problem. On this aspect along, lisp's
> syntax can be considered a problem.
Lisp doesn't have a problem here. Lisp is a programming language, an
inanimate, dispassionate, virtual concept which doesn't (cannot!) "care"
whether it is used at all.
Only people can have problems with something. For example, programmers
who want some of the cool features of Lisp but don't want to put up with
its syntax.
However, for decades, there have been programmers who have learned to
prefer Lisp's syntax over anything else. As long as they continue to
exist, Lisp dialects will continue to exist. Those people don't have a
problem - to the contrary.
Leave them alone - they are happy with their choice.
If you don't like Lisp, there are numerous attempts to copy its features
using other surface syntaxes. Just pick one.
Pascal
--
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
Markus E Leypold
"Malcolm McLean" <regn...@btinternet.com> writes:
> "Miles Bader" <mi...@gnu.org> wrote in message
> news:873b2cx...@catnip.gol.com...
>> "Robert D. Crawford" <rd...@comcast.net> writes:
>>> If it is emacs that makes you happy, then change the things you don't
>>> like and be happy but I fail to see how your whining diatribes serve
>>> any useful purpose. If you don't like lisp then by all means use
>>> something else.
>>
>> Xahlee likes to complain. That's the main factor here.
>>
> There is thought and intelligence in his posts. However they are
> provocative in both the good and the bad sense of the term, and rather
Where is the good sense in there? We have (at c.l.f) people
complaining about parenthesis in lisp every 3 months and the arguments
never get any better or new. Rehashing all that once again doesn't
attest to "thought and intelligence" but rather to a trollish streak.
Regards -- Markus
Markus E Leypold
Rayiner Hashem <ray...@gmail.com> writes:
>> (1) Some 99% of programers are not used to the nested parenthesis
>> syntax. This is a practical problem. On this aspect along, lisp's
>> syntax can be considered a problem.
>
> The first time I saw graph-theory notation, I thought it was
> gibberish. I still think most mathematical notation is gibberish, but
> I deal with it --- I don't turn in proofs written in prose.
Right.
>
>> (2) Arguably, the pure nested syntax is not natural for human to read.
And BTW, it's not natural for humans to read at all.
:-)
>> Long time lispers may disagree on this point.
>
> And mathematical notation is not natural for people to read, at least
> not anybody who grew up learning a natural language. But people deal
> with it. They're remarkably adaptable this way.
Regards -- Markus
Miles Bader
<development-2006-8...@ANDTHATm-e-leypold.de> writes:
> Where is the good sense in there? We have (at c.l.f) people
> complaining about parenthesis in lisp every 3 months and the arguments
> never get any better or new. Rehashing all that once again doesn't
> attest to "thought and intelligence" but rather to a trollish streak.
Indeed, and people have been saying what Xahlee's saying since the
_1950s_! Lisp still has the parens, and there are good reasons for that.
-Miles
--
[|nurgle|] ddt- demonic? so quake will have an evil kinda setting? one that
will make every christian in the world foamm at the mouth?
[iddt] nurg, that's the goal
Miles Bader
> You might be interested in the page 10 Rules of Computer Programming on
> my website which deals with psychological issues in programming. Lisp
> breaks the rule of three in spades.
That suggests that the "rule of three" is wrong...
-Miles
--
o The existentialist, not having a pillow, goes everywhere with the book by
Sullivan, _I am going to spit on your graves_.
Markus E Leypold
"Malcolm McLean" <regn...@btinternet.com> writes:
> You might be interested in the page 10 Rules of Computer Programming
> on my website which deals with psychological issues in
> programming. Lisp breaks the rule of three in spades.
Rule three is about indirection, not about nesting. The other rules
suck also. If your "Refutation of Common Atheist Arguments" have a
similar quality, the atheists will have a field day.
Regards -- Markus
Ken Tilton
Xah Lee wrote:
> Xah Lee wrote:
> «(1) Some 99% of programers are not used to the nested parenthesis
> syntax. This is a practical problem. On this aspect along, lisp's
> syntax can be considered a problem.»
>
> Ken Tilton wrote:
> «Simply wrong. What would be a problem would be if they tried it and
> could not quickly get used to it.»
>
> I think what you said is part of what i said. But let me elaborate.
>
> Lisp's nested parenthesis certainly is a problem, if you want to
> attract programers to lisp and programers are not attracted by sexp in
> the first place.
Ah, but now you are talking about marketing, and I happen to believe
that one does not win at marketing by throwing out one of the best
features of the language.
Do things well and people will find you. Why else has Lisp recovered
from the AI Winter? When has a computer language ever made a comeback?
Below you suggest I may be blinded by perspective. My question to you
is, do /you/ appreciate the importance of parens? If not, your
perspective is the problem.
>
> What you expressed, is to consider the question of whether people can
> get used to sexp. ...snip... Then, that is rather not a interesting question i thinky.
> Because, in general, people can adapt to all kind of wierd shits,
I understand how you went wrong, but you have read something into what I
wrote and are now off on a tangent by yourself, complete with
bibliography <g>. Nowhere did I say people would have to struggle to
appreciate parens, what I said was that it is not interesting if people
who have never tried Lisp complain about the parens. The only
interesting repsondent is one who has tried Lisp for some reason, and no
such person has ever had a problem with the parens. You are reacting to
word of mouth from people who have never tried Lisp, and that means
nothing. Give someone a microphone, they will say something.
But this is all Usenet hair-splitting. The bottom line is this: all
Lispers learned parens at some point, and know from experience that it
was easy for them, that it would be easy for anyone, and that parens are
an absolute advantage. If you disagree on any of those points we likely
will not find common ground.
[a bunch more on the mistaken idea that parens are an acquired taste]
> The interesting question would be, to what degree of botchedness of
> computer language syntax can be, until programers will not be able to
> adapt it and code it fruitfully? Suppose, for each paren in lisp, we
> double it. So, “(+ 3 4)” will be written as “((+ 3 4))”. And suppose
> we force this to be the new syntax for lisp. I will bet you one
> hundred bucks, that all lispers will find in exactly as easy to read
> as before.
You seem deeply convinced that parens /are/ a problem? Perhaps the story
here is that they /do/ confuse you. Anyway, the above is thoroughly
wrong. Lispers hate line noise, which is why they love parens and why
they use macros such as my BIF, which changes:
(let ((x (look-up y)))
(when x (print (list x 42))))
to:
(bwhen (x (look-up y))
(print (list x 42)))
Come to think of it, one reason I like loop is that it lets me express
iteration without so many parens. I guess I am making a tradeoff in
which I accept locally a burden to think about syntax in return for
being able to dash off commonly written code (which commonness means the
syntax will be second-nature). And a big point you have missed: I still
get decent auto indentation of my code even with the whacky loop syntax.
Note, btw, that your second set of parens adds nothing. The first
brilliantly captures lexically that the operator along with its operands
forms a meaningful semantic chunk....hang on.... eureka! So do the
arguments, so (+ 2 3) should really be (+ (2 3)). Ah, but then (+ 40 (-
4 2)) becomes (+ (40 (- (4 2)))... well, I guess Lispers /do/ worry
about readability. :)
Meanwhile, you owe me $100. Paul Graham, at ILC '2003 (? In NYC), said
one problem he wanted to fix with Arc was that Lisp had too many
parnetheses. He picked on COND as an example.
But only because you think the only thing that makes a computer language
readable is experience with it. And you are stuck on the idea of
readability being important, another big mistake. We /write/ code, we do
not read it. The important thing is to make the writing easy. The parens
make writing code code (guessing) twice as easy, certainly refactoring.
Another mistake: code ever being as readable as Stephen King. Nope, with
code one /always/ has to slow down to figure out what is going on.
I think you are also missing that the parens also mean there is a ton of
syntax and precedence I do not need to learn or make mistakes on. One
simple rule and I am good to go.
You need to remember, Xah, that any Lisper is master also of other
computer languages, because we likely pay the bills with something else.
You seem to have a mental model of us in which the only thing we know is
Lisp.
>
> ----------------------------
> Xah Wrote:
> «(3) Most importantly, a pure nested syntax discourages frequent or
> advanced use of function sequencing or compositions. This aspect is
> the most devastating.»
>
> Kenny wrote:
>
> «The example you chose was a command line, where conciseness rules and
> where one is not likely to encounter refactoring or macros. ie, the
> syntax for a command-line has nothing to do with the syntax for
> serious programming.»
>
> Yes the example i gave was unix's shell. It is chosen because it is
> simple to illustrate and widely known.
Well, the problem with examples is the problem with analogies: even if
we agree with the proffered case, what does that add to the discussion?
How well does it apply? What does it say? It just opens up a whole new
thread. The second set of parens is different from the first, a
command-line is not a 3gl with pages of text (and to head you off, if I
was writing a ten-line shell script, yes, I would want sexprs).
How on Earth is that Lispy??! Bring the operator inside, then lose the
[]s and commas. Puzzled.
kenny
geek-no-sexp
> Xah Lee wrote:
[...]
> programers are not attracted by sexp in the first place.
No sex-p ?
Why wonder then why so many women see us geeks as wussies ... :(
Anton van Straaten
Perhaps it's not a coincidence that these two seemingly unrelated
arguments are offered by the same person. Both religious belief and a
belief in the essential importance of syntactic sugar require abandoning
Occam's Razor.
Anton
Xah Lee
Xah Lee wrote:
« (1) Some 99% of programers are not used to the nested parenthesis
syntax. This is a practical problem. On this aspect along, lisp's
syntax can be considered a problem.»
Pascal Costanza wrote:
«Lisp doesn't have a problem here. Lisp is a programming language, an
inanimate, dispassionate, virtual concept which doesn't (cannot!)
"care" whether it is used at all. Only people can have problems with
something. For example, programmers who want some of the cool features
of Lisp but don't want to put up with its syntax. »
You are actually wrong here, because, people can't have a problem.
People are animals, made of meat. They can have a problem when, they
get sick, and their body will disfunction or function abnormally. So,
for example, even sexp has all the problems, lisp morons are still
fine.
Pascal fuckhead wrote:
«However, for decades, there have been programmers who have learned to
prefer Lisp's syntax over anything else. As long as they continue to
exist, Lisp dialects will continue to exist. Those people don't have a
problem - to the contrary.»
existence?
my god... you are quite desperate.
In this thread, a few people already started to post completely off
topic, brainless, pure personal attacks. I think you are still good.
Sometimes i have a problem telling, of those who post brainless things
to my articles, whether they are joking with wanton carelessness, or
if their critical thinking abilities is really that low.
For example, your reply is a good example. I wasn't sure, if you are
just fucking with me, or really, really meant your writing as a valid
argument to my thesis. In this thread, Ken Tilton, also wrote
something that's incredibly stupid. In fact, more or less repeating
what i said, just with antagonism and explicit denial. I take it, that
he acted that way probably because my essay is so cogent and powerful
that it hit a nerve and paralyzed his reasoning faculties and numbed
his nonchalant quip Muse.
There are some others in this thread, which are so hateful, fucking
full of the ugliness of humanity. The replies from Markus E Leypold is
a prime example. I wonder, outside of newsgroups, if he is just a
sophomoron at college.
Other posts in this thread, some sincere ones, are full utterly
fucking stupid drivels. (or i shall put the polite version: logical
fallacies) The level is so low that i'm really ashamed that they
really came out from the mouthes of a class of people in society who's
jobs are to program computers.
(in this regard, see:
The Condition of Industrial Programers
http://xahlee.org/UnixResource_dir/writ/it_programers.html
)
For example, there's this gem: «Programming language syntax shouldn't
be natural for humans to read. Or, rather, this shouldn't be a
requirement which creates technical compromises.»
I think this quote or the concept of it has been around for a while.
If you take it seriously, it's full of MOTHERFUCKING nonsensical,
meaningless, shit. It amounts to a sound bite. Behind it, it wants to
make programers, in particular the elite programers like the lisp
fuckers, to think something along the line: “my syntax is so bizarre
because i'm superior”.
I guess it's lisper's version of “The three chief virtues of a
programmer are: Laziness, Impatience and Hubris”.
Pascal Costanza moron wrote:
«Leave them alone - they are happy with their choice. »
«If you don't like Lisp, there are numerous attempts to copy its
features
using other surface syntaxes. Just pick one. »
Try, perhaps, learn to calm down yourself. You are not under attack.
Lisp the language, is not under attack by my essay. My article,
although cogently detailed why lisp syntax is a serious problem at
several levels, it does not mean that, it is “no good” in some
absolute way. Also, it is far better, then essentially all imperative
language's syntaxes. Even, one can logically agree with my article,
and remain positive, because although lisp perhaps reduce the use of
function sequencing, but that by itself is not necessarily a very bad
thing. Because, function sequencing (aka chaining), although a very
important paradigm, is not necessarily the only way to program, nor
the only way for functional programing. Consider, even today in the
light of OOP. And Common Lisp, in particular, isn't all that much
concerned about purity of functional programing anyway. So logically,
from this perspective or argument, my essay isn't a damning
certificate.
I'm really sorry i have to say the above paragraph, as if like a pat
on the back to some crying pussies. But the juvenility, sensitivity,
ignorance, and stupidity, as shown in the responses in this thread,
made me.
I was hoping, perhaps due to my clear exposition of the sexp problem
for perhaps the first time, that we could move on to other fruitful
discussions, not necessarily agree that it is a problem. For example,
LOGO, DyLan, Arc all abandoned the nested fuck. I mean, lispers may
disagree, but the people behind these LISP languages are not brainless
fuckheads, are they? Alternatively, i was hoping, perhaps there will
be fruitful discussions in the direction of technical issues of
transforming syntax. i.e. of Mathematica's f[a,b] and lisp's (f a b).
Or, perhaps some technically knowledgable people here (there are many)
can by ways of chat, impart some insight about some technical
connections between syntaxes and semantic (apart from myself). For
example, DyLan i believe once was believed to have have sexp
underneath. If so, that would be interesting because it gives us a
actual, existing, example of a lang with sexp underneath alternative
to Mathematica's ways. But also, lisp can actually relatively easily,
create a layer of syntax on top of sexp...
Really, you people need to learn. Be calm. Keep your mind open. I'm
not attacking you or attacking lisp. If there's any attacking, it is
your immature and unhealthy nerve.
PS By the way, i also responded a article recently about why Perl and
Python programers today should learn lisp.
(
“Why learn lisp when there are python and perl?”, Xah Lee, 2007-05-03.
http://xahlee.org/UnixResource_dir/writ/wl_lisp.html
)
Can a lisper write a open letter thanking me for that please?
Tim Bradshaw
> How Lisp's Nested Notation Limits The Language's Utility
Very good. Now, off you go and design and implement an alternative
syntax. It's easy, it's been done hundreds of times. I think I have
two or three limited examples on my web site and several more I never
bothered publishing. There must, as I say, be hundreds of examples
around and probably thousands when you count all the non-published
ones. So pick the best and use them, or, since you're by far the
smartest person here, why not come up with your own? Jon Harrop can
probably help you.
Tamas
I am just a Lisp newbie, quietly lurking in this newsgroup,
occasionally asking questions. Some of these questions are
elementary, doubtless asked a zillion times before (even though I
always search the archives), but kind people in this newsgroup always
give me a lot of helpful answers and hints.
Even though I cannot prevent it, I hate to see them being called names
by a disgruntled teenager (or someone with an equivalent level of
social skills).
So far, I have been using Google Groups, but that has no filtering.
Could somebody please recommend a reliable and cheap (or a convex
combination of the two ;-) news server? I have seen them mentioned in
the past before, but could not find them. Then I could use mutt or
something else to read news, and filter certain messages.
Thanks,
Tamas
PS: Sorry for the OT post, but this thread finally made it clear that
Google Groups (a great free service) is not the perfect solution for
increasing the signal/noise ratio.
On May 5, 11:52 am, Xah Lee <x...@xahlee.org> wrote:
> Dear Pascal moron,
>
[snip]
Mark Tarver
if you make a critical analysis of Lisp and people attack *you*. This
is called an ad hominem argument, and, sadly, they are all too common
on usenet. But calling people names like 'moron' is not the right
way to win hearts and minds. You say some interesting things but you
play into the hands of your critics by launching personal attacks.
Now you will probably get a load more posts attacking your bad manners
and so your original points are lost in the scrum and people write you
off as a troll.
Be cool and if you do think someone is using ad hominem arguments;
tersely point it out and return to the main points. Don't get
abusive.
Mark
> The Condition of Industrial Programershttp://xahlee.org/UnixResource_dir/writ/it_programers.html
Pascal Costanza
> Could somebody please recommend a reliable and cheap (or a convex
> combination of the two ;-) news server? I have seen them mentioned in
> the past before, but could not find them.
I use http://news.individual.net/ and am pretty happy with their service.
Ken Tilton
Tamas wrote:
> Ouch.
>
> I am just a Lisp newbie, quietly lurking in this newsgroup,
> occasionally asking questions. Some of these questions are
> elementary, doubtless asked a zillion times before (even though I
> always search the archives), but kind people in this newsgroup always
> give me a lot of helpful answers and hints.
>
> Even though I cannot prevent it, I hate to see them being called names
> by a disgruntled teenager (or someone with an equivalent level of
> social skills).
We don't need your stinking concern. <kidding!>
Don't worry, Xah is OK. Google applications agreed are not. I use
Mozilla Thunderbird on win32 for mail and news (I have the mail from my
google account forwarded to my ISP mail address so I still get the
portable address and junk filtering).
kenneth
Malcolm McLean
"Anton van Straaten" <an...@appsolutions.com> wrote in message
news:WI1%h.2620$RX....@newssvr11.news.prodigy.net...
reasons, without irritating a lot of Lispers.
A programming language is inherently a compromise between the needs of the
human programmer and the needs of the computer. That's why the 10 rules of
computer programming are all psychological rules. There are many other
things you need to know to program a computer, but they are documented with
the system. The difference is, if you break a psychological rule then the
program still works, but it is too difficult to maintain.
The rules are also ones which people might be tempted to break - obviously
writing code with no comments and one letter identifiers is a bad idea, but
people don't need to be told that, so it's not a rule.
The rule of three was written before I was familiar with Lisp, and so you
might say that Lisp is a counter-example. I don't think it is, because the
first thing that everyone says about Lisp is "I can't do with all those
parentheses". In fact Lisp programmers use indentation to try to impose
another hierarchy of structure on the program, something they wouldn't need
to do if humans could glance at a long expression and match up parentheses.
Malcolm McLean
"Xah Lee" <x...@xahlee.org> wrote in message
news:1178380349.8...@l77g2000hsb.googlegroups.com...
>For example, there's this gem: «Programming language syntax shouldn't
>be natural for humans to read. Or, rather, this shouldn't be a
>requirement which creates technical compromises.»
>I think this quote or the concept of it has been around for a while.
>If you take it seriously, it's full of --------- nonsensical,
>meaningless, ----. It amounts to a sound bite. Behind it, it wants to
>make programers, in particular the elite programers like the lisp
>-----, to think something along the line: “my syntax is so bizarre
>because i'm superior”.
>
Now I also disagreed with Kaz on that one. Compare my post with yours. and
consider why I had to delete some many words in quoting you. Who do you
think is more likely to convince Mr Kylheku that he is in error?
Bob Felts
[...]
>
> But only because you think the only thing that makes a computer language
> readable is experience with it. And you are stuck on the idea of
> readability being important, another big mistake. We /write/ code, we do
> not read it. The important thing is to make the writing easy. The parens
> make writing code code (guessing) twice as easy, certainly refactoring.
We write /and/ read code. Sometimes, especially on large multi-team
projects, some of us spend more time reading it than writing it. One of
the things I have to keep pounding into the heads of our programmers is
that you aren't writing code for yourself and you certainly aren't
writing it for the computer -- you're writing it for other programmers.
That's why it's so important to remember rules such as:
1) "Write clearly -- don't be too clever"
2) "Say what you mean, simply and directly"
3) "Parenthesize to avoid ambiguity"
4) "Use the telephone test for readibility"
And so on, from "The Elements of Programming Style" by Kernighan and
Plaugher. [1]
We have engineers who, I kid you not, have used 9 lines of C code where
1 would do. Think that double and triple negatives are a reasonable way
of writing conditionals. Think that liberal use of temporary variables
is an excellent way of expressing onself. And so on.
This, of course, is true of all programming languages, not just Lisp.
So, while experience in the language contributes to readibility, it's
just (if not more important) that the code is written well. Joyce
certainly was experienced in English but I still find "Ulysses" a
dreadful chore.
-----
[1] I'd gladly buy a version of this book targeted to Lisp.
>
> Another mistake: code ever being as readable as Stephen King. Nope, with
> code one /always/ has to slow down to figure out what is going on.
>
> I think you are also missing that the parens also mean there is a ton of
> syntax and precedence I do not need to learn or make mistakes on. One
> simple rule and I am good to go.
>
> You need to remember, Xah, that any Lisper is master also of other
> computer languages, because we likely pay the bills with something else.
> You seem to have a mental model of us in which the only thing we know is
> Lisp.
>
Lee is suffering from the notion that there is a "natural" way of
expressing onself; the "natural" way, of course, being what he's used
to. The only "natual" language is the one spoken by God and I have the
feeling that He's an omniglot. Lisp, with its parenthesis, is no more
unnatural than Greek. And I like Greek. I can say things in it that I
can't say in English. Lee might as well complain that Greek uses an
"unnatural" alphabet, "funny" punctuation (like two kinds of "breathing
marks"), and an incredibly complex system of verb stems.
Lisp is the most elegant computer language I know, because it allows me
to express thoughts that are difficult to express in other languages.
Part of the reason for this is its syntax, just like one of the reasons
I can say things in Greek that I can't say in English are the different
verb tenses.
I also like Lisp because I can express more with less. Our company
decided to try PSP (Personal Software Process) using two teams as guinea
pigs. Lots of fanfare, classes, etc... Of course it turned out to be,
as Scott Adams might say, "a dead woodchuck". But as part of their
training, engineers had to code a set of eight exercises and collect
various metrics about the code. I think everyone used C; I certainly
did because I wanted to compare my time/size/defect metrics with the
other engineers. In order to improve my Lisp-fu, I later re-did the
exercises in Lisp. I was blown away by how much faster I could work.
The first exercise, for example, took 189 lines of C code but 51 lines
of Lisp. And the Lisp code did more; it had a built in test suite that
the C code did not.
Criticising a language based upon one small point of punctuation shows
that the critic doesn't know anything about languages. Best not to pay
any attention to them.
> >
> > ----------------------------
> > Xah Wrote:
> > «(3) Most importantly, a pure nested syntax discourages frequent or
> > advanced use of function sequencing or compositions. This aspect is
> > the most devastating.»
> >
> > Kenny wrote:
> >
> > «The example you chose was a command line, where conciseness rules and
> > where one is not likely to encounter refactoring or macros. ie, the
> > syntax for a command-line has nothing to do with the syntax for
> > serious programming.»
> >
> > Yes the example i gave was unix's shell. It is chosen because it is
> > simple to illustrate and widely known.
>
> Well, the problem with examples is the problem with analogies: even if
> we agree with the proffered case, what does that add to the discussion?
> How well does it apply? What does it say? It just opens up a whole new
> thread. The second set of parens is different from the first, a
> command-line is not a 3gl with pages of text (and to head you off, if I
> was writing a ten-line shell script, yes, I would want sexprs).
>
> >
> > I could give Mathematica examples with explanations... but its not
> > suitable as the simple unix pipe example because then i'll have to
> > spend great space explaining Mathematica.
> >
[...]
So what? Given _any_ language, human or machine, one can find an
example that is easily expressible in one but not in another. That's
one reason why we keep inventing languages. This will never stop unless
we can no longer find new things to express.
Ken Tilton
There ya go. Natural language is wonderfully ambiguous. We can lump a
lot of things into readability, including typeface and justification. In
this thread we of course must narrow it down to things language
specific. You have failed, and Mr. Bradshaw will be around later to pick
you up.
> Criticising a language based upon one small point of punctuation shows
> that the critic doesn't know anything about languages. Best not to pay
> any attention to them.
We need something to drown out the incessant threads about getting free
software to work.
:)
kxo
Xah Lee
«I think *you* need to cool down Xah Lee. I agree it can be annoying
if you make a critical analysis of Lisp and people attack *you*. This
is called an ad hominem argument, and, sadly, they are all too common
on usenet. ...»
«But calling people names like 'moron' is not the right way to win
hearts and minds....»
Exactly. I've been using online forums since 1990. I've been using
newsgroups since maybe 1994. If i wanted to play politics, given my IQ
and my knowledge of computing, and great skill of composition, i might
be a fucknig George Bush by now, with a massive army of morons at my
commands, not like, the likes of some computing industry leaders.
Understand, politness, is a intrinsic element of politics. (and
politics, means power-struggle) Politness arose from the existance of
hostility and aggression. Without aggression, there is no politness.
One easy way to see this, is notice how the behavior of politeness is
inversly proportional to how close are the parties involved. There
will be little politness, between your sisters, wives, or parents.
There will be a huge politeness, when big stakes are involved between
unbound human animals.
The computing newsgroups, made of males, have been brawling just about
when it begin. Your few words on politness and lecturing, is one
additional off-topic drivel in its history. (though, i appreciate your
kindness and your knowledge)
In this thread, i did not start four-letter words before NUMEROUS
fuckheads began sprouting purely unreasonable, totally off-topic,
personal attacks on me in a way more serious than name calling.
(because, it smacks of witch-hunting) (they naturally did this,
because they perceived that i “attacked” their computer language. This
is because, the computing language newsgroup tech geekers are utterly
ignorant of sociology, and combined with male power struggling
instict, have habored the thought about “trolling”, and some ethical
ideas about what one can or cannot say about other's computer
languages. Utterly bizarre.)
This doesn't happen to just me. It just a normal day in newsgroups.
Whoever, may it be professor, or eminent mathematician, professinoal
senior programers (as many are here), as long as he is a long time
newsgroup user, may have involved in verbal abuses given or taken.
(and each party are fully aware the other's social standings, but it
does'n matter. (e.g. in this very thread, a few started to gang up on
Jon Harrop, who is a author of a few functional language books)) It
is, the culture of newsgroups, so to speak. In a way, it is how people
WANT newsgroups to be the way it is. You knew it, i knew it, and we
should not deny it. If you are concerned about this state of affairs
of newsgroups, you need to rethink about it. Not the same old
instinctive good intentions. George motherfucking Bush has good
intentions and 50k to 300k Islamic civilians are dead. I'm sure you
are a kind man. Thousands of kind men existed in newsgroups before
you. They all have, at one time or another or more, given kind
advices, and contributed to what newsgroup is today.
I recommend a few articles. These articles, if tech geekrs all read
it, will help improve the state of affairs of newsgroups.
• What Desires are Politically Important? by Bertrand Russell
http://xahlee.org/Periodic_dosage_dir/_p2/russell-lecture.html
• Demonic Males. Apes and the Origins of Human Violence.
By Richard Wrangham and Dale Peterson
http://xahlee.org/p/demonic_males.html
Nice meeting you.
Drew Crampsie
> Ouch.
>
> I am just a Lisp newbie, quietly lurking in this newsgroup,
> occasionally asking questions. Some of these questions are
> elementary, doubtless asked a zillion times before (even though I
> always search the archives), but kind people in this newsgroup always
> give me a lot of helpful answers and hints.
>
> Even though I cannot prevent it, I hate to see them being called names
> by a disgruntled teenager (or someone with an equivalent level of
> social skills).
>
> So far, I have been using Google Groups, but that has no filtering.
> Could somebody please recommend a reliable and cheap (or a convex
> combination of the two ;-) news server? I have seen them mentioned in
> the past before, but could not find them. Then I could use mutt or
> something else to read news, and filter certain messages.
I use http://teranews.com/. $3.95 for a lifetime account with a 50mb
daily limit, which is more then enough for the comp.lang.* reading i do.
Cheers,
drewc
>
> Thanks,
>
> Tamas
>
> PS: Sorry for the OT post, but this thread finally made it clear that
> Google Groups (a great free service) is not the perfect solution for
> increasing the signal/noise ratio.
>
> On May 5, 11:52 am, Xah Lee <x...@xahlee.org> wrote:
>> Dear Pascal moron,
>>
> [snip]
>
--
Posted via a free Usenet account from http://www.teranews.com
Jon Harrop
> Leave them alone - they are happy with their choice.
No. No, they aren't. The Lisp community are actually more interested in
other languages than almost all other programming language communities.
This is why I continue to post in c.l.l, because it garners a lot of
interest in my work from the many Lisp users who are still looking for
something better.
Jon Harrop
> Do things well and people will find you. Why else has Lisp recovered
> from the AI Winter?
Lisp didn't recover from the "AI Winter", it remains very unpopular.
> Below you suggest I may be blinded by perspective. My question to you
> is, do /you/ appreciate the importance of parens? If not, your
> perspective is the problem.
Most people disagree.
>> Here's the equivalent lispy form, lispers think its easier to read:
>>
>> CompoundExpression[
>> SetDelayed[
>> cycledMatrix[
>> List[Pattern[m, Blank[Integer]], Pattern[n, Blank[Integer]]],
>> Pattern[cycleLists, List[Repeated[Blank[List]]]]],
>> Module[List[],
>
> How on Earth is that Lispy??! Bring the operator inside, then lose the
> []s and commas. Puzzled.
It is "lispy" because it is prefix notation. Mathematica is probably the
best example to these claims that parens are important because it provides
all of the symbolic rewriting (macro) capabilities of Lisp with the brevity
of a decent programming language. Contrary to the claims of Lispers,
Mathematica clearly demonstrates that you can combine macros with syntax.
Rainer Joswig
"Malcolm McLean" <regn...@btinternet.com> wrote:
The basic problem is that people coming to Lisp have all kinds
of interesting experiences and believes. But Lisp tends to
do things differently. It questions those prior experiences
and believes. But we are unwilling to question what we learned
is true. It is not that the Lisp way is better, but it is
different. Accepting that a different approach to software
development may also make sense seems to be hard.
Once these people get converted, they are the most
active evangelists. ;-)
So the basic first thing when you come to Lisp from other
programming languages and development tools is UNLEARNING.
That's also a reason Lisp was (is?) once popular in computer science
courses. Students are coming to the university full of
prior knowledge (basic, c, ... what ever programming).
Then they have to use Lisp to solve problems. Shock. Horror.
All are suddenly beginners and have to learn something
completely new.
* You work bottom-up talking to a partial ready program?
No batch compiler? No half-hour turn around times with
enough time for a long coffee break?
* No fixed language? No half year waiting time unless
you get a new operator into your language?
Language building built-in?
* S-expressions? Easy manipulation of code by integrated tools?
* Multiple paradigms in one language?
And so on.
About the Lisp syntax has been written quite a lot, I'm
not repeating it. Only a few words.
For me Lisp code is different from Pascal/C++/.. or other code
because it has a completely look & feel. The feel
is also an interesting part.
You see direct manipulative user interfaces quite a lot.
We drag icons around. We get instant visual feedback
from graphical user interfaces. Yet programming
often is far from interactive.
When I press keys and write code, is there a direct connection
from the brain to what I see on the screen and back?
In less than a second?
When I write code for a batch system, I type to an
editor and the objects I work with are characters,
words, sentences. Functions, declarations, etc.
The running application is far away. I have to imagine
what my code will do once it runs. Not so in Lisp.
When I write Lisp code, I talk to an object system via
code on the screen. There is something alive on the other
side. It is a running Lisp image fully loaded with functions, objects,
Lisp code. I type a bit code. Then I give that code to the Lisp
system. Let it compile, execute. I take the literal code and
let it reformat, restructure, walk (macroexpand at all levels).
I talk to a debugger who gives me access to the objects,
functions and the code. So Lisp code has a feel associated to
it. You can manipulate it much more directly and you
can inspect it, reuse it. Pressing enter in an Lisp editor
immediately executes something. This direct interaction
with the program is more extreme on the Lisp machine where
you had the special keyboards tailored for the programmer.
It had a suspend key. When you run a tool in a window
and you press suspend you get a REPL where you can talk
with Lisp directly to the application. This was
for example useful in an editor where you have some
Lisp code, you want to check something, pressing suspend
brings you into an editor typeout window with a REPL,
do a few experiments, press continue. Suddenly the code
is like clay in your hands (some say 'mud'). Code
is no long a bunch of characters. Code suddenly
is data. Data is code.
Another thing adds to that direct manipulative feeling
of Lisp code. Each basic form is enclosed in parentheses.
So you have visual markers for the form. You see where
it begins, where it ends and what is between. If you
want to select a specific form you can click on visual
markers, the parentheses to grab the form. You don't edit
code based on remembering syntax diagrams or operator
precedence. You edit lists of symbols that have a
textual representation and that have a representation
in a running program.
When you work like that, you'll be near the 'flow',
where there is extremely little distance between
your thoughts and an executable form of those thoughts.
Changes and effects are immediate.
But first you have to unlearn batch programming and
hostile syntaxes - both are standing between you and
interactive incremental development with a flexible
language that has direct manipulative qualities.
Malcolm McLean
"Rainer Joswig" <jos...@lisp.de> wrote in message
news:joswig-4F016E....@news-europe.giganews.com...
> In article <7-Kdnd5aj_AcV6Hb...@bt.com>,
> "Malcolm McLean" <regn...@btinternet.com> wrote:
>
> When I write code for a batch system, I type to an
> editor and the objects I work with are characters,
> words, sentences. Functions, declarations, etc.
> The running application is far away. I have to imagine
> what my code will do once it runs. Not so in Lisp.
>
> When I write Lisp code, I talk to an object system via
> code on the screen. There is something alive on the other
> side. It is a running Lisp image fully loaded with functions, objects,
> Lisp code. I type a bit code. Then I give that code to the Lisp
> system. Let it compile, execute. I take the literal code and
> let it reformat, restructure, walk (macroexpand at all levels).
> I talk to a debugger who gives me access to the objects,
> functions and the code. So Lisp code has a feel associated to
> it. You can manipulate it much more directly and you
> can inspect it, reuse it.
>
but I can't get it to work. So I'm writing it like C - write the script, and
submit it. So it works, but not nicely, and I am always counting parentheses
and thinking that, yes, I can see the computer science logic behind this,
but I don't see how I can write a non-trivial program as a programmer.
In software development tools are everything. When you can do things easily
it doesn't just enhance productivity, it actually means you can do more
things - you can draw a picture with a mouse, but not by setting pixel
values in code.
Jon Harrop
> The solution is simple: do something in Lisp that is nearly impossible
> in other languages.
Lisp no longer offers anything new and what it does offer it rather out of
date. So I don't think that is possible.
When I first looked at Lisp, I found that it had two features that set it
apart from the crowd: EVAL and macros. Run-time code generation is done
better in languages like MetaOCaml and F#. Macros are done better in
languages like Mathematica. Neither are particularly useful. EVAL can be
used in regexp engines (bundling with all decent languages) or compiler
writing (a tiny niche). Macros are only worthwhile when you're dealing with
a DSL with complex syntax, like mathematics, so another tiny niche.
My advice is always to point people at Scheme rather than Lisp because it is
a sanitary version of the same thing. There's basically no point in trying
to write real code in Lisp, other languages provide more and do it better.
Lisp is more like an ill-thoughout husk of a language, with painful funcall
problems and without things like bundled pattern matching. I'm amazed that
anyone is still using it but the main reason seems to be that students are
forced to use it precisely because it is a weird curiosity.
Rainer Joswig
"Malcolm McLean" <regn...@btinternet.com> wrote:
You might want to try out one of the no/low-cost versions
of commercial Lisp systems, which usually come
with interactive environments (Allegro CL on
some platforms, LispWorks, Corman CL, MCL, ...).
Tim Bradshaw
> Lisp no longer offers anything new and what it does offer it rather out of
> date. So I don't think that is possible.
> [...]
> My advice is always to point people at Scheme rather than Lisp because it is
> a sanitary version of the same thing. There's basically no point in trying
> to write real code in Lisp, other languages provide more and do it better.
> Lisp is more like an ill-thoughout husk of a language, with painful funcall
> problems and without things like bundled pattern matching. I'm amazed that
> anyone is still using it but the main reason seems to be that students are
> forced to use it precisely because it is a weird curiosity.
>
Remind me why you post here again? If you're hoping it's because
we'll dispatch the helicopters for you then you're out of luck: mine
have been all fully occupied spoiling ballot papers and need
maintenance (bloody chinooks, really expensive to run). Tilton may
have some available.
David Kastrup
> I think *you* need to cool down Xah Lee. I agree it can be annoying
> if you make a critical analysis of Lisp and people attack *you*.
> This is called an ad hominem argument, and, sadly, they are all too
> common on usenet. But calling people names like 'moron' is not the
> right way to win hearts and minds. You say some interesting things
> but you play into the hands of your critics by launching personal
> attacks.
"play" is actually not the four-letter word I would have used here.
--
David Kastrup, Kriemhildstr. 15, 44793 Bochum
jos...@corporate-world.lisp.de
> Pascal Costanza wrote:
> > Leave them alone - they are happy with their choice.
>
> other languages than almost all other programming language communities.
>
> This is why I continue to post in c.l.l, because it garners a lot of
> something better.
You are abusing your postings here for your commercial purposes.
Commercial
purposes which are off-topic in comp.lang.lisp.
I'm also interested in software engineering issues (including
programming language). If I would be interested in your F# offerings
I can read about them in other mailing lists or usenet groups which
may be more
suitable (actually I'm not interested in your offerings, thanks).
Most readers of comp.lang.lisp who are interested in other
programming languages are reading
those other newsgroups and mailing lists too. They don't get their
C/Haskell/... knowledge from comp.lang.lisp.
Face it, your postings about F# and your F#-related business are
completely off-topic
in comp.lang.lisp.
Xah Lee
You wrote to Jon: «... You are abusing your postings here for your
commercial purposes. Commercial purposes which are off-topic in
comp.lang.lisp ...Face it, your postings about F# and your F#-related
business are completely off-topic in comp.lang.lisp.»
I'm a lisp programer, and I've been reading comp.lang.lisp since 1998.
I love lisp. I don't know Jon, but recent reading of his numberous
posts, i find it every interesting and helpful. In particular, his
knowledge about other functional languages, even though i am not
familiar with them and probably will not study them in the near
future. I see no commercialism what-so-ever. I find your accusations
close to libel.
I respect knowledge, and love.
You, Rainer Joswig, your post is off topic and persecuting. This
annoys me greatly. I have seen you had fights with other
comp.lang.lisp dwellers here exchanging vitriol. So, don't fucking
posing like a saint about expressions you don't agree with.
Jon Harrop
> I'm a lisp programer, and I've been reading comp.lang.lisp since 1998.
> I love lisp. I don't know Jon, but recent reading of his numberous
> posts, i find it every interesting and helpful. In particular, his
> knowledge about other functional languages, even though i am not
> familiar with them and probably will not study them in the near
> future.
Thank you. I think you are in the majority here.
I was discussing the reason for this recently. Essentially, people's choice
of programming language or platform is very similar to a choice of
religion. I find the ensuing hatred fascinating. Stating that Lisp's
parentheses are a good thing is like posting "christians kill more people
than muslims in the name of God" on alt.religion.
When I make a statement like "this trivial symbolic rewriter is difficult,
tedious, error-prone and slow when implemented in Lisp", it doesn't matter
to everyone that I can back it up with overwhelming evidence. There are
always a few people who reply with progressively more ridiculous comments
simply to try to fight the Lisp corner. Generally this descends into a
plague of ad-hoc, informally specified and error-prone macros
reimplementing half of ML.
I think it is interesting that c.l.lisp is notorious for this kind of
behaviour but is simultaneously filled with the more fickle programmers
wanting to try more modern languages than any other newsgroup. Perhaps
the "bible bashing" Lispers drive them away?
Either way, the makeup of c.l.lisp is very unusual.
Rainer Joswig
Xah Lee <x...@xahlee.org> wrote:
> Dear Rainer Joswig,
>
> You wrote to Jon: «... You are abusing your postings here for your
> commercial purposes. Commercial purposes which are off-topic in
> comp.lang.lisp ...Face it, your postings about F# and your F#-related
> business are completely off-topic in comp.lang.lisp.»
>
> I'm a lisp programer, and I've been reading comp.lang.lisp since 1998.
You are what? A Lisp programmer? You are joking, right?
Reading comp.lang.lisp does not make you a Lisp programmer.
Writing Lisp programs would do.
> I love lisp. I don't know Jon, but recent reading of his numberous
> posts, i find it every interesting and helpful. In particular, his
> knowledge about other functional languages, even though i am not
> familiar with them and probably will not study them in the near
> future. I see no commercialism what-so-ever. I find your accusations
> close to libel.
Just recently he was advertising his F# business.
See for example this message:
<4624c06d$0$8751$ed26...@ptn-nntp-reader02.plus.net>
from Tue, 17 Apr 2007 13:36:42 +0100.
>
> I respect knowledge, and love.
>
> You, Rainer Joswig, your post is off topic and persecuting. This
> annoys me greatly. I have seen you had fights with other
> comp.lang.lisp dwellers here exchanging vitriol. So, don't fucking
> posing like a saint about expressions you don't agree with.
No surprise. Your own cross-postings are mostly off-topic to
comp.lang.lisp. It's not that I'm not reading them
sometimes, but they are, so, off-topic...
Unfortunately, if your postings here are on-topic,
they are also mostly full of misunderstandings and a total
lack of imagination (just a hint, check out pipes
in SCSH). You can't be a LIsp programmer... no way.
>
> Xah
> x...@xahlee.org
> ∑ http://xahlee.org/
pbu...@gmail.com
> Definition: Turing-complete, n., an expression of Lisp.
> (I should really get some sleep now.)
Why? The full name is Church-Turing thesis, of course... <wink-wink>
Paul B.
Ken Tilton
Jon Harrop wrote:
> Ken Tilton wrote:
>
>>Do things well and people will find you. Why else has Lisp recovered
>>from the AI Winter?
>
>
> Lisp didn't recover from the "AI Winter", it remains very unpopular.
Microsoft just announced support for dynamic languages.* What part of
the second derivative do you not understand?
kzo
* And they are running scared. In listing the languages they hoped to
support with DLR, they did not mention Lisp. Someone should tell them:
you can run, but you cannot hide. k
Dan Bensen
> Jon Harrop wrote:
>> Lisp didn't recover from the "AI Winter", it remains very unpopular.
Plus the first derivative isn't doing too badly these days either:
* Lisp, along with Haskell, has been getting plenty of attention
from Reddit, which seems to be gaining ground on Digg and Slashdot
in the geek world. Much to my disappointment, OCaml hasn't been
getting as much attention recently.
* c.l.l is obviously very active.
* Lisp, again like Haskell, has an active IRC channel.
* There are regular job postings on lispjobs.wordpress.com.
--
Dan
www.prairienet.org/~dsb/
andrew...@gmail.com
> Other posts in this thread, some sincere ones, are full utterly
> fucking stupid drivels. (or i shall put the polite version: logical
> fallacies) The level is so low that i'm really ashamed that they
> really came out from the mouthes of a class of people in society who's
> jobs are to program computers.
>
> (in this regard, see:
> The Condition of Industrial Programershttp://xahlee.org/UnixResource_dir/writ/it_programers.html
> )
>
When Xah Lee cites to his website, it reminds me of Ignatius J. Reilly
citing his own work in Toole's "A Confederacy of Dunces:"
--- excerpt ---
The humble and pious peasant, Piers Plowman, went to town to sell his
children to the lords of the New Order for purposes that we may call
questionable at best. (See Reilly, Ignatius J., _Blood on Their
Hands: The Crime of It All, A study of some selected abuses in
sixteenth-century Europe_, a Monograph, 2 pages, 1950, Rare Book Room,
Left Corridor, Third Floor, Howard-Tilton Memorial Library, Tulane
University, New Orleans 18, Louisiana. Note: I mailed this singular
monograph to the library as a gift; however, I am not really certain
that it was ever accepted. It may well have been thrown out because
it was only written in pencil on tablet paper.)
--- end excerpt --
Ken, are you related to the Tilton who founded the library
mentioned?
Interestingly enough, Ignatius J. Reilly clearly was not put off by
parentheses, as he nests them throughout his writings. This is one
reason I recommend "A Confederacy of Dunces" to people learning Lisp,
though I still feel Practical Common Lisp is the best for total
newbies.
OK, sorry to distract from the main line here.
Best,
Andrew
Rob Warnock
+---------------
| > editor and the objects I work with are characters,
| > words, sentences. Functions, declarations, etc.
| > The running application is far away. I have to imagine
| > what my code will do once it runs. Not so in Lisp.
| >
| > When I write Lisp code, I talk to an object system via code
| > on the screen. There is something alive on the other side.
| > It is a running Lisp image fully loaded with functions, objects,
| > I talk to a debugger who gives me access to the objects,
|
| This makes a lot of sense. I know that I ought to integrate Lisp
| with emacs, but I can't get it to work. So I'm writing it like C -
| write the script, and submit it. So it works, but not nicely, and
+---------------
1. Get an editor -- *ANY* editor, not necessarily Emacs -- which
at the *very* least *balances* [not counts -- nobody counts]
parentheses for you. For example, in most versions of Vi[1]
":set showmatch matchtime=2" will "flash" the cursor back on
the matching open parenthesis for ~200ms whenever you're in
insert mode and type a closing parenthesis. And when sitting
with the cursor on a parenthesis [either flavor], the "%" command
will move you to the matching parenthesis, and when used as
the "motion" command of a any of the commands that take motion
commands to specify their scope, will select the entire s-expr
as the argument. That is, "ady (or "ad%) will copy an s-expr
into Q-register "a (or delete it, respectively); the "ap commmand
will "paste" it back, >% and <% will shift all of the lines
containing the s-expr right or left, respectively. [Note: When
using Vi for Lisp, it helps to ":set shiftwidth=1". Then you
can do >%... to shift some form right four spaces, etc.]
2. You speak of "scripts": {Develop,Choose,Use consistently}
*some* stylized way of writing your scripts that lets you
load them into a running CL image *without* executing them,
so you can debug them at the REPL rather than in "batch" mode
as you seem to be doing [and as Rainer rightfully criticizes].
That lets you *use* the powerful debugging tools that exist
inside most Lisp systems.
For example [not to be blindly copied, but just so you know
that I *do* practice what I preach here], I have the CL that
I most often use [CMUCL] set up so that when I run it with a
REPL, the keyword :REPL ends up on a *SCRIPT-EXIT-HOOKS* list,
but *not* if it's run from a script[2]. So I write all of my
"#!/usr/local/bin/cmucl -script" scripts[3] with a MAIN function
that does all the work, and then at the very bottom of each
script file contains this:
(unless (find :repl *script-exit-hooks*) ; Debugging?
(apply 'main *script-args*))
or this [depending on the needs of the particular script]:
(unless (find :repl *script-exit-hooks*) ; Debugging?
(apply 'main (mapcar #'read-from-string *script-args*)))
[...where *SCRIPT-ARGS* ends up being a list of lightly-massaged
*COMMAND-LINE-STRINGS*.]
The point of this is that if you run the script from the shell,
it "just runs". But if you start up your REPL and LOAD the script,
it just sits there and waits for you to poke at it from the REPL,
e.g., by calling MAIN with a list of manually-constructed command-
line arguments, or by calling some of the internal functions of
your script, etc. If something goes wrong, you drop into the
internal Lisp debugger, where you have access to the entire
environment *and* a full CL implementation at your command,
including the compiler!
3. *Use* the Lisp environment you make your life easier!!
Define as many little personal "conveniece" functions
and/or macros as you find you want or need, and arrange
that they get loaded into your default REPL. Here's just
a small subset of mine:
;;; More shortcuts & conveniences:
(defun ap (string &optional package) ; be more liberal about 2nd arg
(apply #'apropos string (when package (list (find-package package)))))
(defun de (&rest rest) (apply #'describe rest))
(defun dis (&rest rest) (apply #'disassemble rest))
(defun mxp (&rest rest) (pprint (apply #'macroexpand rest)))
(defun mxp0 (&rest rest) (apply #'macroexpand rest)) ; same, but w/o PP
(defun mxp1 (&rest rest) (apply #'macroexpand-1 rest))
(defun mxp* (&rest rest) (apply #'walker:macroexpand-all rest)) ; CMUCL only
;;; For REPL compiles of functions with non-NIL lexical environments,
;;; e.g, (COMPILE* (let ((y 5)) (defun add5 (x) (+ x y)))).
(defmacro compile* (&body body)
`(funcall (compile nil (lambda () ,@body))))
;;; I don't know why I find myself needing this so often, but I do...
(defun hash-table-alist (hash-table &key (test (constantly t)))
(loop for key being each hash-key in hash-table using (hash-value value)
when (funcall test key value)
collect (cons key value)))
4. *Use* the Lisp environment you make your life easier!!
If you can't (or don't want to) use ASDF or MK:DEFSYSTEM
or equiv., at least whip yourself up a little function
that's loaded into your default REPL that lets you reload
and/or recompile all the files you're currently working on --
something short [e.g., "REDO"] that's data-driven [e.g., a
global named *USER-LOAD-LIST*, maybe]. I have one[4] that I
call LOAD*, that does the following:
- Remembers when it was last called.
- If called with args, adds them to the end of *USER-LOAD-LIST*
(suppressing duplicates).
- For each file in the [possibly-just-modified] *USER-LOAD-LIST*,
if the FILE-WRITE-DATE of either the file or [if a compiled
version already exists] the compiled version of it is newer
than the last LOAD* time, re-LOAD that file [recompiling it
first, iff a compiled version already existed].
Then say (DEFUN REDO () (LOAD*) (current-unit-test args...)),
and your "edit/compile/test" cycle becomes:
- Type "Save" in all the editor windows in which you've made changes.
- Type (REDO) to the REPL.
- [Optional:] If what you're working on is a persistent web
applications server, hit your web browser's "Reload" or "Refresh".
That's all the basic "IDE" you need to be *very* productive
in Lisp [CL, Scheme, whatever].
Now that you know all this, time to start coding. *NOW!!*
[Or I'll sic Kenny on you... ;-} ]
-Rob
[1] Some Lispers may consider me a heretic because I don't use Emacs
when writing Lisp. Tough. [I've *tried* to, several times, but
my fingers just don't bend that way. And besides, I've been using
"moded" editors like TECO, Bravo, Ed, & Vi for more than half my
total lifetime.] Frankly, I spend such a *small* percentage of
my programming time on "editor issues" that I simply don't buy
the "I don't have (or can't use) the perfect editor (or IDE)"
obstacle as a legitimate excuse for not simply getting on with
Lisp programming [though as noted in the text above it *does*
help a lot if you have an editor that at least *shows* you the
balancing paren, even better if it can delete/shift an s-expr
as a group -- which almost *all* can, even if not with a single
keystroke].
So if someone says, "I can't use Lisp... no {Emacs,SLIME,IDE}..."
I just say, "FIDO!" [An acronym of supposed military origin;
the last two letters stand for "Drive On"...]
[2] Unless the script explicitly chooses to push it onto the list. ;-}
Which is how I normally run CMUCL -- with a script named "cmu"
that sets up a bunch of stuff, REQUIREs the usual suspects,
pushes :REPL onto *SCRIPT-EXIT-HOOKS*, and falls off the bottom.
This causes "cmucl -script"[3] to start a REPL and *not* silently
exit [which is what a good script should normally do otherwise].
[3] (*sigh*) I've been promising to put my "-script" extension
to CMUCL on the net for entirely too long. Soon, soon...
[Hint for home hobbyists who don't want to wait: It's implemented
by adding a few lines to "/usr/local/lib/cmucl/lib/site-init.lisp"...]
[4] No, I'm not going to clutter this article any more than
it already is with my version of LOAD*. It's simple enough
[mine's only ~40 lines, could be even shorter], and is a
good beginner exercise for one to get used to building
their own personalized "conveniences".
-----
Rob Warnock <rp...@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
Tim X
> Xah Lee wrote:
>> Xah Lee wrote:
>
,snip]
> Below you suggest I may be blinded by perspective. My question to you is, do
> /you/ appreciate the importance of parens? If not, your perspective is the
> problem.
>
Ah, the resounding sound of a nail being firmly hit on the head!
[snip]
>
> I think you are also missing that the parens also mean there is a ton of syntax
> and precedence I do not need to learn or make mistakes on. One simple rule and
> I am good to go.
>
> You need to remember, Xah, that any Lisper is master also of other computer
> languages, because we likely pay the bills with something else. You seem to
> have a mental model of us in which the only thing we know is Lisp.
>
I think this is an important point too often overlooked. Lisp was /the/ easiest
language I ever learnt because the syntax was trivial compared to other
languages. It is going to take me a long time to master the language, but I was
up and coding almost immediately and actually get the results I expected. Other
languages involved a lot more time and had a lot more surprises due to not
knowing/understanding all the operator precedence rules.
I grinned when reading Xah's post and his reference to lisp programmers having
to use indentation because the parens were so hard to read. What other high
level languages /don't/ use indentation to assist in expressing
meaning/structure?
anyone who has done C programming would be familiar with seeing fairly simple
expressions wrapped in aprens because the original author wasn't 100% confident
about operator precedence or pointer arithmetic which can require lots of
parens to get the desired affect (lets not even raise how readable some of that
can be).
Consider Perl and its 'or' versus '||', 'and' versus '&&'. How many times have
perl programmers discovered bugs because the author forgot that these operators
have different precedence and will behave differently in some contexts.
Then, when we move past this fairly trivial issue of parens, we begin to see
what we actually get from them. The straight-forward syntax that allows code to
be treated as data and the power that can bring. The ability to use macros to
make code more readable, reduce the code you type (and the associated parens),
the ability to create a domain specific language that still follows the same
syntax rules and is pretty much indistinguishable from the rest of the
language, etc.
bottom line - if someone can demonstrate an alternative syntax that doesn't
sacrifice the power we get with sexps, which is just as readable or easier and
can be written with the same or less keystrokes and doesn't create a syntax
full of exceptions and odd/inconsistent evaluation rules, then I'd be interested in
considering it. Given that the common easy target for non-lisp programmers has
been the parens and that this has gone on for years, yet it seems nobody has
come up with an alternative that doesn't sacrifice some aspect of the language,
I don't expect to see anything until we have some other paradigm shift with
respect to our basic interface to the computer. Until then, I'm happy with the
parens if it means I don't need to also have an operator precedence chart on
the wall and a <language X> pocket reference sitting on the desk.
tim
P.S. I'm also sick of all those languages with the () and {} and [] and ;
everywhere. I keep missing one or mismatching the () {} and [] or accidently
using : when it should have been ; because my fingers moved too quickly and I
still had the shift key down! Even more frustrating, I didn't realise I had done it
until the compiler barfed after the first 5 minutes of my long build cycle. Now
I've got to fix that silly error and start the build again and I've already had
20 cups of coffee today. I guess another cigarette while I wait for the build
to complete will fill the time. Still, its such a shame software takes so long
to develop.
--
tcross (at) rapttech dot com dot au
Jon Harrop
> Ken Tilton wrote:
>> Jon Harrop wrote:
>>> Lisp didn't recover from the "AI Winter", it remains very unpopular.
>> What part of the second derivative do you not understand?
>
> Plus the first derivative isn't doing too badly these days either:
> * Lisp, along with Haskell, has been getting plenty of attention
> from Reddit, which seems to be gaining ground on Digg and Slashdot
> in the geek world.
I've noticed Haskell growing very rapidly, the same as OCaml, but I haven't
heard of anything exciting that is Lisp related, except maybe Qi.
> Much to my disappointment, OCaml hasn't been
> getting as much attention recently.
Our OCaml-related sales have quadrupled over the past year. Then there's F#.
I think F# will overtake most other FPLs in the next year. It just overtook
Common Lisp according to Google trends:
http://www.google.com/trends?q=common+lisp,+ocaml
+f%23&date=all&geo=all&ctab=0&sa=N
There is certainly work to be done if any FPL is to catch up with the likes
of Mathematica:
http://www.google.com/trends?q=mathematica%2C+haskell%2C+ocaml&ctab=0&geo=all&date=all
Their latest release will give them a well-earned boost in the rankings.
Tim X
> On May 5, 1:11 am, Xah Lee <x...@xahlee.org> wrote:
>> How Lisp's Nested Notation Limits The Language's Utility
>
> Very good. Now, off you go and design and implement an alternative
> syntax. It's easy, it's been done hundreds of times. I think I have
> two or three limited examples on my web site and several more I never
> bothered publishing. There must, as I say, be hundreds of examples
> around and probably thousands when you count all the non-published
> ones. So pick the best and use them, or, since you're by far the
> smartest person here, why not come up with your own? Jon Harrop can
> probably help you.
>
Actually, I think this is a very good idea for Xah. Many have been very
critical of what he posts (including myself), but I suspect a large percentage
of people totally dismiss what he writes because he doesn't provide any
constructive alternatives. He regularly posts about what is wrong with emacs,
lisp, unix, perl etc. but rarely do I see any proposed solutions or
constructive ideas that might actually improve the situation.
come on Xah, you have made frequent references to your superior IQ, your
ability to write and express ideas. Its easy to moan about whats wrong with the
world, time to put your money where your mouth is. Take some of that boundless
IQ and your superior skills in communication and post some ideas on how things
could be improved.
Tim
Pascal Bourguignon
> ;;; I don't know why I find myself needing this so often, but I do...
> (defun hash-table-alist (hash-table &key (test (constantly t)))
> (loop for key being each hash-key in hash-table using (hash-value value)
> when (funcall test key value)
> collect (cons key value)))
Perhaps in your implementation the hash-table are printed opaquely?
In clisp, they dump their contents. I had to write something similar
when I used acl...
> [4] No, I'm not going to clutter this article any more than
> it already is with my version of LOAD*. It's simple enough
> [mine's only ~40 lines, could be even shorter], and is a
> good beginner exercise for one to get used to building
> their own personalized "conveniences".
In some implementations it's also possible to define debugger or
toplevel commands, so you can write some shortcut or specialized
debugging functions for your program.
And if your editor is customizable, you can also add commands in the
editor sending commands to the inferior lisp to automate some stuff,
or add an easy interface to your lisp. For example, I bind function
keys to clisp debugger commands when I use STEP:
(defun clisp-debug-keys ()
"Binds locally some keys to send clisp debugger commands to the inferior-lisp"
(interactive)
(macrolet ((cmd (string)
`(lambda ()
(interactive)
(comint-send-string (inferior-lisp-proc)
,(format "%s\n" string)))))
(local-set-key (kbd "<f5>") (cmd ":s"))
(local-set-key (kbd "<f6>") (cmd ":n"))
(local-set-key (kbd "<f7>") (cmd ":o"))
(local-set-key (kbd "<f8>") (cmd ":c"))))
--
__Pascal Bourguignon__ http://www.informatimago.com/
THIS IS A 100% MATTER PRODUCT: In the unlikely event that this
merchandise should contact antimatter in any form, a catastrophic
explosion will result.
Tim Bradshaw
> Take some of that boundless
> IQ and your superior skills in communication and post some ideas on how things
> could be improved.
Don't post ideas, post implementations. It really is very easy to
implement new syntaxes for Lisp.
Rob Warnock
+---------------
| rp...@rpw3.org (Rob Warnock) writes:
|
| > ;;; I don't know why I find myself needing this so often, but I do...
| > (defun hash-table-alist (hash-table &key (test (constantly t)))
| > (loop for key being each hash-key in hash-table using (hash-value value)
| > when (funcall test key value)
| > collect (cons key value)))
|
| Perhaps in your implementation the hash-table are printed opaquely?
Yup. CMUCL: ;-}
cmu> (make-hash-table)
#<EQL hash table, 0 entries {4893DD45}>
cmu> (loop for i in (iota 20) do (setf (gethash i *) (* i i)))
NIL
cmu> **
#<EQL hash table, 20 entries {4893DD45}>
cmu> (hash-table-alist *)
((0 . 0) (1 . 1) (2 . 4) (3 . 9) (4 . 16) (5 . 25) (6 . 36)
(7 . 49) (8 . 64) (9 . 81) (10 . 100) (11 . 121) (12 . 144)
(13 . 169) (14 . 196) (15 . 225) (16 . 256) (17 . 289)
(18 . 324) (19 . 361))
cmu>
+---------------
| > [4] No, I'm not going to clutter this article any more than
| > it already is with my version of LOAD*. It's simple enough
| > [mine's only ~40 lines, could be even shorter], and is a
| > good beginner exercise for one to get used to building
| > their own personalized "conveniences".
|
| In some implementations it's also possible to define debugger or
| toplevel commands, so you can write some shortcut or specialized
| debugging functions for your program.
+---------------
Ah, yezz... :FOO or ,FOO at the top level. It's not in CMUCL
(by default), but I think there's a package mentioned somewhere
on CLiki that will do that, by replacing the top-level reader.
+---------------
| And if your editor is customizable, you can also add commands in the
| editor sending commands to the inferior lisp to automate some stuff,
| or add an easy interface to your lisp.
+---------------
Indeed, though since the OP said "emacs...can't get it to work", I
was trying to show that not having an "inferior lisp" connection at
all shouldn't be considered a deal-breaker obstacle to using Lisp
[and in fact, really isn't an obstacle at all].
-Rob
Xah Lee
«So far, I have been using Google Groups, but that has no
filtering. ... I could use mutt or something else to read news, and
filter certain messages.»
Dear Damas,
What you want to do, is not a good thing in the long run. In fact, it
just plagued newsgroups worse in your sense of how you want it to be.
Please see:
Killfile Considered Harmful
http://xahlee.org/UnixResource_dir/writ/kill_file_harmful.html
Your gentle, wholly off-topic message, instigated 3 more wholly off-
topic gentle messages. (not counting my own here) So, you, are
actually contributing to the so-perceived “worsening” of newsgroup
quality.
You purport to not want off-topic or drivels in newsgroups, but the
fact judged by your behavior is, you love it. And, you are not the
only one. Thousands before you, all like you, did the same,
intentional or not. So, besides huffy-puffy spittle among tech-geeking
language factions, there is another class of soldier, like yourself,
who perennially install themselves into the awareness of the public,
about how benign and good-hearted they are.
Can you post your valid complaint and criticism to
alt.netiquette.discuss or alt.software.google ?
It would be ON-TOPIC there.
Follow up set!
------------------------
Further readings:
Tech Geekers versus Spammers
http://xahlee.org/UnixResource_dir/writ/tech_geekers_vs_spammers.html
Ken Tilton
Close, but no cigar. Xah's problem is anger. That is why he is always
attacking things -- they make him angry. A clearer proof of his anger
would be this thread. Xah, like any, is a good person with a
hair-trigger anger. It has gotten that way because it has run unchecked,
in turn because the upper cortex always makes sense out of what is
happening. When anger strikes, it never seems as if anger Just Happened,
it always seems as if the thing making one angry was Just Horrible. Xah
needs to use his intellect to see how anger has enslaved him to begin
objectifying it, distancing his true self from his anger, eventually to
break anger's control over him.
hth,ken
Jon Harrop
The problem isn't creating a syntax (all decent PLs have good syntax). The
problem is that CL doesn't bundle a decent syntax (or pattern matching,
or ...). So there's no point in Xah implementing anything.
Arved Sandstrom
news:TNOdnQlUpMyFqqHb...@bt.com...
>
> "Kaz Kylheku" <kkyl...@gmail.com> wrote in message
> news:1178325041....@w5g2000hsg.googlegroups.com...
> On May 4, 5:11 pm, Xah Lee <x...@xahlee.org> wrote:
>>> How Lisp's Nested Notation Limits The Language's Utility
>>> Long time lispers may disagree on this point.
>>
>>Programming language syntax shouldn't be natural for humans to read.
>>Or, rather, this shouldn't be a requirement which creates technical
>>compromises.
>>
> I couldn't disagree more. Occasionally you do need to use a language with
> no technical compromises whatsoever - pure assembly or machine code - but
> only rarely. Most of the time we accept some limitations for the sake of
> making things easier for the human programmer. That includes run-time
> efficiency, but also restrictions in the "power" of the language.
[ SNIP ]
You two are not referring to the same thing. Syntax is not related to the
power of a language (or the lack thereof) in the slightest. Plenty of
languages that operate at higher levels than machine code or assembler are
just as terse and non-intelligible to the uninformed. Kaz simply made a
reference to syntax.
AHS
Malcolm McLean
"Arved Sandstrom" <asand...@accesswave.ca> wrote in message
news:z4o%h.5219$Vi6.3376@edtnps82...
nonsense, because syntax is simply the convention for noting the grammar.
For instance we could use "begin" and "end" instead of '(' and ')' to open
and close lists, without changing anything fundamental about the language,
but it wouldn't be a good idea because it would be totally unreadable. A
change in syntax inherently can't create technical compromises, unless I
suppose you demand a symbol like $ which might not be available on some
machines.
If we use it in the broader sense then we've got something to argue about.
Let's say that we agree that add(1, 2, 3) is easier to read than (add 1 2
3), and we change the underlying representation so that "function calls" are
separate from "lists". Now we've made the language less tidy at the machine
level, but we've also given an advantage to the human programmer. There is
no easy or "right" answer to these questions. My own programming language,
MiniBasic (see website) makes huge technical compromises, such as having
only one numerical type, to make the language easier to learn, because that
is the priority.
Joe Marshall
> How Lisp's Nested Notation Limits The Language's Utility
>
>
> There is a common complain by programers about lisp's notation, of
> nested parenthesis, being unnatural or difficult to read. Long time
> lisp programers, often counter, that it is a matter of conditioning,
> and or blaming the use of "inferior" text editors that are not
> designed to display nested notations. In the following, i describe how
> lisp notation is actually a problem, in several levels.
I think you're wrong, Xah. If the syntax is a problem, why haven't
any alternative syntaxes taken over for s-expressions? I point to
these examples:
M-Expressions (c. 1962)
maplist[x;fn]=[null[x]->NIL;
T->cons [fn[x];maplist [cdr [x];fn]]]
CGOL (c. 1977)
define "CGMAP"(x, inon, disp, typ);
if atom car x or caar x not isin !'(quote function)
or if atom cadar x then typ ne "mapcar" else caadar x ne "LAMBDA"
then (princ typ; let lbd=0, rbd=0; cglist(x, ", ", 0, 0))
else if atom cadar x and typ = "mapcar" then
(cgolprin2(cadar x, lbd, rbd, depth);
princ "["; let lbd=-1, rbd=0;
cglist(cdr x, ", ", 0, 0);
princ "]")
else (printeol;
princ "for ";
for vars on cadr cadar x, argts on cdr x do
(lcprinc car vars;
princ inon;
cgolprin2(car argts, 2, 0, depth+1);
if cdr vars then princ ", ");
princ disp;
let depth = depth+1; printeol;
cglist(cddr cadar x, "; ", 1, 0)) $
Dylan (c. 1990)
define function find-position-and-velocity
(rock :: <rock>, time :: <float>)
=> (position :: <float>, velocity :: <float>)
values(-4.9 * time * time
+ rock.initial-velocity * time
+ rock.initial-position,
-9.8 * time
+ rock.initial-velocity);
end function;
Curl (late 1990s)
{method public {set-size layout:LayoutContext, rect:GRect}:void
{super.set-size layout, rect}
|| match pixmap size with display
let width:int = ((rect.lextent + rect.rextent) / pixel-length) asa
int
let height:int = ((rect.ascent + rect.descent) / pixel-length) asa
int
set self.current-pixmap = {Pixmap width, height, ignore-alpha?
=true}
{self.on-resample}
}
Every year someone comes on comp.lang.lisp and informs us
that it is the parenthesis that are the problem. But in more than
forty years no one has come up with a better alternative, and
it hasn't been for want of trying or lack of imagination.
Jon Harrop
> I think you're wrong, Xah. If the syntax is a problem, why haven't
> any alternative syntaxes taken over for s-expressions?
They have.
Mathematica uses more conventional syntax to handle expressions:
map[{}, _] := {}
map[{h_, t___}, f_] := Prepend[map[{t}, f], f[h]]
or using the built-in map:
f /@ x
For example, squaring the terms of a sum:
In:= #^2& /@ (1 + 3 x + x y)
Out= 1 + 9 x^2 + x^2 y^2
As Xah explained, Mathematica gives you the choice between prefix format
(same properties as Lisp's s-exprs) or more sophisticated syntax. The
latter is far more popular.
OCaml allows you to define infix operators and these can be used to compose
expressions. From the symbolic simplifier example I gave:
let rec ( +: ) f g = match f, g with
| `Q n, `Q m -> `Q (n +/ m)
| `Q (Int 0), e | e, `Q (Int 0) -> e
| f, `Add(g, h) -> f +: g +: h
| f, g -> `Add(f, g)
let rec ( *: ) f g = match f, g with
| `Q n, `Q m -> `Q (n */ m)
| `Q (Int 0), e | e, `Q (Int 0) -> `Q (Int 0)
| `Q (Int 1), e | e, `Q (Int 1) -> e
| f, `Mul(g, h) -> f *: g *: h
| f, g -> `Mul(f, g)
Note that I chose to use infix operators +: and *: to compose expressions. I
could have used prefix syntax but conventional syntax is clearer.
One of the advances made by the F# language (derived from OCaml) is that it
allows operator overloading, so you can use + rather than +: to compose
expressions.
OCaml, MetaOCaml and F# provide quotations, allowing you to generate
expressions from quoted source code.
However, you cannot decompose expressions using a nice syntax:
let rec d f x = match f with
| f + g -> d f x + d g x
| f * g -> f * d g x + g * d f x
| ...
so you must write a macro to extend the pattern matcher in OCaml.
In the future, F# may support overloading infix active patterns (views)
which will provide this functionality from the language itself.
So I think it is fair to say that s-exprs in Lisp have been superceded by
more efficient representations of expressions in most modern FPLs.
Kaz Kylheku
> Free games and programming goodies.http://www.personal.leeds.ac.uk/~bgy1mm
Nutjob.
antoan...@hotmail.com
> D Herring wrote:
> > The solution is simple: do something in Lisp that is nearly impossible
> > in other languages.
>
> Lisp no longer offers anything new and what it does offer it rather out of
> date. So I don't think that is possible.
>
> When I first looked at Lisp, I found that it had two features that set it
> apart from the crowd: EVAL and macros. Run-time code generation is done
> better in languages like MetaOCaml and F#. Macros are done better in
> languages like Mathematica. Neither are particularly useful. EVAL can be
> used in regexp engines (bundling with all decent languages) or compiler
> writing (a tiny niche). Macros are only worthwhile when you're dealing with
> a DSL with complex syntax, like mathematics, so another tiny niche.
>
> My advice is always to point people at Scheme rather than Lisp because it is
> a sanitary version of the same thing. There's basically no point in trying
> to write real code in Lisp, other languages provide more and do it better.
> Lisp is more like an ill-thoughout husk of a language, with painful funcall
> problems and without things like bundled pattern matching. I'm amazed that
> anyone is still using it but the main reason seems to be that students are
> forced to use it precisely because it is a weird curiosity.
>
> --
> Dr Jon D Harrop, Flying Frog Consultancy
> The F#.NET Journalhttp://www.ffconsultancy.com/products/fsharp_journal/?usenet
The real question is how much is Microsoft paying you to write your
nonsense? I've just finished a product with your former savior to poor
programmers souls C# and i'm glad it's over. It was far easier to
write it first with Lisp and recode it in C# than streight coding
in C#, something we tried and get stuck. Oh we're probably too stupid
for such a brilliant technological marble like C#, so we're forced to
stick with Lisp. F# , No thanks. I don't need MS propaganda anymore ,
try some managers ,they might be interested in your latest buzzword.
Malcolm McLean
>
> Every year someone comes on comp.lang.lisp and informs us
> that it is the parenthesis that are the problem. But in more than
> forty years no one has come up with a better alternative, and
> it hasn't been for want of trying or lack of imagination.
>
parentheses are a minor matter used to disambiguate short expressions. So
the first thing you say on seeing a Lisp program is "eek".
The second thing I said was "why not write a graphical editor for this, to
show the lists as trees?".
However I haven't written enough Lisp to comment on how best to work with
it.
antoan...@hotmail.com
> Xah Lee wrote:
> > I'm a lisp programer, and I've been reading comp.lang.lisp since 1998.
> > I love lisp. I don't know Jon, but recent reading of his numberous
> > posts, i find it every interesting and helpful. In particular, his
> > knowledge about other functional languages, even though i am not
> > familiar with them and probably will not study them in the near
> > future.
>
> Thank you. I think you are in the majority here.
I find you're idea of majority quite interesthing. It seems that
onlyone who finds you interesthing and helpful is Xah Lee (Did i
missed somebody else?) the rest of the people here disagree, or think
that you're idot or that someone (Microsoft) is paying you to speak BS
(like I do) .
fireblade
> Pascal Costanza wrote:
> > Leave them alone - they are happy with their choice.
>
> No. No, they aren't. The Lisp community are actually more interested in
> other languages than almost all other programming language communities.
>
> This is why I continue to post in c.l.l, because it garners a lot of
> interest in my work from the many Lisp users who are still looking for
> something better.
>
> --
> Dr Jon D Harrop, Flying Frog Consultancy
> The F#.NET Journalhttp://www.ffconsultancy.com/products/fsharp_journal/?usenet
As a Lisper I'm very happy with Common Lisp. It's not perfect but
it's THE BEST language I've have a chance to work with. I'm not
learning new languages because of unhappiness with Lisp but because I
want to taste how it feels to do something with another language.
>From my own experience with : GWBasic, QBasic,Pascal,C/C++, C#,
SQL,OCaml, PHP,Delphi & Scheme I find Common Lisp closest to my
natural way of thinking. Currently I'm learning Erlang and later I'm
planning to give a try to Forth. And I certainly don't need you Dr Jon
Harrop to preach what is good for me. You and Xah Lee are just
polluting this group, wasting everybody's time with your rubbish and
insulting a lot of good people. So f*ch off both of you.
cheers
bobi
PS.
I hope this isn't a double post , my former reply didn't show up in
google groups.
fireblade
> In article <1178350159.880500.113...@o5g2000hsb.googlegroups.com>,
>
>
>
>
>
> fireblade <slobodan.blaze...@gmail.com> wrote:> > > > vectorAngle[{a1_, a2_}] := Module[{x, y},
> > > > {x, y} = {a1, a2}/Sqrt[a1^2 + a2^2] // N;
> > > > If[x == 0, If[Sign@y === 1, ?/2, -?/2],
> > > > If[y == 0, If[Sign@x === 1, 0, ?],
> > > > If[Sign@y === 1, ArcCos@x, 2 ? - ArcCos@x]
> > > > ]
> > > > ]
> > > > ]
>
> > > > SetDelayed[vectorAngle[List[Pattern[a1,Blank[]],Pattern[a2,Blank[]]]],
> > > > Module[List[x,y],
> > > > CompoundExpression[
> > > > Set[List[x,y],
> > > > N[Times[List[a1,a2],
> > > > Power[Sqrt[Plus[Power[a1,2],Power[a2,2]]],-1]]]],
> > > > If[Equal[x,0],
> > > > If[SameQ[Sign[y],1],Times[?,Power[2,-1]],
> > > > Times[Times[-1,?],Power[2,-1]]],
> > > > If[Equal[y,0],If[SameQ[Sign[x],1],0,?],
> > > > If[SameQ[Sign[y],1],ArcCos[x],
> > > > Plus[Times[2,?],Times[-1,ArcCos[x]]]]]]]]]
>
> > > Yes. The Mathematica language really brings home the fact that non-trivial
> > > syntax is good. In particular, it does an excellent job of mimicking
> > > conventional mathematical notation. Arguing in favor of Lisp syntax is like
> > > advocating the use of cave painting...
>
> > > Also, note that Mathematica provides strictly more in the way of macros.
>
> > > --
> > > Dr Jon D Harrop, Flying Frog Consultancy
>
> > > - Show quoted text -
>
> > ___________________________
> > /| /| | |
> > ||__|| | Please don't |
> > / O O\__ feed |
> > / \ the trolls |
> > / \ \ |
> > / _ \ \ ----------------------
> > / |\____\ \ ||
> > / | | | |\____/ ||
> > / \|_|_|/ | __||
> > / / \ |____| ||
> > / | | /| | --|
> > | | |// |____ --|
> > * _ | |_|_|_| | \-/
> > *-- _--\ _ \ // |
> > / _ \\ _ // | /
> > * / \_ /- | - | |
> > * ___ c_c_c_C/ \C_c_c_c____________
>
> > Sorry for double posting but I'm getting sick of Xah Lee and Jon
> > Harrop.
> > We all get their message :COMMON LISP SUCKS so please let us leave in
> > our misery
> > while you make all the great programms in F#, Mathematica or
> > whatever ...
> > >From now on I'll ignore both of them for good .
>
> > cheers
> > bobi
>
> I fully agree. Neither of them as any (!) clue about Lisp and programming in Lisp.
> Neither of them has written any significant or even non-significant Lisp program.
> Their postings are full of (wrong) assumptions and are mostly based on
> no experience and no knowledge of Lisp programming. Both are only trolling
> in comp.lang.lisp. Best to post a warning sign and other to ignore them...
>
> --http://lispm.dyndns.org- Hide quoted text -
>
> - Show quoted text -
Seems that I was wrong about Xah Lee. He's no troll, but a completely
new flame warrior. Something that could be better described as
crossing of Tireless Rebutter ,Issues & Furious Typer . I will report
him to Mike Reed mr...@hutman.net from http://redwing.hutman.net/~mreed/
. I just don't know how to name it.
http://redwing.hutman.net/%7Emreed/warriorshtm/tirelessrebutter.htm
http://redwing.hutman.net/%7Emreed/warriorshtm/issues.htm
http://redwing.hutman.net/%7Emreed/warriorshtm/furioustyper.htm
Tim Bradshaw
> So I think it is fair to say that s-exprs in Lisp have been superceded by
> more efficient representations of expressions in most modern FPLs.
have you noticed this web thing? It's quite fashionable I believe.
Obviously not as widely used as Ocaml or F#, yet. They use this
tagged bracket notation which they claim is quite useful and
universal. It isn't sexprs, quite.
Tim Bradshaw
> The problem isn't creating a syntax (all decent PLs have good syntax). The
> problem is that CL doesn't bundle a decent syntax (or pattern matching,
> or ...). So there's no point in Xah implementing anything.
As I mentioned in another article, I really think you do need to learn
about this internet thing. One of the nice features it offers is
something called "downloading" - people can write code which you can
then "download" onto your own computer and run there. It's just
amazingly better than the whole shipping magtapes around thing.
jim burton
[...]
> 1) "Write clearly -- don't be too clever"
> 2) "Say what you mean, simply and directly"
> 3) "Parenthesize to avoid ambiguity"
> 4) "Use the tel
> And so on, from "The Elements of Programming Style" by Kernighan and
> Plaugher. [1]
>
[...]
> -----
> [1] I'd gladly buy a version of this book targeted to Lisp.
>
Have you read Norvig & Pitman's guide?
http://www.cc.gatech.edu/computing/classes/cs2360/ghall/style/Good-Lisp-Style.ps
Xah Lee
«I think you're wrong, Xah. If the syntax is a problem, why haven't
any alternative syntaxes taken over for s-expressions? I point to
these examples:»
Do you know how fanatics are blind?
For example, there are Christians, and there are Islamics. Doesn't
matter what you say, what logic, what rationality, what patience, what
evidence, for vast majority of these people, God of their variety will
exist, and will be the only type.
Fanatics are fanatics because they lost their rationality on the
subject. They simply have the need to believe. (other examples in the
computing industry include: Mac fanatics, unix fuckheads (and now
Linux), OpenSource fuckheads.)
My article, is not titled “The stupidity of Lisp Syntax”. Nor “Lisp's
got syntax problems”. Nor, “The moronicity of Common Lisp fuckheads”.
The title is “How Lisp's Nested Notation Limits The Language's
Utility”.
Note that it says “How”, meaning, the article is a exposition. Then,
it says “Nested Notation”. And, it “limits”. Limit what? “Limits the
language's utility”.
In the article, 3 itemized issues are mentioned. I don't think i
should hold each lisper's hand to go thru the article sentence by
sentence. You can eye the article with built-in Common Lisp prejudice
and come off not reading anything, like basically all lispers who
cried in pain here. These lispers, basically, saw the article, skimmed
it, felt the wound, panics, reactionarily thinking to themselves “O!
Another Imperative Moron who can't get used to parens!”, and then like
a gaggle of ducks, all quack about how sexp is just fine and i'm a
“troll”.
Joe, i know you are seasoned lisper, and you love lisp. Me too. (But
i'm getting stronger sense everyday that Common Lispers, at least as
so exhibited in comp.lang.lisp are all motherfuckers, the saboteurs of
the lisp's health.)
In the article, i gave 3 issues. I do not think any lisper can
honestly disagree with any one of them. Note that, let me emphasize
and repeat again here, the conclusion is not: “lisp's syntax is fucked
and needs change”.
(see also my reply to Pascal Costanza, i quote here:
(Try, perhaps, learn to calm down yourself. You are not under attack.
Lisp the language, is not under attack by my essay. My article,
although cogently detailed why lisp syntax is a serious problem at
several levels, it does not mean that, it is “no good” in some
absolute way. Also, it is far better, then essentially all imperative
language's syntaxes. Even, one can logically agree with my article,
and remain positive, because although lisp perhaps reduce the use of
function sequencing, but that by itself is not necessarily a very bad
thing. Because, function sequencing (aka chaining), although a very
important paradigm, is not necessarily the only way to program, nor
the only way for functional programing. Consider, even today in the
light of OOP. And Common Lisp, in particular, isn't all that much
concerned about purity of functional programing anyway. So logically,
from this perspective or argument, my essay isn't a damning
certificate.)
(I'm really sorry i have to say the above paragraph, as if like a pat
on the back to some crying pussies. But the juvenility, sensitivity,
ignorance, and stupidity, as shown in the responses in this thread,
made me. ) )
Joe wrote:
«Every year someone comes on comp.lang.lisp and informs us that it is
the parenthesis that are the problem.»
Huh? What you wrote above, has nothing to do with my essay. It has to
do with Common Lisping fuckhead's nagging toothache.
«But in more than forty years no one has come up with a better
alternative, and it hasn't been for want of trying or lack of
imagination. »
What about Logo? Dylan? Arc? Mathematica? And the Scheme Lisp's coming
standard, the R6RS, introducing [] {} and other syntaxes that breaks
the nested paren. (note: this is mentioned in the article)
Also, in the article, i mentioned, that lisp syntax itself, contains
several _ad hoc_ syntax sugars for the purpose of reducing nested
parenthesis. This, for anyone not prejudiced, who put thought into
reading the article, might suggest a argument that too many nested
parens is considered a problem by the grand daddies of lisp founder
themselves. When you code lisp tonight, why don't you aways use
“(quote ...)” instead of “'”, hum?
As to why, Common Lisp, didn't change its syntax away from parens...
well... with all the Common Lisp fuckheads in hostile denial as
exhibited in this thread, and the stale air hold by these old lispers
new fanatical recruits, how's any change, if necessary, ever gonna
begin?
A prosperous society needs open mind and open discussion. The lisper
fuckheads, as exhibited in this thread, have been unreasonable and
persecuting to criticism. I believe, many lisp's problems,
(specifically, problems of Common Lisp today), its stagnation, is due
to these fuckheads.
Rainer Joswig
Xah Lee <x...@xahlee.org> wrote:
> 2007-05-06
>
> «I think you're wrong, Xah. If the syntax is a problem, why haven't
> any alternative syntaxes taken over for s-expressions? I point to
> these examples:»
>
> Do you know how fanatics are blind?
>
> For example, there are Christians, and there are Islamics. Doesn't
> matter what you say, what logic, what rationality, what patience, what
> evidence, for vast majority of these people, God of their variety will
> exist, and will be the only type.
>
> Fanatics are fanatics because they lost their rationality on the
> subject. They simply have the need to believe. (other examples in the
> computing industry include: Mac fanatics, unix fuckheads (and now
> Linux), OpenSource fuckheads.)
The fanatic is you.
>
> My article, is not titled “The stupidity of Lisp Syntax”. Nor “Lisp's
> got syntax problems”. Nor, “The moronicity of Common Lisp fuckheads”.
>
> The title is “How Lisp's Nested Notation Limits The Language's
> Utility”.
Sure. And it is full of false assumptions written by somebody
who never has written a single line of Common Lisp code.
Why should anyone listen to your false assumptions?
>
> Note that it says “How”, meaning, the article is a exposition. Then,
> it says “Nested Notation”. And, it “limits”. Limit what? “Limits the
> language's utility”.
>
> In the article, 3 itemized issues are mentioned.
And these are wrong.
> I don't think i
> should hold each lisper's hand to go thru the article sentence by
> sentence. You can eye the article with built-in Common Lisp prejudice
> and come off not reading anything, like basically all lispers who
> cried in pain here. These lispers, basically, saw the article, skimmed
> it, felt the wound, panics, reactionarily thinking to themselves “O!
> Another Imperative Moron who can't get used to parens!”, and then like
> a gaggle of ducks, all quack about how sexp is just fine and i'm a
> “troll”.
No, I read it. Example: I saw you pipe example. I saw that you
don't understand what you are talking about.
a|b|c
okay, what is it in Lisp?
First, your ideas are wrong anyway. On first glance.
(c (b (a))) would not achieve the same effect.
Evaluation is inside out and not in parallel.
In Lisp you would write:
(| a b c)
Now | is taken for symbols already. And usually in Lisp
you won't introduce characters, but identifiers it would be:
(pipe a b c)
If there were arguments, you would write:
(pipe (ls)
(grep ".lisp")
(sort))
PIPE would be a macro that transforms this stuff into
the machinery for pipes.
That's so obvious for anybody who has written some Lisp.
Actually SCSH has exactly such a pipe syntax. If you
want to see who you do the usual scripting stuff
in Lisp notation, check out SCSH.
Now comes the interesting part as a task:
write the pipe macro in Common Lisp and report back.
>
> Joe, i know you are seasoned lisper, and you love lisp. Me too. (But
> i'm getting stronger sense everyday that Common Lispers, at least as
> so exhibited in comp.lang.lisp are all motherfuckers, the saboteurs of
> the lisp's health.)
>
> In the article, i gave 3 issues. I do not think any lisper can
> honestly disagree with any one of them. Note that, let me emphasize
> and repeat again here, the conclusion is not: “lisp's syntax is fucked
> and needs change”.
But your idea that it limits the utility is plain wrong.
See the pipe example.
Mostly Dead.
> Dylan?
Mostly Dead.
> Arc?
Where?
> Mathematica?
No Lisp.
> And the Scheme Lisp's coming
> standard, the R6RS, introducing [] {} and other syntaxes that breaks
> the nested paren.
[] and {} are just parentheses and optional.
In Common Lisp those characters are available to
the user. You can set them to anything you
like. If you want them to be another set of parentheses?
Easy. Change the readtable for these characters.
Examples where this is already used:
[] for embedded SQL in LispWorks
{} for Xappings in Connection Machine Lisp
http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node192.html
Common Lisp has a programmable reader.
You want new parentheses? Five lines.
(defun |[-reader| (stream char)
(declare (ignore char))
(read-delimited-list #\] stream t))
(set-macro-character #\[ #'|[-reader|)
(set-macro-character #\] (get-macro-character #\) nil))
Now you have new parentheses:
CL-USER 11 > [let [[a 1] [b 2]] (+ (sin a) (sin b))]
1.7507684
> (note: this is mentioned in the article)
>
> Also, in the article, i mentioned, that lisp syntax itself, contains
> several _ad hoc_ syntax sugars for the purpose of reducing nested
> parenthesis. This, for anyone not prejudiced, who put thought into
> reading the article, might suggest a argument that too many nested
> parens is considered a problem by the grand daddies of lisp founder
> themselves. When you code lisp tonight, why don't you aways use
> “(quote ...)” instead of “'”, hum?
It is a shorthand notation with very little visual impact.
Common Lisp is not about parentheses for everything.
Common Lisp is about a minimal syntax and a
programmable and extensible reader. It is usual for Common
Lisp programs to add new syntaxes. Common Lisp
tries to get out of the way for those applications and
embedded programming languages as much as possible.
It comes with some defined reader syntax:
" " : strings
#(a b c) : vectors
#c(1 2) : complex numbers
|Foo| : symbols
#| documentation |# : comments
(a b c) : lists
#'foo : (function foo)
'foo : (quote foo)
#*10001 : bit vectors
#xFFAA : hex numbers
`(foo ,bar) : Quasi quotes
and so on...
> As to why, Common Lisp, didn't change its syntax away from parens...
> well... with all the Common Lisp fuckheads in hostile denial as
> exhibited in this thread, and the stale air hold by these old lispers
> new fanatical recruits, how's any change, if necessary, ever gonna
> begin?
You listed yourself the attempts that never went off.
Lisp syntax as it is is simple extremely practical.
>
> A prosperous society needs open mind and open discussion. The lisper
> fuckheads, as exhibited in this thread, have been unreasonable and
> persecuting to criticism. I believe, many lisp's problems,
> (specifically, problems of Common Lisp today), its stagnation, is due
> to these fuckheads.
Write a line of Lisp first.
> Xah
> x...@xahlee.org
> ∑ http://xahlee.org/
PeterCro...@gmail.com
> 2007-05-06
>
>
> «But in more than forty years no one has come up with a better
> alternative, and it hasn't been for want of trying or lack of
> imagination. »
>
> What about Logo? Dylan? Arc? Mathematica? And the Scheme Lisp's coming
> standard, the R6RS, introducing [] {} and other syntaxes that breaks
> the nested paren. (note: this is mentioned in the article)
They all failed or vapourware.
>
> As to why, Common Lisp, didn't change its syntax away from parens...
> well... with all the Common Lisp fuckheads in hostile denial as
> exhibited in this thread, and the stale air hold by these old lispers
> new fanatical recruits, how's any change, if necessary, ever gonna
> begin?
I'm new lisper but too old programmer to be called someones recruit. I
've heard about lisp , try it & like it. Offer some good alternative
and people will come to you without torturing them with your long
threads.The languages you offer are known to everybody but this people
still prefer Common Lisp.
>
> A prosperous society needs open mind and open discussion. The lisper
> fuckheads, as exhibited in this thread, have been unreasonable and
> persecuting to criticism. I believe, many lisp's problems,
> (specifically, problems of Common Lisp today), its stagnation, is due
> to these fuckheads.
>
> Xah
> x...@xahlee.org
> ∑http://xahlee.org/
What do you want to achieve Xah Lee ? People at Common Lisp like
this kind syntax ,I find it little bit odd at first but now halfway
through On Lisp I understand why it has to be like that and I just get
use to it. If you don't find natural just move on pal there's a plenty
of other languages over there , or create your own. Reiterating the
same thing all over and insulting those who are sick of your threads
won't do any good. Why bother with f*ckheads ?
Pet
Jeremi...@gmail.com
> 2007-05-06
>
>
> A prosperous society needs open mind and open discussion. The lisper
> fuckheads, as exhibited in this thread, have been unreasonable and
> persecuting to criticism. I believe, many lisp's problems,
> (specifically, problems of Common Lisp today), its stagnation, is due
> to these fuckheads.
>
> Xah
> x...@xahlee.org
> ∑http://xahlee.org/
A prosperous society needs open mind and open discussion , not an
insults and miles of empty words from people who don't know anything
about the subject. Learn some Lisp before posting more thrash for
something you don't know anything about.
JT
Lisp rules Xah Lee and Jon Harrop suck
Bob Felts
Tamas Papp
> A prosperous society needs open mind and open discussion , not an
> insults and miles of empty words from people who don't know anything
> about the subject. Learn some Lisp before posting more thrash for
> something you don't know anything about.
>
> JT
> Lisp rules Xah Lee and Jon Harrop suck
Imagine someone, who hasn't played a musical instrument and is
apparently tone-deaf, rushing in to a practice session of the NY
Philharmonic and screaming "Morons! You are holding those violins
WRONG!". Later on, he will give them an "Edu Corner" presentation on
why they should be holding the bow with their toes.
Use a news reader, and discover the magic of scoring (L a in gnus).
HTH,
Tamas
--
Posted via a free Usenet account from http://www.teranews.com
Xah Lee
Xah Lee wrote:
«How Lisp's Nested Notation Limits The Language's Utility
http://xahlee.org/UnixResource_dir/writ/notations.html
»
A Common Lisp fuckface, Rainer, wrote:
«Sure. And it is full of false assumptions written by somebody who
never has written a single line of Common Lisp code. Why should
anyone listen to your false assumptions?»
The context of my article, is lisp. More specifically, the nested
notation used by lisp. You should not hijack it to mean Common Lisp.
Lisp, as you know, is a family of languages. Broadly, it can include
Logo, Dylan, or even Mathematica. Narrowly, it includes Common Lisp,
Emacs Lisp, and Scheme. The latter group, all employ a somewhat
uniform nested syntax.
Rainer —a Common Lisp fuckface— wrote:
«... Why should anyone listen to your false assumptions?»
Rainer, When did you stop beating your wife?
As to my qualitifications, I think you know well that i'm not some
student or lisp newbie. So, from my point of view, you are simply
fucking with me, and sputtering unreasonable garbage typical of a
newsgroup brawl.
When responding to a article, it is reasonable to know the author's
qualifications. My qualifications in particular for my article, is
openly and easily viewable on my public website http://XahLee.org/ .
However, to quetsion the author's qualitifications in the context of a
newsgroup discussion, like the Rainer fuckface has done, is
unreasonable. Online forum discussions (such as newsgroups), by its
nature, are often anonymous and informal. You can't just arbitrarily
demand authorship and qualifacitons in any argument in the posts. For
example, let me ask you then, what qualifications do you have, in
responding to my criticism?
If you want to press the issue, i can show you my IQ score, my jobs
held, the software i've written, and the measurement of my cock size.
I don't think you can touch me.
What are the gaggle of troll-cryer's qualifications, when they called
me a troll? Do they, say, have a sociology degree or psychiatric
certificate?
Rainer fuckhead wrote:
«No, I read it. Example: I saw you pipe example. I saw that you don't
understand what you are talking about.»
What if i tell you, honestly, you are a fucking moron in relative to
me?
Dear Rainer, yes i mean it. I truely, honestly, in no humor or joking
sense, believe, that when you, in comparison to me, of the abilities,
knowledge, or skill, in the areas of Lisp (not Common Lisp), computing
languages, programing ability, mathematics, critical thinking, fields,
you are a like moron.
Now, perhaps, maybe, you believe the same way about me? How can we
resolve it then? Usually, there are many ways. For example, we can
both take IQ tests. We can also, have a competition in any of the
areas. There are plenty, well-accepted, qualified, ways in judging
skills and knowledge. Alternatively, we can also, have qualified
experts, assess our abilities in particular areas. For example, in the
areas of Math, we could have say, have 10 mathematicians selected at
random, and grill us for an hour... etc. Similarly, we could have
expert, accomplished, computer language designers, assess our
comparative abilities or merits in questions abot languages... and so
on.
In the context of newsgroup discussion, it might be a bit difficult.
Since, we are limited to just what we write. And, there's not gonna be
the energy, or resource, to actually carry out any of the above tests.
Though, it is still possible, to realize to fairly good conclusions,
of whether party A or party B is more qualified or expert in
particular area, in newsgroups. For example, perhaps, we can start to
get serious, and continue our argument. So, your technical arguments
will be countered by mine, and mine by yours. And, eventually, when
this is done for a while, i think it would show, fairly accurately,
whether one party actually know what he is talking about, while the
other party, may lack lustre. (this might be unfair to you, since your
writing ability may be far below me)
The problem now is, that the parties don't necessarily want to
participate in this process. First of all, comparing cock sizes in a
show down is not exactly the purpose of newsgroups. Also, in practice,
each of us has other slackings to do. Further, a party, such as you,
may fear the eventual failure, and as a man, will feel defeated and
ashamed. So, as a stradgy in a power struggle, one might befuddle
one's real intention in participanting in a serious, final show down,
of the participant's qualifications and relative merits.
Are you, as a Common Lisp fuckhead, willing to have a tech show down
with me? I don't have nothing to do all day. For other Common Lisping
fuckheads who has said fucking shits in this thread, i entertain the
possibility of accepting their challenges too.
> In Lisp you would write:
>
> (| a b c)
Dear Rainer, the context is syntax, not semantics. What your Pipe code
shown above, is semantically Composition as i have written in my
article... (i sense some Common Lisp moron will jump my bone here...
any minute now)
I also replied to Kenny using examples from Mathematica, not unix
pipes. Did you read that?
Rainer wrote:
> > What about Logo?
>
> Mostly Dead.
>
> > Dylan?
>
> Mostly Dead.
>
> > Arc?
>
> Where?
>
> > Mathematica?
>
> No Lisp.
>
> > And the Scheme Lisp's coming
> > standard, the R6RS, introducing [] {} and other syntaxes that breaks
> > the nested paren.
>
> [] and {} are just parentheses and optional.
> ...
Rainer... i get tired of responding to your silly arguments. So, what
about tech show down with me?
Before i expend energy, to seriously answer your posts, i need to
know, if you are serious, not just fucking around and picking typos
here and there.
You know, people usually are not serious where there's no stake. In
job interviews, you would be very serious. In cutting a pizza, you
would be serious. When shopping for a prostitute with money, you would
be serious. But in newsgroup discussions, anyone can say shit as they
please. There is no price to pay.
So, i want to be able to acertain some seriouness before we proceed to
a shown down.
What are ways that can assure us this? Maybe we can both pitch in to
paypal some agreed amount of money? I mean, c'mon friend, make some
suggestions that we can get this over with. I'm willing, to, say, put
money in paypal account to domenstrate that I, have the sincerity to
participate. Sure, this is getting a bit weird in newsgroups, but if
serious argumentation is what you really want, we could take this
approach. Yes?
O, any of the Common Lisping fuckheads who participated in this
thread, please suggest ways. You can open a paypal account, and i will
drop in money. I don't run Paypal, and of course this is not the only
way. We could, perhaps hire some respected computer scientist to be
our arbitraror, or something. And we each sign affidavits.
asan...@gmail.com
On May 7, 3:29 pm, Xah Lee <x...@xahlee.org> wrote:
> Dear Rainer Joswig fuckface,
>
>
> Are you, as a Common Lisp fuckhead, willing to have a tech show down
> with me? I don't have nothing to do all day. For other Common Lisping
> fuckheads who has said fucking shits in this thread, i entertain the
> possibility of accepting their challenges too.
>
How long has this troll been here? Judging by the other posts, it
seems that for ages. How do you guys manage it? It's amazing. When you
think you've known enough types of people...
Tim Bradshaw
> Dear Rainer, the context is syntax, not semantics. What your Pipe code
> shown above, is semantically Composition as i have written in my
> article...
That's curious, because, as you'd know if you'd used scsh, what it does
is exactly what a Unix shell pipeline does.
Tim Bradshaw
> How long has this troll been here? Judging by the other posts, it
> seems that for ages. How do you guys manage it? It's amazing. When you
> think you've known enough types of people...
He's been around since at least 2002. He's OK so long as you treat him
as an amusement.
Rainer Joswig
Xah Lee <x...@xahlee.org> wrote:
I'm not quoting lots of stuff from your posting, stuff I'm not
interested in responding to.
> The context of my article, is lisp. More specifically, the nested
> notation used by lisp. You should not hijack it to mean Common Lisp.
> Lisp, as you know, is a family of languages. Broadly, it can include
> Logo, Dylan, or even Mathematica.
Logo is a derived language from way back. My last usage
of Logo is long ago and I can't really say if
it is stilly connected to Lisp nowadays.
There were a few Logo implementations in Lisp,
that shared some features with Lisp.
I haven't seen anybody mentioning Logo in connection
to Lisp in the past decade. But that is just my
impression.
Dylan is not really a Lisp dialect any more.
The first Dylan was a Lisp.
It had Lisp syntax and was 'dynamic'. It was way cool.
The later Dylan is more like a derived language. It
is a bit tragic, Dylan stood for Dynamic Language.
Later Dylan was mostly (as in its definition) a
static language. So Stalan would be a fine name
for Dylan now - for the language definition.
The implementations had some dynamic features, though.
Mathematica is no Lisp at all. Mathematica
has a different computing model (term rewriting). I has some features
of Lisp (and others Lisp does not have).
If you know Mathematica it will help
with Lisp, no doubt. But in essence it does not belong to
the Lisp family. This is nothing negative. It is just
so. I wouldn't even call it a derived language.
It is more derived from some applications that
happen to be written in Lisp (SMP, Macsyma, ...).
I'd say Mathematica is related to Lisp like Prolog
is related to Lisp.
> Narrowly, it includes Common Lisp,
> Emacs Lisp, and Scheme. The latter group, all employ a somewhat
> uniform nested syntax.
Wow, that's atleast correct.
They not only have a similar syntax, but they have
also lots of other things in 'common'.
Though Scheme is the odd one when it comes to syntax.
Scheme has a formal syntax
(http://www.schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-10.html#%_sec_7.1).
We can add EuLisp, ISLisp, InterLisp, XLisp, AutoLisp, Goo and
Lisp Machine Lisp.
> As to my qualitifications, I think you know well that i'm not some
> student or lisp newbie.
No student, okay. But Lisp expert?
I can believe that you have lots of knowhow about
programming languages. But Lisp? I mean what
is your experience in Lisp? You did some Emacs
customization, okay? But Lisp programming?
I mean really real Lisp programming? Give me
a hint. I honestly have no idea, because I saw
nothing so far but bullshitting.
> When responding to a article, it is reasonable to know the author's
> qualifications. My qualifications in particular for my article, is
> openly and easily viewable on my public website http://XahLee.org/ .
Xah, I'm looking. I see lots of Mathematica. I see
some Emacs customization. Lots of interesting stuff.
But I fail to see any hint of a Lisp program.
Maybe I cannot find it. Give me a hint.
Emacs is fine, but it's Lisp is ancient and limited.
There are larger Emacs modes written in Lisp.
Maybe that's what I'm missing?
> > In Lisp you would write:
> >
> > (| a b c)
>
> Dear Rainer, the context is syntax, not semantics. What your Pipe code
> shown above, is semantically Composition as i have written in my
> article...
How can you know what it semantically is? You
just see a syntactic form. It can be anything in Lisp
(-> Macros). You claimed that the Lisp syntax
limits Lisp. But that's not the case. Lisp has
extensibility built in (macros, readmacros, ...).
> (i sense some Common Lisp moron will jump my bone here...
> any minute now)
>
> I also replied to Kenny using examples from Mathematica, not unix
> pipes. Did you read that?
Yes, but Mathematica is no Lisp. Lisp looks and feels
different. That you had to resort to Mathematica to argue
shows.
> Before i expend energy, to seriously answer your posts, i need to
> know, if you are serious, not just fucking around and picking typos
> here and there.
There is no need to take the time and write more. Use
the time to do some Lisp programming. If you have problems
representing things in Lisp, comp.lang.lisp may have
some ideas and may help. Theoretical debates of what
could hinder us to write code is useless. I've
seen dedicated guys who wrote and maintained large
amounts of Lisp code. That's more important to me
than discussing what "could" hinder us. There have been
Lisp systems written from a few hundred to more than a million
lines of code. Your problem is just a joke.
On the Internet you can find lots of larger bodies
of Lisp code, which you can study and see if they
are limited by Lisp syntax and what they are doing
to get around this, if necessary.
Have fun.
Xah Lee
i don't know who you are. But i vaguely recall, you are one of the
moronic respondents to one of my criticisms on how Emacs needs to be
modernized. (and i hated you very much)
(See
Modernization Emacs
http://xahlee.org/emacs/modernization.html
)
One of the criticism of my numerous criticism in the computing
industry, is that i am not “constructive” in some way. This is fuzzy
and silly.
For example, poeple don't respond to professional critics, by
retorting “What have you done?”
(
See
Criticism versus Constructive Criticism
UnixResource_dir/writ/criticism.html
)
A good criticism, in itself, is a contribution to the community.
Philosophers, for example, are examplary in this regard.
But as to what i have actually done for the computing communities of
which i've criticized besides criticism, i think there's a few.
Mostly, i have several tutorials on my website:
Perl and Python tutorial (~80 HTML pages)
• http://xahlee.org/perl-python/python.html
Emacs and Emacs Lisp tutorial (~80 HTML pages)
• http://xahlee.org/emacs/emacs.html
A complete, mirror of the official HTML documentation of Emacs Lisp,
with HTML code modified (corrected) so that they are W3C valid HTML
document, and CSS added for easier reading. (~850 HTML pages)
• http://xahlee.org/elisp/index.html
A Java tutorial
• http://xahlee.org/java-a-day/java.html (~40 HTML pages)
A Javascript and HTML and CSS tutorial (~70 HTML pages)
• http://xahlee.org/js/js.html
These are informal tutorials. Sure, they are not as rigorous as
published books in print. Sure, perhaps 20% of the content of my
tutorials are filled with technical criticisms.
You, as a tech geeker, may argue that my writings or teachings are in
bad quality or taste in your eyes. But they are there, and unarguably
took years to create. In all fairness, i think society would judge
them, to be positive, or “constructive” contributions. (and i do
receive regular emails from professional programers, educators,
professors, mathematicians (including a Nobel Prize laureate, to thank
me on my articles in diverse areas)
There was a Python fuckhead, who's name is Steve Holden ( http://www.holdenweb.com/
), in 2005-04-12, in response to criticisms i made of the
motherfucking garbage of the Python documentation, challenged me to
rewrite it, with the offer of $100 USD.
I responded, and the result is a full-rewrite of the Python's RE doc.
(
Pyhton Regex Documentation: String Pattern Matching
http://xahlee.org/perl-python/python_re-write/lib/module-re.html
)
He, reneged his promise to pay, citing that i missed the deadline
(that he missed my announcement), and that i failed the qualifications
of which he made the $100 offer.
Regardless of the situation, my rewrite of the entire Python
documentation of its RE module, is a contribution.
So, yeah, i made contributions, and arguably, quite a lot in the
computing industry. By my mere criticism, and by actual tutorials and
codes. (not counting, areas in Math, or Mathematica programing)
But really, the newsgroup fuckheads, their accusation of my “negative”
criticism, or my “lack of contribution”, really are due to their lack
of general education in the area of humanities (in particular: their
lack of understanding of the role of criticism), and as a execuse to
attack me in the political struggle, and or simply careless farts to
posts they don't like in newsgroups.
Xah
x...@xahlee.org
∑ http://xahlee.org/
Xah Lee wrote:
« How Lisp's Nested Notation Limits The Language's Utility
http://xahlee.org/UnixResource_dir/writ/notations.html
»
Tim Bradshaw wrote:
« Very good. Now, off you go and design and implement an alternative
syntax. It's easy, it's been done hundreds of times. I think I have
two or three limited examples on my web site and several more I never
bothered publishing. There must, as I say, be hundreds of examples
around and probably thousands when you count all the non-published
ones. So pick the best and use them, or, since you're by far the
smartest person here, why not come up with your own? Jon Harrop can
probably help you. »
Tim X wrote:
«
Actually, I think this is a very good idea forXah. Many have been very
critical of what he posts (including myself), but I suspect a large
percentage of people totally dismiss what he writes because he doesn't
provide any constructive alternatives. He regularly posts about what
is wrong with emacs, lisp, unix, perl etc. but rarely do I see any
proposed solutions or constructive ideas that might actually improve
the situation.
come onXah, you have made frequent references to your superior IQ,
your ability to write and express ideas. Its easy to moan about whats
wrong with the world, time to put your money where your mouth is. Take
some of that boundless IQ and your superior skills in communication
and post some ideas on how things could be improved.
»
Ken Tilton
asan...@gmail.com wrote:
> Hallo,
>
> On May 7, 3:29 pm, Xah Lee <x...@xahlee.org> wrote:
>
>>Dear Rainer Joswig fuckface,
>>
>>
>>Are you, as a Common Lisp fuckhead, willing to have a tech show down
>>with me? I don't have nothing to do all day. For other Common Lisping
>>fuckheads who has said fucking shits in this thread, i entertain the
>>possibility of accepting their challenges too.
>>
>
>
> How long has this troll been here? Judging by the other posts, it
> seems that for ages. How do you guys manage it?
It is springtime, everyone is busting out. My damn corn plant even
flowered. Xah is normally not so, um, sociable.
hth,kzo
--
http://www.theoryyalgebra.com/
"Algebra is the metaphysics of arithmetic." - John Ray
"As long as algebra is taught in school,
there will be prayer in school." - Cokie Roberts
"Stand firm in your refusal to remain conscious during algebra."
- Fran Lebowitz
"I'm an algebra liar. I figure two good lies make a positive."
- Tim Allen
Joe Marshall
> «I think you're wrong, Xah. If the syntax is a problem, why haven't
> any alternative syntaxes taken over for s-expressions? I point to
> these examples:»
>
>
> got syntax problems". Nor, "The moronicity of Common Lisp fuckheads".
>
> The title is "How Lisp's Nested Notation Limits The Language's
> Utility".
Point taken. I got distracted.
Joe Marshall
particularly relevant to Xah's original post.
> Joe Marshall wrote:
> > If the syntax is a problem, why haven't
> > any alternative syntaxes taken over for s-expressions?
On May 6, 3:45 pm, Jon Harrop <j...@ffconsultancy.com> wrote:
> They have.
They have? Then where's the argument?
I've been programming in lisp quite recently and I don't recall
an algorithmic syntax. Did I miss something?
> Mathematica uses more conventional syntax to handle expressions:
What does this have to do with lisp?
>
> OCaml allows you to define infix operators and these can be used to compose
> expressions.
What does this have to do with lisp?
>
> So I think it is fair to say that s-exprs in Lisp have been superceded by
> more efficient representations of expressions in most modern FPLs.
This makes no sense. I ask why alternative lisp syntaxes never took
off,
and you tell me about the syntax of unrelated languages.
Pascal Costanza
> But also, lisp can actually relatively easily,
> create a layer of syntax on top of sexp...
It was hard to find out that there is actually a question somewhere deep
down in your posting.
Here is one possible answer:
(defmacro pipe (&body forms)
(let ((var (gensym)))
`(macrolet ((=> (&body forms)
`(let ((,',var (funcall #',(car forms) ,',var)))
,(if (cdr forms) (cdr forms) ',var))))
(let ((,var ,(car forms)))
,(if (cdr forms) (cdr forms) var)))))
> (defun square (x) (* x x))
SQUARE
> (pipe 5 => 1+ => square => print)
36
This is just a sketch. A full version would probably require some more
work. But there you go...
Pascal
--
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
Jon Harrop
>> Joe Marshall wrote:
>> > If the syntax is a problem, why haven't any alternative syntaxes taken
>> > over for s-expressions?
>
You asked why "alternative syntaxes never took off". Nothing Lisp specific
so I cited several non-Lisp examples.
If you want a Lisp specific example then I'd say why did closures not take
off in BASIC? I think the answer is that BASIC programmers who wanted
something more learned a better tool...
Andy Freeman
> Joe Marshall wrote:
> >> Joe Marshall wrote:
> >> > If the syntax is a problem, why haven't any alternative syntaxes taken
> >> > over for s-expressions?
>
> > I ask why alternative lisp syntaxes never took off,
>
> You asked why "alternative syntaxes never took off". Nothing Lisp specific
> so I cited several non-Lisp examples.
The thread is about lisp syntax. Marshall even wrote "taken over for
s-expressions", which restricts the domain to languages which had s-
expressions to be taken over for.
Of course, Harrop can't be bothered. He's got a language to flog.
> If you want a Lisp specific example then I'd say why did closures not take
> off in BASIC?
In other words, Harrop isn't even trying to honestly participate.
(BASIC features, or lack thereof, are not Lisp-specific.)
Does Harrop really think that his participation in cll makes folks
more friendly toward F#/OCaml or anything else that he apparently
values?
Joe Marshall
> Joe Marshall wrote:
> >> Joe Marshall wrote:
> >> > If the syntax is a problem, why haven't any alternative syntaxes taken
> >> > over for s-expressions?
>
> > I ask why alternative lisp syntaxes never took off,
>
> You asked why "alternative syntaxes never took off". Nothing Lisp specific
> so I cited several non-Lisp examples.
Huh? This thread is called ``How Lisp's Nested Notation Limits The
Language's Utility Options''. I embedded a paragraph from Xah which
starts ``There is a common complain by programers about lisp's
notation, of nested parenthesis, being unnatural or difficult to
read.'' I then mentioned M-expressions (the original Lisp syntax),
CGOL (an alternative Lisp syntax), Dylan (a language with a strong
lisp heritage that abandoned the s-expression syntax), and Curl (a
language with a strong lisp heritage that replaced parens by curly
braces). Most people know I'm a lisp hacker, too.
What on earth did you think I was talking about?!
> If you want a Lisp specific example then I'd say why did closures not take
> off in BASIC? I think the answer is that BASIC programmers who wanted
> something more learned a better tool...
Am I missing something here? What does BASIC have to do with Lisp?
What are you smoking, dude?
Jon Harrop
>> If you want a Lisp specific example then I'd say why did closures not
>> take off in BASIC?
>
Syntax is not Lisp specific.
> Does Harrop really think that his participation in cll makes folks
> more friendly toward F#/OCaml or anything else that he apparently
> values?
We got our last order from a Lisper 2.5hrs ago. So yes.