About 2 weeks ago, I posted a question about which language - CL or
Scheme - would be better for my purposes. Since the post, I received
many e-mail replies as well as reply posts on the news group. Because
some people wanted to know what other people think on the topic, I am
posting the summary of e-mails I received. I also archived the news
group thread, but I didn't included it here.
First of all, thanks a lot to all of you who replied me via e-mail or on
the news group. The LISP/Scheme community was really helpful and kind to
me. But even with the help I couldn't determine which language to use yet,
because among the 10 e-mail replies I received, 4 people recommended to use
CL and 6 people recommended Scheme.
So I am studying the topic myself now - which I have had do from the start
anyway. I bought 2 books:
* SICP (2nd Ed.), to learn what functional programming is like.
* CLtL2, to find out what additional functionality CL has compared to Scheme.
Followings are the replies I received. In some cases, I edited out some
lines to avoid duplications and if there are any misinterpretations due to
the omissions, all the responsibility is mine.
Best regards,
------------------------------------------------------------------------------
Yunho Jeon Tel: +82-2-880-6482~90 ext) 416
Intelligent Control Lab +82-2-875-9183
School of Electrical Engineering Fax: +82-2-888-4182
Seoul National University, Korea Email: ·····@csl.snu.ac.kr
===========================================================================
From: ········@wavehh.hanse.de (Martin Cracauer)
Hello,
first of all, let me say that I'm interestedt in this, too. Would you
please tell me what you hear from others? Thanks.
In comp.lang.lisp you write:
>1) Which language is easier to learn (for C/C++ programmer)?
> Scheme seems to be easier because it is much smaller than common lisp,
> but how big is the difference (in terms of learning curve)?
The difference is giantic. It will take about two year to learn CL up
to a level of being familar with most constructs used in current
applications.
On the other hand, every non-trivial application in Scheme will
introduce a number of (maybe much superiour in the application domain)
replacements for standard CL constructs and when you read such
sources, you might have to spend a lot of extra time becoming familar
with those maybe worse-documented self-made constructs.
Personally, I found that CL was very hard to learn until I reached a
level where I didn't miss to use proper constructs in the right place
(I'm not sure I readed it now). On the other hand, while it is easier
not to miss Scheme features, I found that Scheme saves you nothing
after all, since you will write some complex stuff yourself and/or you
will have have to understand those stuff from other people.
Scheme will get better if you're up to the perfect thing, when you
write all your constructs in optimal form for your application domain,
when you start using your own macro system and parse your code. But at
least I am far away from that level. CL's constructs are usually good
enough for me.
I think the best way to find out is to learn some of the additional
features CL has over Scheme:
- multi-value symbols
- setf
- reader macros
- complex lambda lists
- compilation and declarations
- additional data types
Just look these up in a good book on Common Lisp ("ANSI CL" or CLtL2)
and see if you can master these, if you find it them useful, and - if
so - you find them worth the additional complexity.
Additonally, look up some of the existing free software for CL and
Scheme. Both have many GUI toolkits. CL has Screamer, Scheme has
QobiScheme. Look at OO toolkits. Reading the source you will pretty
easy get the idea how people use these languages. See what usage fits
your mind better.
>2) The command to parse and execute a source program is 'eval', right?
> If it is, is it a standard feature of Scheme? The Scheme FAQ was not
No, but you can write code out and use (read ...). In my opinion, that
shows in extreme where Scheme folks sometimes loose every focus on
performance that might ever had.
> very clear on this point. Surely some implementations have it, but
> the language seems to be more suited for compilers. Does the run-time
> has embedded compiler? What's the overhead of it (size/speed)?
> If I can't use compiler for my purposes, what do I lose and how much
> (again in terms of speed)?
Another very weak point about Scheme. Most implementations are very
slow and don't have a useful compilation Scheme. Others have a
comiler, but don't allow you to write out compiled files! Scheme48 and
therefore scsh do. They (byte-)compile a file everytime it is read
in. This is of course best seen in the semantics of the language, but
again a case where some Scheme folks - in my opinion - did screw up
performance.
If you need a decent compiling support in you application (maybe to
optimize in ways Peter Norvig points out in his book by comiling data
to new functions and compile these), then you are probably better off
using Common Lisp.
>3) What about foreign language (C/C++) language interface and GUI's?
> It's not essential for now, but it may be needed in future.
In general, all implementations of CL and Scheme have those. I found
the Common Lisp interfaces much more elegant. While most Scheme
implemenations require you to convert data types by writing one
additional C function to interface to you "real" C functions, most
Common Lisp implementations can model the foreign data inside the Lisp
runtime.
>4) I am going to use Linux as the experiment platform, and don't want to
> buy any commercial software - I'm only a student and it's hard to buy
> and get support of such a software in Korea, where I live.
> Both language has a lot of free implementations, but are they mature
> enough?
Sure. CMUCL is great, gcl and clisp maybe, too. Scheme-wise, you might
want to choose by the application domain a Scheme implemenations is
made for, most have a clear focus. While many Scheme tools are
excellent for one problem domain, I found it very difficult to find an
implementation that can take *all* the good stuff.
You didn't ask, but besides from missing reader macros I found the
greatest disadvantace of Scheme is lack of declarations. Those are
needed to produce efficient numerical code, for example. Some Scheme
implemenations violate the Scheme standard by assuming certain data
type limitations by themself (i.e. Bigloo) to get decent
performance. That's inacceptable.
Before I close, let me say that *some* Scheme folks are clearly up to
do things right. The MIT Scheme implementation, the things Jeff
Siskind wrote, Scsh and others are all excellent in their domain and
most critique I listed don't apply to these in special. But *overall*,
I found the CL community to be more on focus when it comes to actually
produce tools for a somewhat "normal" programmer (who need to reuse
language library things, who need decent performance and who needs to
put a lot of different things in one application).
Feel free to contact me if you have further questions. And please let
me know what other people think about these issues.
Martin
--
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
···············@wavehh.hanse.de http://cracauer.cons.org Fax.: +4940 5228536
"As far as I'm concerned, if something is so complicated that you can't ex-
plain it in 10 seconds, then it's probably not worth knowing anyway"- Calvin
===========================================================================
From: ······@MATH.Purdue.EDU (Brad Lucier)
I really like gambit-c, a Scheme to C compiler and interpreter
that runs great on Linux. Get it from ftp.iro.umontreal.ca,
directory pub/parallele/gambit. It has the other things you would
like, too.
Brad Lucier ······@math.purdue.edu
===========================================================================
From: Dominique Boucher <········@IRO.UMontreal.CA>
Hi,
1) IMHO, Scheme is much simpler to learn than Lisp. It has fewer
concepts (the standard is only 80 pages long) and allows for faster
implementations.
2) No, eval is not a standard Scheme procedure. But one way to
circumvent this is to generate closures (functions) instead of
s-expressions (Scheme expressions). The generated code will run much
faster.
3) It depends on the compiler you use. Gambit-C is a very nice Scheme
compiler/interpreter and has a C interface that is very well designed.
4) Gambit-C runs on a lot of platforms. I run it on Linux and Windows
95, Alpha/AXP, Sparc. It is a very mature implementation. It has been
integrated in a few commercial softwares. It supports dynamic loading,
the full numerical tower, unicode strings and files. It can be used in
interactive mode or as a batch compiler. In a word, it is the best
Scheme interpreter/compiler I know. And it is free:
http://www.iro.umontreal.ca/~gambit
--Dominique
+------------------------------------------+-------------------+
| Dominique Boucher, M.Sc. | //\\ |
+------------------------------------------+ \\ |
| L a m b d a S o f t | /\\ |
| Software Consultant | S/O F\T |
| Functional Programming Systems and Tools | // \\// |
+------------------------------------------+-------------------+
===========================================================================
From: ······@cam.cornell.edu (Won Gyu Choe)
Hello, if I'm correct, you're the micro mouse guy, right?
In article <···················@csl.snu.ac.kr> you wrote:
: 1) Which language is easier to learn (for C/C++ programmer)?
Let me point out that there are actually *two* things you have to learn.
The first one is the functional programming style - whichever language
you may use. The second is the target language (scheme or lisp) itself.
These two are not independent, actually, for you have to choose a langauge
to practice the functional style.
In any case, I *strongly* recommend to start in Scheme. It's simple,
clear and do not have any nasty redundancy that lisp suffers from.
If you are planning to build an expert system or huge relational database,
Lisp would be the choice. But if you just want to write a hundreds lines
of codes in a couple of months, Scheme is the better.
: 2) The command to parse and execute a source program is 'eval', right?
: If it is, is it a standard feature of Scheme? The Scheme FAQ was not
: very clear on this point. Surely some implementations have it, but
: the language seems to be more suited for compilers. Does the run-time
: has embedded compiler? What's the overhead of it (size/speed)?
: If I can't use compiler for my purposes, what do I lose and how much
: (again in terms of speed)?
I don't think I have clearly understand this question, but let me try
to explain. Eval is *not* in standard scheme. Rather, there is "apply".
It works like this. Suppose you want to evaluate (+ 3 4).
LISP --> (eval '(+ 3 4)) --> blind eval!
SCHEME --> (apply + '(3 4)) --> apply procedure to argument list.
Tricky? I feel like apply is a sort of low-level eval. Of course,
one may build eval from apply.
: 3) What about foreign language (C/C++) language interface and GUI's?
: It's not essential for now, but it may be needed in future.
It depends on the scheme implementation. These scheme implementations
have FFI(Foreign function interface).
MzScheme from Rice University --- C,C++[in limited context]
scm of Aubry Jaffer -- C
Elk, mainly for X window interface -- C
guile scheme of GNU -- C
I am using MzScheme - it's nice. It has *clean* extension mechanism.
For GUI part, perhaps STk (scheme + Tk) would be the only one having
built-in GUI. But you can bind the GUI's using extension mechanism, but
it's not an easy one. I am currently using MzScheme + XView extension.
: 4) I am going to use Linux as the experiment platform, and don't want to
: buy any commercial software - I'm only a student and it's hard to buy
: and get support of such a software in Korea, where I live.
Sure. I strongly suggest you to start with Aubry Jaffer's scm(can be
found in Jacal package), or Rice University's MzScheme. MIT Scheme is
just a huge idiot, avoid it.
Please feel *extremely* free when you have questions. --- WG.
Choe, Won-Gyu
Center for Applied Mathematics
Cornell University
===========================================================================
From: "Choi jong won (DM-4338-96.8.1)" <······@gsen.goldstar.co.kr>
Hi,
> 1) Which language is easier to learn (for C/C++ programmer)?
> Scheme seems to be easier because it is much smaller than common lisp,
> but how big is the difference (in terms of learning curve)?
Rainer's opinion is right. Scheme has some experiment aspects, CL(Common
Lisp) has some industrial strength. You should consider your application first,
IMHO. Many Lisp programmers can speak CL and Scheme also.
>
> 2) The command to parse and execute a source program is 'eval', right?
> If it is, is it a standard feature of Scheme? The Scheme FAQ was not
> very clear on this point. Surely some implementations have it, but
> the language seems to be more suited for compilers. Does the run-time
> has embedded compiler? What's the overhead of it (size/speed)?
> If I can't use compiler for my purposes, what do I lose and how much
> (again in terms of speed)?
Do you know Lisp's nature? If you expect small sized fast code, it's not for
Lisp. Typical applications included Lisp system itself(blur dvelopement system
and applications). IMHO, Lisp is for large, complex, non
trivial things(for example, dynamic fetch is possible). Of course, some Lisp
wizards can write Lisp codes even beat some C codes.
Commercial Lisp systems don't have compiler when a user dumps delivery system.
Free softwares like GCL(Gnu Common Lisp) and CMU CL have the compiler still,
maybe. NOTE: Lisp's compiler is a function call like:
(compile-file "my-lisp.lsp") There is another function to compile a function.
>From Lisp book(I don't remember the title exactly. Gentle introduction ...
maybe), 2-100 times faster when it is compiled than interpreted(there is a
function call (time ) to calculate this situation, BTW.
> 3) What about foreign language (C/C++) language interface and GUI's?
> It's not essential for now, but it may be needed in future.
Rainer is right, again. FFI(foreign function interface) is not a standard yet.
But typical Lisp systems(including Scheme implementation) has their FFI.
GUI. Are you serious? Then there are great thing in Lisp. CLIM(Common Lisp
Interface Manager). It's not free unfortunately. But there is some movement
to implement free CLIM. See http://cracauer.cons.org
CLIM is OOUI(Obeject Oriented User Interface) written about 10 years ago!
>
> 4) I am going to use Linux as the experiment platform, and don't want to
> buy any commercial software - I'm only a student and it's hard to buy
> and get support of such a software in Korea, where I live.
> Both language has a lot of free implementations, but are they mature
> enough?
Rainer also right. Franz's Allegro CL for Linux is for you. Franz is one of
the best Lisp companies.
But you can't expect things like:
CLIM, delivery system generator, compiler system in runtime of your
application, and so on.
Final words. To learn Lisp pick these books(I think your library also be a
good source :-)
* Basic Lispy things
o Little Schemer
o Seasoned Schemer
* Powerful Lispy things(all Lispers have to get this)
o Structure and Interpretation of Computer Programs(aka SICP) the best CS book
* Your reference, all the time
o Common Lisp the Language 2nd ed.(aka CLtL2) (all Lispers have to get this)
o Common Lisp the Reference (aka CLtR)
* Modern Lisps
o Ansi Common Lisp (you can pick it up from Kyobo or Jongno maybe)
o On Lisp (For mastering macros)
* Lisp OOPs
o Object Oriented Programming in Common Lisp - be a CLOS user
o The Art of Meta Object Protocol(aka AMOP) - be a CLOS developer
* If you are a really serious person want to be a Lisp wizard.
o A full set of Symbolics Lisp Machine Manuals
> Thanks for any helps in advance.
> Best regards,
Good luck!
- Jong-won Choi
===========================================================================
From: Chris Bitmead <·············@alcatel.com.au>
>1) Which language is easier to learn (for C/C++ programmer)?
> Scheme seems to be easier because it is much smaller than common lisp,
> but how big is the difference (in terms of learning curve)?
Scheme is easier, but LISP and Scheme are similar enough, that it
won't make that much difference. Personally I find there are things in
LISP that don't make a lot of sense to me, so I'm glad I learnt
Scheme.
>2) The command to parse and execute a source program is 'eval', right?
> If it is, is it a standard feature of Scheme? The Scheme FAQ was not
> very clear on this point. Surely some implementations have it, but
> the language seems to be more suited for compilers. Does the run-time
> has embedded compiler? What's the overhead of it (size/speed)?
> If I can't use compiler for my purposes, what do I lose and how much
> (again in terms of speed)?
It's not an official standard. (The standard is called R4RS). But
there is a preliminary discussion around which was meant to become
R5RS, which mentions eval. Basicly every version of Scheme probably
has it, and probably they work the same, but not necessarily.
>3) What about foreign language (C/C++) language interface and GUI's?
> It's not essential for now, but it may be needed in future.
It's not standard for either LISP or Scheme. Many versions have a C
interface though.
>4) I am going to use Linux as the experiment platform, and don't want to
> buy any commercial software - I'm only a student and it's hard to buy
> and get support of such a software in Korea, where I live.
> Both language has a lot of free implementations, but are they mature
> enough?
Oh yes. There are many very robust and stable versions of both.
Personally I think Scheme is a good choice for you.
===========================================================================
From: Sascha Ziemann <···@aibon.ping.de>
Yunho Jeon wrote:
> languages, I would like to get answers from LISP/Scheme experts
> for the following questions.
I'm no expert but I think I can give you also some hints.
> 1) Which language is easier to learn (for C/C++ programmer)?
> Scheme seems to be easier because it is much smaller than common lis=
p,
> but how big is the difference (in terms of learning curve)?
I think Scheme is the right choice. The FSF uses Scheme as an extension
language. If you learn Scheme you can use it for some other things, too.
> 2) The command to parse and execute a source program is 'eval', right?
> If it is, is it a standard feature of Scheme?
No, but everyone has it.
> The Scheme FAQ was not
> very clear on this point. Surely some implementations have it, but
> the language seems to be more suited for compilers. Does the run-tim=
e
> has embedded compiler? What's the overhead of it (size/speed)?
> If I can't use compiler for my purposes, what do I lose and how much
> (again in terms of speed)?
>=20
> 3) What about foreign language (C/C++) language interface and GUI's?
> It's not essential for now, but it may be needed in future.
With Guile you can use Tk.
> 4) I am going to use Linux as the experiment platform, and don't want t=
o
> buy any commercial software - I'm only a student and it's hard to bu=
y
> and get support of such a software in Korea, where I live.
> Both language has a lot of free implementations, but are they mature
> enough?
The FSF wants to create the best extension language and they develop
Guile. I think if they code something, one can trust.
For me Guile works fine.
-- bis sp=E4ter...
- Sascha ---<~>=3D( http://www.ping.de/sites/aibon/ )=3D<~>---
() Free speech online
/\ http://www.eff.org/BlueRibbon/bluehtml.html
===========================================================================
From: Ken Harding <·······@Franz.COM>
Dear Yunho,
I saw your posting on the newsgroups inquiring whether Lisp or Scheme would
be the easiest/best to learn and I wanted to touch base with you as I work
for Franz, Inc., the leading Lisp vendor. We have available a free,
un-crippled version of our Allegro Common Lisp for the Linux platform. So
you may try it out and compare it to the Scheme implementations out there.
For all intents and purposes, Scheme is a subset of lisp, with somewhat less
functionality and capabilities. Where scheme tends to be used more in
teaching only, Lisp is used for teaching, research and commercial
applications. Please see below for other comments inserted into your
message to the newsgroups (which I see you have already received an answer).
As the Lisp community is relatively small, I try to keep in touch with
any/all hackers in my territory. Are you interested in
getting your name put onto our mailing list? We send out quarterly
which outlines Franz' activity in the industry in addition to new
product announcements and selected 3rd party application stories.
I have your address, so if you would answer a few questions I would be
happy to send the Linux CD-ROM out to you. In what area is your development
concentrated? Do you have delivery plans for your application?
What other languages, software products have/do you use in conjunction with
your CL development/research?
Thanks in advance for taking the time to read this message. I hope
that you will be so kind to respond either way. Please let me know if
you have any questions regarding Allegro CL. I have also enclosed a
brief product description for your review at the end of this message.
>1) Which language is easier to learn (for C/C++ programmer)?
> Scheme seems to be easier because it is much smaller than common lisp,
> but how big is the difference (in terms of learning curve)?
--> Many of our customers had given us the feedback that a good C or C++
programmer can be writing code relatively quickly (2-3 weeks) and with some
work can be relatively capable after 2-3 months.
>3) What about foreign language (C/C++) language interface and GUI's?
> It's not essential for now, but it may be needed in future.
--->Allegro has a FFI to C, which can then be used to couple to C++. For
the future we are working on a direct C++ foreign function interface.
>4) I am going to use Linux as the experiment platform, and don't want to
> buy any commercial software - I'm only a student and it's hard to buy
> and get support of such a software in Korea, where I live.
> Both language has a lot of free implementations, but are they mature
> enough?
--->Our Linux lisp is essentially the lisp that we sell into the market,
Allegro CL 4.3, it is our standard version. This is a very robust and
mature flavor of Lisp. The Linux version, however, is not supported unless
one pays for maintenance.
There are universities all over the world who license the Allegro Common
Lisp environment for teaching and research. It is not only used at the
university level, but in the international business arena as well, where
very large companies use it in a very wide variety of ways.
For more information on this, please see our web page at: http://www.franz.com
Thanks in advance for reading this long message. I hope that these comments
help in your decision. If you have any questions please feel free to
contact me anytime.
Cheers,
Ken Harding
Franz Inc.
·······@franz.com
--------------------------------
<Information about Allegro CL 4.3 omitted - yunho>
* * * * * * * *
Ken Harding * * * * * * 1995 University Ave
Account Manager * * * * * * Berkeley, CA 94704
Franz Inc. * D Y N A M I C * * * * * Tel: (510) 548-3600
·······@franz.com * * * * * (888) CLOS NOW
http://www.franz.com * * * * * Fax: (510) 548-8253
* * * * *
===========================================================================
From: Clemens Heitzinger <········@student.tuwien.ac.at>
>>>>> "Yunho" == Yunho Jeon <·····@csl.snu.ac.kr> writes:
Hello!
Yunho> 1) Which language is easier to learn (for C/C++
Yunho> programmer)? Scheme seems to be easier because it is much
Yunho> smaller than common lisp, but how big is the difference (in
Yunho> terms of learning curve)?
Usually, you don't need all the functions that Common Lisp provides.
When you learn it, you should start with a good book to get an
overview. As time goes by, the set of functions you use increases,
but I am pretty sure that nobody really uses (or needs) *all* of them.
In my opinion, Common Lisp is much easier to use for large (or real
world) programs: e.g., it has sophisticated I/O routines, which Scheme
lack.
Yunho> 2) The command to parse and execute a source program is
Yunho> 'eval', right? If it is, is it a standard feature of
Yunho> Scheme? The Scheme FAQ was not very clear on this
Yunho> point. Surely some implementations have it, but the
Yunho> language seems to be more suited for compilers. Does the
Yunho> run-time has embedded compiler? What's the overhead of it
Yunho> (size/speed)? If I can't use compiler for my purposes,
Yunho> what do I lose and how much (again in terms of speed)?
CL implementations provide eval. Scheme implementations don't have
to. Most implementations come with interpreters and compilers.
Yunho> 3) What about foreign language (C/C++) language interface
Yunho> and GUI's? It's not essential for now, but it may be
Yunho> needed in future.
Many implementations have ffi's, some let you have access to tk.
Yunho> 4) I am going to use Linux as the experiment platform, and
Yunho> don't want to buy any commercial software - I'm only a
Yunho> student and it's hard to buy and get support of such a
Yunho> software in Korea, where I live. Both language has a lot
Yunho> of free implementations, but are they mature enough?
These are the CL implementations that you should have a look at:
CLISP: (http://ma2s2.mathematik.uni-karlsruhe.de)
Clean, fast bignums, but the (byte) compiler is not always the
fastest. Can also easily be used for shell scripts.
CMU CL:
Has recently been ported to Linux. Very, very *LARGE*. You need at
least 32 MB. Quite good, but it seems that the development has
stalled.
Allegro CL: (commercial) (http://www.franz.com)
They have started to distribute an uncrippled version for *free* (even
shippment). I have not had a close look at it, but it's certainly
professional. However, you are not allowed to do commercial
development with this version (without license). You have to pay for
the GUI (CLIM).
Gnu Common Lisp:
Well, not too bad, but still doesn't have the loop macro.
ECL: (http://ftp.di.unipi.it/pub/lang/lisp)
A decendant of GCL, but I still have problems with the compile-command
(ELF-related, probably). If working, probably great for connecting
C/C++ -- Lisp.
The problem with Scheme implementations is, that each one provides
extensions to the language which are not consistent with other
implemenations. So when you want to use another implementation, you
have to change some code. In CL, almost everything is standardized,
so you seldom have this problem. Well, check out both.
Hope this helps,
Yours,
Clemens Heitzinger
--
----------------------------------------------------------------------
Clemens Heitzinger ········@fbma.tuwien.ac.at
Stud. Techn. Math. Technische Universit�t Wien
University of Technology, Vienna, Austria
----------------------------------------------------------------------
===========================================================================
From: Clemens Heitzinger <········@student.tuwien.ac.at>
Well, I am certainly not a die hard CL fan, but you should also
consider this: If you want to do OO programming, CL is probably the
better choice, because CLOS (the OO part of CL) is standardized,
whereas for Scheme, there exist some, not standardized extensions,
which are more or less bound to the particular implementation.
Yours,
Clemens
--
----------------------------------------------------------------------
Clemens Heitzinger ········@fbma.tuwien.ac.at
Stud. Techn. Math. Technische Universit�t Wien
University of Technology, Vienna, Austria
----------------------------------------------------------------------
===========================================================================
From: Jeff Dalton <····@aiai.ed.ac.uk>
A while back, ·····@csl.snu.ac.kr (Yunho Jeon) asked:
I have some idea to experiment with, and the idea needs a language
which can execute codes produced by the program itself. Naturally, I
thought LISP would be the best choice. But while reading LISP FAQ, I
found that there are some varients of the language. Notably, Scheme
seemed to be more modern and cleaner language than LISP. Because I
have almost no experience in those languages, I would like to get
answers from LISP/Scheme experts for the following questions.
1) Which language is easier to learn (for C/C++ programmer)?
Scheme seems to be easier because it is much smaller than common lisp,
but how big is the difference (in terms of learning curve)?
······@netcom.com (Will Hartung) replied:
Frankly, I would say that Lisp would be easier to learn than Scheme
for an C/C++ programmer.
Scheme is a lovely, elegant language, and is, I believe simpler and
easier to learn in its own right. It is hard not to like Scheme. But,
for someone who has a lot of history with C/C++, the way Scheme is
presented could throw you for a loop. [...]
The "Scheme Way" of programming is very functional, lots of recursion,
local helper functions, etc. It is really a pretty nice way to go
about task of coding. However, its not the way MOST people
(particularly C/C++ people) write code. The idioms are all wrong.
If you look at how Lisp is presented, especially in something like
Paul Grahams "ANSI Common Lisp" book, it is easier to see the how your
entrenched C/C++ idioms translate into Lisp syntax and structures.
I don't know which language (Scheme or Common Lisp) would be easier
to learn for a C/C++ programmer, but Scheme is *much* smaller, greatly
reducing the "which subset do I learn?" problem.
In any case, the question remonded me of something I saw here a
while back, namely a table of approximate translations between
Scheme and C++. I've put a link to a copy in
http://www.aiai.ed.ac.uk/~jeff/scheme/
along with a link to a Scheme quick-reference (also posted here a
while back).
-- jeff
>CMU CL:
>Has recently been ported to Linux. Very, very *LARGE*. You need at
>least 32 MB. Quite good, but it seems that the development has
>stalled.
CMUCL development is very active these days. See
http://www.cons.org/cmucl
16 MB is fine as long as you don't try a big Lisp GUI system like
Garnet or one of the CLOS-based GUIs. This number assume there's no
other memory hog one the box (Netschrapel Navigator etc).
Martin
--
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
···············@wavehh.hanse.de http://cracauer.cons.org Fax.: +4940 5228536
"As far as I'm concerned, if something is so complicated that you can't ex-
plain it in 10 seconds, then it's probably not worth knowing anyway"- Calvin
On 3 Feb 1997 01:48:15 GMT, Yunho Jeon <·····@csl.snu.ac.kr> wrote:
>some people wanted to know what other people think on the topic, I am
>posting the summary of e-mails I received. I also archived the news
I have made a great mistake by posting e-mails I received without asking
to the senders. I assumed (wrongly) that people wrote me e-mails instead
of follow-up articles because they didn't want to waste bandwidth
and I thought that it would help others if I summarize them and post it.
But I should have asked first to the writers whether they like their mails
to be posted or not. After I posted the summary someone complained that
he wrote me e-mail instead of posting follow-up article because he didn't
want to be involved in a language flame war.
I am really sorry about this and I apologize to all people who tried
to help me.
Please *DON'T FOLLOW UP* the summary I previously posted. Even if you
have different opinion or think that something is wrong in the summary,
please don't try to follow up or write e-mails to the original writers.
All responsibility is mine, so please complain me (via private e-mail)
if you think there's any problem.
------------------------------------------------------------------------------
Yunho Jeon Tel: +82-2-880-6482~90 ext) 416
Intelligent Control Lab +82-2-875-9183
School of Electrical Engineering Fax: +82-2-888-4182
Seoul National University, Korea Email: ·····@csl.snu.ac.kr
On 3 Feb 1997 01:48:15 GMT, Yunho Jeon <·····@csl.snu.ac.kr> wrote:
>some people wanted to know what other people think on the topic, I am
>posting the summary of e-mails I received. I also archived the news
I have made a great mistake by posting e-mails I received without asking
to the senders. I assumed (wrongly) that people wrote me e-mails instead
of follow-up articles because they didn't want to waste bandwidth
and I thought that it would help others if I summarize them and post it.
But I should have asked first to the writers whether they like their mails
to be posted or not. After I posted the summary someone complained that
he wrote me e-mail instead of posting follow-up article because he didn't
want to be involved in a language flame war.
I am really sorry about this and I apologize to all people who tried
to help me.
Please *DON'T FOLLOW UP* the summary I previously posted. Even if you
have different opinion or think that something is wrong in the summary,
please don't try to follow up or write e-mails to the original writers.
All responsibility is mine, so please complain me (via private e-mail)
if you think there's any problem.
------------------------------------------------------------------------------
Yunho Jeon Tel: +82-2-880-6482~90 ext) 416
Intelligent Control Lab +82-2-875-9183
School of Electrical Engineering Fax: +82-2-888-4182
Seoul National University, Korea Email: ·····@csl.snu.ac.kr