52

I am starting to learn Scheme by the SICP videos, and I would like to move to Common Lisp next.

The language seems very interesting, and most of the people writings books on it advocate that it has unequaled expressive power. CL seems to have a decent standard library.

Why is not Lisp more widespread? If it is really that powerful, people should be using it all over, but instead it is nearly impossible to find, say, Lisp job advertisements.

I hope it is not just the parenthesis, as they are not a great problem after a little while.

Dynamic
  • 5,746
  • 9
  • 45
  • 73
Andrea
  • 5,355
  • 4
  • 31
  • 36
  • 5
    Steel Bank (common) LISP is actually more popular than you might imagine. LISP like macro processors (e.g M4) are also widely used. You might not see it in your domain of choice, but it's still out there (for better or for worse). – Tim Post Mar 21 '11 at 02:50
  • 10
    The recent earthquake and tsunami wiped out the parenthesis factory in Japan. :-( – oosterwal Mar 22 '11 at 13:45
  • 1
    Which version of Lisp should we be using? Remember Lisp dialects are more or less incompatible. –  Apr 07 '11 at 06:19
  • @Oosterwal That shouldn't be a problem; you can write a macro to expand a pair of parentheses indefinitely. – Mark C Aug 22 '11 at 15:16
  • 2
    LISP (or dialects of ) are used all over the place eg AutoLISP is a dialect of LISP used by Autocad http://en.wikipedia.org/wiki/AutoLISP or EMACS http://en.wikipedia.org/wiki/Emacs_Lisp – Jaydee Feb 21 '12 at 16:57
  • 1
    "I hope it is not just the parenthesis, as they are not a great problem after a little while.": The problems with the parentheses are just a myth. I have been writing quite some Lisp code recently and the parentheses are no problem at all! – Giorgio Oct 21 '16 at 19:18
  • Aren't all LISP dialects in theory compatible with each other via running simple queries on S-expressions (like jQuery). – aoeu256 Jul 01 '19 at 19:18

11 Answers11

73

Expressiveness isn't always a positive language trait in a corporate environment. Java is extremely popular partly because its easy to learn, easy to write, and easy to read. Mediocre programmers can still be very productive in Java, even if their code is wordy and inelegant.

Furthermore, it's easy to abuse expressive languages. An expert java programmer can refactor poorly written code quickly. The more expressive the language, the more difficult understanding and refactoring horrible code becomes. LISP macros are a good example. Macros are powerful tools in the right hands. In the wrong hands, they can result in confusing and hard to debug code.

LISP is a risky choice for senior management. If things go wrong, no one is going to blame management for picking a popular object oriented language backed by a major corporation like Oracle or Microsoft. Its much easier to hire programmers with experience in popular, easy to learn languages.

Even progressive companies willing to use a more powerful language usually don't choose LISP. This is because many of the newer languages try and compromise by borrowing powerful features from LISP, while staying easy to learn for the masses. Scala and Ruby follow this model. Bad programmers can pick them up quickly and keep writing the same mediocre code that they did in Java. Good programmers can take advantage of the more advanced features to write beautiful code.

Parentheses are not the problem. Haskell is an incredibly powerful and expressive language with a syntax similar to Python or Ruby and it hasn't been widely adopted for many of the same reasons as LISP.

Despite all this, I am hoping...

Clojure has a chance of becoming popular. It runs on the JVM, has great interop with Java, and makes concurrent programming much simpler. These are all important things to many companies.

*This is my perspective as a professional JVM programmer with experience in Java, Clojure, JRuby, and Scala.

dbyrne
  • 1,378
  • 1
  • 11
  • 15
  • 27
    The objection about the difficulty of finding qualified programmers is a bit of a dog chasing its tail. If Lisp was more widespread, it would be easier to find good programmers. – Andrea Mar 19 '11 at 23:17
  • 3
    @Andrea That is definitely true. Its harder to learn lisp though, which contributes to the problem as well. I realize that might be a controversial opinion, as many professors teach scheme as a first language. – dbyrne Mar 19 '11 at 23:24
  • @dbyrne: What do you mean by "expressive languages"? languages that do "lots" of things in only a few instructions, like APL? – Eric O. Lebigot Mar 19 '11 at 23:52
  • 9
    Yes, APL is an excellent example of an expressive language. Also, a good example of why expressiveness isn't the most important thing ;) – dbyrne Mar 19 '11 at 23:54
  • 9
    I don't think this definition actually conveys what expressive means. Personally, before I call a language expressive, I would make sure that I am able to read what I have written. For example, using nontrivial logic in the loop initializer in C may save you some lines of code, but it is not readily understandable. On the other hand a list comprehension in Python can save a couple of line **and** be more readable. So you actually have found a way to express what you meant more concisely. If it is not readable, you have not find a way to express anything at all. – Andrea Mar 20 '11 at 00:17
  • @Andrea I agree with you, but in the context of this discussion its hard to define what "readable" means. Even the most clearly written functional code can seem like voodoo to a programmer with a background in imperative languages. Conversely, I believe programmers with a background in functional languages don't have as much trouble reading imperative code (even if they hate it). – dbyrne Mar 20 '11 at 00:25
  • I see the point... – Andrea Mar 20 '11 at 00:32
  • 1
    "An expert java programmer can refactor poorly written code quickly." I don't think this is true at all. Most java code does a lot of side effects. Side effect infested code is very hard to refactor. Refactoring a clojure funciton is almost as easy as copying and pasting the s-expr and putting defn around it. – jshen Mar 20 '11 at 03:44
  • "Ease of refactoring" is determined by a whole lot more than simply the amount of side effects a particular piece of code causes. Besides, Clojure isn't a "pure" functional language like Haskell. A bad programmer can surely introduce ugly side effects into their clojure code. – dbyrne Mar 20 '11 at 03:53
  • 3
    I think maybe I am coming off as someone who doesn't like lisp. In truth, I love it. Clojure is an incredible language. I think its a very viable choice for a certain kind of company to use. I am just pointing out there are a lot of companies where it wouldn't make sense, and using something like Scala is a much more practical choice. – dbyrne Mar 20 '11 at 04:00
  • I never claimed side effects were the sole factor for ease of refactoring. I gave one example of why I believe java isn't easier to refactor. Clojure's default is immutability, java's is side effects. This makes a big difference. – jshen Mar 20 '11 at 04:57
  • 1
    I think a lot of why Haskell is really catching on where Lisp hasn't is due to the research effort put into showing that Haskell code is "more correct." Lisp has a reputation of being very flexible but not necessarily for making objectively better programs. Haskell has a large body of research (especially towards concurrent programming) to show that a Haskell program is provably correct. I think that lowers the percieved risk factor and makes it a more viable choice. – CodexArcanum Mar 22 '11 at 04:00
  • @dbyrne: isn't one of the chief complaints about scala that it veers towards being a write-only language? The features that make it expressive and suitable for DSLs is also the features that, in the wrong hands, make it difficult to read and maintain. Isn't this ultimately the reason you give that LISP is not more popular? If so, how is scala any different? Note that I like both scala and clojure, but given the abundance of mediocre programmers I'm not certain I'd want to work with them in a team environment. – Kevin Feb 21 '12 at 19:08
  • @Kevin: It depends on the team: if you find the right team of "elite" Lisp programmers... ;-) – Giorgio Oct 21 '16 at 19:22
  • @Kevin Note from 2016 (almost 2017!): Scala isn't hard to read because of its expressivity. The type signatures of some library methods are relatively hard to read because Scala is a hybrid functional+OO language, and this results in complex signatures when writing generic functions that must also deal with subtyping and inheritance. This however is seldom found in code written by regular programmers, so it's not a big deal for Scala. More problematic is the widespread use of implicits, which make some Scala code really hard to follow (but they are unrelated to expressiveness!). – Andres F. Nov 25 '16 at 13:29
  • @dbyrne I must challenge the assumption that Java code is easier to read. Complex Java code is *really hard* to read, especially by novice programmers who don't understand side-effects or what changes what. Refactors in Java often break things precisely because all the verbosity hides what's really going on. – Andres F. Nov 25 '16 at 13:31
  • I also have advocate for Clojure. I've been writing with it for a few months now and it's pretty fun. Intellij+Cursive(free) and you're set. – Carcigenicate Nov 25 '16 at 23:34
  • I'd code in LISP & Clojure if they let me, and JavScript & Python too. Please give me a job : (. If we had Lisp we would have used a macro DSL for HTML, CSS, and SQL hmm... – aoeu256 Jul 01 '19 at 19:22
  • Scala is easier than LISP...? – aoeu256 Mar 29 '21 at 02:51
