3 ms·
Lots of reasons. 1) Lisp acquired a reputation of being associated with AI, back when that was a bad thing, lots of government-funded "expert system" boondoggl
by bitwize 5y ago
Lots of reasons.
1) Lisp acquired a reputation of being associated with AI, back when that was a bad thing, lots of government-funded "expert system" boondoggles and the like. It is not considered a general purpose language, despite being one.
2) Lisp is thought to have poor library support. Unlike Java or JavaScript, which have standard libraries for every task, Lisp is thought to lack this. Quicklisp helps, but it's not as comprehensive as Maven or npm.
3) Lisp is associated with a certain programmer type: highly intelligent, persnickety, only interested in solving interesting problems. Companies prefer programmers who have only a moderate amount of technical skill but who are diligent, who will take orders and get the job done without complaint.
4) Not many programmers actually know Lisp, because not many bother to learn it. If CS students are exposed to Lisp in college, they will complain about it and won't touch it again after passing required classes that use it. This means Lisp has a much smaller qualified candidate pool and it's much harder to hire Lisp programmers.
5) Software projects, especially enterprise software projects, are optimized to require lots of programmers each of whom develop one component without stepping on each other's toes. In the enterprise, not breaking existing things is more important than building new things rapidly. This is why OO languages like Java are so well loved... they help encapsulate programmers from each other as well as encapsulating units of functionality. Each programmer poses more risk in a small team where every programmer's responsibility is larger (and every programmer could theoretically rebuild the whole system themself given enough time) than in a large team where none of the programmers have a complete understanding of the system and everybody stays in their lane.
7) Larger programming teams are just more impressive. As a manager if you have 100 direct reports instead of 10, you are a bigger deal. You can command a bigger budget, which also makes you seem more important.
So the odds are pretty stacked against Lisp. It doesn't scale well to large teams, but it lets a small team get more done. The incentives in most software development reward large teams of programmers just barely smart enough to get the job done, not small surgical teams of wizardly Lisp hackers. So Lisp remains niche, perhaps rightly so.
- daniel-cussen 5y agoYou might be able to hire 100 Lisp engineers. It's just super expensive, they're going for really high prices right now, and it might be way overkill.
- daniel-cussen 5y agoTo expand on this, JPL probably has 100 Lisp engineers because it has intricate astrophysics problems that warrant 100 Lisp engineers. Most companies will never have such difficult problems. They may think they can, but they cannot. They can have crappy problems, however, and crappy problems can tie up those engineers provided they have very little agency in solving the underlying problems that give rise to those crappy problems. And you have to be careful to manage them very adversarially to keep it that way because they will totally try to actually fix things without your knowledge or permission. Not always, though, sometimes they get stuck in a mesh of very nerdy concepts and then there's no risk.
- returnfalse 5y agoReally good observations
- Jach 5y ago> It doesn't scale well to large teams Doesn't saying stuff like this just contribute to your reasons 1-3 that boil down to perception issues, and not anything wrong fundamentally with the language itself or even its modern day practitioners? I don't disagree that Lisp doesn't scale in the sense that there's not enough Lisp programmers available to actually scale to such grand sizes of even 1000 developers right away, but as I'm sure you already know I want to say for the benefit of passersby that Common Lisp itself is object oriented, has namespaces and can support a modular or component style of development, its global memory model isn't too unlike that of the JVM prior to Java 9 (i.e. everything dynamically loaded and being introspectable and to some degree changeable (more effort in JVM)), it's been used for multi-million line projects (not sure how large the teams for those are/were though), and nothing of the recent microservices trend to scale in a different way is forbidden to Lisp... Besides, it's not like enterprise companies that have 1000+ devs actually have a 1000+ size team with a single standup. No, things are divided into smaller teams of around 2-10 with maybe 6 being average. I disagree somewhat with your reasons 3 and 5 and 7, having worked at an enterprise company with thousands of developers and been involved in hiring processes. Maybe I was just lucky and other enterprises are different? In my case, the implicit incentives might sometimes align in the direction you indicate, but explicitly, no, they don't. Hiring selects for stronger technical skills over weaker technical skills, interviewers prefer candidates who have a story of leadership/taking action/dealing with people socially (i.e. how do you handle such and such kind of a disagreement) over heads down and take orders and pretends there are no disagreements, no participation. Each engineer is pressured into career growth and expected to reach a certain role level after N years. Getting promoted to such a level typically involves taking on some sort of leadership role that impacts more than just your own team, and often more than one such role or a secondary role in another's project because things fall through. Despite encapsulation, things very often broke in the monolith (note only in development, production breakages were rare), and many new hires had to be trained to not sync every day if they wanted a more peaceful life. The teams that end up with a domineering management who allow no input from the development side typically don't last long because the developers switch teams (easy to do in an enterprise org where there are tons of teams with headcount every quarter) and with no team left area ownership will be dispersed. No manager has 100 direct reports. They might have 100+ indirect reports, but after a certain direct size, they have to become a higher level manager. They may still retain a couple ICs as direct reports but most of their directs change into a small number of other managers or directors, in classic org chart hierarchy.
- mbrodersen 5y agoThis is yet another “non-Lisp programmers are not as smart as Lisp programmers” comment. Seriously? I know Lisp well and have implemented my own variations for fun. But I prefer other languages. Lisp has been over hyped for 50+ years and have still very little to show for it. The world runs 99.999% on non-Lisp code. So perhaps consider that there might be a reason why? Unless you actually want to suggest that 99.999% of developers out there are less intelligent than Lisp programmers? Really?
- medo-bear 5y agoWhat did you implement? :)
- mbrodersen 5y agoA console game generating $500 million+ in revenues, a high performance optimising compiler used in production, an embedded web server used by companies in the field, Android software used for warehouse management, commercial 3D engines etc. And much more I can’t remember right now. Why?
- medo-bear 5y agolol. ok. but do tell (or better show!) what lisp you implemented
- mbrodersen 5y agoSo what have you implemented in your magical 10x language? I told you some of what I have done not using Lisp. Here is your chance to brag about all the cool production stuff you have written in Lisp. Let me get my popcorn. I am waiting :)
- medo-bear 5y agoyes you made some claims but i am a little bit skeptical :) tbh i don't think you have a handle on this subject at all. also i specifically asked you about your implementations of lisp and you mentioned everything except that. it's not interesting. as for me i work in machine learning and we are starting a project in which lisp is used as a sort of glue language between various components. i only wish more of the stack consisted of lisp components, but who knows maybe it will eventually :)