13 ms·
The objections the author had way back in the day are no longer the objections programmers of mainstream languages have to Lisp today. Today the objections I h
by pmoriarty 10y ago
The objections the author had way back in the day are no longer the objections programmers of mainstream languages have to Lisp today.
Today the objections I hear are more along the lines of:
1 - All those parenthesis. (Still a top objection)
2 - Lisp doesn't look like or work like what I'm used to.
3 - Lisp doesn't have as many libraries as the most popular mainstream programming languages.
4 - There aren't nearly as many Lisp programmers, so it'll be hard to find more to join your project/company if you use Lisp.
5 - There aren't nearly as many Lisp jobs, so why bother learning Lisp if you're going to have a hard time finding work using it?
6 - Lisp is ancient, and anything that old is useless and primitive compared to new and shiny languages.
- emsy 10y agoFor me it's not the paranthesis, but that Lisp posts always show low level code. At least half of my programming is tying together high level services and libraries. I know how I can express those concepts succinctly in Java, C++, JS, Swift etc. I'd love to see some examples of Lisp for something like a REST controller, where I call services, repositories etc.
- chimeracoder 10y ago> At least half of my programming is tying together high level services and libraries. I know how I can express those concepts succinctly in Java, C++, JS, Swift etc. I'd love to see some examples of Lisp for something like a REST controller, where I call services, repositories etc. You should look at Racket. Racket is a Scheme-like[0] Lisp that aims to be "batteries-included". It includes things like a web-server out-of-the-box. [0] it is technically a hybrid of R5RS and R6RS, so pedants can argue over whether it is really "a Scheme" or not.
- klibertp 10y ago> whether it is really "a Scheme" or not It's not and it's not about being pedantic. Racket changed its name nearly a decade ago and, at that point, it already wasn't Scheme either. I have a post about where Racket (and Clojure) come from: https://klibert.pl/posts/clojure_and_racket_history.html https://klibert.pl/posts/clojure_and_racket_history.html
- klibertp 10y ago> I'd love to see some examples of Lisp for something like a REST controller, where I call services, repositories etc. Not exactly what you're looking for, but take a look at my post: https://klibert.pl/posts/racket_quickie.html https://klibert.pl/posts/racket_quickie.html It shows a little JSON-based REST service which stores a list of messages and allows listing them and adding to them. With more URLs you'd likely use something like this: http://docs.racket-lang.org/web-server/dispatch.html http://docs.racket-lang.org/web-server/dispatch.html for dispatch, instead of hand-coded function. It's notable for only using stdlib, no additional packages (beyond purely syntactic, Clojure-like, `~>` support). To be honest, the APIs exposed in the stdlib feel kind of awkward - like using SimpleHTTPServer in Python. Still, it's just a couple of lines and easy (automatic, in this example) in-process concurrency is not bad.
- cygned 10y agoI have written an example web application for my cloud computing lecture. The code is not pretty nor 100% functionally and there are some bugs, but it shows how my applications work. It's just for demonstration purposes and therefore kept simple. https://github.com/dak0rn/Zwitscher https://github.com/dak0rn/Zwitscher Feel free to shout me questions or remarks. Edit: Here's a simple endpoint that uses a service which then works with the database; https://github.com/dak0rn/Zwitscher/blob/master/src/zwitscher/routes/settings.clj https://github.com/dak0rn/Zwitscher/blob/master/src/zwitsche...
- TheApexTheater 10y agoAs a response to your objections, 1) It's just a syntax thing... It's still possible to make an understandable program through good style 2) I don't have anything. 3-6) I've heard Racket is a good spiritual successor to Lisp, complete with external libraries and a broad(er) userbase.
- kazinator 10y agoFor (2) ("Lisp doesn't look like or work like what I'm used to") I have something: * Lisp does look quite a bit like stuff you're used to: foo(bar(arg, (foo (bar arg <foo><bar>arg arg2), arg2) arg2</bar> xyzz()); (xyzz)) <xyzz/></foo> * Lisp does actually work a lot like stuff you are used to: evaluation of argument expressions to argument values, which are passed by value: much like C or Java. Functions return a value or multiple values. It has familiar features like mutable lexical and global variables, control constructs for selection and iteration and so on. There is even a form of goto. Aggregate objects like structures, class instances, lists, vectors and so on are actually referential values, like in many languages. It is said that Javascript is a dialect of Lisp. If you understand how Javascript evaluates expressions, that goes a long way toward Lisp. Ruby is sometimes called MatzLisp, after the surname of its creator, for very good reasons. Lisp has inspired many features found in other languages. The comma, ?:, && and || operators in C appear to be Lisp inspired, as is the very idea of "expression statements": for instance when we call a function in C as a statement, it is an expression with a value, which is discarded, just like in Lisp. Lisp lists lack encapsulation; they are not opaque bags with which you do things like (add list item). That takes getting used to: always capturing the result value of a list construction. It doesn't take that much getting used to for programmers coming from C, who understand a bunch of ways of representing lists, including representations in which a null pointer represents an empty list. A container-like list data type is easily written in Lisp, either as a function-based ADT with a couple of functions around small state struct (or perhaps cons cell or vector), or full blown OOP.
- ScottBurson 10y ago> Lisp lists lack encapsulation; they are not opaque bags with which you do things like (add list item). That takes getting used to: always capturing the result value of a list construction. You're conflating two properties: lack of encapsulation and functional update. It's true that lists expose their internal structure as conses, and it's also true that they're usually updated functionally (requiring, as you say, capturing the result), but these properties don't have to go together. It's entirely possible, and arguably desirable, to have functional collections -- where instances are immutable, but which provide operations for creating new instances from existing ones -- which are also opaque data types; see for example FSet [0]. Conversely, it's possible to have fully-mutable lists that expose their internal structure; you just have to wrap each list in a mutable cell. It would be ugly, and I don't know why you'd do it, but it's entirely possible. [0] https://github.com/slburson/fset https://github.com/slburson/fset
- marcosdumay 10y agoTo be fair, the one time I decided to do something biggish and kinda important in Lisp, I stopped at #3. Not exactly because "it does not have many libraries", but because "library for X, Y and Z are not there and I don't want to write them". Oddly, Haskell has a similar problem, but going through C code by the FFI does not feel like a problem. I don't think why it does in Lisp, it may be just a matter of better documentation.
- jakebasile 10y agoClojure has a good selection of libraries, and similarly can call into any Java library pretty easily.
- cutler 10y agoThere's also Hy (hylang.org) which is kinda Clojure-in-Python giving you access to the Python library ecosystem.
- rhaps0dy 10y agoThe only difference of using Hy instead of Python are the macros though. What can you do easily with macros that is cumbersome to do with regular Python?
- cutler 10y agoMacros aside, Hy removes the single statement limitations of Python lambdas and the reliance on indentation. The fact that it's a Lisp also introduces a higher level of composability.
- kazinator 10y agoI'm working on FFI for TXR Lisp. Until this morning, it was in the stage of "collection of working API functions, written in C, exposed with Lisp bindings". I have almost everything I want working, including callbacks. There is a decently rich type system which supports pointers that annotate data passing directions for automatic malloc and free, and this works in both directions: out calls and callbacks (closures). I support by-value passing and returning of structures. And also of C arrays! Even though C doesn't have by-value arrays. You see, my FFI type (array 42 int) is actually equivalent to the C type struct __anon { int __anon[42] } and not the C type int [42]. Just this morning, between 6 and 6:45 a.m I wrote a partial implementation of the FFI declaration language. Here is what it looks like, with actual output: Load the under-construction FFI macros: (load "ffi") Define a show macro for showing an an expression and its value as expr -> value: (defmacro show (expr) (let ((val (gensym))) ^(let ((,val ,expr)) (format t "~s -> ~!~s\n" ',expr ,val) ,val))) Now the FFI test. Some structures we need, and declarations of FFI typedefs for them giving type info. The above typedefs aren't required; we we could just write out the (struct ...) syntax inline in the later FFI declarations. ;; Lisp struct representing C struct ldiv (defstruct ldiv nil quot rem) ;; FFI typedef for it (deffi-type ldiv (struct ldiv (quot long) (rem long))) (defstruct pipe nil rfd wfd) (deffi-type pipe (struct pipe (rfd int) (wfd int))) (defstruct dirent nil ino off) (deffi-type dirent (struct dirent (ino int) (off int) (nil (array 62 int)))) ;; the member named nil here is anonymous padding Now, declare some FFI functions. Very succinct and expressive: (with-dyn-lib (libc "libc.so.6") (deffi c-abs "abs" int (int)) (deffi ldiv "ldiv" ldiv (long long)) (deffi c-getenv "getenv" (buf 3) (str)) (deffi c-getenv-2 "getenv" str (str)) (deffi wcslen "wcslen" ulong (wstr)) ;; Two ways to call pipe: using a pointer to two-int ;; structure, or an int[2] array. They are binary identical. (deffi c-pipe "pipe" int ((ptr-out pipe))) (deffi c-pipe-2 "pipe" int ((ptr-out (array 2 int)))) (deffi c-read "read" int (int buf int)) (deffi c-read-str "read" int (int (ptr (array 10 char)) int)) (deffi opendir "opendir" cptr (str)) (deffi readdir-r "readdir_r" int (cptr (ptr-out dirent) (ptr-out cptr)))) Finally, the test: with two lines of interactive input from the TTY to satsify two read calls from file descriptor 0. For both of these, I enter the text abc[Enter]: (show (c-abs -42)) (show (ldiv 47 6)) (show (c-getenv "HOME")) (show (c-getenv-2 "HOME")) (show (wcslen "foo bar")) (let ((pi (new pipe))) (show pi) (show (c-pipe pi)) (show pi)) (let ((pi (vector 2))) (show pi) (show (c-pipe-2 pi)) (show pi)) (let ((buf (make-buf 5 #xa0))) (show buf) (show (c-read 0 buf (length-buf buf))) (show buf)) (let ((str "xxxxxxxxxxx")) (show str) (show (c-read-str 0 str 10)) (show str)) (let* ((de (new dirent)) (dp (cptr 0)) (dir (show (opendir ".")))) (show (readdir-r dir de dp)) (show de) (show dp)) Output: (c-abs -42) -> 42 (ldiv 47 6) -> #S(ldiv quot 7 rem 5) (c-getenv "HOME") -> #b'2f686f' (c-getenv-2 "HOME") -> "/home/kaz" (wcslen "foo bar") -> 7 pi -> #S(pipe rfd nil wfd nil) (c-pipe pi) -> 0 pi -> #S(pipe rfd 4 wfd 5) pi -> #(nil nil) (c-pipe-2 pi) -> 0 pi -> #(6 7) buf -> #b'a0a0a0a0a0' abc <-------------------------------------- TTY input (c-read 0 buf (length-buf buf)) -> 4 buf -> #b'6162630aa0' str -> "xxxxxxxxxxx" abc <-------------------------------------- TTY input (c-read-str 0 str 10) -> 4 str -> "abc\nxxxxxx" (opendir ".") -> #<cptr: a34e118> (readdir-r dir de dp) -> 0 de -> #S(dirent ino 669944 off 1) dp -> #<cptr: a32a258> Look what is happening in (c-read-str 0 str 10). We pass in a Lisp string which contains "xxxxx...". Magically, it becomes "abc\nxxxxxx..." after the read, as if we were working in C. This is because the type for the parameter (ptr (array 10 char)). The FFI framework recognizes arrays of char and makes them correspond to strings in a two-way manner.
- Davertron 10y agoYeah, back when I tried Common Lisp #3 was a stumbling block. I hear Clojure solves that problem pretty well, maybe because it's a little more mainstream than other lisps and also because my understanding is it's pretty easy to work with existing Java libs from Clojure.
- chongli 10y agoYou left out a rather glaring objection: 7 - Lisp has a tendency to lure programmers up the river of insanity [0] due to the sheer power of macros (particularly reader macros). This can leave the rest of the team (or any successors) struggling with a mountain of technical debt. Overall, I think the power of Lisp makes it difficult for a community to organize without a BDFL to keep everyone on the same page. [0] http://tvtropes.org/pmwiki/pmwiki.php/Main/RiverOfInsanity http://tvtropes.org/pmwiki/pmwiki.php/Main/RiverOfInsanity
- deleted 10y ago[deleted]
- wtetzner 10y agoYeah, this seems to be a common objection, but in my experience of actually having used a lisp (Clojure) in production, this was never a problem. Sure, you'll likely still end up with some technical debt, but no more than the Java project's we had at the same company. And not because of macros. When people first learn about macros, they go crazy trying to do all kinds of things that weren't possible without macros. But once developers gain a little experience with macros, they learn to use them judiciously and tastefully.
- Chris2048 10y agoI think one problem with certain 'declarative' styles, is that imperative code is, in a sense, temporarily ordered. When you lose this, you need to replace it with some other enforced order, that helps you navigate the code. Think how much debugging is based on locating buggy code by walking through the execution path and/or data-path. When you lose that kind of strictly linear execution, you still need a layer of heavy modulation to compensate. Consider reaching a state of https://www.emacswiki.org/emacs/DotEmacsBankruptcy https://www.emacswiki.org/emacs/DotEmacsBankruptcy you can easily modify the editor in any way from any file, so you really need to use in-build tools to navigate how the environment is affected by the config files.
- el_memorioso 10y ago1) You can become familiar with the parentheses. One might say, "all that white space" about Python, but that doesn't make Python any less powerful a language. 2) It does not look like what you're used to, but it certainly can work like you're used to since it is a multiparadigm language. Of course, programming Lisp like you program C or Python loses a lot of the power. 3) As a Lisp programmer, this is my biggest gripe. 4-5) True. If you aren't a contractor/freelancer that can choose your tools, Lisp is a hard sell. 6) Lisp is ancient. That said, the rest of the programming world has yet to catch up to the some of the concepts in Lisp like conditions or CLOS. Many of the "advances" in the new shiny languages have been in Lisp for decades.
- crimsonalucard 10y agoLearning lisp or functional programming is more of a conceptual experience than a practical one. That is not to say it is not practical to learn lisp, but the state of the programming world as it is today makes it so that it is less practical to learn lisp than it is to learn about say something like java.
- nine_k 10y agoIf you ever have to write JavaScript, a fairly practical and widespread language, the functional paradigm proves to be highly useful.
- Scarblac 10y agoBut luckily in newer versions, sane features like modules are introduced that are syntactic sugar over the trick with closures that have to be used to fake them. And things like Promises instead of passing callback functions everywhere. The functional paradigm in Javascript is used everywhere because that's all there was.
- crimsonalucard 10y agoI have used javascript extensively. I can tell you the functional paradigm is almost NEVER used in javascript. Javascript just contains libraries, features and concepts brought over from functional programming but I have never seen anyone program javascript functionally.. If a single one of your functions in javascript contains more than one imperative procedure you have exited the functional paradigm.
- ASipos 10y agoI guess the stuff about parentheses that's highly confusing in Lisp is that x is different from (x). Outside of that, it's just ordinary grouping.
- brlewis 10y agoIn JavaScript it's confusing that these are different: function(x) { return x; } function(x) { return x; }() To reduce confusion, JavaScript programmers follow the Lisp convention and put parens around expressions like the latter. Once you take the 5 minutes needed to get used to the difference between x and (x) it's actually less confusing than popular alternatives.
- Will_Parker 10y ago7 - It's too easy to make a mess. And the mess made by brilliant people who are looking for any excuse to put higher order metaprogramming and functional concepts into production is considerable. 8 - It has consistently lost in the marketplace in the last 20 years. We had most top CS grads in North America groomed on SICP at one point in history. You'd think many of them would want to use Lisp in production. Many of them did. Now MIT uses Python to introduce programming, and Lisp code bases tend to be (horrifying) legacy systems. Virtually no startups base the core of their business on Lisp anymore, and it's not because the technical founders aren't aware of it. (Lots of skunkworks Clojure projects are out there bearing load though.)
- Jach 10y agoSICP uses Scheme, which is not Lisp. It was taught at an introductory level because some concepts of computation can be taught nicely with Scheme, up to making a compiler for another language (perhaps a "real" language in the student's minds?), but it doesn't actually teach you Lisp, and I imagine leaves a bad taste in many students' mouth at the nonsense no-for-looping-no-mutation they had to suffer through which isn't a requirement in Lisp (nor necessarily in Scheme). SICP doesn't even have something as quick to go through as e.g. this series http://malisper.me/2015/07/07/debugging-lisp-part-1-recompilation/ http://malisper.me/2015/07/07/debugging-lisp-part-1-recompil... to get a feel for what it's actually like to work with Lisp. Clojure has been very successful though it seems like your point #7 would apply more-so to it (since Lisp isn't as functional oriented) unless you mean crazy-in-production things like closures and mapping functions. =P I don't even think you can call all that many Clojure projects skunkworks ones, because the language is quite visibly successful. Something like https://www.ptc.com/cad/elements-direct/modeling https://www.ptc.com/cad/elements-direct/modeling you might call a skunkworks success for Lisp...
- icc97 10y ago> SICP uses Scheme, which is not Lisp. Wikipedia [0]: > Scheme is a functional programming language and one of the two main dialects of the programming language Lisp. [0]: https://en.wikipedia.org/wiki/Scheme_%28programming_language%29 https://en.wikipedia.org/wiki/Scheme_%28programming_language...
- AnimalMuppet 10y ago6: Lisp is ancient. It really is. Also on the front page of HN today: SQL is 43 years old. So, exactly what is the problem with being ancient? Nobody objects to SQL on those grounds. So I suspect that 6 is really "I want to object, and I found a plausible-sounding reason to do so". (It could be people who actually evaluate stuff based on how new it is. But I'd prefer to think that there aren't people who really evaluate languages that way...)
- gumby 10y ago> The objections the author had way back in the day are no longer the objections programmers of mainstream languages have to Lisp today. > Today the objections I hear are more along the lines of: > 3 - Lisp doesn't have as many libraries as the most popular mainstream programming languages. Amusingly one of the "objections" to Common Lisp when it was standardized was its absurdly large library. Things sure look different today. I have to say though that many languages have a large number of libraries, the quality is, naturally, variable.+ The real library strength of a language is the power of its standard library. (Admittedly some of that can come via lore or acculturation, e.g. numpy. On the other hand, what legs will, say, react have? Who knows?) + no examples because I have no desire to insult anyone -- rather thanks for releasing your code!
- blowski 10y agoThe number of bad libraries doesn't affect the number of good libraries, so that is still an important distinction. Also, if an average quality library is good enough that I don't need to spend a few weeks doing it myself, that's still a bonus.
- hasenj 10y ago_My_ main objection to lisp is that it's confusing. I don't mean the syntax is hard to grasp. I mean the way it looks. It becomes very confusing when the program grows in size. This is not unique to Lisp. It applies to all dynamic languages that don't have strong tooling support (IDE's with intellisense). (Maybe I am wrong about Lisp being dynamic; my only experience has been with "arc"; and I have had someone tell me before that common-lisp has static types) I used to be happy about programming python and javascript in a plain text editor (vim). However, as I was doing my first intermediate size project, I realized that I've hit a limit. My project was in Javascript (frontend) and I couldn't keep track of what was going on anymore. Each unit of code is understandable on its own but the whole thing is a mess to look at. When I need to change the inputs or outputs of a function, I have no idea if I've done it correctly or not; due to the lack of type checking. I absolutely need to make sense of what is what. Having everything look the same makes me confused. And I've come to realize that tooling support is of the utmost importance. Having an editor like vim with cool tricks is nice, but what I really need is to "rename variable" or "rename function" automatically across all usages in the project.
- dorfsmay 10y agoThey are IDEs, and if you think about it for a minute, Lisp languages have to be the easyest to implement IDEs for, as their syntax is exactly the AST and easy to parse.
- dualogy 10y ago> if you think about it for a minute, Lisp languages have to be the easyest to implement IDEs for, as their syntax is exactly the AST and easy to parse I wouldn't think the parsing stage has ever been the top bottleneck or chief complexity/complication for IDE/tooling developers..
- kazinator 10y agoIf every feature of a programming language syntax can be used in about 100 kilobytes of code, and your project is 3000 kilobytes, that's a 30:1 "sameness ratio" at best. If you use every language feature in that program, any 3% (if not more) of your program will look the same as some other 3%. Most programs don't exercise every language feature throughout most of their code, so their pieces look even more self-same than that. In Lisp, we have to learn to factor in the identity of the operators into what is "same": learn not to see (defclass bear (animal) ..) as being the same "same" as (block foo (init) ...). When you're reading Lisp code, you're seeing chunks like this: xxxxxx xxxxxxxxxxxxxxxxx xxxxxx xxx xxxxxxxxxxxxxxxx xxxxxxx xxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxx xxxxxxxxxx You have to train yourself to see the upper left corner of this blob before any other processing: (defun xxxxxxxxxxxxxxxxxx xxxxxx xxx xxxxxxxxxxxxxxxx xxxxxxx xxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxx xxxxxxxxxx The meaning of the rest of it depends on that one; it has to look different from other blobs that have something else in that corner.
- Chyzwar 10y ago1. Lisp have less symbols than other language (defun averagenum (n1 n2 n3 n4) (/ ( + n1 n2 n3 n4) 4) ) vs function averagenum(n1, n2, n3, n4){ return (n1 + n2 + n3 + n4)/4 } Lisp 9 vs 13 JavaScript(excluding keywords and return) 2, 3 ,4 , 5, 6 -> Chicken and egg problems, Lisp is not popular enough an this makes things difficult. Lisp real issues are: 1. Fragmentation: Scheme, CL, Clojure, ELisp, Racket... 2. Tooling: package manager, build system, support outside emacs. 3. Concurrency and safety: some do better than other but added to late.
- gedy 10y agoTrue, but the issue is that most academic and vast majority of paid coding roughly looks like the JavaScript example (C/C++/Java/JS/etc) - so to most the Lisp style looks odd and hard to parse, not the raw symbol count.
- Chyzwar 10y agoLisp style is more elegant, almost everything is either data or function. Other languages you mention are massively more complex and difficult to understand. For me C++ is some kind of clusterfuck of symbols/keywords/operators and plain magic. After you learn prefix notation, Lisp is super easy. Unfortunately in the world were "worse is better" we discard beautiful and smart: Smalltalk, Lisp and ML. Instead we build our towers of Babel using PHP, JavaScript and C++. It is so ridiculous that people choose to spend whole career using PHP because it is easy learn.
- lelandbatey 10y agoIt is not. When it comes to learning anything, we humans have a massive tendency to prefer that which is familiar. This means that when a human is faced with an obstacle and must choose between: - An unfamiliar tool or paradigm which is custom built to solve this and all future problems (should they arise) such that time and effort is saved - A familiar tool which has been extended this one time to solve this one problem, and which can be inellegantly extended to solve future problems potentially at the cost of time and effort People will almost always pick the later.
- dualogy 10y ago> All those parenthesis. (Still a top objection) I'm glad for its parens. Would never have checked out Haskell (and gotten into purity&lazy-eval) if Lisp's syntax was like Haskell's (no mandatory braces except by choice, no mandatory parens except by choice --- indent is enough and in practice we all mostly end up indenting all code in all languages anyway, so.. works for me)
- jacquesm 10y agoTo me the hard part about lisp is that every programmer that uses lisp tailors it so to their own taste that it can become quite hard to read the 'top level' of a lisp program without first having gone through all the lower layers. It is as if every project in lisp somehow magically develops its own DSL. That's a high hurdle for newbies to clear.
- Roboprog 10y agoFortunately, JEE & Spring are MUCH easier to get started with :-) Let them eat COBOL...
- vajrabum 10y agoCobol, that's where you get your CICS! The original heavyweight framework, callbacks and all. Loads of fun.
- AceJohnny2 10y agoSounds like a common objection to C++, where the language is so large that every team chooses its own subset of features they'll use, and ignore the rest :)
- int_19h 10y agoThat's much less of a problem, because if you know the whole thing, then any subset of it is also known. It only becomes a problem if you need to change the code, because then you have to be aware of the subset to restrict yourself to. C++ actually has a similar problem with developing idiosyncratic in-house solutions to common problems - it's not uncommon to find hand-rolled collections, reference-counting pointers etc, especially in older codebases from before STL and Boost became more widely accepted. But because the language doesn't offer anything close to the flexibility of Lisp macros, those idiosyncrasies are also much easier to parse.
- Volt 10y agoI don't know anyone who claims to know the whole of C++.
- lisper 10y ago> 1 - All those parenthesis. (Still a top objection) If you actually count parens fairly you will find that Lisp has no more than any other language, it's just that other languages use a mix of parens, square brackets and curly braces whereas Lisp only uses parens. Also, if you really don't like parens, you can get rid of a lot of them using macros. See e.g.: https://github.com/rongarret/ergolib https://github.com/rongarret/ergolib and in particular the binding-block (BB) construct. > 2 - Lisp doesn't look like or work like what I'm used to. Neither does anything else until you get used to it. > 3 - Lisp doesn't have as many libraries as the most popular mainstream programming languages. That used to be one of my objections, but it's simply not true any more. And with Quicklisp accessing the (very large) collection of available libraries is incredibly convenient. (Thanks Zach!) > 4 - There aren't nearly as many Lisp programmers, so it'll be hard to find more to join your project/company if you use Lisp. That becomes a self-fulfilling prophecy. But it's no harder to create new Lisp programmers than it is to create new X programmers for any other value of X. > 5 - There aren't nearly as many Lisp jobs, so why bother learning Lisp if you're going to have a hard time finding work using it? Because knowing Lisp is a huge lever for learning other languages. Once you know Lisp everything else becomes a lot easier to learn (but a lot more frustrating too because now you will be aware of the shortcomings of other languages). > 6 - Lisp is ancient, and anything that old is useless and primitive compared to new and shiny languages. Chasing the shiny new thing is usually a mistake. Most old things suck simply because most things suck in general. But the things that don't suck continue to not suck even after they become old. In fact, standing the test of time is one of the defining characteristics of non-sucky things.
- ue_ 10y agoThe part about lisp being primitive was rather silly. Many languages don't have anything close to what Lisp has in its macro system, not even other functional languages, even in those languages with temperating systems. Perhaps Perl 6 comes close (I haven't had the chance to use p6 macros yet) but to say that lisp is 'primitive' is rubbish, unless you're going to claim that case insensitivity is enough to declare a language primitive.
- brianberns 10y ago>> 1 - All those parenthesis. (Still a top objection) > If you actually count parens fairly you will find that Lisp has no more than any other language Bull. For example, compare the Lisp factorial function from the article: (define (fact x) (if (zero? x) 1 (* x (fact (- x 1))))) with the corresponding F# implementation: let rec fact x = if x = 0 then 1 else x * fact (x - 1) That's 7 vs. 1 pair of parens. Also, the problem isn't just that Lisp has so many parens, but that they nest so deeply and quickly. Five nested levels of parens for factorial alone.
- oxryly1 10y agoUsing Lisp (in the form of Racket) for many years in a production environment, I've observed: 1. People do complain about the parentheses but they generally get to work dealing with them right away. It's the loudest complaint, but it doesn't really even slow people down. 2. This is a similar complaint, and does scare people off from jumping in if they have a real choice. 3. Racket in particular solves this one to an extent. We've used it with Redis, JSON, MySQL, Perforce, etc etc productively. More commentary below, though... 4. This one is a non-issue as far as I've seen. If you hire someone who can program, then can quickly learn and be productive in Lisp. 5. This is tied in with 4, a non-issue. 6. This is an issue with perception. The problem is more that people believe they know something about Lisp because they've heard of it, and they come in with the expectation that it'll be weird or difficult, which is a bit of a speed bump to getting to work right away. Ultimately the biggest issue we've seen is that the broader ecosystem of organizations using Lisp (or Racket) in production environments is missing. As such, there are many sharp corners that you have to file off yourself as you deploy your usage. Useful resources like Stack Overflow just don't have the answers prepackaged because it's likely you're the first to use Perforce to deploy a precompiled version of your Racket application on Windows (for example). It's easy to underestimate just how much work people have put into making ecosystems in C++, Java, and Python contain all the pieces, experience, and knowledge you'll need to solve your particular problems quickly and effectively. Another pieced missing along with that ecosystem: outside of the implementation of the language itself, no one has taken an application of significant size and age and added a major feature to it. This is something that happens in production all the time -- and it happens on a schedule with a budget. Virtually no one using a small or academically minded languages ever does this, though. And it's not until you try that do you discover all those sharp corners and missing support tools and libraries.
- grey-area 10y agoThe hesitation I'd have with Lisp(s) as an outsider, which ties in to number 3, is that the language itself is compact, elegant and extensible. It's the opposite problem to C++ (the language is too large) - the language is too small and it encourages you to build other languages inside it. So it'd be very hard to share code with others because as soon as you start building abstractions your language and worldview diverges from everyone else's version of lisp - to use a library you have to learn someone else's mini-language. Maybe this is an invented concern though, did you find integrating other libraries a problem? Did you have any problems with development speed or performance in production or was that fine?
- nickbauman 10y agoThe parenthesis go away pretty fast once you start writing. I remember it took me a day or so. Mind you I mostly work in Clojure where parentheses are not used everywhere (function airity is described using a vector [ ] for example).