19

Why is not Lisp more widespread? If it is really that powerful, people should be using it all over,

If you believe that languages are chosen for their technical merits, you are in for a soul-crushing disappointment.

Such decisions are made based on Strippers And Steaks. Microsoft can afford them. Oracle can. Sun spent so much money hyping Java that they went bankrupt. Twice. A decentralized, heterogenous, volunteer community cannot compete with that.

but instead it is nearly impossible to find, say, Lisp job advertisements.

Funnily enough, the Lisp companies say exactly the opposite: they constantly have job openings but can't find enough people to fill them. (The same applies to Haskell, ML, O'Caml, Forth, Smalltalk, ...)

Jörg W Mittag
  • 101,921
  • 24
  • 218
  • 318
  • 5
    Where I live (Italy) I doubt even a single Lisp company exists... – Andrea Mar 19 '11 at 23:58
  • 1
    Which large companies are pushing Ruby, Python & JavaScript? JS is an admittedly special case, but the other two seem plenty popular without massive corporate/vendor backing – Ben Hughes Mar 20 '11 at 05:05
  • Yes, that's true for other languages as well. Most good COBOL coders already have jobs, and are not reading the ads anyway. Why bother advertising? – Bo Persson Mar 20 '11 at 13:14
  • What really? I'll code in any language thats not mainstream, although Haskell sounds way over my head. The small amount of code I've coded in it is extremely beatiful, but without a good mentor I have no idea when to use each Monad and the Applicative Functors. – aoeu256 Jul 01 '19 at 19:24
