3 ms·

Common Lisp advantages: - "more interactive" resumable exceptions, better code reloading functionality - multiple values (cumbersome to use for superficial re

by patrec 8y ago

Common Lisp advantages: - "more interactive" resumable exceptions, better code reloading functionality - multiple values (cumbersome to use for superficial reasons, but with much better semantics than in e.g. scheme, for sure and probably also Lua) - compiler macros - readtable macros (although the design leaves to be desired) - more sophisticated pretty printer - more "target platforms"; with clojure it's basically jvm or, to a lesser extent, JS. If you dislike both you're out of luck - there's a treasure trove of old but interesting material that uses Common Lisp (like PAIP by Norvig) - much nicer for writing highly imperative code Common Lisp disadvantages: - Common Lisp has no eco system to speak off (but at least there's less churn than in clojure land) - the language is frozen/dead - career suicide, even compared to clojure - no high quality free implementations (for example sbcl has a rather poor garbage collector compared to java, go and other widely used languages) - single precision is de-facto the default floating point type - built around cons cells which are a terrible data structure: slow, cumbersome and brittle; there's OK support for vectors and slightly worse support for multidimensional arrays and hash-tables and very poor support for generic collection manipulation or efficient functional data structures - no out of the box support for laziness - no concurrency or parallelism abstractions - no good standard pattern matching library - brain drain: very few smart people doing interesting things left (most left by the 90ies) - often feels plodding and cumbersome compared to clojure (destructuring, basic string or sequence operations)

