Over the last year or so, I have used Java more than any other
programming language (next to Lisp, of course), and I hate it. I
suppose that once one learns how to compute symbolically, it is very
difficult to return to the structured impediments of the other
languages. I realized quickly that the reason that Lisp will never go
out style is because there will always be lists to process. In my AP
Java class, we have to use multiple arrays, or an arraylist, which is
similar to a normal Lisp list. Of course Java does not have any of the
builtin functions or functionality for dealing with lists, making some
easy practice problems for the exam. I suppose that if people don't
want to use Lisp, that other languages will evolve to eventually become
Lisp. I think that is what we are seeing with languages like Java.
Just my two cents on why I love Lisp so much :)
Philip Haddad
Philip Haddad wrote:
> Over the last year or so, I have used Java more than any other
> programming language (next to Lisp, of course), and I hate it. I
> suppose that once one learns how to compute symbolically, it is very
> difficult to return to the structured impediments of the other
> languages. I realized quickly that the reason that Lisp will never go
> out style is because there will always be lists to process. In my AP
> Java class, we have to use multiple arrays, or an arraylist, which is
> similar to a normal Lisp list.
I don't know much about Java, but I doubt this.
Are those arraylists composed of cons cells? If not, they are
not really lists in the LISP sense. It is difficult to
replacd/replaca on them, for example.
Of course Java does not have any of the
> builtin functions or functionality for dealing with lists, making some
> easy practice problems for the exam. I suppose that if people don't
> want to use Lisp, that other languages will evolve to eventually become
> Lisp.
Lisp has more than one defining feature.
- No syntax facilitates powerful macros
- No syntax and powerful macros facilitates tailor-made
languages of arbitrary complexity
- Automatic garbage collection relieves the programmer
of managing memory himself
- Functional programming is good for writing
software components that have no
bugs (Forgive trivializing the issue for
brevity).
These features mix and match very well, but they
are only loosely coupled. It is possible to have a
portable assembler like C that has a lisp-like
syntax, for example. It is possible to wrap a
GC language in a more conventional syntax (python
comes to mind). You can have a functional language
with an unlispy syntax (JOY). Macros are possible,
though cumbersome and inherently less powerful, in
languages with infix notation. I think Lisp owes
its clever combination of avantgardistic features
and how they interact to its long tradition in
hackerish circles who invested a lot of brain-power,
talent and taste into its architecture. This is
in gross contrast to Java, which appearantly was
designed and programmed by a commercial enterprise with
the aim to build a better remote control, or
run tiny mini-apps in a web-browser, or run huge
applications on a web-server, or give pointy-haired
bosses the next big thing for harnessing the
power of massively parallel batteries of mediocre
coder-droids (or what those bosses think are
mediocre coder-droids).
On the other hand: Lisp looks like a theoretical
optimum. It has a minimalistic way of structuring
hierarchical data, it has a minimalistic way of
expressing program structure as hierarchical data,
it has a minimalistic way of automatizing
writing program snippets. In this light it is
very well possible that a sufficiently advanced
civilization has Lisp, just as it is entirely possible
that it has a Go-like game. It would be a next
to impossible incident if this civilization had
a Chess-like game or Java because both are much
more arbitrary than Lisp or Go. Who knows how
well those extra-terristial Lispniks do in convincing
their compatriats adopting the language? Maybe
the first signal from space-alien will be a
flame-war between Lispniks and members of the
extra-terrestial equivalent of the ruling Java-mainstream.
In other words: I think we were lucky that John
McCarthy "discovered" Lisp, and that MIT-geeks
adopted it and polished it to the point where
its sheer elegance shines even thru the cruft.
Had this not happened, there wouldn't be a Lisp
today. On the other hand: Since Lisp IS more (or
less) than a collection of arbitrary syntactical
conventions and ad-hoc techniques, someone else
would have invented it sooner or later (my guess
is later).
So it is possibly true that Lisp will never go
out of style, and if it does, there will be another
McCarthy who re-invents it. A new, although fringy,
fad in enterprise programming is XML-based programming
by the way. The aim is to keep a computer program's
MEANING indepent from any particular syntax. XML
is used what looks like S-expressions. Talk about
re-inventing the wheel. Pointy-haired bosses seem
to hate Lisp so much, they don't its syntax
even if they want its features. Problem is, you
can't get Lisp without its syntax-less syntax.
Where was I?
> I think that is what we are seeing with languages like Java.
If Java is amended to the point where it looks and
feels like Lisp it will be Lisp. If it is still
called Java, I'll be all for it. (In other
words: deal!)
> Just my two cents on why I love Lisp so much :)
> Philip Haddad
>
Right on!
To the best of my knowledge, Lisp is the only language that uses cons
cells. What I meant about lists is that they are large groups of data,
that the programmeer may know a lot about (size, types, etc), or almost
nothing about. Since a lot of programming is manipulating huge sets of
data, Lisp will (in my opinion) always be the best language for this
purpose.
BTW, along the lines of what you were saying about XML, check out
jatha.sourceforge.net
it's a little cooler then XML, basically a Lisp parser in Java, or vice
versa, I played around with it a little, it's pretty neat IMO.
Philip Haddad
Philip Haddad wrote:
> Since a lot of programming is manipulating huge sets of
> data, Lisp will (in my opinion) always be the best language for this
> purpose.
Mumps. :)
From: Marcin 'Qrczak' Kowalczyk
Subject: Re: Why Lisp will never go out of style
Date:
Message-ID: <87irtqpq35.fsf@qrnik.zagroda>
"Philip Haddad" <·············@gmail.com> writes:
> To the best of my knowledge, Lisp is the only language that uses
> cons cells.
No. Besides Scheme and Dylan lisp-style lists are used by SML, OCaml,
Haskell, Clean, Miranda, Prolog, Mercury and many others (although
they differ whether they are mutable and whether they are dynamically
typed).
> What I meant about lists is that they are large groups of data, that
> the programmeer may know a lot about (size, types, etc), or almost
> nothing about.
This is not specific to cons cells but to dynamically typed languages.
It's orthogonal. There are lots of dynamically typed languages besides
Lisp, e.g. Smalltalk, Perl, Python, Ruby, Icon, JavaScript, Rebol.
--
__("< Marcin Kowalczyk
\__/ ······@knm.org.pl
^^ http://qrnik.knm.org.pl/~qrczak/
In article <························@g47g2000cwa.googlegroups.com>,
"Philip Haddad" <·············@gmail.com> wrote:
> To the best of my knowledge, Lisp is the only language that uses cons
> cells.
Lots of languages have a "pair" data type. C++, for example, uses it
quite extensively for things such as key/value for trees and hash
tables. Unlike Common Lisp, Scheme and Dylan though there is no
particular help with using them as linked lists.
The ML/Caml/Haskell family have list handling functionality that really
only seems to make sense to implement using cons cells, though I don't
know for sure that they do.
--
Bruce | 41.1670S | \ spoken | -+-
Hoult | 174.8263E | /\ here. | ----------O----------
Caml uses lists extensively. It is not list-based, but it is even more
functional than Lisp. Just take a look:
http://caml.inria.fr/about/taste.en.html
Also, it is very fast, sometimes even faster than Lisp and near C
performance.
Am Wed, 14 Dec 2005 16:46:05 +0100 schrieb Tin Gherdanarra:
> Philip Haddad wrote:
>> Over the last year or so, I have used Java more than any other
>> programming language (next to Lisp, of course), and I hate it. I
>> suppose that once one learns how to compute symbolically, it is very
>> difficult to return to the structured impediments of the other
>> languages. I realized quickly that the reason that Lisp will never go
>> out style is because there will always be lists to process. In my AP
>> Java class, we have to use multiple arrays, or an arraylist, which is
>> similar to a normal Lisp list.
>
> I don't know much about Java, but I doubt this.
> Are those arraylists composed of cons cells? If not, they are
> not really lists in the LISP sense. It is difficult to
> replacd/replaca on them, for example.
>
> Of course Java does not have any of the
>> builtin functions or functionality for dealing with lists, making some
>> easy practice problems for the exam. I suppose that if people don't
>> want to use Lisp, that other languages will evolve to eventually become
>> Lisp.
>
> Lisp has more than one defining feature.
> - No syntax facilitates powerful macros
> - No syntax and powerful macros facilitates tailor-made
> languages of arbitrary complexity
> - Automatic garbage collection relieves the programmer
> of managing memory himself
> - Functional programming is good for writing
> software components that have no
> bugs (Forgive trivializing the issue for
> brevity).
>
> These features mix and match very well, but they
> are only loosely coupled. It is possible to have a
> portable assembler like C that has a lisp-like
> syntax, for example. It is possible to wrap a
> GC language in a more conventional syntax (python
> comes to mind). You can have a functional language
> with an unlispy syntax (JOY). Macros are possible,
> A new, although fringy,
> fad in enterprise programming is XML-based programming
> by the way. The aim is to keep a computer program's
> MEANING indepent from any particular syntax. XML
> is used what looks like S-expressions. Talk about
> re-inventing the wheel.
Yeah, google for "XML programming language" and you will find things like
this one:
http://www.o-xml.org/spec/langspec.html
(display "hello world")
becomes
<display content="hello world" />
lacks some elegance :(
--
Andi
| Mail: ·······@web.de
| Web: http://beza1e1.tuxen.de
| Jabber: ·······@amessage.de
Andi wrote:
> Am Wed, 14 Dec 2005 16:46:05 +0100 schrieb Tin Gherdanarra:
>
>
>>Philip Haddad wrote:
>>
>>>Over the last year or so, I have used Java more than any other
>>>programming language (next to Lisp, of course), and I hate it. I
>>>suppose that once one learns how to compute symbolically, it is very
>>>difficult to return to the structured impediments of the other
>>>languages. I realized quickly that the reason that Lisp will never go
>>>out style is because there will always be lists to process. In my AP
>>>Java class, we have to use multiple arrays, or an arraylist, which is
>>>similar to a normal Lisp list.
>>
>>I don't know much about Java, but I doubt this.
>>Are those arraylists composed of cons cells? If not, they are
>>not really lists in the LISP sense. It is difficult to
>>replacd/replaca on them, for example.
>>
>> Of course Java does not have any of the
>>
>>>builtin functions or functionality for dealing with lists, making some
>>>easy practice problems for the exam. I suppose that if people don't
>>>want to use Lisp, that other languages will evolve to eventually become
>>>Lisp.
>>
>>Lisp has more than one defining feature.
>>- No syntax facilitates powerful macros
>>- No syntax and powerful macros facilitates tailor-made
>> languages of arbitrary complexity
>>- Automatic garbage collection relieves the programmer
>> of managing memory himself
>>- Functional programming is good for writing
>> software components that have no
>> bugs (Forgive trivializing the issue for
>> brevity).
>>
>>These features mix and match very well, but they
>>are only loosely coupled. It is possible to have a
>>portable assembler like C that has a lisp-like
>>syntax, for example. It is possible to wrap a
>>GC language in a more conventional syntax (python
>>comes to mind). You can have a functional language
>>with an unlispy syntax (JOY). Macros are possible,
>>A new, although fringy,
>>fad in enterprise programming is XML-based programming
>>by the way. The aim is to keep a computer program's
>>MEANING indepent from any particular syntax. XML
>>is used what looks like S-expressions. Talk about
>>re-inventing the wheel.
>
> Yeah, google for "XML programming language" and you will find things like
> this one:
> http://www.o-xml.org/spec/langspec.html
Funny you'd mention it -- o-xml was exactly what
I was talking about. There are more XML-programming
languages, but o-xml is the most mature (or so
it seems).
>
> (display "hello world")
> becomes
> <display content="hello world" />
>
> lacks some elegance :(
Don't be surprised if it becomes the next big
thing in enterprise programming in 2011, gaining
larger acceptance than all lisp-dialects combined.
A powerful force to be reckoned with is the
lobby of doctors specializing in carpal tunnel-syndrome.
They are all for it!
(+ 2 2)
becomes
<plus>
<argument-list>
<item>
2
</item>
<item>
2
</item>
</argument-list>
</plus>
I'm exegarrating, but not much.
In IT, everything looks like a race to technologies
that suck most. I have no plausible explanation for it.
>
Tin Gherdanarra wrote:
> Don't be surprised if it becomes the next big
> thing in enterprise programming in 2011, gaining
> larger acceptance than all lisp-dialects combined.
> A powerful force to be reckoned with is the
> lobby of doctors specializing in carpal tunnel-syndrome.
> They are all for it!
>
> (+ 2 2)
>
> becomes
>
> <plus>
> <argument-list>
> <item>
> 2
> </item>
> <item>
> 2
> </item>
> </argument-list>
> </plus>
>
> I'm exegarrating, but not much.
See also http://homepages.inf.ed.ac.uk/wadler/language.pdf ;)
Pascal
--
My website: http://p-cos.net
Closer to MOP & ContextL:
http://common-lisp.net/project/closer/
Tin: It's funny that no one has mentioned XSL(T). The if statements
work well, I wish they had a proper case statement though.
<a href="http://www.xml.com/lpt/a/2003/09/03/trxml.html">Writing your
own functions in XSLT 2.0</a>
Looks good (haven't tried it yet), and I wish XSL/XML were less on the
fringe because they make writing webpages fun. Opens up a new world,
etc.
Philip: Anyway, I'll mention Paul Graham, because he's written an essay
on LISP. Java is missing a lot of annoying/interesting things, like
pointers. It's similar to LISP in the fact that there are a lot of
pre-coded libraries that come with the compiler. Example, graphic
libraries. There are how many ways to make a GUI using C/C++? Microsoft
has their MFC stuff, there's GTK, FLTK, QT, etc. But with Java, there's
already a library/package for GUI creation.
I myself love LISP because it's very easy to code in and looks more
comforting than Python, Ruby and Perl. It's hard to believe because of
all the brackets heh.
OMouse wrote:
> ... It's similar to LISP in the fact that there are a lot of
> pre-coded libraries that come with the compiler. Example, graphic
> libraries.
Is this supposed to be sarcastic? There isn't that much of pre-coded
library that comes with Lisp implementation. In fact, that's one of the
weakness of Lisp.
One of the strength of Java is that huge standard library of
Socket/Threading/Collection/Concurrency. What ever implementation you
use Java (Sun/IBM/GNU) you will always find FileOutputStream or
ThreadLocal class to use.
That is not true for lisp; both about the amount of pre-coded library
and the fact of being standard.
> There are how many ways to make a GUI using C/C++? Microsoft
> has their MFC stuff, there's GTK, FLTK, QT, etc. But with Java, there's
> already a library/package for GUI creation.
>
Java also have things like SWT for more natively looking apps. But
people probably stick with what's given when they first learned it. I
guess that's the benefit of having standard library, you can
communicate easier with people in the same programming language because
you know more of the same API.
> I myself love LISP because it's very easy to code in and looks more
> comforting than Python, Ruby and Perl. It's hard to believe because of
> all the brackets heh.
I like both Ruby and Lisp. Ruby comes closest to lisp in the field of
expressiveness. What I like Ruby that, despite the lacks of macro, it
still manages to be the very good language for DSL. So you can simplify
concept like macroexpansion-time and eval-time. The ability to redefine
any class at runtime, even the primitive type, makes the lacks of
multidispatch more livable also. The only thing Ruby doesn't have from
Lisp is lovely condition system though.
That's true. I've only recently started learning CLisp and I found a
nice XML parser pretty easily which I can't say is true for C++. I had
to write my own XML parser for C++ because I found none that did what I
wanted them to do. With Java you would most likely have an XML parser
right there in a package. Thanks for the correction, it's the morning
and I haven't had a coffee yet ;)
OMouse ha escrito:
> I myself love LISP because it's very easy to code in and looks more
> comforting than Python, Ruby and Perl. It's hard to believe because of
> all the brackets heh.
It is easy until you enter the incredible world of macros... now from
that moment it becomes not easy but just wounderfull. ;)
Andi wrote:
> Yeah, google for "XML programming language" and you will find things like
> this one:
> http://www.o-xml.org/spec/langspec.html
>
> (display "hello world")
> becomes
> <display content="hello world" />
>
> lacks some elegance :(
Some? What would (display foo) become? Certainly an attribute isn't
appropriate anymore, and XML doesn't have complex (non-text) attributes.
Talk about foresight in language design...
--
If you have to ask what jazz is, you'll never know.
Louis Armstrong