11

I have no experience in working for a real company, but I know why LISP has been hard for me to use.

First of all, this reminds me of this blog post: http://steve-yegge.blogspot.com/2006/04/lisp-is-not-acceptable-lisp.html

The main problem that I have with Lisp is the "which Lisp" question. I usually work on Linux as my main platform, but the things I make need to be compatible with Windows. That means that when I'm evaluating a technology to use, it must make my life easy when working on two radically different operating systems. I don't like this requirement, but to use it on a real project that's a requirement. Now I'll use languages that don't have very good support on Windows for my own personal side projects, but because I never get a chance to write a large software project in them, I don't have the necessary experience.

Now when I was trying to learn a functional language, I really wanted to learn Common Lisp. It seemed like the right thing to do. I started reading Practical Common Lisp as a jumping off point since I really didn't know the built-in functions and needed a project to work on in Lisp. S-expressions were beautiful and easy. All those parenthesis were incredibly beatiful to me as it was clear as day exactly what was happening in the code.

So I try to write my first program in Lisp outside of the book. I wanted a command line tool that would count lines of code and remove trivial lines from the code count. Not the most useful tool, but fun to do. It involves file access, a bit of parsing, and counting. I had implemented the same tool in Python about a week earlier.

I need to access command line arguments. Then I learn there is no standard way to get command line arguments. They're all non-standard features. It's not cross-platform at all. It mostly just gets worse from there as the language doesn't have a lot of libraries built into it. I ended up switching to Haskell and didn't get very far into Common Lisp (so my complaints may not even be valid).

This kind of non-standard thing has always been a pain for me in the past. C++ has this same problem, but with libraries like Boost you can get around those weaknesses.

It also doesn't help that the Lisp syntax for everything other than S-expressions is a little ugly.

jsternberg
  • 1,531
  • 11
  • 15
  • 1
    PLT Racket (formerly PLT Scheme) runs well on both Linux and Windows. – Larry Coleman Mar 22 '11 at 13:47
  • Interesting, I would expect Common Lisp to be much more standard and usable for real applications than Scheme is. (I am reading Practical Common Lisp right now.) – Giorgio Dec 12 '12 at 13:27
  • I commend you for choosing Haskell (which is a better language in my opinion), but what about Clojure? It runs on the JVM, so it should be portable and have access to all the libraries you need. – Andres F. Nov 25 '16 at 13:35
  • Command line arguments are difficult to use in C++? Really? – Nick Keighley Apr 10 '17 at 10:50
  • Isn't it trivial to build a cross-complier that changes Lisp to Scheme to Clojure? Why don't people use them? – aoeu256 Jul 01 '19 at 19:26
  • It also depends on which implementation of common lisp you use, which may be another issue that new programmers have... Different implementations may not be compatible with different operating systems... Which can be a pain. I have always thought that LISP was great for web applications and back end mobile applications since you can use whatever implementation you want on your own servers. I thinks that's where LISP could've had a future. – Simeon Ikudabo Nov 27 '19 at 07:51