sedachv 8y ago
You have a lot of very wrong opinions on Common Lisp. > multiple values (cumbersome to use for superficial reasons How so? > Common Lisp has no eco system to speak off False. https://www.quicklisp.org/beta/ https://www.quicklisp.org/beta/ https://cliki.net/ https://cliki.net/ > the language is frozen/dead False. Extensions are being done through libraries and in the implementations. > career suicide, even compared to clojure I only ever get positive attention for having been a professional Common Lisp (and Scheme) programmer. Never had trouble finding freelance or full-time work. > no high quality free implementations (for example sbcl has a rather poor garbage collector compared to java, go and other widely used languages) How do you go from "SBCL's GC is slower than Java's" (which is a nonsensical statement, because different JVMs have different GCs), to "no high-quality free implementations?" There are three Free Software ones to choose from: SBCL, CCL, and ECL. > single precision is de-facto the default floating point type False. Where do you even pick up a ridiculous idea like that? http://www.lispworks.com/documentation/HyperSpec/Body/t_short_.htm http://www.lispworks.com/documentation/HyperSpec/Body/t_shor... > built around cons cells which are a terrible data structure Ignoring how dumb labeling the linked list a "terrible data structure" is, you do realize that data structures are something that you implement in a language, not something that you have to build into one? There are libraries for all kinds of data structures. > no out of the box support for laziness There is no reason to make it built in at the language level when you have closures. > no concurrency or parallelism abstractions That is handled by implementations and libraries. > no good standard pattern matching library Just a bunch of really great ones. > brain drain: very few smart people doing interesting things left (most left by the 90ies) You don't seem to know anything or anyone from the Common Lisp world. The best techniques for using the language (advanced use of closures, read macros, the condition system, and applications to domain-specific languages and transpilation) have only started coming out in the past 15 years, from people like Edi Weitz, Doug Hoyte, and Tobias Rittweiler. The only thing relevant from the 1990s is Paul Graham's On Lisp. Norvig's PAIP is very overrated.
- kamaal 8y ago
  >>The best techniques for using the language That is good, but availability of Libraries are better. Let's face it. Most people can't use even basic programming features well. When programming went mainstream we traded art for plumbing. What matters now is being able to talk to http end points, working with databases, message buses and myriad of other backend interfaces. To have widespread adoption you have to do library stuff well, and then may be other features will matter. Perl is an interesting use case in this regards. The language is very 'functional programming language like' in nature but has a very practical focus for common people, while providing the powerful features for advanced users.
- patrec 8y ago
  Wrt brain drain: Edi Weitz is a smart guy, but not in the same league as e.g. Henry Baker, Jeffrey Mark Siskind, David Moon, Bill Gosper, Guy Steele, Marvin Minsky, Peter Norvig etc. There are still several people worth following left, even if you're not a common lisp fanboi (e.g. paul khuong), but hardly a lot which are moving the state of computing forward to the extent it was the case for many decades. Dough Hoyte wrote Let over Lambda which is strong on the same breathless prose gracing its blurp: > Let Over Lambda is one of the most hardcore computer programming books out there. Starting with the fundamentals, it describes the most advanced features of the most advanced language: but IMO much weaker than PAIP on the actual "hardcore" programming. I can see why it would appeal to you more. Wrt single precision being the default floating point type in practice: * *read-default-float-format* SINGLE-FLOAT * (cos 355/113) -1.0 * (cos (/ 355 113.0)) -1.0 * (cos (/ 355 113d0)) ; get a more accurate answer by using double float literal -0.9999999999999645d0 The only practical implementation which diverged from this for some time was CCL (which used doubles), and they gave up because of friction with the rest of the community. I don't have time to address all your other claims that what I wrote is ridiculously false right now, so if it makes you feel better you can tell yourself that you still showed me wrong on 9 out of 11 points.
  - sedachv 8y ago
    > Wrt single precision being the default floating point type in practice: The only relevant example in your list is the fact that irrational functions coerce rational arguments to single floats (http://clhs.lisp.se/Body/12_acc.htm http://clhs.lisp.se/Body/12_acc.htm). Why do you think that dividing an integer by a single float should produce a double float?

by patrec 8y ago

sedachv 8y ago

You have a lot of very wrong opinions on Common Lisp. > multiple values (cumbersome to use for superficial reasons How so? > Common Lisp has no eco system to speak off False. https://www.quicklisp.org/beta/ https://www.quicklisp.org/beta/ https://cliki.net/ https://cliki.net/ > the language is frozen/dead False. Extensions are being done through libraries and in the implementations. > career suicide, even compared to clojure I only ever get positive attention for having been a professional Common Lisp (and Scheme) programmer. Never had trouble finding freelance or full-time work. > no high quality free implementations (for example sbcl has a rather poor garbage collector compared to java, go and other widely used languages) How do you go from "SBCL's GC is slower than Java's" (which is a nonsensical statement, because different JVMs have different GCs), to "no high-quality free implementations?" There are three Free Software ones to choose from: SBCL, CCL, and ECL. > single precision is de-facto the default floating point type False. Where do you even pick up a ridiculous idea like that? http://www.lispworks.com/documentation/HyperSpec/Body/t_short_.htm http://www.lispworks.com/documentation/HyperSpec/Body/t_shor... > built around cons cells which are a terrible data structure Ignoring how dumb labeling the linked list a "terrible data structure" is, you do realize that data structures are something that you implement in a language, not something that you have to build into one? There are libraries for all kinds of data structures. > no out of the box support for laziness There is no reason to make it built in at the language level when you have closures. > no concurrency or parallelism abstractions That is handled by implementations and libraries. > no good standard pattern matching library Just a bunch of really great ones. > brain drain: very few smart people doing interesting things left (most left by the 90ies) You don't seem to know anything or anyone from the Common Lisp world. The best techniques for using the language (advanced use of closures, read macros, the condition system, and applications to domain-specific languages and transpilation) have only started coming out in the past 15 years, from people like Edi Weitz, Doug Hoyte, and Tobias Rittweiler. The only thing relevant from the 1990s is Paul Graham's On Lisp. Norvig's PAIP is very overrated.

kamaal 8y ago
>>The best techniques for using the language That is good, but availability of Libraries are better. Let's face it. Most people can't use even basic programming features well. When programming went mainstream we traded art for plumbing. What matters now is being able to talk to http end points, working with databases, message buses and myriad of other backend interfaces. To have widespread adoption you have to do library stuff well, and then may be other features will matter. Perl is an interesting use case in this regards. The language is very 'functional programming language like' in nature but has a very practical focus for common people, while providing the powerful features for advanced users.
patrec 8y ago
Wrt brain drain: Edi Weitz is a smart guy, but not in the same league as e.g. Henry Baker, Jeffrey Mark Siskind, David Moon, Bill Gosper, Guy Steele, Marvin Minsky, Peter Norvig etc. There are still several people worth following left, even if you're not a common lisp fanboi (e.g. paul khuong), but hardly a lot which are moving the state of computing forward to the extent it was the case for many decades. Dough Hoyte wrote Let over Lambda which is strong on the same breathless prose gracing its blurp: > Let Over Lambda is one of the most hardcore computer programming books out there. Starting with the fundamentals, it describes the most advanced features of the most advanced language: but IMO much weaker than PAIP on the actual "hardcore" programming. I can see why it would appeal to you more. Wrt single precision being the default floating point type in practice: * *read-default-float-format* SINGLE-FLOAT * (cos 355/113) -1.0 * (cos (/ 355 113.0)) -1.0 * (cos (/ 355 113d0)) ; get a more accurate answer by using double float literal -0.9999999999999645d0 The only practical implementation which diverged from this for some time was CCL (which used doubles), and they gave up because of friction with the rest of the community. I don't have time to address all your other claims that what I wrote is ridiculously false right now, so if it makes you feel better you can tell yourself that you still showed me wrong on 9 out of 11 points.
- sedachv 8y ago
  > Wrt single precision being the default floating point type in practice: The only relevant example in your list is the fact that irrational functions coerce rational arguments to single floats (http://clhs.lisp.se/Body/12_acc.htm http://clhs.lisp.se/Body/12_acc.htm). Why do you think that dividing an integer by a single float should produce a double float?