Lisp vs. Common Lisp
in [Lisp]
|
Prev: 2010 world cup Spain jerseys,paypal payment and free shipping
Next: An instructive example of trace-function and some example of debugging
From: Eric S on 12 Jun 2010 14:45 Simon <o.simon(a)gmail.com> wrote in news:a08412a9-16a6-4b11-ba4f- fad745d4526f(a)g39g2000pri.googlegroups.com: > One comment I find a lot when people talk about Lisp is that Lisp is > wonderful, but CL has a lot of problems (problems I cannot understand > due to my newbieness). Now, I don't want to learn the wrong Lisp. The problems people perceive in CL are mostly caused by not learning it very well. It's extremely powerful, but you have to understand a lot of abstract ideas to really understand it in depth and be able to make the best use of it. The majority of the people on the planet, programmers and otherwise, are reluctant to learn anything, much less CL. It's much easier to make excuses against CL than learn it. That's close to the exact meaning of the metaphor "sour grapes". Imagine a company with a million programmers, all willing and able to learn. Would that company be well served by writing their own compilers etc. for whatever language they use? Yes, because they have a million programmers, the cost of doing things in house to make those programmers more cost effective, is divided by a million. By writing their own compilers they get more control and ability to quickly fix whatever problems they encounter in their compilers etc. Now imagine that same company works to make their programming language more sophisticated, by adding new features to that language and their compiler for it. Those new features can make those million programmers even more productive. It's far better in a situation like that to spend more on the compiler than to have all the programmers work around its limitations. CL is like that. The compiler, etc., are far more costly to develop, but you get a lot more. And if a million programmers use them, you come out way ahead. But we don't need a million programmers, because CL has been under development for decades, and was launched in a time when it got major funding from government. So we effectively get most of the compilers etc. as if they were free, or as if we could divide the cost among a million programmers. When someone invents a new programming language now, from scratch, they don't make it anywhere near as sophisticated as CL. It would take too much time and effort. So CL is really our only chance to be able to use such powerful and sophisticated programming tools. So some people love CL and some people hate it. They see the same thing from different points of view. Some say "whoa, treasure beyond my wildest dreams", and others say "whoa, what a mess, let's start over from scratch and invent something cleaner." Those who start over from scratch to invent something cleaner but equally powerful, spend years at it, sometimes their whole lives, and usually end up making their own mess, much worse than CL, and less powerful.
From: Tamas K Papp on 12 Jun 2010 14:51 On Sat, 12 Jun 2010 11:06:19 -0700, Simon wrote: > I don't remember all the comments I read about some-great-Lisp vs. CL, > but one easy to locate is Paul Graham's > http://www.paulgraham.com/popular.html . I quote from section 4 > Hackability: > > « Historically, Lisp has been good at letting hackers have their way. > The political correctness of Common Lisp is an aberration. Early Lisps > let you get your hands on everything. » > > « A really good language should be both clean and dirty: cleanly > designed, with a small core of well understood and highly orthogonal > operators, but dirty in the sense that it lets hackers have their way > with it. C is like this. So were the early Lisps. » I think that you can safely ignore the above statements. They are very vague and ideological. "Political correctness"? What does he even mean? I only wish that he used "abomination" instead of "aberration". The former sounds so much more theological. PG wrote two books on CL, so he is certainly very knowledgeable about the language. But lately, he started designing his own dialect, called Arc. Arc has a lot of "principles" like the above, but I don't think that many people consider it very innovative. Last time I checked, I got the impression that one can implement the whole things as a thin library layered on CL/Scheme. I fail to see what the fuss is about, and why this necessitates a new language. But apparently, it is enough to make CL evil now :-) Best, Tamas
From: Pascal J. Bourguignon on 12 Jun 2010 15:35 Giovanni Gigante <giov(a)cidoc.iuav.it> writes: > Simon wrote: >> I'm deeply interested in Lisp. I'm learning it through Peter Seibel's >> PCL. >> >> One comment I find a lot when people talk about Lisp is that Lisp is >> wonderful, but CL has a lot of problems (problems I cannot understand >> due to my newbieness). Now, I don't want to learn the wrong Lisp. >> >> What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5, >> the particular dialect they used and fall in love with? >> >> If this unidentified Lisp is so great, why don't they use it and avoid >> all the pitfalls of CL? > > > From a still-partly-newbie: > > There is no Lisp per se, nor "unidentified lisp". Lisp is a family of > languages. > > The most evident feature of CL is that it's a very big language. This > means that it's either "bloated"/"unelegant" or > "feature-rich"/"industrial strength", depending on the point of view. This is wrong. In 1984-1986, when Common Lisp has been standardized, the standard document was big, compared to other programming languages of that time. But if you compared apples-to-apples, and oranges-to-oranges, Common Lisp is actually as small a language as any other. The difference, is that at that time, the specifications of Scheme, Pascal, or C or any similar languages took only about 50 pages, because they specified only the core of the language, while the Common Lisp standard included the standard library. If you add the specifications of the SRFIs (for scheme), of any set of 'standard' library for Pascal or C (eg POSIX.1-2001), you will soon get document sizes much bigger than the ANSI Common Lisp standard document. And nowadays, you would have to include all the network, graphic, GUI, web, xml, database access and whatever other "essential" library in your standard, then the CL language starts to looks like a microb of a language compared to monsters such as perl (including CPAN), Ruby (including Gems), python (including whatever they have) and even Haskell (including his cabale stuff which is so big they have to specifically address the problem of "too many libraries"). Programming languages are all small, on the same order of magnitude. What's big, and what's takes ten years to master, is their ecosystems, their libraries (whether they're documented in a "standard document" or are just de-facto "standards"), and their cultures. > Another thing: CL is a "lisp-2", meaning that there are separate > namespaces for functions and values. Instead, Scheme is a > "lisp-1". There are advantages and disadvantages, none of which should > you care at the moment. > > "Lisp 1" (without the hyphen) and "lisp 1.5", instead, refer to very > early designs, of antiquarian interest only. Actually, that would be "LISP I" and "LISP 1.5". At that time, men were men, women were women, it was LISP, and no confusion with a lisp was possible. > There is no wrong lisp to learn. All lisps are right. Stay with CL, > it's fine. > > gg -- __Pascal Bourguignon__ http://www.informatimago.com/
From: Pascal Costanza on 12 Jun 2010 15:47 On 12/06/2010 18:36, Simon wrote: > I'm deeply interested in Lisp. I'm learning it through Peter Seibel's > PCL. > > One comment I find a lot when people talk about Lisp is that Lisp is > wonderful, but CL has a lot of problems (problems I cannot understand > due to my newbieness). Now, I don't want to learn the wrong Lisp. > > What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5, > the particular dialect they used and fall in love with? > > If this unidentified Lisp is so great, why don't they use it and avoid > all the pitfalls of CL? The claim that Common Lisp has a lot of pitfalls is highly exaggerated. What is actually the case is that Lispers either accidentally used one particular dialect, and then may have difficulties moving to some of the other ones, or they have studied several different dialects, and chose one or more of them as their preferred dialects, and can give reasons for their choice, which are sometimes good, and sometimes not so good. Languages are never designed in a vacuum, and unless they are just very minimal academic exercises, have to make compromises and trade offs in order to resolve different, sometimes conflicting goals. Different users have different preferences with regard to such goals, and so they also have different preferences with regard to which dialect with a certain set of trade offs they prefer. The most commonly used dialects are Scheme and Common Lisp (and, depending on your perspective, Emacs Lisp). In recent years, Clojure also gained some popularity, but whether it will become one of the long-lasting Lisp dialects remains to be seen (I am skeptical). As far as I can tell, the applicability of Emacs Lisp is limited, so you are basically confronted with choosing between Scheme, Common Lisp and Clojure, of which I would describe Scheme and Common Lisp as being the most archetypal dialects. My strong recommendation is to take a look at both of these, since they make very different trade offs and have some fundamentally different design decisions, and see which of them resonates best with your style of programming. You should then spend some time with that Lisp dialect, to get some proficiency in it. After some time, you will better understand certain aspects of that dialect, which will then help you to better understand the other dialects as well, once you decide to take a second look at them. By then, you will probably be able to make a better decision which dialect you will mostly use in the long run. Lisp 1.5 is an ancient dialect for which you will hardly find any implementations anymore. The term "Lisp 1" probably doesn't mean anything, at least not the way you seem to use it. (There exist the term "Lisp-1", but that's a technical term that doesn't refer to a Lisp dialect, but to something completely different.) Even if you find implementations of Interlisp or other similar Lisp dialects, they are mostly interesting for historians. For practical purposes, the above mentioned Lisp dialects are the most important ones. 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/
From: Pascal J. Bourguignon on 12 Jun 2010 15:49
Simon <o.simon(a)gmail.com> writes: > On Jun 13, 2:29�am, Tim Bradshaw <t...(a)tfeb.org> wrote: >> On 2010-06-12 17:36:50 +0100, Simon said: >> >> >> >> > One comment I find a lot when people talk about Lisp is that Lisp is >> > wonderful, but CL has a lot of problems (problems I cannot understand >> > due to my newbieness). Now, I don't want to learn the wrong Lisp. >> >> I think what you are obsreving is that Lisp people like to moan, and >> complaining about the indequacies of various dialects & implementations >> is a very common way they do this. �The reasons for this are lost in >> time - however you'll fairly quickly realise that people are often >> complaining vigorously to avoid actually getting stuff done, often >> because they don't really have much idea what to do: obviously if you >> can persuade yourself that it's *Lisp* preventing you from writing the >> Great American Compiler, then you don't have to face the fact that, in >> fact, it's you. >> >> > If this unidentified Lisp is so great, why don't they use it and avoid >> > all the pitfalls of CL? >> >> There are two very common patterns you'll see. �Firstly is the CL/other >> lisp-related-language thing, where adherents of the other sect spend a >> huge amount of time being rude about CL. �The other is "once upon a >> time, we had <implementation> which was perfect, but now it is gone, >> nothing will ever be that good again, the heroes have ridden into the >> west it is the end of an age mutter". �What they never say was that >> <implementation> was used by 6 people ever, was written in assembler on >> a machine which could address some tens of k and executed a few hundred >> thousand instructions a second, didn't have a working garbage >> collector, had only upper-case characters, used octal, had no string >> data type, no numbers greater than 48.6, and in fact on closeer >> investigation turns out never to have existed at all. >> >> CL is just fine. > > Thank you all for your answers. I'll continue learning CL and then see > from there where to go next. > > I don't remember all the comments I read about some-great-Lisp vs. CL, > but one easy to locate is Paul Graham's http://www.paulgraham.com/popular.html > . I quote from section 4 Hackability: > > � Historically, Lisp has been good at letting hackers have their way. > The political correctness of Common Lisp is an aberration. Early Lisps > let you get your hands on everything. � You must also remember that the years 1980 where the years when software was enslaved by proprietary software producers like Microsoft (but the movement was initiated by the US government prohibing IBM to bundle its software with its hardware, and thus susciting the development of proprietary software. In this context, access to the sources of a Common Lisp implementation was unthinkable. On the other hand lisp systems developed in the years 1970 gave source access to the whole system, and you could modify any function at run-time, even something deep in the "kernel". Well, with a lot of care, of course. On the other hand, it's true that the CL standard specifies things in a way that specifically allows the implementations to take shortcuts in order to provide easily an efficient implementation. This makes it indeed possible to develop an implementation of CL in which it is not possible to modify an internal function without breaking the system. That said, there is always the possibility in lisp to implement your "changes" in the guise of a metalinguistic abstracion (ie implementing your lisp over the current lisp) on one hand, and on the other, most implementations let you modify things in the CL package (at your risks and perils), and some even offer compilation time options to make it even easier to do so (eg sbcl :sb-fluid feature). Moreover, nowadays, whatever the problem you may have with a program, you can get the sources and modify it, so if anything is not of your liking in a Common Lisp implementation (or any other programming language or program), wget, emacs, and five minutes is all you need. So today you can effectively get your hands on everything, and this criticism is not in order anymore, if it was ever. > � A really good language should be both clean and dirty: cleanly > designed, with a small core of well understood and highly orthogonal > operators, but dirty in the sense that it lets hackers have their way > with it. C is like this. So were the early Lisps. � -- __Pascal Bourguignon__ http://www.informatimago.com/ |