8

IMO, it's mostly due to:

  • Poor library support. Sure, there's Quicklisp now, which makes it easy to install libraries, but it doesn't compensate for them being still fairly few, and quite a few are poorly documented or not very well maintained. Compared to Python, there's a good chance that writing non-trivial Lisp application (regardless of the particular dialect) will probably still involve reinventing at least part of a wheel or two.
  • Lack of familiarity with the model adopted by development tools. Most of the folks I know are fairly intimidated by having to use SLIME and Emacs, which is understandable for people used to Eclipse and Visual Studio. There are two Eclipse plugins I think, I only tried one of them a few years ago and it was pretty buggy. The whole Lisp ecosystem looks like it's stuck halfway between the days when it was part of a full-fledged Lisp-running system and the modern standard of oh-it's-another-language. Learning Lisp is not limited to learning a new language -- you also need to learn an entirely different way of working and thinking, and while this is okay if you're doing it as a hobby, it's questionable whether it's worth doing it in a business.

Things are starting to look slightly better though, especially with Clojure being around.

donkey_lz
  • 127
  • 2
  • 1
    "Most of the folks I know are fairly intimidated by having to use SLIME and Emacs, which is understandable for people used to Eclipse and Visual Studio.": Again and again I get the feeling that Lisp is for elite. – Giorgio Oct 21 '16 at 19:25
  • 2
    "You also need to learn an entirely different way of working and thinking, and while this is okay if you're doing it as a hobby, it's questionable whether it's worth doing it in a business.": Isn't the increased productivity a good enough reason? – Giorgio Oct 21 '16 at 19:26
  • Has this "increased productivity" been demonstrated? It certainly isn't clear to me (yes I've programmed in a Lisp dialect). There Are No Silver Bullets. – Nick Keighley Apr 10 '17 at 10:46
  • @nickkeighley there was a study that showed that Lisp is at least less verbose when compared to Java: https://norvig.com/java-lisp.html . Whether or not that makes someone more productive, I don't know, but typically the difficulty of maintaining a system is the length of the program. There are also many things that you cannot do in a language such as Java without essentially creating a Lisp or Python interpreter without realizing you have done so. I think that's extremely relevant in web development back-end programming. – Simeon Ikudabo Nov 27 '19 at 07:55
  • Proving something is less verbose than Java is setting the bar kind of low... – Nick Keighley Nov 29 '19 at 13:40
6

I learned LISP a billion years ago in college.

LISP, like FORTH, is great for logic. But most programming is not about logic, it's about manipulating data in boring mechanical ways. For example, at the time there as no way to right-justify numeric output.

LISP is about nested functionality, and people just don't think that way. They think in terms of DO A, B, C, D, then E. Not do A, which involves doing B and C, then D and E. THis involves a kind of concurrency which is confusing. Except for predefined tasks like "file an income tax return", people don't think concurrently, they think sequentially. This is why procedural languages are dominant today.

As a result, produral code liks Java and C can be translated into English easily. LISP code can not; no human language is structured in that way.

So it's great for problem solving, but problem solving is not very important in programming. Data entry, validation, output formatting, all of which LISP was terribly weak at.

