3 ms·
A few questions for the Lisp fans out there: 1. The summary here seems to be "modern high-level languages, used, well, are just as productive as Lisp." Does th
by wpietri 8y ago
A few questions for the Lisp fans out there:
1. The summary here seems to be "modern high-level languages, used, well, are just as productive as Lisp." Does that seem right?
2. One of the tensions for me in technology is between love of simplicity and love of complexity. An example of the latter is Enterprise Java, where the tendency toward a FactoryProxyBeanMutatorFactoryInterfaceImplementation is well known. Is the perceived superiority of Lisp perhaps because it attracts people with strong simplicity bias?
3. Every "Lisp is super-productive" story I hear is about a lone individual. Is Lisp's suite spot that of the solo programmer? Since the rise of the Internet, I think most software has shifted to be about teams, and I'm wondering if Lisp is less suited to team collective ownership or projects where many teams are involved.
- ska 8y agore: 3. I can't speak for anyone else, but some of the most productive research coding I have done was in lisp. I do think it is difficult to work in large teams with lisps, their flexibility becomes a barrier to communication. The enterprise model of "100s of programmmers, all fungible" isn't quite right anywhere, but it really spectacularly falls apart in an environment like lisp. I do think lisps are amongst, if not the, most productive languages for one programmer (or a very small team that works well together) to do novel, exploratory programming. This fits really well in some types of research. On the other hand, if a lot of what you want to do is basically glue - lisp doesn't buy you too much. For example, I don't thing python is a very productive language, but it is a very productive ecosystem - if that makes sense. Far more so that lisp(s) today for many problem domains. If you really want to start something basically from scratch, it's still a very good match. But if you are going to spend a lot of time building 70-80% solutions for problems that in another environment would be one include away ... maybe you won't be so fast.
- 13415 8y agoMy answers only reflect my own opinions as a long time Lisper and Scheme user. Other's mileage may differ. 1. Yes, more or less. LISP used to be superior to everything else but modern languages have caught up in most areas. LISP still has a few special tricks like MOP in CL, macros, dynamic loading of code, resumable exceptions, but these are rarely needed in everyday programming. 2. No, not at all. Neither CL nor Racket nor any other mature LISP and Scheme dialects are simple to use and easy to learn. They have long-steep learning curves, especially idiomatic CL. The syntax is somewhat simple if you ignore special reader extensions, but that's irrelevant. CL is a large language, you need to learn both imperative and functional programming techniques, and then there are tons of libraries and conventions to learn. 3. Yes, I would say. LISP is incredibly powerful in the hand of one hacker who really knows the system. You will get awesome results very fast and can do things that would be really hard in other languages. It also encourages high level abstractions like no other language I've ever seen. But the main disadvantage of LISP is maintainability. It may be hard to even understand your own code a year or two later, let alone that by other people. Everybody has his own stile and every larger program will create a DSL you have to learn in order to understand what it does.
- Viliam1234 8y ago> But the main disadvantage of LISP is maintainability. LISP allows programmers to use abstraction so powerful that sky is the limit. Problem is, humans have their limits, too. And different humans have different limits. Abstractions are powerful, but then you have to think abstractly in order to use them properly. When you are good at abstract thinking, LISP will liberate you. When your colleague is better than you, or just as good as you but has more LISP experience, reading their code will make your head hurt. To make you two cooperate, your colleague would have to give up some of their powers... but the ability to use those powers to their maximum was the thing that made them love LISP. So now one of you is going to suffer. Other languages often put artificial limits to your abstract thinking. For example, you have a few parts of code you realize are somehow just different instances of the same pattern; the pattern could be extracted and reused... but doing it in this language would either be impossible, or the outcome would be really ugly, or it would require writing so much boilerplate code that the more abstract version would end up being longer, less legible, and not really nice at all. So you sigh and don't do it. And the same thing happens to your colleagues in similar situations, so now you are all writing approximately on the same level of abstraction. In other words, with lesser languages, the frustrating thing is the language. With LISP, the frustrating thing is other humans (and that may include yourself on a different day). But the frustration is always there. Unless you are really good and working alone, I guess. But that puts the company that employs you in a dangerous situation, so it is unlikely to happen.
- kazinator 8y agoWhen your friend is a faster runner, and is wearing running shoes, he will leave you in the dust. Solution: everyone wears combat boots, and carries a 30 pound load on their back. Now the field is level; and you even have to cooperate to go forward.
- Viliam1234 8y agoThat's the sad fact about human nature: when you have a project that requires everyone to move at the same speed, chaining people together and putting unnecessary weight on their back works better (more reliably) that asking the fastest ones to please slow down a little. (Then of course there are also other problems, such as companies wanting to keep all their employees completely replaceable, which is incompatible with people using their unique skills.)
- aidenn0 8y ago1. The gap is smaller, and shrinking every year but still exists, and it's not just macros; the condition system and the tooling is way better. The tooling alone is sufficient reason for me to use lisp. Even commercial IDEs for python (e.g. pycharms) are nowhere near as good as slime, plus sbcl is a compiled language. I can change a function, run a test and get instruction level profiling information. Pretty much no modern dynamic language lets you do that, and the non-modern static languages (e.g. C++) take longer to link (much less compile) then it takes me to do all of those steps for incremental changes in lisp code. 2. I have a strong simplicity bias, so I can't argue there. I will say that lisp is good at "getting out of your way" which helps remove a lot of accidental complexity. Java (particularly the Java from 15 years ago), is notoriously bad at "getting out of your way" so they are near opposite ends of the spectrum there. 3. Lisp works fine in teams; most languages with small communities have fewer team projects just because the set of possible teams grows quadratically with the size of the community. This is exacerbated in the lisp community which historically has several silos. For open source projects, SBCL (which is written in lisp) is the first team project that comes to mind. For commercial software, QPX comes to mind; ITA was listed as having 400ish employees, I'm not sure how many were working on lisp code though.
- zackmorris 8y agoI feel like Lisp didn't win out for the same reason that HP calculators never won out: people don't like the mental burden of flipping their calculations around by hand. Which is another way of saying that functional programming (FP) doesn't follow any of the imperative programming (IP) conventions they're used to (by design, generally). Everything about FP is conceptually good except for the human element. I find other people's FP examples to be exceptionally hard to read. But in fairness not as hard as object-oriented programming (OOP) IP languages like Ruby or Angular. I picture them as two extremes: abstract formalism with FP on the one hand and syntactic sugar/convention/patterns with IP/OOP on the other. I'm classically trained so to speak, so I can make the mental leap to FP when I need to. But I continuously have trouble with IP languages because for the most part I don't understand what problem they're trying to solve. I think Elixir, Clojure and F# are making inroads on the FP<->IP/OOP front but they still aren't easy enough for mainstream adoption IMHO. Haskell, Scala etc are too fringe and have probably already reached saturation. Also I do agree about the ignorance aspect. Most programmers I've met don't understand the difference between simple and easy, as examined in depth by Rich Hickey: https://www.youtube.com/watch?v=34_L7t7fD_U https://www.youtube.com/watch?v=34_L7t7fD_U