for help !
is lisp language hard to learn ?
and whick book i should read first?
i never touch lisp before but not it seem lisp is very great mind language;
who can help me?
On Oct 13, 9:33 am, jack <········@gmail.com> wrote:
> for help !
> is lisp language hard to learn ?
No
> and whick book i should read first?
For learning common lisp if you're already experienced in some other
language and you just want to get on creating applications with lisp:
1. http://www.gigamonkeys.com/book/ free as ebook, worth every
cent
of the paper edition.
If you're new to programming or just prefer slower pace :
2. Gentle introduction to symbolic computation
http://www-cgi.cs.cmu.edu/afs/cs.cmu.edu/user/dst/www/LispBook/index.html
The other free ebooks worth looking at, some of them offer printed
editions are,
3.Succesfull Common lisp http://www.psg.com/~dlamkins/sl/contents.html
4.Loving lisp http://www.markwatson.com/opencontent/
5. COMMON LISP: An Interactive Approach http://www.cse.buffalo.edu/~shapiro/Commonlisp/
6. Basic Lisp Techniques, http://www.franz.com/resources/educational_resources/cooper.book.pdf
Great for starters but without free online editions are:
7 Ansi Common Lisp by Paul Graham
8 Lisp by Winston & Horn might be nice too.
There's some nice videos that Franz made available free of charge
from
their certification program at http://www.franz.com/services/classes/download.lhtml
> i never touch lisp before but not it seem lisp is very great mind language;
> who can help me?
You already have everything you need just download some implementation
that fits your system, it doesn't matter which one for a starter, you
could switch without a problem later if you change your mind.
Commercial
http://www.franz.com/downloads/allegrodownload.lhtml
http://www.lispworks.com/downloads/
http://www.cormanlisp.com/
Open Source
http://sbcl.sourceforge.net/
http://www.clozure.com/clozurecl.html
http://clisp.cons.org/
http://ecls.sourceforge.net/
http://www.cons.org/cmucl/
http://common-lisp.net/project/armedbear/
for a full study of lisp implementations check http://common-lisp.net/~dlw/LispSurvey.html
bobi
On Oct 13, 3:33 am, jack <········@gmail.com> wrote:
> for help !
> is lisp language hard to learn ?
> and whick book i should read first?
> i never touch lisp before but not it seem lisp is very great mind language;
> who can help me?
I've gotten good milage out of Common Lispcraft by Robert Wilensky.
More formal than Seibel and less intense than Graham. You can pick up
a used copy for a very reasonable price.
CC
On 13 Ott, 09:33, jack <········@gmail.com> wrote:
> for help !
It's hard to learn if new & flexible & simple concepts are not your
force.
It's very easy to learn if your mind is wired in an easy-to-receive
"new & flexible & simple concepts" way.
Anyway, you will have to spend some deeply going mind circles, if you
want to become some kind of master-of-art.
-PM
On Oct 13, 12:33 am, jack <········@gmail.com> wrote:
> for help !
> is lisp language hard to learn ?
> and whick book i should read first?
> i never touch lisp before but not it seem lisp is very great mind language;
> who can help me?
You can read my lisp tutorial, at:
http://xahlee.org/emacs/elisp.html
This is the best emacs lisp tutorial that exists, period. You can read
the basic chapters of this tutorial with good understanding in a
couple of days and start producing useful code.
Also, i consider emacs lisp the most practical lisp among Common Lisp
and Scheme Lisp.
Other top quality free books on lisp are:
• Teach Yourself Scheme in Fixnum Days by Dorai Sitaram, 1998-2004
http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme.html
• Structure and Interpretation of Computer Programs, by Abelson,
Sussman, and Sussman.
http://mitpress.mit.edu/sicp/
The above are the best lisp tutorials, period. (the SICP book teachs
more about theoretical aspects of programing than lisp)
Note: you'll also hear recommendations about
“ Practical Common Lisp” (2003) by Peter Seibel
http://www.gigamonkeys.com/book/
which i didn't consider a good book, even though between Common Lisp
and Scheme Lisp, i root for Common Lisp more.
Xah
∑ http://xahlee.org/
☄
Le Mon, 13 Oct 2008 09:14:18 -0700 (PDT),
·······@gmail.com" <······@gmail.com> a écrit :
> On Oct 13, 12:33 am, jack <········@gmail.com> wrote:
> [...]
> > and whick book i should read first?
>
> You can read my lisp tutorial, at:
> [...]
> This is the best emacs lisp tutorial that exists, period. [...]
pfiewww, it seems you have disproportionate ego !
--
Jacques, the best ! :-)
jack <········@gmail.com> writes:
> for help !
> is lisp language hard to learn ?
> and whick book i should read first?
> i never touch lisp before but not it seem lisp is very great mind language;
> who can help me?
Here are some books you could read:
GENTLE = Common Lisp: A Gentle Introduction to Symbolic Computation
http://www-cgi.cs.cmu.edu/afs/cs.cmu.edu/user/dst/www/LispBook/index.html
http://www.cs.cmu.edu/~dst/LispBook/
CLAIA = "COMMON LISP: An Interactive Approach"
by Stuart C. Shapiro:
http://www.cse.buffalo.edu/~shapiro/Commonlisp/
PCL = Practical Common Lisp = http://www.gigamonkeys.com/book/
SICP = Structure and Interpretation of Computer Programs
http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html
http://swiss.csail.mit.edu/classes/6.001/abelson-sussman-lectures/
http://www.codepoetics.com/wiki/index.php?title=Topics:SICP_in_other_languages
http://eli.thegreenplace.net/category/programming/lisp/sicp/
You can find other references on:
http://www.cliki.net/
--
__Pascal Bourguignon__ http://www.informatimago.com/
ATTENTION: Despite any other listing of product contents found
herein, the consumer is advised that, in actuality, this product
consists of 99.9999999999% empty space.
On Oct 13, 2:53 am, ····@informatimago.com (Pascal J. Bourguignon)
wrote:
> PCL = Practical Common Lisp =http://www.gigamonkeys.com/book/
I thought it was COBOL-Lisp.
That book has:
The following function uses nested loops to find the first pair
of numbers, each less than 10, whose product is greater than the
argument, and it uses RETURN-FROM to return the pair as soon as
it finds it:
(defun foo (n)
(dotimes (i 10)
(dotimes (j 10)
(when (> (* i j) n)
(return-from foo (list i j))))))
Mindless redundancy! "foo" is repeated.
Ruby:
def foo n
10.times{|i|
10.times{|j|
return [i, j] if i*j > n }}
end
foo(48)
---> [6, 9]
----
(defun plot (fn min max step)
(loop for i from min to max by step do
(loop repeat (funcall fn i) do (format t "*"))
(format t "~%")))
You could define the following function:
(defun double (x) (* 2 x))
which you could then pass to plot.
CL-USER> (plot #'double 0 10 1)
**
****
******
********
**********
************
**************
****************
******************
********************
NIL
But it's easier, and arguably clearer, to write this:
CL-USER> (plot #'(lambda (x) (* 2 x)) 0 10 1)
Ruby:
def plot min, max, step
min.step( max, step ){|x| puts ·@" * yield( x ) }
end
double = proc{|x| x * 2 }
plot(0, 10, 1, &double)
plot(0, 10, 1){|x| x*2 }
----
(defparameter *random* (loop repeat 100 collect (random 10000)))
Then the following loop will return a list containing various
summary information about the numbers:
(loop for i in *random*
counting (evenp i) into evens
counting (oddp i) into odds
summing i into total
maximizing i into max
minimizing i into min
finally (return (list min max total evens odds)))
Ruby:
Never forget: "We don't need no stinkin' loops!"
r = (1..100).map{ rand( 10_000 ) }
evens = r.select{|n| 0==n%2}.size
[ r.min, r.max, r.inject{|a,b| a+b}, evens, r.size - evens ]
---> [60, 9951, 503427, 49, 51]
On Oct 13, 4:09 pm, William James <·········@yahoo.com> wrote:
> def foo n
> 10.times{|i|
> 10.times{|j|
> return [i, j] if i*j > n }}
> end
> def plot min, max, step
> min.step( max, step ){|x| puts ·@" * yield( x ) }
> end
> r = (1..100).map{ rand( 10_000 ) }
>
> evens = r.select{|n| 0==n%2}.size
> [ r.min, r.max, r.inject{|a,b| a+b}, evens, r.size - evens ]
> Never forget: "We don't need no stinkin' loops!"
Fucker. The reason you don't need loops is because you are using
predefined specialized looping functions that do all the job for you.
All one needs to do if they want to join in your mental masturbation
is to define in Lisp a step function, a select/filter function, some
list comprehension syntax and whatmore. Then, they can compile it to
native code and send Ruby to hell.
William James <·········@yahoo.com> writes:
> On Oct 13, 2:53�am, ····@informatimago.com (Pascal J. Bourguignon)
> wrote:
>
>> PCL � �= Practical Common Lisp � � � =http://www.gigamonkeys.com/book/
>
> I thought it was COBOL-Lisp.
>
> That book has:
>
> The following function uses nested loops to find the first pair
> of numbers, each less than 10, whose product is greater than the
> argument, and it uses RETURN-FROM to return the pair as soon as
> it finds it:
>
> (defun foo (n)
> (dotimes (i 10)
> (dotimes (j 10)
> (when (> (* i j) n)
> (return-from foo (list i j))))))
>
> Mindless redundancy! "foo" is repeated.
>
> Ruby:
>
> def foo n
> 10.times{|i|
> 10.times{|j|
> return [i, j] if i*j > n }}
> end
Wrong!
(def foo(n) # Sorry, there's a silly rule that prevent you
# to write (def foo (n)
(10 . times { | i | # Sorry, there's a silly rule that imposes
# the dot and the space between times and {
# and that imposes { } instead of () around lambda.
# Sorry also about the silly rule that imposes | |
# instead of () around parameter lists...
(10 . times { | j | # Sorry, there's a silly rule
# that imposes infix instead of
# God's give prefix.
(if ((i * j) > n) # Sorry, no macro, no when.
(return [ i , j ]) # Sorry, a silly rule
# imposing useless commas.
# No multiple value, so we have to return a vector!
end) # Sorry, silly rule imposing random keywords
})
})
end)
# So, without the comments:
(def foo(n)
(10 . times { | i |
(10 . times { | j |
(if ((i * j) > n)
(return [ i , j ])
end)
})
})
end)
# There's also a silly rule that prevent writing two sexps on the same
# line...
> foo(48)
Wrong!
> ---> [6, 9]
irb(main):099:0> (foo 48)
[6, 9]
So, now that we restored some sanity, let's answer to your redundancy
critic. Try to write this in BrokenMatzLisp:
(defun foo (n)
(loop :for i :from 0 :below 10 :collect
(loop :named bar :for j :from 0 :below 10 :do
(when (> (* i j) n)
(return-from bar (list i j))))))
(foo 6)
--> (NIL (1 7) (2 4) (3 3) (4 2) (5 2) (6 2) (7 1) (8 1) (9 1))
> Ruby:
>
> def plot min, max, step
> min.step( max, step ){|x| puts ·@" * yield( x ) }
> end
Wrong!
(def plot(min , max , step) # Silly useless and mindless commas.
(min . step(max , step) { | x | (puts (·@" * (yield x))) })
end)
> double = proc{|x| x * 2 }
> plot(0, 10, 1, &double)
>
> plot(0, 10, 1){|x| x*2 }
Now try to implement this, with your ToyMatzLisp:
(defun plot (fn plot-it min max step)
(loop :for i :from min :to max :by step :do
(funcall plot-it (funcall fn i))))
(plot (lambda (x) (+ 20 (* 20 (+ (sin (* 3 x)) (/ (sin x) 3)))))
(lambda (x) (loop :repeat x :do (format t "*") :finally (format t "~%")))
0 pi 0.1)
--
__Pascal Bourguignon__ http://www.informatimago.com/
There is no worse tyranny than to force a man to pay for what he does not
want merely because you think it would be good for him. -- Robert Heinlein
On Oct 13, 8:09 pm, William James <·········@yahoo.com> wrote:
> On Oct 13, 2:53 am, ····@informatimago.com (Pascal J. Bourguignon)
> wrote:
>
> > PCL = Practical Common Lisp =http://www.gigamonkeys.com/book/
>
> I thought it was COBOL-Lisp.
>
> That book has:
>
> The following function uses nested loops to find the first pair
> of numbers, each less than 10, whose product is greater than the
> argument, and it uses RETURN-FROM to return the pair as soon as
> it finds it:
>
> (defun foo (n)
> (dotimes (i 10)
> (dotimes (j 10)
> (when (> (* i j) n)
> (return-from foo (list i j))))))
>
> Mindless redundancy! "foo" is repeated.
>
> Ruby:
>
> def foo n
> 10.times{|i|
> 10.times{|j|
> return [i, j] if i*j > n }}
> end
>
> foo(48)
Poor style junior. Your program is roughly equivalent to which is
usable if you don't care much extending it later.
(defun foo (n &optional (i 1) (j 1))
(cond ((= j 10) nil)
((= i 10) (foo n 1 (1+ j)))
((> (* i j) n) (list j i))
(t (foo n (1+ i) j))))
>(foo 48)
(6 9)
Now if you read some good book like http://mitpress.mit.edu/sicp/
instead of playing with trivial programs you would know what is wrong
with your solution.
if can't name something you can summon it's magic. You can't change it
extend it nor improve it. If you want to check is your solution any
good try changing some of the requirements and see how easy it to
modify it.
Lets examine the problem a little bit:
Find the first pair of numbers, each less than 10, whose product is
greater than the argument.
I would start with a brute force approach:
(defun naturals (n &optional (i 1))
(if (= i n) nil (cons i (natural n (1+ i)))))
(defun cartesian (x y)
(let (res)
(dolist (ex x (reverse res))
(dolist (ey y)
(push (list ex ey) res)))))
(defun brute (n)
(find-if (lambda (x) (> (* (car x) (cadr x)) n))
(cartesian (naturals 10) (naturals 10))))
Now let's get back to our problem. It says all numbers, not all
natural numbers.
Let's include positive rational numbers, since they're infinite will
add a stepping parameter, plus who said they're always going to start
from 1 so will add start and end parameters.
(defun rationals (n &optional (i 1) (step 1))
(if (>= i n) nil
(cons i (rationals n (+ i step) step))))
(defun brute (n &key (start 1) (step 1) (end 10))
(find-if (lambda (x) (> (* (car x) (cadr x)) n))
(cartesian (rationals end start step) (rationals end start
step))))
Quick fix. Because I could see where the proposed solution is
generated and tested.
Now let's get rid of those ugly cars & cadr.
(lambda (x) (> (reduce #'* x) n)); this will not only pair but with
anything
(defun brute (n &key (start 1) (step 1) (end 10))
(find-if (lambda (x) (> (reduce #'* x) n)); this will not only pair
but with anything
(cartesian (rationals end start step) (rationals end start
step))))
Now we aren't bond to pairs , we could change generating funciton
cartesian with some that generates triples , quads or whatever it will
still work.
And note that solution shape still looks the same. That's not with
your case.
I could even change find-if and cartesian with a generator based
solution like to prevent creating all pairs, but the shape will be the
same.
(defun brute (n &key (start 1) (step 1) (end 10))
(find-if-in-generator (lambda (x) (> (reduce #'* x) n)); this will
not only pair but with anything
(cartesian-generator (rationals end start step) (rationals
end start step))))
>
> ---> [6, 9]
>
> ----
>
> (defun plot (fn min max step)
> (loop for i from min to max by step do
> (loop repeat (funcall fn i) do (format t "*"))
> (format t "~%")))
>
> You could define the following function:
>
> (defun double (x) (* 2 x))
>
> which you could then pass to plot.
>
> CL-USER> (plot #'double 0 10 1)
>
> **
> ****
> ******
> ********
> **********
> ************
> **************
> ****************
> ******************
> ********************
> NIL
>
> But it's easier, and arguably clearer, to write this:
>
> CL-USER> (plot #'(lambda (x) (* 2 x)) 0 10 1)
>
> Ruby:
>
> def plot min, max, step
> min.step( max, step ){|x| puts ·@" * yield( x ) }
> end
>
> double = proc{|x| x * 2 }
> plot(0, 10, 1, &double)
>
> plot(0, 10, 1){|x| x*2 }
>
> ----
>
> (defparameter *random* (loop repeat 100 collect (random 10000)))
>
> Then the following loop will return a list containing various
> summary information about the numbers:
>
> (loop for i in *random*
> counting (evenp i) into evens
> counting (oddp i) into odds
> summing i into total
> maximizing i into max
> minimizing i into min
> finally (return (list min max total evens odds)))
>
> Ruby:
>
> Never forget: "We don't need no stinkin' loops!"
>
> r = (1..100).map{ rand( 10_000 ) }
>
> evens = r.select{|n| 0==n%2}.size
> [ r.min, r.max, r.inject{|a,b| a+b}, evens, r.size - evens ]
>
> ---> [60, 9951, 503427, 49, 51]
William James schrieb:
> (defun foo (n)
> (dotimes (i 10)
> (dotimes (j 10)
> (when (> (* i j) n)
> (return-from foo (list i j))))))
>
> Mindless redundancy! "foo" is repeated.
>
> Ruby:
>
> def foo n
> 10.times{|i|
> 10.times{|j|
> return [i, j] if i*j > n }}
> end
The Lisp code you gave has only 20 code elements.
Your Ruby program has 24 code elements and is thus more complicated.
> (defun plot (fn min max step)
> (loop for i from min to max by step do
> (loop repeat (funcall fn i) do (format t "*"))
> (format t "~%")))
Why not loading the scripting lib for Lisp?
(defun plot (fn min max step)
(for (i min max step) (print* (funcall fn i) "*")))
> You could define the following function:
>
> (defun double (x) (* 2 x))
Why not use Currying?
(def double [* 2])
> But it's easier, and arguably clearer, to write this:
>
> CL-USER> (plot #'(lambda (x) (* 2 x)) 0 10 1)
Yes, or (plot [* 2] 0 10 1)
> Ruby:
>
> def plot min, max, step
> min.step( max, step ){|x| puts ·@" * yield( x ) }
> end
Yes, nice solution and nearly as short as the Lisp one.
> double = proc{|x| x * 2 }
Why not curry?
> plot(0, 10, 1, &double)
>
> plot(0, 10, 1){|x| x*2 }
Better:
plot(0, 10, 1)<* 2>
> (defparameter *random* (loop repeat 100 collect (random 10000)))
>
> Then the following loop will return a list containing various
> summary information about the numbers:
>
> (loop for i in *random*
> counting (evenp i) into evens
> counting (oddp i) into odds
> summing i into total
> maximizing i into max
> minimizing i into min
> finally (return (list min max total evens odds)))
>
>
> Ruby:
>
> Never forget: "We don't need no stinkin' loops!"
>
> r = (1..100).map{ rand( 10_000 ) }
In Lisp it has on code element less:
(defparameter *random* (mapcar [random 10000] (1.. 100)))
It just looks longer because of the longer names for operators, like
defparameter instead of = or mapcar instead of map, *random* instead of r
or random instead of rand.
(= r (map [rand 10000] (1.. 100))
> evens = r.select{|n| 0==n%2}.size
select has a longer name in Lisp, but of course if we disregard the
character count for a moment then Lisp is of course shorter than Ruby:
(defparameter *evens* (length (remove-if-not #'evenp *random*)))
Lisp: 7 code elements
Ruby: 13 code elements.
If Lisp hadn�t long names then:
(= evens (len (select #'evenp r)))
I would instead suggest defining *odds* respectively.
> [ r.min, r.max, r.inject{|a,b| a+b}, evens, r.size - evens ]
Inside a function definition, done with my functional def instead of defun:
(mapcar [apply _ *r*] (list min max + (constantly *evens*) (constantly
*odds*)))
As you see, one can also do it in Lisp without loops. As nearly allways
in Lisp it is shorter and less complex than in Ruby.
This is because Ruby was designed for doing small scripting tasks.
Rubys inventor knows this, so he said:
�Some may say Ruby is a bad rip-off of Lisp or Smalltalk, and I admit
that. But it is nicer to ordinary people.�
Andr�
--
In article <············@news.cn99.com>, jack <········@gmail.com>
wrote:
> for help !
> is lisp language hard to learn ?
Not really.
Can you program in another programming language? If yes, it will add
a few days of unlearning.
> and whick book i should read first?
> i never touch lisp before but not it seem lisp is very great mind language;
> who can help me?
Can you program already?
Then see 'Practical Common Lisp' by Peter Seibel.
http://gigamonkeys.com/book/
For more basic introductions see:
David S. Touretzky
"Common Lisp: A Gentle Introduction to Symbolic Computation"
or
Paul Graham, ANSI Common Lisp
--
http://lispm.dyndns.org/
On Oct 13, 5:33 am, jack <········@gmail.com> wrote:
> is lisp language hard to learn ?
Not at all. Very easy.
> and whick book i should read first?
The others already provided excellent links, even Xah.
The only point I might add is that the best way to learn any Lisp is
at an interpreter command-prompt, the so-called REPL (read-eval-print-
loop). That way you can learn a lot from your mistakes and to
properly code with parenthesis. I mean, once you get lots of syntax
errors, you'll be more careful on that regard... :)
From: Robert Maas, http://tinyurl.com/uh3t
Subject: Re: HOW TO LEARN LISP?
Date:
Message-ID: <rem-2008oct15-002@yahoo.com>
> From: jack <········@gmail.com>
> for help !
> is lisp language hard to learn ?
> and whick book i should read first?
Lisp is two different things:
- What's really getting done, such as processing various kinds of
data values (including CONS trees), defining functions (lexical
closures) on the fly, doing I/O, etc.
- The syntax by which you specify all these things to do, usually
s-expressions, but it could be CGOL/RLISP expressions
alternately, or even the syntax of other popular 21st-century
languages such as Dylan or Python, or the minimal-syntax
stack-oriented paradigm of Forth.
Which of those are you most interested in studying first?
Note that the two don't necessarily need to be studied together.
I've been recently proposing a no-syntax way to develop algorithms,
whereby you work from the intentional datatype via menus to select
previously-defined operations available on the given datatypes. In
some sense it's like you are programming in dataflow diagrams and
D-charts, except you never have to draw anything, you just select
from options in context. Each time you connect some input data
nodes via a menu-selected operation, you thereby create a new
output data node that can be used as input for future operations.
On Oct 13, 11:33 am, jack <········@gmail.com> wrote:
> is lisp language hard to learn ?
I would say, no.
I mean, the language itself is not that difficult
to learn. The main problem is the great shift in mind you have
to do to understand how complex things can be made easy.
This is what LISP really does.
> and whick book i should read first?
Seibel's.
You'll find it here: http://www.gigamonkeys.com/book
> i never touch lisp before but not it seem lisp is very great mind language;
We can, but after some efforts of you. :-)
MasterZiv <·········@gmail.com> writes:
> On Oct 13, 11:33�am, jack <········@gmail.com> wrote:
>
>> is lisp language hard to learn ?
>
> I would say, no.
> I mean, the language itself is not that difficult
> to learn. The main problem is the great shift in mind you have
> to do to understand how complex things can be made easy.
> This is what LISP really does.
Indeed. When you read a book such as SICP, there's almost no material
about learning scheme. These languages are very small, R5RS is 50
pages, Common Lisp is really just 17 special operators (and associated
notions). All the rest is libraries.
But indeed that may be a shock for learners. Learning lisp is easy,
you don't spend a semester on it, just a couple of weeks. Then the
rest of the semester is spent on learning more interesting things such
as algorithms, paradigms, AI, etc. This means _real_ _work_!
When you learn C++, you can spend the year learning by heart little
insignificant syntactic details, and when you're done, you still have
a low level language where you need to implement (or integrate
libraries) even the most basic mechanisms such as bignums.
--
__Pascal Bourguignon__
On Oct 16, 3:28 am, ····@informatimago.com (Pascal J. Bourguignon)
wrote:
> MasterZiv <·········@gmail.com> writes:
> > On Oct 13, 11:33 am, jack <········@gmail.com> wrote:
>
> >> is lisp language hard to learn ?
>
> > I would say, no.
> > I mean, the language itself is not that difficult
> > to learn. The main problem is the great shift in mind you have
> > to do to understand how complex things can be made easy.
> > This is what LISP really does.
>
> Indeed. When you read a book such as SICP, there's almost no material
> about learning scheme. These languages are very small, R5RS is 50
> pages, Common Lisp is really just 17 special operators (and associated
> notions). All the rest is libraries.
>
> But indeed that may be a shock for learners. Learning lisp is easy,
> you don't spend a semester on it, just a couple of weeks. Then the
> rest of the semester is spent on learning more interesting things such
> as algorithms, paradigms, AI, etc. This means _real_ _work_!
>
> When you learn C++, you can spend the year learning by heart little
> insignificant syntactic details, and when you're done, you still have
> a low level language where you need to implement (or integrate
> libraries) even the most basic mechanisms such as bignums.
The above is a typical Evangelical bullshit. A warm and fuzzy ball of
words, lacking any substance and reality. Similar sentiment you'll get
from perl fanatics about perl, and java fanatics about java.
its value is that its plausible and pleasing to hear for the group, so
it gets spread as gospels.
All you have to do to test its validity is to publish it outside of
your community. (such as cross-posting lang X gospels to lang X, Y, Z,
groups) Even though lots of response will be senseless knee-jerking
drivels, but in the discussion, you'll start to see how vain was your
beliefs.
Xah
∑ http://xahlee.org/
☄
Pascal J. Bourguignon wrote:
> Indeed. When you read a book such as SICP, there's almost no material
> about learning scheme. These languages are very small, R5RS is 50
> pages,
When i read SICP, it was R4RS.
> Common Lisp is really just 17 special operators (and associated
> notions). All the rest is libraries.
LOL. Your mom is 17 special operators and associated notions.
> But indeed that may be a shock for learners. Learning lisp is easy,
> you don't spend a semester on it, just a couple of weeks. Then the
> rest of the semester is spent on learning more interesting things such
> as algorithms, paradigms, AI, etc. This means _real_ _work_!
Learning Mathematica is even easier. Just couple days instead of
lisp's weeks. Then, you spend the rest of your life learning
mathematics.
> When you learn C++, you can spend the year learning by heart little
> insignificant syntactic details,
Such as lisp's ·····@,|” syntactic details?
> and when you're done, you still have
> a low level language where you need to implement (or integrate
> libraries) even the most basic mechanisms such as bignums.
and when you are done leaning lisp's syntactical warts, you still need
to implement (or integrate libraries), even the most basic pattern
matching facilities, infinite precision arithmetic, mathematical
functions.
-----------------------------------
Pascal's writings above is a typical Evangelical bullshit. A warm and
fuzzy ball of words, lacking any substance and reality. Similar
sentiment you'll get from perl fanatics about perl, and java fanatics
about java.
its value is that its plausible and pleasing to hear for the group, so
it gets spread as gospels.
All you have to do to test its validity is to publish it outside of
your community. (such as cross-posting lang X gospels to lang X, Y, Z,
groups) Even though lots of response will be senseless knee-jerking
drivels, but in the discussion, you'll start to see how vain was your
beliefs.
Xah
∑ http://xahlee.org/
☄
······@gmail.com wrote:
> All you have to do to test its validity is to publish it outside of
> your community. (such as cross-posting lang X gospels to lang X, Y, Z,
Ah, yes, justifying his flame-baiting.
> groups) Even though lots of response will be senseless knee-jerking
> drivels, but in the discussion, you'll start to see how vain was your
> beliefs.
Plonk.
--
Lew
On Thu, 16 Oct 2008 12:28:23 +0200, Pascal J. Bourguignon wrote:
> When you learn C++, you can spend the year learning by heart little
> insignificant syntactic details, and when you're done, you still have a
And then later on, you can chase bugs which are the result of remembering
operator precedence rules incorrectly. I have seen seasoned C++
programmers do this, it is a sad sight.
Tamas