Andy Canfield
  • 2,083
  • 12
  • 10
  • 9
    Problem solving IS all we do. Manipulating data is not easy in Java or C. Manipulating data in cons cells is much easier in Lisp and other functional languages. Most operations on data are the exact same and don't care what order you process them in. These are easily done with a call to map and a function pointer. I would also say it's easier to think in nested functionality than in procedural functionality (as one details your goal, and the other details how to perform said goal), but I have no proof for that. Either way, I would not say this is the reason LISP isn't used. – jsternberg Mar 22 '11 at 06:35
  • 6
    Programming is not about problem solving? I don't think so. And by the way I don't think that you can **learn** a language in college either. – Adam Arold Aug 02 '11 at 15:24
  • +1, sounds very plausible for me who don't know any Lisp. I would state the same reason C/Java is better than Python for enterprise-size solutions. – Jonas Byström Jul 08 '12 at 11:13
  • 1
    This is the only answer so far that raised the huge topic of functional vs procedural, but let's not forget procedural thinking tends to like tinkering with globs of data in vars everywhere you can touch from many places and threads creating synchronization problems. Functional doesn't suffer as quickly from this, well-written functional doesn't suffer at all. – maxpolk Nov 25 '16 at 15:32
  • 1
    A programmer once asked me what the best way to express a for loop using a a data-flow diagram. For such people there is no point to non-procedural languages. The *think* in FORTRAN. – Nick Keighley Apr 10 '17 at 10:53
  • Actually if you ask non-programmers to come up with languages or specifications for programs many of them will see the world in turn of concurrent processes or objects that communicate with each other, some will think of prolog or constraints, some will think functionally, and yes many will think imperatively. – aoeu256 Jul 22 '19 at 21:43
  • @aoeu256 could you provide references to any research backing that claim? It would be very interesting to read. – Magne Feb 15 '21 at 15:34
6

I think one problem with Lisp not yet mentioned is that for a mediocre or novice programmer (like myself, I freely admit), it can be difficult to see how you turn Lisp code into a big program. It's easy to write but hard to architect. I don't think any of the concepts are particularly difficult, but the DIY mentality is so strong that I often feel at a loss where to even begin.

With an OOP language like Java or C#, you can use the type system to boost yourself towards a working model, and build off that. With Lisp (or Lua, or Javascript, for that matter) there's this notion that you can go out and do it any way you want. If you want OOP, just make your own OOP system! Except making your own OOP, or learning someone else's, is a new barrier on top of the language before you get usable programs. Plus I always feel like the OOP in Lisp or Lua isn't really there, like I could just ignore it if I really wanted, so what's the point?

In short, I think programming in Lisp requires a great deal of discipline, and that's very hard to come by. Strongly-typed languages and OOP languages both offer a kind of built in discipline, so the programmer can focus their limited reserves on finishing projects instead of tweaking the language.

EDIT: As an analogy that just struck me, it's like if you need to do some wood work and two people offer you their tool boxes. One person's tools are kind of crummy, but would basically get the job done with a bit of effort. The other person has a big bin of parts, but is promising that you can combine those parts to make the best tools you'll ever used, perfectly suited to your grip and of the best quality. You just have to build them first.

CodexArcanum
  • 3,421
  • 21
  • 23
  • 2
    Common Lisp, at least, is explicitly an OO language: the Common Lisp Object System is part of the standard. – Frank Shearar Mar 22 '11 at 08:45
  • True, and as I understand it's a very powerful one, but it comes across to me as a side-feature of the language. It isn't like Java where you need to understand objects from day 1. Practical Common Lisp doesn't touch on CLOS until chapter 16. I may also just be biased towards static-typing, though I don't dislike dynamically-typed languages. – CodexArcanum Mar 22 '11 at 13:58
  • Lisp allows you to use closures (let-over-lambda) instead of objects for light-weight OOP, but I believe its easy to upgrade to use OOP via CLOS. – aoeu256 Jul 22 '19 at 21:39
2

I've been wondering the same for long, and I even went to Lisp conferences to try to understand what is this Lisp "dark side" that keeps everyone from adopting it.

I've found no complete decent answer.

Ignorance may be the reason for the missing popularity, but what puzzles me more is that even who for sure knows about Lisp (for example Google - Peter Norvig works for them) is not using it.

The only partial explanation I come up with is that most of Lisp great ideas are now commonplace, the only really important missing one (a hugely important one IMO) is ease of metaprogramming.

