At http://wiki.alu.org/Pascal_Costanza's_Road_To_Lisp
Pascal Costanza says:
I have learned considerably much about Common Lisp
in a relatively short amount of time. This is probably due
to the fact that I haven't started with toy examples but
attempted a rather large piece of software as a learning
device. This is because I have read amazing things about
Common Lisp everywhere, especially that you can write
software with it that you wouldn't even dare to write in other
languages. So I have decided to put it to the test.
All I can say is that I really recommend such an approach.
Many of Common Lisp's features only make sense for
programming in the large, and you can only get a feel for
those features by actually writing large programs.
So what is the smallest example you can come up with of a
programme which is large and complicated enough to appreciate
CL ?
On Mar 25, 6:43 am, Spiros Bousbouras <······@gmail.com> wrote:
> Athttp://wiki.alu.org/Pascal_Costanza's_Road_To_Lisp
> Pascal Costanza says:
>
> I have learned considerably much about Common Lisp
> in a relatively short amount of time. This is probably due
> to the fact that I haven't started with toy examples but
> attempted a rather large piece of software as a learning
> device. This is because I have read amazing things about
> Common Lisp everywhere, especially that you can write
> software with it that you wouldn't even dare to write in other
> languages. So I have decided to put it to the test.
>
> All I can say is that I really recommend such an approach.
> Many of Common Lisp's features only make sense for
> programming in the large, and you can only get a feel for
> those features by actually writing large programs.
>
> So what is the smallest example you can come up with of a
> programme which is large and complicated enough to appreciate
> CL ?
You have 3 options:
1. Take some project you coded in language you already know and
convert it to lisp.
2. Study implementation of library that you found interesthing.
3. Implement fibers.
Ok probably without third one.
slobodan
http://tourdelisp.blogspot.com
Spiros Bousbouras wrote:
> So what is the smallest example you can come up with of a
> programme which is large and complicated enough to appreciate
> CL ?
I think every application which has some real world benefit and where you
can test how multiple things works together. E.g. something like this:
http://www.frank-buss.de/formula/index.html
If you convert it to Lisp, you can learn a bit about how to implement a
formula evaluator, how to use a GUI for Lisp and how to bundle all into an
executable.
Another example, already in Lisp, but not the smallest I can think of:
http://www.frank-buss.de/lisp/aqueduct.html
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
From: Edi Weitz
Subject: Re: How big a programme to properly appreciate CL ?
Date:
Message-ID: <uprtiak9w.fsf@agharta.de>
On Tue, 25 Mar 2008 06:43:59 -0700 (PDT), Spiros Bousbouras <······@gmail.com> wrote:
> So what is the smallest example you can come up with of a programme
> which is large and complicated enough to appreciate CL ?
42.
--
European Common Lisp Meeting, Amsterdam, April 19/20, 2008
http://weitz.de/eclm2008/
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
Spiros Bousbouras <······@gmail.com> writes:
> At http://wiki.alu.org/Pascal_Costanza's_Road_To_Lisp
> Pascal Costanza says:
>
> I have learned considerably much about Common Lisp
> in a relatively short amount of time. This is probably due
> to the fact that I haven't started with toy examples but
> attempted a rather large piece of software as a learning
> device. This is because I have read amazing things about
> Common Lisp everywhere, especially that you can write
> software with it that you wouldn't even dare to write in other
> languages. So I have decided to put it to the test.
>
> All I can say is that I really recommend such an approach.
> Many of Common Lisp's features only make sense for
> programming in the large, and you can only get a feel for
> those features by actually writing large programs.
>
> So what is the smallest example you can come up with of a
> programme which is large and complicated enough to appreciate
> CL ?
Strong AI. ;-)
--
__Pascal Bourguignon__
On 25 Mar, 14:43, Spiros Bousbouras <······@gmail.com> wrote:
> So what is the smallest example you can come up with of a
> programme which is large and complicated enough to appreciate
> CL ?
Write some missing CL library, and maintain it over the next
decades...
-JO
Spiros Bousbouras wrote:
> So what is the smallest example you can come up with of a
> programme which is large and complicated enough to appreciate
> CL ?
It is certainly true that some things such as DSLs manifest themselves
only as a program gets big enough to have grown internal APIs, but when
you say "to appreciate CL", shucks, check my RtL, I figured it out while
loading the MCL manual chapters into the binder.
kt
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
"In the morning, hear the Way;
in the evening, die content!"
-- Confucius
On Mar 25, 1:43 pm, Spiros Bousbouras <······@gmail.com> wrote:
> Athttp://wiki.alu.org/Pascal_Costanza's_Road_To_Lisp
> So what is the smallest example you can come up with of a
> programme which is large and complicated enough to appreciate
> CL ?
It's often said that Common Lisp really shines when used for large
projects but this shouldn't detract from the fact that it's well
suited to smaller programs too.
I find myself using Lisp more and more as my scripting and prototyping
language as well as my preferred day to day "real" programming
language. I know there are others who do the same. Previously I had
used Python for this, which does have the advantage of shipping with
lots of libraries. But once you have ASDF set up and a well populated
set of systems this becomes a non-issue.
(Sure, we can't always compete with the "pure functional" people and
their 5 line maths puzzles...unless someone's feeling brave and
threatens to write "their" language as a macro or two!).
--
Phil
http://phil.nullable.eu/
On Mar 26, 1:51 am, ···············@gmail.com wrote:
> (Sure, we can't always compete with the "pure functional" people and
> their 5 line maths puzzles...unless someone's feeling brave and
> threatens to write "their" language as a macro or two!).
Embedding language in lisp is piece of cake (usually) but integrating
them ...
that's not so easy.
>
> --
> Philhttp://phil.nullable.eu/
Spiros Bousbouras <······@gmail.com> writes:
> So what is the smallest example you can come up with of a
> programme which is large and complicated enough to appreciate
> CL ?
I suspect that the name-space management provided by the
packages is more heavy duty than a individual programmer
really needs, and only shines at full brightness when
several programmers are working full time. The reason I say
this is because of the pick-and-mix way that inheritance
works. An individual programmer can use the package system
to organise his own code, with some of his private packages
exporting symbols to others of his private packages, then he
can create another package that exports selected symbols to
his colleagues.
Same for the condition system. It establishes a protocol for
reporting and handling exceptions. Though it is a
complicated protocol it seems to have evolved through "war
story push". There were big projects, with many programmers,
in earlier dialects of Lisp, and simpler condition systems
didn't cut it. You are unlikely to face these difficulties
on your own, because extending an ad hoc protocol works
fairly well when it is just you, and only becomes an
embarrassing source of quarrels and misunderstandings when
the members of a big team start working at cross purposes.
Sometimes people post on c.l.l. asking if Common Lisp is
suitable for large projects. This surprises me. Some CL
features scream "Big Team" and I only understand them when I
reminisce about working on Blue Fox with 300 others
engineers.
Alan Crowe
Edinburgh
Scotland