From: gavino
Subject: LISP V APL?
Date: 
Message-ID: <1156654414.197494.132400@75g2000cwc.googlegroups.com>
how does lisp compare to apl?

I read an mazing apl faq and it sounded like many descriptions of lisp

it said the brevity is power because u can make shorted programs and
control complexity

how does it stack up to lisp?

I want to learn programmign but can't focus due to my desire to pick
most powerful tool but also something practical not theoretical.
 help!

From: Frank Buss
Subject: Re: LISP V APL?
Date: 
Message-ID: <19lxvkhhtdxa7$.cvhiw6izrz3x$.dlg@40tude.net>
gavino wrote:

> how does lisp compare to apl?

You may find some answers in this thread:

http://groups.google.de/group/comp.lang.lisp/browse_frm/thread/574bcf953913f3f5/92c1d9806ac3a7a7

APL like language are very powerful. You should try both. J is a free APL
like language:

http://www.jsoftware.com/

For Common Lisp I suggest to start with the trial edition of LispWorks or
Allegro Common Lisp or http://www.gigamonkeys.com/lispbox/ , if you like
Emacs.

-- 
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156702500.093990.74990@i3g2000cwc.googlegroups.com>
I've used both APL and Lisp quite extensively [*] and love(d) them
both. Others have pointed you to comparisons, but there is one very
good reason no to bother with APL (or J, it's recent reincarnation):
It's deader than a doornail. No one uses it (them) anymore. It (they)
has (have) been superseded by other languages -- esp. MatLab. If you
want to learn a useful (although very painful) mathematical programming
language, learn MatLab, not APL/J.

'Jeff

[*] Indeed, both inside and out: I was head of the project that wrote
Univac's APL implementation! Univac is even more dead now than APL.
From: ····@carlislegroup.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156871999.653489.29640@74g2000cwt.googlegroups.com>
········@gmail.com wrote:
> I've used both APL and Lisp quite extensively [*] and love(d) them
> both. Others have pointed you to comparisons, but there is one very
> good reason no to bother with APL (or J, it's recent reincarnation):
> It's deader than a doornail. No one uses it (them) anymore.

Come on now, shake your head. It's a large world out there.

APL is alive and better than ever. The premier commercial development
interpreter is Dyalog APL, www.dyalog.com. It is constantly improving
and enhancing the interpreter.

Dyalog APL has a full fledged IDE, native GUI, multithreading, complete
support for OOP and .NET, and too many more enhancements (tail
recursion, closure, etc) to Ken Iverson's original invention to mention
here.

Many small to medium size  (and  highly profitable) companies are built
on it.

It is used by every major investment and commercial bank in the world,
either directly or indirectly, .... and not in legacy apps.
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156920493.557578.60180@m79g2000cwm.googlegroups.com>
> APL is alive and better than ever.
> Many small to medium size  (and  highly profitable) companies are built
> on it.
> It is used by every major investment and commercial bank in the world,
> either directly or indirectly, .... and not in legacy apps.

Don't take my word for it; eleventy zillion flies can't be wrong
(heuristically and statistically speaking):

(loop for word in '(programming programmer programs code)
      do (format t "~%~%~a:~%~%" word)
      (loop for (phrase . n) in
                                              ;; SNOBOL is a control
Better be the least!
            (sort (loop for lang in  '(csh javascript shell haskell
snobol basic
                                                 fortran cobol apl j
lisp c++ java mathematica
                                                 ocaml perl python
matlab)
                        as phrase = (format nil "~a%20~a" lang word)
                        as goog-result =
                        (web-page-contents (format nil

"http://www.google.com/search?hl=en&q=%22~a%22" phrase))
                        as of-about-pos = (search "of about"
goog-result)
                        as unboldpos = (search "</b>" goog-result
:start2 of-about-pos)
                        as numstring = (subseq goog-result
                                         (+ (length "of about <b>")
of-about-pos) unboldpos)
                        ;; Ugh: 123,456,789! Is there a better way to
remove these????
                        as w/o-commas = (coerce (loop for c across
numstring
                                                      unless
(char-equal #\, c)
                                                      collect c)
'string)
                        as n = (read-from-string w/o-commas)
                        collect (cons phrase n))
              #'< :key #'cdr)
            do (format t "~a : ~a~%" phrase n)))
::


PROGRAMMING:

SNOBOL%20PROGRAMMING : 588
CSH%20PROGRAMMING : 9990
J%20PROGRAMMING : 21100
OCAML%20PROGRAMMING : 32200
MATHEMATICA%20PROGRAMMING : 33200
HASKELL%20PROGRAMMING : 34500
APL%20PROGRAMMING : 43600
MATLAB%20PROGRAMMING : 118000
COBOL%20PROGRAMMING : 168000
FORTRAN%20PROGRAMMING : 197000
LISP%20PROGRAMMING : 227000
PYTHON%20PROGRAMMING : 1100000
SHELL%20PROGRAMMING : 1130000
PERL%20PROGRAMMING : 1590000
JAVASCRIPT%20PROGRAMMING : 2020000
BASIC%20PROGRAMMING : 2380000
C++%20PROGRAMMING : 4850000
JAVA%20PROGRAMMING : 6940000


PROGRAMMER:

CSH%20PROGRAMMER : 30
SNOBOL%20PROGRAMMER : 30
MATLAB%20PROGRAMMER : 582
APL%20PROGRAMMER : 663
J%20PROGRAMMER : 918
OCAML%20PROGRAMMER : 952
MATHEMATICA%20PROGRAMMER : 10900
HASKELL%20PROGRAMMER : 12600
SHELL%20PROGRAMMER : 16900
FORTRAN%20PROGRAMMER : 44300
LISP%20PROGRAMMER : 47800
JAVASCRIPT%20PROGRAMMER : 58700
PYTHON%20PROGRAMMER : 138000
COBOL%20PROGRAMMER : 148000
BASIC%20PROGRAMMER : 201000
PERL%20PROGRAMMER : 280000
C++%20PROGRAMMER : 341000
JAVA%20PROGRAMMER : 1710000


PROGRAMS:

SNOBOL%20PROGRAMS : 260
CSH%20PROGRAMS : 559
APL%20PROGRAMS : 18400
MATHEMATICA%20PROGRAMS : 19000
J%20PROGRAMS : 19600
OCAML%20PROGRAMS : 38400
HASKELL%20PROGRAMS : 47300
SHELL%20PROGRAMS : 93700
MATLAB%20PROGRAMS : 95200
JAVASCRIPT%20PROGRAMS : 112000
LISP%20PROGRAMS : 147000
COBOL%20PROGRAMS : 184000
PYTHON%20PROGRAMS : 213000
PERL%20PROGRAMS : 350000
FORTRAN%20PROGRAMS : 467000
BASIC%20PROGRAMS : 573000
JAVA%20PROGRAMS : 1680000
C++%20PROGRAMS : 2060000


CODE:

SNOBOL%20CODE : 477
CSH%20CODE : 11600
APL%20CODE : 15000
OCAML%20CODE : 41100
HASKELL%20CODE : 54500
MATHEMATICA%20CODE : 58800
COBOL%20CODE : 98200
SHELL%20CODE : 177000
J%20CODE : 203000
LISP%20CODE : 273000
MATLAB%20CODE : 350000
FORTRAN%20CODE : 585000
PYTHON%20CODE : 981000
PERL%20CODE : 1310000
BASIC%20CODE : 1420000
JAVASCRIPT%20CODE : 4150000
C++%20CODE : 7910000
JAVA%20CODE : 9340000

> NIL
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156920856.073805.46820@74g2000cwt.googlegroups.com>
ps. The only obvious anomalous result in the above is "J Code" - J is,
of course, particularly problematic being highly confusable. And
indeed, there appear to be a bunch of other concepts called "j code(s)"
that have nothing to do with the J programming language.
From: Paul Mansour
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156942060.329916.303940@74g2000cwt.googlegroups.com>
········@gmail.com wrote:

> Don't take my word for it;

Why would I take your word for anything, when you don't write what you
mean ;)

You said APL is dead, no one uses it. You meant APL is unpopular.That
this would be a relevant criteria for whether or not to learn a
particular language is rather surprising coming from this group. (I'd
be willing to bet that in a hundred years, there will be people
programming in Lisp and APL and not Java.)

Clearly APL is not dead, there are people using it, the development of
it has not stagnated, and there are up-to-date professional
interpreters available.

What do you want me to take your word for, that APL is unpopular? What
a brilliant observation. Hold on, I'll alert the media!
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156948844.626031.312960@74g2000cwt.googlegroups.com>
Yes, I mostly agree with you. (Except for what we'll be programming in
100 years.... about which I decline to comment.)
From: Joe Marshall
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156955690.648460.277630@m73g2000cwd.googlegroups.com>
········@gmail.com wrote:
>
> PROGRAMMING:
>
> SNOBOL%20PROGRAMMING : 588
> CSH%20PROGRAMMING : 9990
> J%20PROGRAMMING : 21100
> OCAML%20PROGRAMMING : 32200
> MATHEMATICA%20PROGRAMMING : 33200
> HASKELL%20PROGRAMMING : 34500
> APL%20PROGRAMMING : 43600
> MATLAB%20PROGRAMMING : 118000
> COBOL%20PROGRAMMING : 168000
> FORTRAN%20PROGRAMMING : 197000
> LISP%20PROGRAMMING : 227000
> PYTHON%20PROGRAMMING : 1100000
> SHELL%20PROGRAMMING : 1130000
> PERL%20PROGRAMMING : 1590000
> JAVASCRIPT%20PROGRAMMING : 2020000
> BASIC%20PROGRAMMING : 2380000
> C++%20PROGRAMMING : 4850000
> JAVA%20PROGRAMMING : 6940000
>
>
> PROGRAMMER:
>
> CSH%20PROGRAMMER : 30
> SNOBOL%20PROGRAMMER : 30
> MATLAB%20PROGRAMMER : 582
> APL%20PROGRAMMER : 663
> J%20PROGRAMMER : 918
> OCAML%20PROGRAMMER : 952
> MATHEMATICA%20PROGRAMMER : 10900
> HASKELL%20PROGRAMMER : 12600
> SHELL%20PROGRAMMER : 16900
> FORTRAN%20PROGRAMMER : 44300
> LISP%20PROGRAMMER : 47800
> JAVASCRIPT%20PROGRAMMER : 58700
> PYTHON%20PROGRAMMER : 138000
> COBOL%20PROGRAMMER : 148000
> BASIC%20PROGRAMMER : 201000
> PERL%20PROGRAMMER : 280000
> C++%20PROGRAMMER : 341000
> JAVA%20PROGRAMMER : 1710000
>
>
> PROGRAMS:
>
> SNOBOL%20PROGRAMS : 260
> CSH%20PROGRAMS : 559
> APL%20PROGRAMS : 18400
> MATHEMATICA%20PROGRAMS : 19000
> J%20PROGRAMS : 19600
> OCAML%20PROGRAMS : 38400
> HASKELL%20PROGRAMS : 47300
> SHELL%20PROGRAMS : 93700
> MATLAB%20PROGRAMS : 95200
> JAVASCRIPT%20PROGRAMS : 112000
> LISP%20PROGRAMS : 147000
> COBOL%20PROGRAMS : 184000
> PYTHON%20PROGRAMS : 213000
> PERL%20PROGRAMS : 350000
> FORTRAN%20PROGRAMS : 467000
> BASIC%20PROGRAMS : 573000
> JAVA%20PROGRAMS : 1680000
> C++%20PROGRAMS : 2060000
>
>
> CODE:
>
> SNOBOL%20CODE : 477
> CSH%20CODE : 11600
> APL%20CODE : 15000
> OCAML%20CODE : 41100
> HASKELL%20CODE : 54500
> MATHEMATICA%20CODE : 58800
> COBOL%20CODE : 98200
> SHELL%20CODE : 177000
> J%20CODE : 203000
> LISP%20CODE : 273000
> MATLAB%20CODE : 350000
> FORTRAN%20CODE : 585000
> PYTHON%20CODE : 981000
> PERL%20CODE : 1310000
> BASIC%20CODE : 1420000
> JAVASCRIPT%20CODE : 4150000
> C++%20CODE : 7910000
> JAVA%20CODE : 9340000
>
> > NIL

I grabbed this from
http://www.digitalmars.com/d/archives/digitalmars/D/32010.html
They searched for `written in <language>'

PHP           2,190,000
Java          1,820,000
C             1,560,000
Perl          1,150,000
C++             836,000
Python          681,000
C#              344,000
Fortran         209,000
Visual Basic    204,000
Ruby            120,000
Delphi           90,000
Common Lisp      72,000
Haskell          33,500
Objective C      26,700
OCaml            23,200
Brainfuck           964
Eiffel              770
D                   769
RPG                 700
Modula-2            699
Algol               620
APL                 591
Euphoria            537
PS                  494
J                   429
Dylan               323
TERSE               301
SNOBOL              254
INTERCAL             92
CP/M                 45
Prometheus           28
Regina               11
From: Rob Thorpe
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156957973.700594.207300@m73g2000cwd.googlegroups.com>
Joe Marshall wrote:
> ········@gmail.com wrote:
<snip>
> > > NIL
>
> I grabbed this from
> http://www.digitalmars.com/d/archives/digitalmars/D/32010.html
> They searched for `written in <language>'
>
> PHP           2,190,000

Wow, that's impressive.

Especially considering the searchs I did below:-
Results 1 - 10 of about 3,860,000 for "written in english". (0.15
seconds)
Results 1 - 10 of about 321,000 for "written in spanish". (0.11
seconds)

Dare I mention that this particular google feature is rather unreliable.
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156960526.961857.127020@b28g2000cwb.googlegroups.com>
> Dare I mention that this particular google feature is rather unreliable.

That's the least of the issues, which is why (a) I did multiple
phrases, and (b) I said that my analysis was (to put it as positively
as possible) heuristic and statistical -- meaning: Probably mostly
wrong! :-)

[Although it's interesting and scary too see how much code it takes to
approximate a whole google tool (google trends -- although I'd have to
wrap another loop around it to go across time). Google's sort of like
fifty ten-line lisp programs (or one line APL programs! :-), mapped
over a giant centralized database, each with a fancy name and icon, a
bad ajax interface, and piled hugh with advertising. Amazing what you
can make a zillion dollars for these days.]
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156961200.289478.189620@i42g2000cwa.googlegroups.com>
BTW, not beyond self-criticism, one of the things that is great about
APL is select/compress, which would have helped here in my above code:

              ...
              ;; Ugh: 123,456,789! Is there a better way to
              ;; remove these????
              (coerce (loop for c across numstring
                                    unless (char-equal #\, c)  collect
c) 'string)
              ...

In APLisp this is (I don't know how to do the J chars, so I'll just
write it out in made-up Lisp list comprehensions):

              (compress (maparray #'(lambda (char) (char-equal #',
char))
                                                 mystring) mystring)

Or (more APL-like, though still wrong, since I don't know J):

            (#\a == mystring)/mystring

Of course, I could always just trivially defun compress in about 1.5
lines of lisp....
... but I digress! :-)
From: Juho Snellman
Subject: Re: LISP V APL?
Date: 
Message-ID: <slrnefblk3.q37.jsnell@sbz-30.cs.Helsinki.FI>
········@gmail.com <········@gmail.com> wrote:
> BTW, not beyond self-criticism, one of the things that is great about
> APL is select/compress, which would have helped here in my above code:
>
>               ...
>               ;; Ugh: 123,456,789! Is there a better way to
>               ;; remove these????
>               (coerce (loop for c across numstring
>                                     unless (char-equal #\, c)  collect
> c) 'string)
>               ...

(remove #\, numstring)

-- 
Juho Snellman
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1157036549.361162.274910@m73g2000cwd.googlegroups.com>
Juho Snellman wrote:
> (remove #\, numstring)

Nice if this would work, but it does not work. Try it!
From: Juho Snellman
Subject: Re: LISP V APL?
Date: 
Message-ID: <slrnefe1kn.j2e.jsnell@sbz-30.cs.Helsinki.FI>
········@gmail.com <········@gmail.com> wrote:
> Juho Snellman wrote:
>> (remove #\, numstring)
>
> Nice if this would work, but it does not work. Try it!

Could you expand on that? I don't know how you want it to work, but it
does the same thing as the expression you posted.

(let ((numstring "123,456,789"))
  (assert (equal (coerce (loop for c across numstring
	                       unless (char-equal #\, c) 
	                       collect c) 'string)
	         (remove #\, numstring))))

-- 
Juho Snellman
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1157040310.021801.12160@h48g2000cwc.googlegroups.com>
Juho Snellman wrote:
> ········@gmail.com <········@gmail.com> wrote:
> > Juho Snellman wrote:
> >> (remove #\, numstring)
> >
> > Nice if this would work, but it does not work. Try it!
>
> Could you expand on that? I don't know how you want it to work, but it
> does the same thing as the expression you posted.
>
> (let ((numstring "123,456,789"))
>   (assert (equal (coerce (loop for c across numstring
> 	                       unless (char-equal #\, c)
> 	                       collect c) 'string)
> 	         (remove #\, numstring))))

Actually, you're right; I'm completely wrong. I have no idea what I was
thinking but I seem to have faked myself out somehow into thinking that
I needed all that crap. Duh; Sorry.
From: Joe Marshall
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156962606.377272.8140@i42g2000cwa.googlegroups.com>
Rob Thorpe wrote:
> Joe Marshall wrote:
> > ········@gmail.com wrote:
> <snip>
> > > > NIL
> >
> > I grabbed this from
> > http://www.digitalmars.com/d/archives/digitalmars/D/32010.html
> > They searched for `written in <language>'
> >
> > PHP           2,190,000
>
> Wow, that's impressive.
>
> Especially considering the searchs I did below:-
> Results 1 - 10 of about 3,860,000 for "written in english". (0.15
> seconds)
> Results 1 - 10 of about 321,000 for "written in spanish". (0.11
> seconds)
>
> Dare I mention that this particular google feature is rather unreliable.

I suspect that the result is extrapolated from the density of the hits
for finding the first ten results (i.e., it probably stopped looking
after it got the first ten or so results, looked at how much data it
had to sift through, and estimated how many more hits it would get if
it sifted through the entire data set).
From: Pascal Bourguignon
Subject: Re: LISP V APL?
Date: 
Message-ID: <87bqq2qi5m.fsf@informatimago.com>
"Joe Marshall" <··········@gmail.com> writes:
> I grabbed this from
> http://www.digitalmars.com/d/archives/digitalmars/D/32010.html
> They searched for `written in <language>'
>
> PHP           2,190,000
> Java          1,820,000
> C             1,560,000
> Perl          1,150,000
> C++             836,000
> Python          681,000
> C#              344,000
> Fortran         209,000
> Visual Basic    204,000
                  188,400  CL+Lisp+Scheme
> Ruby            120,000
> Delphi           90,000
  Lisp             77,400
> Common Lisp      72,000
  Pascal           64,000
  Scheme           47,000

But the real problem is that this doesn't count the number of programs
written in each language, but the number of _copies_ that are used on
the web, for PHP, Java and Perl.

Otherwise, you'd be forgetting the 200,000,000 copies of MS-Windows
written (mostly?) in C, not counting the 3,000,000,000 copies of GSM
phone software written (mostly?) in C too?

-- 
__Pascal Bourguignon__
From: William James
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156962202.983618.296580@h48g2000cwc.googlegroups.com>
········@gmail.com wrote:

> (loop for word in '(programming programmer programs code)
>       do (format t "~%~%~a:~%~%" word)
>       (loop for (phrase . n) in
>                                               ;; SNOBOL is a control
> Better be the least!
>             (sort (loop for lang in  '(csh javascript shell haskell
> snobol basic
>                                                  fortran cobol apl j
> lisp c++ java mathematica
>                                                  ocaml perl python
> matlab)
>                         as phrase = (format nil "~a%20~a" lang word)
>                         as goog-result =
>                         (web-page-contents (format nil
>
> "http://www.google.com/search?hl=en&q=%22~a%22" phrase))
>                         as of-about-pos = (search "of about"
> goog-result)
>                         as unboldpos = (search "</b>" goog-result
> :start2 of-about-pos)
>                         as numstring = (subseq goog-result
>                                          (+ (length "of about <b>")
> of-about-pos) unboldpos)
>                         ;; Ugh: 123,456,789! Is there a better way to
> remove these????
>                         as w/o-commas = (coerce (loop for c across
> numstring
>                                                       unless
> (char-equal #\, c)
>                                                       collect c)
> 'string)
>                         as n = (read-from-string w/o-commas)
>                         collect (cons phrase n))
>               #'< :key #'cdr)
>             do (format t "~a : ~a~%" phrase n)))


(define (hits language word)
  (regex "(?i)results <b>1</b>.*? of about <b>([\\d,]+)"
    (get-url (string "http://www.google.com/search?hl=en&q=%22"
                     language "%20" word "%22")))
  (int (replace "," $1 "")))

(dolist (word '(programming programmer programs code))
  (println "\n" (title-case (string word)) ":\n")
  (dolist (x
    (sort (map (lambda (language) (list (hits language word) language))
      '(csh javascript shell haskell snobol basic
        fortran cobol apl j lisp c++ java mathematica
        ocaml perl python matlab))))
      (println (format "%-13s%8d" (string (last x))  (first x)))))

;; newLisp

===>

Programming:

snobol            588
csh              9990
j               21100
ocaml           32200
mathematica     33200
haskell         34500
apl             43600
matlab         118000
cobol          168000
fortran        197000
lisp           227000
python        1100000
shell         1130000
perl          1590000
javascript    2020000
basic         2380000
c++           4850000
java          6940000

Programmer:

csh                30
snobol             30
matlab            582
apl               663
j                 918
ocaml             952
mathematica     10900
haskell         12600
shell           16900
fortran         44300
lisp            47800
javascript      58700
python         138000
cobol          148000
basic          201000
perl           280000
c++            341000
java          1710000

Programs:

snobol            260
csh               559
apl             18400
mathematica     19000
j               19600
ocaml           38400
haskell         47300
shell           93700
matlab          95200
javascript     112000
lisp           147000
cobol          184000
python         213000
perl           350000
fortran        467000
basic          573000
java          1680000
c++           2060000

Code:

snobol            477
csh             11600
apl             15000
ocaml           41100
haskell         54500
mathematica     58800
cobol           98200
shell          177000
j              203000
lisp           273000
matlab         350000
fortran        585000
python         981000
perl          1310000
basic         1420000
javascript    4150000
c++           7910000
java          9340000


--
Common LISP is the PL/I of Lisps.  Too big and too
incomprehensible, with no examiniation of the real
world of software engineering.  ---  Jeffrey M. Jacobs
From: William James
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156966466.167078.131230@i3g2000cwc.googlegroups.com>
William James wrote:

> (define (hits language word)
>   (regex "(?i)results <b>1</b>.*? of about <b>([\\d,]+)"
>     (get-url (string "http://www.google.com/search?hl=en&q=%22"
>                      language "%20" word "%22")))
>   (int (replace "," $1 "")))
>
> (dolist (word '(programming programmer programs code))
>   (println "\n" (title-case (string word)) ":\n")
>   (dolist (x
>     (sort (map (lambda (language) (list (hits language word) language))
>       '(csh javascript shell haskell snobol basic
>         fortran cobol apl j lisp c++ java mathematica
>         ocaml perl python matlab))))
>       (println (format "%-13s%8d" (string (last x))  (first x)))))
>
> ;; newLisp

MatzLisp (Ruby):

require 'open-uri'
google = "http://www.google.com/search?hl=en&q=%22"

puts  %w(
  programming programmer programs code
  ).
  map{ |word|
    [
      "\n#{ word.capitalize }:\n\n",
      %w(
          csh javascript shell haskell snobol basic
          fortran cobol apl j lisp c++ java mathematica
          ocaml perl python matlab
        ).
        map{ |language|
          [
            open( "#{ google }#{ language }%20#{ word }%22" ){ |f|
              f.read }[ /Results <b>1.*? of about <b>([\d,]+)/, 1].
              delete(",").to_i ,
            language
          ]
        }.sort.map{|a| format( "%-13s%8d", a.last, a.first) }
    ]
}

--
Do you really think people in 1000 years want to be
constrained by hacks that got put into the foundations of
Common Lisp because a lot of code at Symbolics depended on
it in 1988?  ---  Paul Graham
From: Timofei Shatrov
Subject: Re: LISP V APL?
Date: 
Message-ID: <44f66bf4.4143918@news.readfreenews.net>
On 30 Aug 2006 12:34:26 -0700, "William James" <·········@yahoo.com>
tried to confuse everyone with this message:

>            open( "#{ google }#{ language }%20#{ word }%22" ){ |f|
>              f.read }[ /Results <b>1.*? of about <b>([\d,]+)/, 1].
<snip similar line noise>

Thanks. You just reminded me why I decided against learning Ruby
(MatzLisp? looks more like MatzPerl to me).

-- 
|Don't believe this - you're not worthless              ,gr---------.ru
|It's us against millions and we can't take them all... |  ue     il   |
|But we can take them on!                               |     @ma      |
|                       (A Wilhelm Scream - The Rip)    |______________|
From: Pisin Bootvong
Subject: Re: LISP V APL?
Date: 
Message-ID: <1157091447.161066.143470@m79g2000cwm.googlegroups.com>
Timofei Shatrov wrote:
> On 30 Aug 2006 12:34:26 -0700, "William James" <·········@yahoo.com>
> tried to confuse everyone with this message:
>
> >            open( "#{ google }#{ language }%20#{ word }%22" ){ |f|
> >              f.read }[ /Results <b>1.*? of about <b>([\d,]+)/, 1].
> <snip similar line noise>
>
> Thanks. You just reminded me why I decided against learning Ruby
> (MatzLisp? looks more like MatzPerl to me).
>

 "#{google}#{language}%20#{word}%22"

is a more concise and clearer version of lisp's:

 (format-to-string "~a~a%20~a%22" google language word)

(more clear is subjective but I think it is easier to understand when
you don't have to match each ~a with value in corresponding position)


open(x){| f | ... }      # return value of last statement in block is
return value of this calls.

is basically:

(with-open-file (f x)  ... )      ;; return value of last form in body
is return value of this calls.

Without any need to use macro.


s[i] is widely known as getting element at index. s[/regexp/] is
basically grepping using regular expression.

This is very basic idiom of Ruby and I don't see how

/Results <b>1.*? of about <b>([\d,]+)/

is harder to understand than.

"(?i)results <b>1</b>.*? of about <b>([\\d,]+)"

So to be honest, I think both Lisp and Ruby version has about the same
amount of clarity.

> --
> |Don't believe this - you're not worthless              ,gr---------.ru
> |It's us against millions and we can't take them all... |  ue     il   |
> |But we can take them on!                               |     @ma      |
> |                       (A Wilhelm Scream - The Rip)    |______________|
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1157037037.718077.320430@74g2000cwt.googlegroups.com>
William James wrote:
> ········@gmail.com wrote:
...
>   (int (replace "," $1 "")))
...

What's this? It's not CL. [Not the $1, I know that THAT is... I mean
this usage of replace doesn't seem anything like CL. Is it some
personal library function?]
From: Rob Thorpe
Subject: Re: LISP V APL?
Date: 
Message-ID: <1157037261.685577.19830@74g2000cwt.googlegroups.com>
········@gmail.com wrote:
> William James wrote:
> > ········@gmail.com wrote:
> ...
> >   (int (replace "," $1 "")))
> ...
>
> What's this? It's not CL. [Not the $1, I know that THAT is... I mean
> this usage of replace doesn't seem anything like CL. Is it some
> personal library function?]

It's newLisp.  "Replace" has two meanings in newLisp, one for strings,
another for lists.
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1157038511.378035.318650@i3g2000cwc.googlegroups.com>
Rob Thorpe wrote:
> ········@gmail.com wrote:
> > William James wrote:
> > > ········@gmail.com wrote:
> > ...
> > >   (int (replace "," $1 "")))
> > ...
> >
> > What's this? It's not CL. [Not the $1, I know that THAT is... I mean
> > this usage of replace doesn't seem anything like CL. Is it some
> > personal library function?]
>
> It's newLisp.  "Replace" has two meanings in newLisp, one for strings,
> another for lists.

Oh. I'm sure that there are threads dating back to infinity and beyond
about this, but it seems to me that "new" Lisps should be upward
compatible from CL. ... Okay... Never mind.
From: Jon Harrop
Subject: Re: LISP V APL?
Date: 
Message-ID: <44f194cb$0$2679$ed2619ec@ptn-nntp-reader02.plus.net>
gavino wrote:
> how does lisp compare to apl?
> 
> I read an mazing apl faq and it sounded like many descriptions of lisp
> 
> it said the brevity is power because u can make shorted programs and
> control complexity
> 
> how does it stack up to lisp?

AFAIK, APL's features are easily added to Lisp but not vice-versa. So Lisp
is better as a general purpose programming language.

> I want to learn programmign but can't focus due to my desire to pick
> most powerful tool but also something practical not theoretical.

Yes, there are lots of wildly different languages out there. You'll need to
learn at least one from each paradigm if you want to become a good
programmer...

-- 
Dr Jon D Harrop, Flying Frog Consultancy
Objective CAML for Scientists
http://www.ffconsultancy.com/products/ocaml_for_scientists
From: Mallor
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156830654.026974.93460@74g2000cwt.googlegroups.com>
Jon Harrop wrote:
>
> Yes, there are lots of wildly different languages out there. You'll need to
> learn at least one from each paradigm if you want to become a good
> programmer...

Um, no.  Only needed if you want to become a knowledgeable, lettered
programmer.  *Good* programmers are defined by most of the industry as
those who can spew out a lot of code on time, on budget.  Plenty of
people only know 1 language and are "good" by that metric.

Over the past 2 years I've studied a lot of languages and also some
compiler theory.  It did not make me a better programmer.  It did make
me a more knowledgeable programmer.  Getting my hands dirty with build
systems made me a better programmer, because it added "scripting
mentality" to my repertoire.  That's something I needed, given my low
level ASM optimization background and tendency towards premature
optimization.  I am much better at "just getting things working" now
than I was 2 years ago.


Cheers,
Brandon Van Every
From: gavino
Subject: Re: LISP V APL?
Date: 
Message-ID: <1156958668.853162.281350@h48g2000cwc.googlegroups.com>
APL's features can be ADDEd to lisp?
!!
HOW?
what the!
From: Ari Johnson
Subject: Re: LISP V APL?
Date: 
Message-ID: <m2ac5lnazh.fsf@hermes.theari.com>
"gavino" <········@yahoo.com> writes:

> APL's features can be ADDEd to lisp?
> !!
> HOW?
> what the!

This just shows how poorly you understand APL, Lisp, and programming
in general.  How about this: Propose by posting to this newsgroup a
feature of APL that is not available in Common Lisp, and start your
stopwatch.  Come back in two hours and see how many Common Lisp
implementations of that feature are already posted.
From: gavino
Subject: Re: LISP V APL?
Date: 
Message-ID: <1157048094.866574.169900@b28g2000cwb.googlegroups.com>
Really?
Can common lisp use memory mapped files?
From: ···@itasoftware.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1157053918.934931.79680@h48g2000cwc.googlegroups.com>
gavino wrote:
> Really?
> Can common lisp use memory mapped files?

Does the standard define it: No.

Can most implementations do it: Yes.

Is it used in at least one production Lisp app: Yes.
From: Ari Johnson
Subject: Re: LISP V APL?
Date: 
Message-ID: <m2wt8o90ak.fsf@hermes.theari.com>
"gavino" <········@yahoo.com> writes:

> Really?
> Can common lisp use memory mapped files?

Can APL?  I asked you to name a specific APL feature that you don't
believe is in Lisp.  "[Using] memory mapped files" is not at all
specific.
From: ········@gmail.com
Subject: Re: LISP V APL?
Date: 
Message-ID: <1157054509.406376.139990@h48g2000cwc.googlegroups.com>
Ari Johnson wrote:
> "gavino" <········@yahoo.com> writes:
>
> > Really?
> > Can common lisp use memory mapped files?
>
> Can APL?  I asked you to name a specific APL feature that you don't
> believe is in Lisp.  "[Using] memory mapped files" is not at all
> specific.

Much as I understand where you are coming from, and I agree that memory
mapping files isn't a good example (as it's more of an implementation
feature than a part of the language spec, although these blend into one
another), implementing APL's automatic n-dimension matrix hacming
operations would be difficult (although obviously not impossible) in
Lisp, or any other language. Of course, you could start by saying:
Assume we have an n-dimensional matrix mapping package ... but that
obviously would not be fair.

Another interesting and under-appreciated (by anyone but APL
programmers) is that it had a true eval (because it is a true
interepreter!), and true macros -- indeed, it is the langauge closest
to Lisp (IMHO) in this regard! What makes Lisp macros possible is that
the syntax of the language is trees, which is the same as the basic
data structure (plus eval, and/or a compiler). The same is true of APL:
The syntax is operators all strung together in a vector, and the basic
data structure is vectors (or, more generally, arrays). As a result,
one can actually write quite elegant APL macro functions that create
and then eval the APL code. (Of course there are no compiler macros
because there's not compiler!) They're not quote as general as Lisp --
there is some waco syntax in APL, but we used to use this all the time
to write cool and unusual APL (that did competely un-understandable yet
amazing things)!

Like I said before, I actually loved APL and miss it. It had an
elegance approaching that of Lisp (although in the domain of matrices,
not lists).
From: Casey Hawthorne
Subject: Re: LISP V APL?
Date: 
Message-ID: <kuocf2l6srsksi8jg2mp7slirqd3f0nn6m@4ax.com>
"gavino" <········@yahoo.com> wrote:

>I want to learn programmign but can't focus due to my desire to pick
>most powerful tool but also something practical not theoretical.
> help!

The most powerful tool should be your brain -- which doesn't seem to
be the sharpest avocado in the garden!

--
Regards,
Casey