Unfortunately I see no easy way to adsorb this concept for other languages because metaprogramming to be nice requires an homoiconic and regular language (I'm talking about general metaprogramming, not the dumbed-down template-only version). In other words it basically requires the Lisp approach to syntax: code is data and data is code. Writing code in a syntax-rich language that manipulates an AST is more difficult because you need to know two languages: how to write the code and how to write the AST. This is especially hard if your AST is fixed and also complex and irregular with a lot of different node types. Lisp instead has a reasonably regular (and extensible!) AST and you already normally code by directly writing the AST.

Metaprogramming is also inherently more difficult (and meta-metaprogramming even more and so on) and most programmers and managers apparently just prefer the "no one would need that" answer.

I find particularly sad that "new" languages like go ended up using text-based metaprogramming when is needed (externals code generators writing text files) and "magic" (i.e. the compiler can do what the programmers cannot do).

I think the solution to the complexity problem are powerful tools and education. The trend is apparently instead blunt tools and pretending the problem is not present.

6502
  • 731
  • 6
  • 8
  • +1 for "I think the solution to the complexity problem are powerful tools and education." – Giorgio Apr 09 '17 at 14:09
  • after 50 years the 'ignorance' excuse is wearing pretty thin – Nick Keighley Apr 10 '17 at 11:01
  • 1
    @NickKeighley: depends. Even today most programmers really don't know anything about Lisp (for example most of the times you hear Lisp described as a functional language). Even among who "knows" Lisp almost no one ever saw the macro idea with sufficient detail (I'm not talking about the dumbed-down version of scheme, but full algorithmic power with convenience of quasi-quoting when that fits better). – 6502 Apr 10 '17 at 13:46
  • @6502: While not being purely functional, IMO Lisp does support functional programming much better than many mainstream languages like C#, Java, C++, and so on. For many programmers, FP means just using a lambda expression from time to time: these programmers won't miss Lisp or Clojure or Haskell. So I would add: (1) Lisp does support FP pretty well and functional programmers would profit from it but (2) ignorance about FP and its benefits is one reason why Lisp is not used more often. – Giorgio Apr 19 '17 at 10:24
  • @Giorgio: If you call Lisp a functional language then you should also call Python or Javascript a functional language. The language itself is multiparadigm and Lisp has a slightly better support than say Python because anonymous functions do not have limitations (in Python the body is limited to a single expression) and because Python has the statement/expression duality. I'd find hard to say that is however "more functional" than Javascript. – 6502 Apr 19 '17 at 11:01
  • 1
    @6502: Having lists as basic data structure and the usual high-order functions on lists is also a feature that is missing in Javascript. And, as far as I can remember, Javascript also has the duality statement / expression. I would definitely place Lisp (Common Lisp) a few steps further in the direction of FP than Javascript or Python. By this I do not mean that Common Lisp is a purely functional language, I agree that it is multi-paradigm, but it supports FP much better than other multi-paradigm languages. – Giorgio Apr 19 '17 at 11:21
  • @Giorgio: Yes Javascript has statement/expression duality but it's less annoying than in Python because assignment is an expression; given you also have the ternary expression for conditionals and comma operator for sequences you get all control structures with the exception of loops as expressions. Moreover you can always put any code (including loops) in the middle of an expression with `(function(){...})()` that's sort of a pattern in Javascript for other reasons (e.g. implementing `let` before it was standard). – 6502 Apr 19 '17 at 17:49
  • @Giorgio: having lists as basic data structure has nothing to do with functional programming: FP is about immutability and pure functions and Lisp (the original its evolution in CL, not the Clojure dialect) has nothing special about immutability. Python 3 for example is going in that direction as more and more parts of its standard library are becoming lazy (`dict.keys()`, `range()`, `map()` etc... and lazy computation doesn't mix well with side effects). Here I'm not saying that FP sucks, but if you say Lisp is functional then you need to double check your vocabulary. – 6502 Apr 20 '17 at 06:13
  • @6502: "Mapping and filtering is the bread and butter of every functional programmer's toolbox.", from http://learnyouahaskell.com/higher-order-functions – Giorgio Apr 20 '17 at 06:25
  • @Giorgio: Mapping and filtering is not about list: is about sequences. Mapping and filtering of sequences (especially lazy and potentially infinite ones) is very FP-esque, but CL has no support for it (for example Python instead provides generators, even if map and filter are less idiomatic than comprehensions). – 6502 Apr 20 '17 at 10:53
  • Can't you just use a LISP front-end for JavaScript or the JVM? – aoeu256 Jul 22 '19 at 21:48
  • @aoeu256: yes... those are in my opinion very interesting options. If you like common lisp there is e.g. Armed Bear Common Lisp (https://common-lisp.net/project/armedbear/) and the non-CL but currently trendy Clojure (of which I personally don't like much among other things the strange **and fixed** reading syntax and more importantly the obsession about immutability - support for immutability is ok, being obsessed by immutability is not). Compiling to Javascript is even more interesting in my opinion... performance is getting amazing and the "compiled code" is even more portable than Java. – 6502 Jul 23 '19 at 05:54
1

For web development with Lisp dialects, there can be a bit of a chicken-and-egg problem - because few people use Lisp, hosts either don't allow it or don't make it easy, and because it's not easy, few people use it. But actually, getting Lisp running on a host can be easier than you might think, even if it requires a bit more work than their out-of-the-box PHP service does. I recently got guile Scheme apps working here with just a little effort.

gcbenison
  • 123
  • 3
1

It seems that even CL does not have very good library support. At least according to people who switched from Lisp to Python:

http://www.redmountainsw.com/wordpress/archives/reddit-switches-from-lisp-to-python

Personally, I know some Scheme and enjoy playing with it, but can't imagine doing a non-trivial project in that language.

Nemanja Trifunovic
  • 6,815
  • 1
  • 26
  • 34
  • 2
    This is no more true. [Quicklisp](http://www.quicklisp.org) solved that problem. –  Mar 19 '11 at 23:04
  • 2
    It's also worth mentioning that with CFFI, any C library can be used from Common Lisp. CFFI is well-documented and works well. On the other hand, if spending a few hours writing wrappers for C functions has a major impact on your project, Lisp probably isn't the right choice for it anyway. – Larry Coleman Mar 21 '11 at 13:06
  • I did a non-trivial project in Scheme and know a company that uses Scheme (Chicken Scheme) for several products. – Giorgio Apr 20 '17 at 07:40
1

Being powerful doesn't necessarily imply widespread use. Have you heard of the term 'Optimize for the common case'? Unfortunately as many have told before mediocrity if assured consistently is a lot better for people than big hits with many failures in between them.

This isn't just the case with lisp, but with a lot of technologies. A good touch over Unix text processing tools, awk, sed, perl can save you days of programming. Unfortunately I have seen people take days do these sort of tasks in other tools badly what could have done with these tools more efficiently in minutes. But if one spends all his life in eclipse he will never come to appreciate the value of these things. You may write a huge program with readability and maintainability and all that, but whats the whole point of writing such a program while not writing it could have easily done the job.

Another aspect while designing tools these days how much useful out of the box they are to use them directly to solve a problem. You can't build something too generic and then then say you will hedge all of that through libraries and frameworks. Its a little difficult to work things out that way.A good tool gels well with the environment and problem around it. That's why tools like php,perl and awk continue to remain relevant despite endless trolling and bashing, because they are too useful to throw them away and often they do a lot of work than a general language with many libraries and frameworks bolted on.

Similarly you will see languages like Java/Python are very good and I would say best for certain tasks. Python especially is very good and easy to learn and write. Also these languages do really good if your data end points are standard. Some sort of a database or a XML or data of that sort. Basically structured data.

Lisp will be there around for long time, but not necessarily widespread. As you will see each tool has its niche. And they solve certain set of problems very well out of the box. I think and I'm sure lisp is doing good in areas and problems for which its designed to solve well.

kamaal
  • 1,125
  • 7
  • 10
  • +1 for citing the "Optimize for the common case" principle. – Giorgio Dec 12 '12 at 13:30
  • Yeah but LISP's Closures are an optimization for the common case of Objects. Also I was wondering if anybody makes changes to their LISP code base via treating it as a tree and running queries on it like JQuery for HTML. – aoeu256 Jul 02 '19 at 13:01
0

IMO, it's mostly a matter of poor timing: Lisp was old (and almost by definition no longer exciting) long before it became practical for most people or uses. Clojure (for one example) stands a much better chance. Its success will depend far more on being perceived as new, fashionable and cool than anything as practical as interoperation with Java (and everything else that runs on the JVM) though.

Jerry Coffin
  • 44,385
  • 5
  • 89
  • 162