After a somewhat long journey that started with me thinking Lisp was a
dead language (why?) I have arrived at the conclusion that I want to
adopt Lisp/Scheme as my new development language/religion ;-)
Lisp appears to me to be somewhat unfriendly to someone developing
under Win32. As much as I would like to develop using SBCL it just
doesn't appear to be practical. I would love some help/advice on which
path to take and for that you will need some idea of my requirements.
1. Windows XP OS. (I may move to Linux some time in the next year or so
- still undecided).
2. Preferably free.
3. Potential to run under Linux with very little or no source code
changes. (See 1.)
4. Numerical and general code execution speed is fairly important to
me.
5. Decent GUI and graphics libraries or easy access to them. I will be
developing a charting package and some animations among other things.
6. Decent sockets + networking + web libraries.
7. Straight forward development environment.
8. Not too concerned about debuggers but a nice-to-have.
My own conclusions so far:
As much as I would like to stay in the "pure" Common Lisp environment
the only option I can see that comes close to meeting my requirements
is CLISP and I am almost certain that code performance (point 4. above)
will not be sufficient. From benchmarks I have seen it appears to me
about 5 times slower than the Scheme alternatives. (of course SBCL is
fantastic but not for Win32).
So that leaves me with Scheme. In Scheme there are I think 4
alternatives for me PLT, Bigloo, Gambit and Chicken.
PLT is brilliant for development environment, community, docs,
libraries etc but slooooow.
Gambit is probably a bit too spartan for me but has a lot of potential.
Bigloo and Chicken are very close but...
Chicken wins for me because it is probably only second to PLT in terms
of libraries, community etc. It has apparently about as fast execution
as Bigloo - which is much faster than CLISP and PLT.
So looks like I am a Chicken candidate.
What do people think?
I have a preference for Common Lisp, so Corman Common Lisp has worked
out very well. The free evaluation comes with full source for the
CormanLispServer COM component, even though it is commercial software.
My code is not directly portable to other environments, but I get to
use a version of lisp with a great FFI and great license. (The
evaluation even comes with the ability to create standalone .exe or
.dll programs!)
Sean SCC wrote:
> I have arrived at the conclusion that I want to
> adopt Lisp/Scheme as my new development language/religion ;-)
> What do people think?
"Lisp" is indeed like a religion. My apologies in advance to
non-Christians for the references which follow, but I just couldn't
help myself. ;)
Common Lisp is like the Catholic Church, with it's rich language and
history, and a standard Catechism it's followers can consult for
official answers. Scheme, in contrast, is the splintering of Protestant
denominations, the Reformation which sought to strip the faith of undue
formality and then couldn't agree amongst themselves on the details.
Sure they all share a common underlying faith and can call each other
"Listians", but a Sunday service at the First Methodist Church Of
Bigloo is a far cry from one at PLT Presbyterian, and both are even
further from a Mass at the Roman Catholic Cathedral of Common Lisp.
"Sean SCC" <···········@googlemail.com> writes:
> After a somewhat long journey that started with me thinking Lisp was a
> dead language (why?) I have arrived at the conclusion that I want to
> adopt Lisp/Scheme as my new development language/religion ;-)
>
> Lisp appears to me to be somewhat unfriendly to someone developing
> under Win32. As much as I would like to develop using SBCL it just
> doesn't appear to be practical. I would love some help/advice on which
> path to take and for that you will need some idea of my requirements.
>
> 1. Windows XP OS. (I may move to Linux some time in the next year or so
> - still undecided).
> 2. Preferably free.
> 3. Potential to run under Linux with very little or no source code
> changes. (See 1.)
> 4. Numerical and general code execution speed is fairly important to
> me.
> 5. Decent GUI and graphics libraries or easy access to them. I will be
> developing a charting package and some animations among other things.
> 6. Decent sockets + networking + web libraries.
> 7. Straight forward development environment.
> 8. Not too concerned about debuggers but a nice-to-have.
>
> My own conclusions so far:
>
> As much as I would like to stay in the "pure" Common Lisp environment
> the only option I can see that comes close to meeting my requirements
> is CLISP and I am almost certain that code performance (point 4. above)
> will not be sufficient. From benchmarks I have seen it appears to me
> about 5 times slower than the Scheme alternatives. (of course SBCL is
> fantastic but not for Win32).
>
> So that leaves me with Scheme. In Scheme there are I think 4
> alternatives for me PLT, Bigloo, Gambit and Chicken.
>
> PLT is brilliant for development environment, community, docs,
> libraries etc but slooooow.
> Gambit is probably a bit too spartan for me but has a lot of potential.
> Bigloo and Chicken are very close but...
>
> Chicken wins for me because it is probably only second to PLT in terms
> of libraries, community etc. It has apparently about as fast execution
> as Bigloo - which is much faster than CLISP and PLT.
>
> So looks like I am a Chicken candidate.
>
> What do people think?
Give the LispWorks Personal Edition (free and downloadable) a shot. I
haven't used it much but it appears that you can write once on any
platform and compile it for any other platform that LispWorks
supports. If you are doing serious development work (at present, I am
not), then it will be worth the price tag for the full edition when
you get ready to ship your product. If you are not doing serious
development work, then it may still be worth the money to you but the
Personal Edition should almost be mandatory for anyone in your
position to at least try out.
Sean SCC wrote:
> After a somewhat long journey that started with me thinking Lisp was a
> dead language (why?) I have arrived at the conclusion that I want to
> adopt Lisp/Scheme as my new development language/religion ;-)
>
> Lisp appears to me to be somewhat unfriendly to someone developing
> under Win32. As much as I would like to develop using SBCL it just
> doesn't appear to be practical. I would love some help/advice on which
> path to take and for that you will need some idea of my requirements.
>
> 1. Windows XP OS. (I may move to Linux some time in the next year or so
> - still undecided).
...cut...
> 3. Potential to run under Linux with very little or no source code
> changes. (See 1.)
> 4. Numerical and general code execution speed is fairly important to
> me.
> 5. Decent GUI and graphics libraries or easy access to them. I will be
> developing a charting package and some animations among other things.
> 6. Decent sockets + networking + web libraries.
> 7. Straight forward development environment.
> 8. Not too concerned about debuggers but a nice-to-have.
Lispworks.
...paste...
> 2. Preferably free.
Sounds like...
>
> What do people think?
>
...You do not quite have religion yet.
:)
hth, 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
On 15 Aug 2006 11:53:02 -0700, "Sean SCC" <···········@googlemail.com> wrote:
> After a somewhat long journey that started with me thinking Lisp was a
> dead language (why?) I have arrived at the conclusion that I want to
> adopt Lisp/Scheme as my new development language/religion ;-)
>
> Lisp appears to me to be somewhat unfriendly to someone developing
> under Win32. As much as I would like to develop using SBCL it just
> doesn't appear to be practical. I would love some help/advice on which
> path to take and for that you will need some idea of my requirements.
I think Windows programming under Common Lisp is very practical, although
you might reconsider the commercial options if you want/need fully-baked
solutions right away.
> 1. Windows XP OS. (I may move to Linux some time in the next year or so
> - still undecided).
> 2. Preferably free.
> 3. Potential to run under Linux with very little or no source code
> changes. (See 1.)
> 4. Numerical and general code execution speed is fairly important to
> me.
> 5. Decent GUI and graphics libraries or easy access to them. I will be
> developing a charting package and some animations among other things.
> 6. Decent sockets + networking + web libraries.
> 7. Straight forward development environment.
> 8. Not too concerned about debuggers but a nice-to-have.
My focus is on UI programming at this stage (I am writing a UI library
for Windows). I have personally worked with CLISP, LispWorks personal
edition, and most recently SBCL. I've experimented with Corman
and Allegro (the latter not in connection with my library project,
though).
If you haven't already, take a look at this page at CLiki:
http://www.cliki.net/Common%20Lisp%20implementation
There are a number of portable UI libraries in various stages of
completion available. I'd recommend either LTk or cells-gtk
since they are ready to use. There is also wxCL which could
use help.
Again, a CLiki pointer for your reference:
http://www.cliki.net/Graphics%20Toolkit
You also should look around The Common Lisp Directory
(http://cl-user.net) for all kinds of CL software.
So, my summary of the situation right now is that if you go the
"free" route, you really need to be prepared to roll up your sleeves.
(Folks, please exercise restraint, I don't want to start that
flamewar all over again).
That's the route I have taken and I've learned a lot, so I'm glad to
have made that choice. But YMMV and that's why I suggested reconsidering
the commercial options. As another respondent pointed out, Corman is quite
affordable. If you read back through recent threads in this newsgroup, you
will find plenty of debate about what the benefits of a LW or Allegro
license are vs. the up-front license cost.
There isn't a clear and obvious answer, but there are many options.
> My own conclusions so far:
>
> As much as I would like to stay in the "pure" Common Lisp environment
> the only option I can see that comes close to meeting my requirements
> is CLISP and I am almost certain that code performance (point 4. above)
> will not be sufficient. From benchmarks I have seen it appears to me
> about 5 times slower than the Scheme alternatives. (of course SBCL is
> fantastic but not for Win32).
CLISP has by all reports very efficient bignum performance. SBCL is
running on Windows, and yeah it still has rough edges but they need
more folks to try it out and report problems (and contribute patches
or documentation, etc, etc).
--
Jack Unrue
http://common-lisp.net/project/graphic-forms
Sean SCC wrote:
> After a somewhat long journey that started with me thinking Lisp was a
> dead language (why?) I have arrived at the conclusion that I want to
> adopt Lisp/Scheme as my new development language/religion ;-)
Regarding PLT:
PLT is quite fast. Using the compiler can make it faster.
I've heard the new JIT version is good too.
Don't be fooled by DrScheme, which in terms of performance is one of
the nastiest programs in the universe. Try your code in proper
MzScheme or MrEd and you'll see it go much faster.
Regarding lisp:
You could also try ECL. I'm unaware of any MS Windows GUIs that are
beyond the experimental stages in the free CLs.
Le Wed, 16 Aug 2006 10:48:54 -0700, Rob Thorpe a écrit :
> I'm unaware of any MS Windows GUIs that are beyond the experimental
> stages in the free CLs.
In general, GTK+ bindings seem to work very well on any language with
Windows. Has someone tried a GTK+ binding there? Specifically, has
anyone tried Clg?
I'd suspect that It Just Works, if GTK+ is correctly installed and UFFI
knows how to get it.
Curiously,
Nowhere man
--
···········@levallois.eu.org
OpenPGP 0xD9D50D8A
From: Ken Tilton
Subject: Re: Best Lisp/Scheme for Windows development?
Date:
Message-ID: <ibOEg.34$fE5.12@newsfe11.lga>
Pierre THIERRY wrote:
> Le Wed, 16 Aug 2006 10:48:54 -0700, Rob Thorpe a écrit :
>
>>I'm unaware of any MS Windows GUIs that are beyond the experimental
>>stages in the free CLs.
>
>
> In general, GTK+ bindings seem to work very well on any language with
> Windows. Has someone tried a GTK+ binding there?
http://common-lisp.net/project/cells-gtk/
kt
--
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 is it about Scheme that makes it so popular, when it is so much
more limiting than Lisp?
Also, what is the deal about how the first item in a function call form
is evaluated differently than in Lisp? I don't quite get that.
"jmckitrick" <···········@yahoo.com> writes:
> What is it about Scheme that makes it so popular, when it is so much
> more limiting than Lisp?
Who said Scheme was more popular than Lisp?
http://googlefight.com/index.php?lang=en_GB&word1=scheme+cons+car+cdr&word2=lisp+cons+car+cdr
> Also, what is the deal about how the first item in a function call form
> is evaluated differently than in Lisp? I don't quite get that.
Basically, it's the difference between lisp-1 (scheme) and lisp-2
(Common Lisp, emacs lisp, etc).
To simplify, in a lisp-1, each symbol has only one value,
while in a lisp-2, each symbol has two values:
- a normal value (symbol-value sym),
- a function value (symbol-function sym).
So when you have a form such as (f a) in a lisp-1, there's no problem,
you get the only value of the symbol f (which must be a function), and
the only value of the symbol a, and call the function with the
argument.
But in a lisp-2, for (f a) we take the function value of the symbol f,
and the value value of the symbol a, and we call the function with the
argument.
In Scheme, (f a) <=> (funcall f a)
<=> (funcall (symbol-value 'f) (symbol-value 'a))
In Lisp, (f a) <=> (funcall (symbol-function 'f) a)
<=> (funcall (symbol-function 'f) (symbol-value 'a))
The practical consequence, is that in Lisp you can write:
(defun f (list)
(flet ((list (list) (list list list)))
(list list)))
and get (f 1) --> (1 1)
while in Scheme, it wouln't work, you'd have to write:
(define (f lst)
(let ((lyst (lambda (lst) (list lst lst))))
(lyst lst)))
And in Lisp, you have to use (function f) and (funcall fv a) to go
between the function name space and the value name space.
(All this, ignoring the fact that lexical scope is used, so it's not
the value slot of the symbols that is used in general (only for special
(dynamic) variables).
--
__Pascal Bourguignon__ http://www.informatimago.com/
"I have challenged the entire quality assurance team to a Bat-Leth
contest. They will not concern us again."
From: Pascal Costanza
Subject: Re: Best Lisp/Scheme for Windows development?
Date:
Message-ID: <4kikbjFcamblU1@individual.net>
jmckitrick wrote:
> What is it about Scheme that makes it so popular, when it is so much
> more limiting than Lisp?
Scheme is more popular only in certain circles. Its minimality and focus
and mathematically strict definitions (like the strict separation of all
types) makes it more useful to illustrate concepts and prove some of
their properties, so it's especially popular in academia.
> Also, what is the deal about how the first item in a function call form
> is evaluated differently than in Lisp? I don't quite get that.
That's one element of Scheme's minimality. Scheme has only namespace
(for variables) whereas Common Lisp has many (variables, functions,
blocks, go tags, catch tags, classes, etc.). If you introduce a concept
as a language extension in Scheme, it's likely that you only have to do
it once, whereas in Common Lisp there is a certain likeliness that you
have to at least consider the different namespaces.
Pascal
--
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
jmckitrick wrote:
> What is it about Scheme that makes it so popular,
I'm not tempted to describe Scheme as "so" popular, or even popular.
Heck, I'm not even tempted to describe Common Lisp as popular, as
compared to Python or Ruby or Java or C#. CL is more popular than
Scheme in general, but for my game development problems specifically,
neither is popular at all.
> when it is so much more limiting than Lisp?
I'm not seeing an inherent limitation. Everyone's got their own
problem domains; mine involve C FFIs, and there's nothing common about
C FFIs in Common Lisp. Every implementation has rolled their own. You
live and die by your implementation, and that's no different than the
Scheme universe. The open source offerings on Windows are much better
in the Scheme universe than the CL universe. If SBCL was ready for
prime time on Windows a year ago, I'd be using it. It wasn't, and
won't be for a year yet, and so I went with Chicken Scheme.
I've been shopping for usable, performance-oriented compilers on
Windows that talk well to C. I could care less whether it's Scheme,
Common Lisp, OCaml, etc. Just give me something better than C++ that
doesn't cost an arm and a leg to try out. Yeah, a year ago I might
have bought Corman Lisp for $250. But it looked like it was on its
last legs, and that's part of what scared me off. It's done a release
since then and I suppose it's healthier than I might have surmised.
But, now I'm doing Chicken Scheme. Historical accident. An
implementation's ability to attract and retain programmers is as
important a consideratin as anything else. It stands for things, like,
how much am I going to have to screw around with stuff to get things
working.
Cheers,
Brandon Van Every
Some entity AKA ·············@gmail.com" <············@gmail.com>
wrote this mindboggling stuff, while thinking about the OS-BBQ.
(selectively-snipped-or-not-p)
> What does it mean by "on its last legs" ??
>
Merely arithmatic, My dear Watson, mere arithmatic ...
a centipede devoured 98 of them.
cor
--
OSBBQ 9 SEPTEMBER 2006 http://osbbq.nl.linux.org/info.html
Gewoon omdat het lekker is
The morons` Lisp-implementation is a ruby python