From: gavino
Subject: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1154849422.303528.262280@n13g2000cwa.googlegroups.com>
aggkk
my brain frozen

how do I decide what to learn?

From: justinhj
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1154874809.491700.309750@i42g2000cwa.googlegroups.com>
There are plenty of introductory tutorials and examples of all these.
You can spend a day with each and stick with the one you enjoy the
most.

Unless you have a specific project in mind, in which they all have
their own strengths and weaknesses.

gavino wrote:
> aggkk
> my brain frozen
> 
> how do I decide what to learn?
From: ········@gmail.com
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1154883649.957309.92410@h48g2000cwc.googlegroups.com>
Well, you can skip APL, perl, smalltalk, and scheme; They're dead,
dying, or superseded languages. From your list that leaves only
haskell, python and Lisp. I don't know Haskell, so can't speak to it.
Python and Lisp are nearly the same language; Lisp is way simpler and
way better; python is way more useful in the real world. I'd say that
you should learn both (which is pretty easy, since they're nearly the
same language). You neglected the other obvious ones: C, C++, Java, and
Ruby. I'd say that of these you should learn C and Java -- mainly Java
(C is useful if you want to understand the underpinnings of Java). Ruby
is, again, Lisp (un)done wrong, but it's gaining ground on Python, and
just as Python rolled PERL, Ruby will probably roll python. Eventually
they'll all be Lisp again, but with enough packages to make it useful
in the real world. Then all one will need to know is Lisp and Java. :-)
From: Frank Buss
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1l8rafuyprc1.18abz1ltipdkh.dlg@40tude.net>
········@gmail.com wrote:

> Lisp is way simpler and
> way better; python is way more useful in the real world. 

If Python is way more useful, it is way better for the OT to learn it,
isn't it?

-- 
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
From: Ken Tilton
Subject: Re: Google Schmoogle
Date: 
Message-ID: <%xABg.2907$9T2.788@fe10.lga>
········@gmail.com wrote:
> Ron Garret wrote:
> 
>>In article <·······················@p79g2000cwp.googlegroups.com>,
>> ········@gmail.com wrote:
>>
>>
>>>>* When Norvig completed his "Python is Lisp" keynote address at ILC
>>>>200x, McCarthy asked him if Python could handle code as data. To his
>>>>credit, Norvig got the answer right.
>>>
>>>Of course it can handle code as data! All you need to do is to write a
>>>sufficiently complicated Python program containing an ad hoc,
>>>informally-specified, bug-ridden, slow implementation of half of Common
>>>Lisp. :-)
>>
>>http://groups.google.com/group/comp.lang.lisp/msg/351389610070f5dc?hl=en&
> 
> 
> Q.E.D.
> 

What is that, Latin for "It's Turing complete!"?

<sigh>

kenny

-- 
Cells: http://common-lisp.net/project/cells/

"I'll say I'm losing my grip, and it feels terrific."
    -- Smiling husband to scowling wife, New Yorker cartoon
From: ········@gmail.com
Subject: Re: Google Schmoogle
Date: 
Message-ID: <1154931971.495063.213990@b28g2000cwb.googlegroups.com>
> > Q.E.D.
>
> What is that, Latin for "It's Turing complete!"?

No, it's Latin for:

(loop for i from 1 to 25
      as pht*bt = (string-downcase (format nil "pt~:{~a~}bt!"
                                                         (loop for l
below i collect '(h))))
      as goog-result = (web-page-contents (format nil

"http://www.google.com/search?hl=en&q=~a" pht*bt))
      as of-about-pos = (search "of about" goog-result)
      do (format t "~a (~a) has ~a google hits.~%" pht*bt i
           (if of-about-pos
               (read-from-string
                    (subseq goog-result (+ (length "of about")
of-about-pos))) "no")))

pthbt! (1) has <B>856</B> google hits.
pthhbt! (2) has <B>109</B> google hits.
pthhhbt! (3) has <B>74</B> google hits.
pthhhhbt! (4) has <B>120</B> google hits.
pthhhhhbt! (5) has <B>16</B> google hits.
pthhhhhhbt! (6) has <B>18</B> google hits.
pthhhhhhhbt! (7) has <B>24</B> google hits.
pthhhhhhhhbt! (8) has no google hits.
pthhhhhhhhhbt! (9) has no google hits.
pthhhhhhhhhhbt! (10) has <B>8</B> google hits.
pthhhhhhhhhhhbt! (11) has <B>3</B> google hits.
pthhhhhhhhhhhhbt! (12) has no google hits.
pthhhhhhhhhhhhhbt! (13) has no google hits.
...
From: Bill Atkins
Subject: Re: Google Schmoogle
Date: 
Message-ID: <1154935911.002646.86360@n13g2000cwa.googlegroups.com>
········@gmail.com wrote:
> > > Q.E.D.
> >
> > What is that, Latin for "It's Turing complete!"?
>
> No, it's Latin for:
>
> (loop for i from 1 to 25
>       as pht*bt = (string-downcase (format nil "pt~:{~a~}bt!"
>                                                          (loop for l
> below i collect '(h))))
>       as goog-result = (web-page-contents (format nil
>
> "http://www.google.com/search?hl=en&q=~a" pht*bt))
>       as of-about-pos = (search "of about" goog-result)
>       do (format t "~a (~a) has ~a google hits.~%" pht*bt i
>            (if of-about-pos
>                (read-from-string
>                     (subseq goog-result (+ (length "of about")
> of-about-pos))) "no")))
>
> pthbt! (1) has <B>856</B> google hits.
> pthhbt! (2) has <B>109</B> google hits.
> pthhhbt! (3) has <B>74</B> google hits.
> pthhhhbt! (4) has <B>120</B> google hits.
> pthhhhhbt! (5) has <B>16</B> google hits.
> pthhhhhhbt! (6) has <B>18</B> google hits.
> pthhhhhhhbt! (7) has <B>24</B> google hits.
> pthhhhhhhhbt! (8) has no google hits.
> pthhhhhhhhhbt! (9) has no google hits.
> pthhhhhhhhhhbt! (10) has <B>8</B> google hits.
> pthhhhhhhhhhhbt! (11) has <B>3</B> google hits.
> pthhhhhhhhhhhhbt! (12) has no google hits.
> pthhhhhhhhhhhhhbt! (13) has no google hits.
> ...

      as pht*bt = (format nil "pt~abt!" (make-string i :initial-element
#\h))
From: Lars Brinkhoff
Subject: Re: Google Schmoogle
Date: 
Message-ID: <85psfdt1lv.fsf@junk.nocrew.org>
"Bill Atkins" <·········@gmail.com> writes:
> ········@gmail.com wrote:
>> (loop for i from 1 to 25
>>       as pht*bt = (string-downcase
>>                    (format nil "pt~:{~a~}bt!"
>>                            (loop for l below i collect '(h))))
>
>       as pht*bt = (format nil "pt~abt!" (make-string i :initial-element #\h))

        as pht*bt = (format nil "pt~v{~a~}bt!" i '#1=(#\h . #1#))
From: Christophe Rhodes
Subject: Re: Google Schmoogle
Date: 
Message-ID: <sqpsfcj3mk.fsf@cam.ac.uk>
Lars Brinkhoff <·········@nocrew.org> writes:

> "Bill Atkins" <·········@gmail.com> writes:
>> ········@gmail.com wrote:
>>       as pht*bt = (format nil "pt~abt!" (make-string i :initial-element #\h))
>        as pht*bt = (format nil "pt~v{~a~}bt!" i '#1=(#\h . #1#))

         as pht*bt = (format nil "pt~v,,,vabt!" i #\h "")

(an optimization in the format string is possible for values of #\h
equalling #\~.)

Christophe
From: Lars Brinkhoff
Subject: Re: Google Schmoogle
Date: 
Message-ID: <85k65ku9j2.fsf@junk.nocrew.org>
Christophe Rhodes <·····@cam.ac.uk> writes:
> Lars Brinkhoff <·········@nocrew.org> writes:
>> "Bill Atkins" <·········@gmail.com> writes:
>>> ········@gmail.com wrote:
>>> as pht*bt = (format nil "pt~abt!" (make-string i :initial-element #\h))
>>  as pht*bt = (format nil "pt~v{~a~}bt!" i '#1=(#\h . #1#))
>   as pht*bt = (format nil "pt~v,,,vabt!" i #\h "")
>
> (an optimization in the format string is possible for values of #\h
> equalling #\~.)

And for values of #\h equalling #\h:

    as pht*bt = (format nil "pt~v,,,'habt!" i "")
From: Bill Atkins
Subject: Re: Google Schmoogle
Date: 
Message-ID: <1154956631.824727.273220@n13g2000cwa.googlegroups.com>
Lars Brinkhoff wrote:
> Christophe Rhodes <·····@cam.ac.uk> writes:
> > Lars Brinkhoff <·········@nocrew.org> writes:
> >> "Bill Atkins" <·········@gmail.com> writes:
> >>> ········@gmail.com wrote:
> >>> as pht*bt = (format nil "pt~abt!" (make-string i :initial-element #\h))
> >>  as pht*bt = (format nil "pt~v{~a~}bt!" i '#1=(#\h . #1#))
> >   as pht*bt = (format nil "pt~v,,,vabt!" i #\h "")
> >
> > (an optimization in the format string is possible for values of #\h
> > equalling #\~.)
>
> And for values of #\h equalling #\h:
>
>     as pht*bt = (format nil "pt~v,,,'habt!" i "")

I'd say a cryptic FORMAT string is moving in the wrong direction.  If
it's consing that's the problem, I'd prefer:

   ...
   ;; with this many iterations, the consing will actually matter
   with prepared-hs = (make-string 250000 :initial-element #\h)
   for i from 1 to 250000
   ...
   as pht*bt = (format nil "pt~abt!" (substring prepared-hs 0 i))
   ...

But I was just going for clarity.  In any case, I am as puzzled as Ken
is about what this Python interpreter proves, and I think it will take
more than a long list of "pthhhhhhbt"'s to clear up my puzzlement.

Bill
From: Bill Atkins
Subject: Re: Google Schmoogle
Date: 
Message-ID: <1154957739.981334.203640@75g2000cwc.googlegroups.com>
Bill Atkins wrote:
> Lars Brinkhoff wrote:
> > Christophe Rhodes <·····@cam.ac.uk> writes:
> > > Lars Brinkhoff <·········@nocrew.org> writes:
> > >> "Bill Atkins" <·········@gmail.com> writes:
> > >>> ········@gmail.com wrote:
> > >>> as pht*bt = (format nil "pt~abt!" (make-string i :initial-element #\h))
> > >>  as pht*bt = (format nil "pt~v{~a~}bt!" i '#1=(#\h . #1#))
> > >   as pht*bt = (format nil "pt~v,,,vabt!" i #\h "")
> > >
> > > (an optimization in the format string is possible for values of #\h
> > > equalling #\~.)
> >
> > And for values of #\h equalling #\h:
> >
> >     as pht*bt = (format nil "pt~v,,,'habt!" i "")
>
> I'd say a cryptic FORMAT string is moving in the wrong direction.  If
> it's consing that's the problem, I'd prefer:
>
>    ...
>    ;; with this many iterations, the consing will actually matter
>    with prepared-hs = (make-string 250000 :initial-element #\h)
>    for i from 1 to 250000
>    ...
>    as pht*bt = (format nil "pt~abt!" (substring prepared-hs 0 i))
>    ...

D'oh, that would still cons.  Nevermind.
From: Nathan Baum
Subject: Re: Google Schmoogle
Date: 
Message-ID: <Pine.LNX.4.64.0608071602240.21556@localhost>
On Mon, 7 Aug 2006, Bill Atkins wrote:

>
> Bill Atkins wrote:
>> Lars Brinkhoff wrote:
>>> Christophe Rhodes <·····@cam.ac.uk> writes:
>>>> Lars Brinkhoff <·········@nocrew.org> writes:
>>>>> "Bill Atkins" <·········@gmail.com> writes:
>>>>>> ········@gmail.com wrote:
>>>>>> as pht*bt = (format nil "pt~abt!" (make-string i :initial-element #\h))
>>>>>  as pht*bt = (format nil "pt~v{~a~}bt!" i '#1=(#\h . #1#))
>>>>   as pht*bt = (format nil "pt~v,,,vabt!" i #\h "")
>>>>
>>>> (an optimization in the format string is possible for values of #\h
>>>> equalling #\~.)
>>>
>>> And for values of #\h equalling #\h:
>>>
>>>     as pht*bt = (format nil "pt~v,,,'habt!" i "")
>>
>> I'd say a cryptic FORMAT string is moving in the wrong direction.  If
>> it's consing that's the problem, I'd prefer:
>>
>>    ...
>>    ;; with this many iterations, the consing will actually matter
>>    with prepared-hs = (make-string 250000 :initial-element #\h)
>>    for i from 1 to 250000
>>    ...
>>    as pht*bt = (format nil "pt~abt!" (substring prepared-hs 0 i))
>>    ...
>
> D'oh, that would still cons.  Nevermind.

How about:

   ...
   with prepared-hs = (make-sequence 'list 250000 :initial-element #\h)
   for i from 250000 downto 1
   as pht*bt = (format nil "pt~{~A~}bt!" (nthcdr prepared-hs i))
   ...

?

If you didn't mind doing the queries in 'reverse' order, you could use

   ...
   for pht*bt on prepare-hs
   ...
   (format nil "http://www.google.com/search?hl=en&q=pt~{~a~}bt!" pht*bt)
   ...

and (probably) avoid consing the extra string as well.
From: jurgen_defurne
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1156875841.469688.83360@e3g2000cwe.googlegroups.com>
········@gmail.com wrote:
> Well, you can skip APL, perl, smalltalk, and scheme; They're dead,
> dying, or superseded languages. From your list that leaves only
> haskell, python and Lisp. I don't know Haskell, so can't speak to it.
> Python and Lisp are nearly the same language; Lisp is way simpler and
> way better; python is way more useful in the real world. I'd say that
> you should learn both (which is pretty easy, since they're nearly the
> same language). You neglected the other obvious ones: C, C++, Java, and
> Ruby. I'd say that of these you should learn C and Java -- mainly Java
> (C is useful if you want to understand the underpinnings of Java). Ruby
> is, again, Lisp (un)done wrong, but it's gaining ground on Python, and
> just as Python rolled PERL, Ruby will probably roll python. Eventually
> they'll all be Lisp again, but with enough packages to make it useful
> in the real world. Then all one will need to know is Lisp and Java. :-)

Python may have rolled Perl, but certainly not because Python is more
powerful than Perl. You cannot return an anonymous function/subroutine
in Python which isn't an expression. What I mean is that in Python you
have a lambda operator, but that is much less powerful than Perl's sub
keyword, which makes it possible to do things in Perl that are Lisp
like. In fact, the only thing missing in Perl in comparison to Lisp are
macros.

Python just has a simpler syntax than Perl, that is what makes it
successful. But it is not nearly as powerful as Lisp, or Perl for that
matter.

Regards,

Jurgen
From: Robert Uhl
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <m3ac5ntezd.fsf@NOSPAMgmail.com>
"jurgen_defurne" <··············@pandora.be> writes:
>
> Python may have rolled Perl, but certainly not because Python is more
> powerful than Perl. You cannot return an anonymous function/subroutine
> in Python which isn't an expression. What I mean is that in Python you
> have a lambda operator, but that is much less powerful than Perl's sub
> keyword, which makes it possible to do things in Perl that are Lisp
> like.

You can get the same effect with a def form.  def x... is the same as
lambda:, it just allows more complex functions.  The more important
criterion is that access to outer-scope variables is read-only, although
I am told that there are ways around that too, e.g.:

  def anon(foo):
    var = [foo]
    def func():
      var[0] += 1
      return var[0]
    return func

  f = anon(1)
  f() -> 2
  f() -> 3

Not, perhaps, the most elegant thing but...

> In fact, the only thing missing in Perl in comparison to Lisp are
> macros.

*cough* CLOS.  And conditions.  And a compiler (granted, not all Lisp
 implementations have one).

> Python just has a simpler syntax than Perl, that is what makes it
> successful. But it is not nearly as powerful as Lisp, or Perl for that
> matter.

Does Perl have list comprehensions and generators?  Serious
question--while my Perl-fu was once pretty good, it's been many years
now, so I really can't remember.  And I'm pretty certain that Perl
doesn't allow operator overloading (although whether this is actually
bad is a matter of some disagreement).

Python is also more regular than Perl (no list collapsing or scalar
mangling, which is nice).  And its object system--while bolted on--is at
least sane.

Lisp is nicer than Python, but either is nicer than Perl IMHO.

-- 
Robert Uhl <http://public.xdi.org/=ruhl>
Who does not love wine, women, and song,
Remains a fool his whole life long.
            --Johann Heinrich Voss
From: jurgen_defurne
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1156930688.869820.301500@m73g2000cwd.googlegroups.com>
Robert Uhl wrote:
> "jurgen_defurne" <··············@pandora.be> writes:
> >
> > Python may have rolled Perl, but certainly not because Python is more
> > powerful than Perl. You cannot return an anonymous function/subroutine
> > in Python which isn't an expression. What I mean is that in Python you
> > have a lambda operator, but that is much less powerful than Perl's sub
> > keyword, which makes it possible to do things in Perl that are Lisp
> > like.
>
> You can get the same effect with a def form.  def x... is the same as
> lambda:, it just allows more complex functions.  The more important
> criterion is that access to outer-scope variables is read-only, although
> I am told that there are ways around that too, e.g.:
>
>   def anon(foo):
>     var = [foo]
>     def func():
>       var[0] += 1
>       return var[0]
>     return func

Allright, I did not know you could do it that way. Last time I tried
returning functions, I tried using anonymous ones. It seems that Python
is capable of returning functions at different addresses.

>
>   f = anon(1)
>   f() -> 2
>   f() -> 3
>
> Not, perhaps, the most elegant thing but...
>
> > In fact, the only thing missing in Perl in comparison to Lisp are
> > macros.
>
> *cough* CLOS.  And conditions.  And a compiler (granted, not all Lisp
>  implementations have one).

I do OO programming in Perl. I have a whole OO library built in Perl
for our operations (40000 lines of code approx.). And Perl has an
introspection package (I do not use it, but I know it is there).

Try eval {}; if (·@) {} for conditions. It is not as explicitly defined
as in CL, but is usable and extendable. I have a whole lot of functions
which call external programs, so I made a version of system(), which
checks for the exit status and throws an exception if there has been an
error.

Well, Python doesn't have a compiler either (maybe attempts).

> > Python just has a simpler syntax than Perl, that is what makes it
> > successful. But it is not nearly as powerful as Lisp, or Perl for that
> > matter.
>
> Does Perl have list comprehensions and generators?  Serious
> question--while my Perl-fu was once pretty good, it's been many years
> now, so I really can't remember.  And I'm pretty certain that Perl
> doesn't allow operator overloading (although whether this is actually
> bad is a matter of some disagreement).

Perl does not have list comprehensions, but since Perl supports
closures and OO, it is quite easy to create generators and iterators in
several different flavours.

I have taken a look at list comprehensions, and it mostly seems
syntactic sugar to generate lists from other lists. I suppose that if
one really needs something like list comprehensions, it is possible to
define them in Perl. I would recommend reading 'Higher-order Perl' from
Mark Jason Dominus to see what can be done with Perl.

> Python is also more regular than Perl (no list collapsing or scalar
> mangling, which is nice).  And its object system--while bolted on--is at
> least sane.

I do not have a problem with Perl's OO system.

> Lisp is nicer than Python, but either is nicer than Perl IMHO.

The only thing I really hate about Perl is its verbose syntax. That is
why I got interested in Scheme and Common Lisp.

Regards,

Jurgen
From: jurgen_defurne
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1156939341.909728.38570@74g2000cwt.googlegroups.com>
> Robert Uhl wrote:
> >
> > Does Perl have list comprehensions and generators?  Serious
> > question--while my Perl-fu was once pretty good, it's been many years
> > now, so I really can't remember.  And I'm pretty certain that Perl
> > doesn't allow operator overloading (although whether this is actually
> > bad is a matter of some disagreement).

Oh, I almost forgot : Perl does allow operator overloading.

Regards,

Jurgen
From: jayessay
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <m3r6yyz0bo.fsf@rigel.goldenthreadtech.com>
"jurgen_defurne" <··············@pandora.be> writes:

> Robert Uhl wrote:
> > "jurgen_defurne" <··············@pandora.be> writes:
> > >
...
> > > In fact, the only thing missing in Perl in comparison to Lisp are
> > > macros.
> >
> > *cough* CLOS.  And conditions.  And a compiler (granted, not all Lisp
> >  implementations have one).
> 
> I do OO programming in Perl. I have a whole OO library built in Perl

You can do OO programming in C++, Java, or C and assembly for that
matter.  That doesn't mean you have anything like the capabilities of
CLOS at hand.


> Try eval {}; if (·@) {} for conditions. It is not as explicitly defined

Errors are a proper subset of exceptions which are a proper subset of
conditions.  You need to go back and look this over again to
understand the point being made about missing conditions (and CLOS as
well).



> > Does Perl have list comprehensions and generators?  Serious
> > question--while my Perl-fu was once pretty good, it's been many years
> > now, so I really can't remember.  And I'm pretty certain that Perl
> > doesn't allow operator overloading (although whether this is actually
> > bad is a matter of some disagreement).
> 
> Perl does not have list comprehensions, but since Perl supports
> closures and OO, it is quite easy to create generators and iterators in
> several different flavours.

WRT generators, you're claim here is a vast overstatement.


> > Python is also more regular than Perl (no list collapsing or scalar
> > mangling, which is nice).  And its object system--while bolted on--is at
> > least sane.
> 
> I do not have a problem with Perl's OO system.

What's that have to do with the "sanity" (or lack thereof) of it?


> > Lisp is nicer than Python, but either is nicer than Perl IMHO.
> 
> The only thing I really hate about Perl is its verbose syntax.
                                                 ^^^^^^ ?!?!?

Wow.  First time I've seen "line noise" called "verbose".


/Jon

-- 
'j' - a n t h o n y at romeo/charley/november com
From: jurgen_defurne
Subject: Re: Google Schmoogle
Date: 
Message-ID: <1156876325.213922.202760@m79g2000cwm.googlegroups.com>
Ken Tilton wrote:
> ········@gmail.com wrote:
> >>Please. You could say Python was better than Lisp and be less wrong than
> >>when you say it is <mumble-mumble> the same as Lisp.
> >
> >
> > Please. Tell it to Norvig: "Python supports all of Lisp's essential
> > features except macros, ..." "Python can be seen as either a practical
> > (better libraries) version of Scheme..." "Take a Lisp program, indent
> > it properly, and delete the parens, and you end up with something that
> > looks rather like a Python program." (All directly from:
> > http://www.norvig.com/python-lisp.html)
> >
>
> If I am not mistaken, you just defended yourself against a charge of
> sucking up to Google by quoting their Director of Research.
>
> Where do I begin?*
>
> kenny
>
> * When Norvig completed his "Python is Lisp" keynote address at ILC
> 200x, McCarthy asked him if Python could handle code as data. To his
> credit, Norvig got the answer right.
>
> k
>
> --
> Cells: http://common-lisp.net/project/cells/
>
> "I'll say I'm losing my grip, and it feels terrific."
>     -- Smiling husband to scowling wife, New Yorker cartoon

What does it mean to handle code as data ? I like comparing Perl to
Lisp, because with Perl I can do much things that are possible in Lisp.

I think that Perl can handle code as data.

First, there is an eval statement.

Second, substitutions can be done, and they can be done before run-time
using the BEGIN {} or INIT {} clauses.

The only thing that Lisp has is that macros are automatically processed
at compile time. In Perl, you would need to add several BEGIN {} and/or
INIT {} clauses for all macro's you would need to write.

Regards,

Jurgen
From: Ken Tilton
Subject: Re: Google Schmoogle
Date: 
Message-ID: <aF4Jg.729$Cn5.252@newsfe09.lga>
jurgen_defurne wrote:
> Ken Tilton wrote:
> 
>>········@gmail.com wrote:
>>
>>>>Please. You could say Python was better than Lisp and be less wrong than
>>>>when you say it is <mumble-mumble> the same as Lisp.
>>>
>>>
>>>Please. Tell it to Norvig: "Python supports all of Lisp's essential
>>>features except macros, ..." "Python can be seen as either a practical
>>>(better libraries) version of Scheme..." "Take a Lisp program, indent
>>>it properly, and delete the parens, and you end up with something that
>>>looks rather like a Python program." (All directly from:
>>>http://www.norvig.com/python-lisp.html)
>>>
>>
>>If I am not mistaken, you just defended yourself against a charge of
>>sucking up to Google by quoting their Director of Research.
>>
>>Where do I begin?*
>>
>>kenny
>>
>>* When Norvig completed his "Python is Lisp" keynote address at ILC
>>200x, McCarthy asked him if Python could handle code as data. To his
>>credit, Norvig got the answer right.
>>
>>k
>>
>>--
>>Cells: http://common-lisp.net/project/cells/
>>
>>"I'll say I'm losing my grip, and it feels terrific."
>>    -- Smiling husband to scowling wife, New Yorker cartoon
> 
> 
> What does it mean to handle code as data ? I like comparing Perl to
> Lisp, because with Perl I can do much things that are possible in Lisp.
> 
> I think that Perl can handle code as data.

Well, it is a gray area, so just because perl can do some tricks does 
not mean it has effectively the same power as Lisp. But I do not know 
perl so I may not be much help in deciding.

> 
> First, there is an eval statement.

I never use Lisp eval, fwiw.

> 
> Second, substitutions can be done, and they can be done before run-time
> using the BEGIN {} or INIT {} clauses.

"can be done"? By you or a preprocessor. Are you talking about something 
akin to the C preprocessor? That is certainly useful (I beat on the C 
preprocessor like I was its daddy back in my day) but not what we are 
talking about.

> 
> The only thing that Lisp has is that macros are automatically processed
> at compile time. 

How do you know? Do you know how to write good hairy Lisp macros? If 
not, you might want to retract the above.

The key to Lisp code=data is not eval, it is that code is /represented/ 
just like a form of Lisp data (the list, including nested lists) which 
has two huge consequences for macros: they can take apart their code 
bodies with all of Lisp's power to dissect lists, and they can generate 
code trivially just by producing other lists. Of code.

For another language to offer Lisp macros, the macro keyword would have 
to pre-parse the Java or COBOL or Python source and present it to the 
macro function as a terribly convenient data structure for that 
language, and be prepared to accept same once transformed by the macro 
function and produce sensible run-time code therefrom. There then still 
is a new burden of understanding the transformation from native syntax 
to convenient representation, but as long as they use lists it won't be 
too hard. :)

ken

-- 
Cells: http://common-lisp.net/project/cells/

"I'll say I'm losing my grip, and it feels terrific."
    -- Smiling husband to scowling wife, New Yorker cartoon
From: Nicola Mingotti
Subject: Re: Google Schmoogle
Date: 
Message-ID: <44f4cca0$0$75036$14726298@news.sunsite.dk>
> What does it mean to handle code as data ? I like comparing Perl to
> Lisp, because with Perl I can do much things that are possible in Lisp.
> 
> I think that Perl can handle code as data.
> 
> First, there is an eval statement.
> 
> Second, substitutions can be done, and they can be done before run-time
> using the BEGIN {} or INIT {} clauses.
> 
> The only thing that Lisp has is that macros are automatically processed
> at compile time. In Perl, you would need to add several BEGIN {} and/or
> INIT {} clauses for all macro's you would need to write.
> 

I don't know Perl well but I think you can't do the following
so easily.

This (very)ugly example shows how a Lisp program can modify itself ... 
code is data.
It does also something : it counts.

;; ------------
(setq i 1)

(setq program
       '(tagbody
	start
	 (format t "~%i --> ~A~%" i)
	 (format t "-- CODE --: ~%~S" program)
	 (if (> i 2) (go quit))
	 (setf (third (second (fifth program))) (+ 1 i))
	 (setq i (+ i 1))
	 (sleep 2)
	 (go start)
	quit))
	
(eval program)
;; ------------


Bye

Nicola Mingotti
From: Rob Thorpe
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1154886010.249966.308670@i42g2000cwa.googlegroups.com>
gavino wrote:
> aggkk
> my brain frozen
>
> how do I decide what to learn?

Any of them, it doesn't matter.

Then once you know one language learn another, it's much easier the
second time.

It's not important where you start, only that you persist.
From: Stefan Scholl
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1T3c710mI781Nv8%stesch@parsec.no-spoon.de>
gavino <········@yahoo.com> wrote:
> aggkk
> my brain frozen
> 
> how do I decide what to learn?

Start with C64-BASIC and 6502 Assembler, like everybody else,
too.
From: ············@gmail.com
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1154965506.502182.144040@n13g2000cwa.googlegroups.com>
Perl, is still popular than Python and Ruby, but I wonder when Perl 6
will be out.

Haskell is difficult, in my opinion it's harder than Lisp, though Lisp
is harder than most of the languages I think. I've tried to write a
simple guess number from 1 to 100 and the computer told you it should
be bigger or smaller. It's easy in most of the languages, but I found
it's harder in Haskell than other languages.

Python to tell the truth is a lot easier than Lisp. Why?? First, only
one implementation, you won't have trouble choosing which
implementation to use, and it's cross-platform. On the other hand, it
has a rich initial library for you to use without installing other
packages.

Lisp to tell the truth isn't easy because it's an almost free-format
language, it relies a lot on the editors to check the parenthesis, and
it lacks modern universal libraries. There are many implementations,
but it's really hard to choose one unlike Python.

Smalltalk, Hmmmm...I think it's declining, but there is still some
communities, if you want, I suggest Squeak, a smalltalk implementation.
From: Pierre THIERRY
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <pan.2006.08.07.20.36.42.669395@levallois.eu.org>
Le Mon, 07 Aug 2006 08:45:06 -0700, ············@gmail.com a écrit :
> Perl, is still popular than Python and Ruby, but I wonder when Perl 6
> will be out.

It is somewhat already out, with Pugs. You can already code in Perl 6.

Quickly,
Nowhere man
-- 
···········@levallois.eu.org
OpenPGP 0xD9D50D8A
From: Casey Hawthorne
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <a63gd2t777e1ckj21prio3c3iglb6g53rp@4ax.com>
"gavino" <········@yahoo.com> wrote:

>aggkk
>my brain frozen
>
>how do I decide what to learn?


You might want to explore a few programming paradigms:

imperative - asking "how"

- procedural: Python

imperative and objects

- object-oriented - asking "who": Python, Java

- aspect-oriented - asking "who" and "cross-cutting concerns": Java



declarative - asking "what"

- functional: Scheme, Haskell

- logic: Prolog


laerer.rhs.dk/andersb/sodp/programmingparadigms/programmingparadigms.ppt

--
Regards,
Casey
From: justinhj
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1155053531.825758.271240@m73g2000cwd.googlegroups.com>
> You might want to explore a few programming paradigms:
>
> imperative - asking "how"
>
> - procedural: Python
>
> imperative and objects
>
> - object-oriented - asking "who": Python, Java
>
> - aspect-oriented - asking "who" and "cross-cutting concerns": Java
>

> declarative - asking "what"
>
> - functional: Scheme, Haskell
>
> - logic: Prolog
>
>
> laerer.rhs.dk/andersb/sodp/programmingparadigms/programmingparadigms.ppt
> 

Or all at once with common lisp*?

*With a little legwork
From: Mallor
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1155067444.692416.204680@p79g2000cwp.googlegroups.com>
gavino wrote:
> aggkk
> my brain frozen
>
> how do I decide what to learn?

If you are trying to be a Windows game developer, doing 3D and AI and
so forth, then join me in Chicken Scheme land.  That's where my 2 year
language quest led me, and I need converts.
http://www.call-with-current-continuation.org

Otherwise, Your Mileage May Vary.  If you have a lot of time on your
hands for gratuitous education, and you're not immediately in need of a
job, then just pick something and go with it.  You get a lot more done
sticking to 1 language than flitting around between dozens of
languages.  I have breadth of awareness of many languages, particularly
Functional Programming languages, but I can't really do anything in any
of 'em because I spent so much time evaluating them all.  Depending on
your problem domain, it can take a painfully long time to become
proficient at any particular language or implementation, so again, pick
something and get started.


Cheers,
Brandon Van Every
From: ············@gmail.com
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1155090935.574041.17830@h48g2000cwc.googlegroups.com>
Mallor wrote:
> gavino wrote:
> > aggkk
> > my brain frozen
> >
> > how do I decide what to learn?
>
> If you are trying to be a Windows game developer, doing 3D and AI and
> so forth, then join me in Chicken Scheme land.  That's where my 2 year
> language quest led me, and I need converts.
> http://www.call-with-current-continuation.org
   In your other post, it seems you spent 9 months to learn Chicken
Scheme??
   I am not sure how good it is as a game language.
From: Daniel Trstenjak
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <20060809170917.GA7227@linux>
Hi Brandon,

On Tue, Aug 08, 2006 at 01:04:04PM -0700, Mallor wrote:
> If you are trying to be a Windows game developer, doing 3D and AI and
> so forth, then join me in Chicken Scheme land.  That's where my 2 year
> language quest led me, and I need converts.

Why do you favor Chicken Scheme to Common Lisp, especially for
game programming ?

In which cases is Chicken Scheme superior ?


Regards,
Daniel
From: Mallor
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1155153671.865491.228480@i3g2000cwc.googlegroups.com>
Daniel Trstenjak wrote:
> Hi Brandon,
>
> On Tue, Aug 08, 2006 at 01:04:04PM -0700, Mallor wrote:
> > If you are trying to be a Windows game developer, doing 3D and AI and
> > so forth, then join me in Chicken Scheme land.  That's where my 2 year
> > language quest led me, and I need converts.
>
> Why do you favor Chicken Scheme to Common Lisp, especially for
> game programming ?
>
> In which cases is Chicken Scheme superior ?

There are no well supported open source Common Lisp native code or
Lisp-to-C compilers available on Windows.  In contrast, Chicken Scheme
and Bigloo Scheme are 2 performance oriented Scheme-to-C
implementations available.  Chicken Scheme also has some C++ support, a
larger community than Bigloo, a BSD license, and me making sure that
things work properly on MinGW, VC++, and Cygwin.


Cheers,
Brandon Van Every
From: ············@gmail.com
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1155188765.141406.33900@h48g2000cwc.googlegroups.com>
I am not sure why there is no well supported open source Common Lisp
native code or
Lisp-to-C compilers available on Windows, but it's just harder to
implement than Scheme.
From: Mallor
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1155239261.355710.134190@i3g2000cwc.googlegroups.com>
············@gmail.com wrote:
> I am not sure why there is no well supported open source Common Lisp
> native code or
> Lisp-to-C compilers available on Windows, but it's just harder to
> implement than Scheme.

Well, there's history for starters.  Open source is generally either a
Unix crowd or a Java crowd.  That's where the critical mass is; there
are very very few people like myself trying to make a go at open source
on Windows.  There's also a question of what Windows is good for.  For
me, it's good for game development.  "Good" in this context doesn't
mean I like it, but rather, there are game consumers.  In contrast,
MacOS is marginal and Linux is a joke.  Most Lispers haven't been game
developers, game developers are performance oriented, and Common Lisp
does not define a standard C FFI.  So I see very little to "pull" open
source developers to Windows.  Really, when I think about who I will be
converting to Chicken Scheme for game development some day, I think
I'll be converting native Windows developers, not extant Unix open
source developers.

Even Chicken Scheme, which had MSVC already working most of the time,
and Cygwin well supported, has taken me 9 months to kick into proper
shape on Windows with CMake.  Chicken Scheme is a very small project
compared to any Common Lisp implementation.  So it is no shock to me
that the CL porting jobs are ongoing and haven't gotten done.


Cheers,
Brandon Van Every
From: ············@gmail.com
Subject: Re: haskell APL perl+maypole/gantry, python smalltalk clisp plt scheme how decide?
Date: 
Message-ID: <1155260032.812190.118350@i3g2000cwc.googlegroups.com>
Chicken Scheme takes 9 months to work, which to me is a long time. At
least with the support of SWIG it's an advantage over Corman Lisp.
Maybe most of the time spent is on the CMake part.