4 years ago by dang
Some past threads:
Lisp as an alternative to Java (2000) - https://news.ycombinator.com/item?id=26720403 - April 2021 (94 comments)
Lisp as an Alternative to Java ā Faster, More Productive - https://news.ycombinator.com/item?id=21899854 - Dec 2019 (1 comment)
Lisp as an Alternative to Java (1999) - https://news.ycombinator.com/item?id=12197131 - July 2016 (103 comments)
Lisp as an Alternative to Java (2000) [pdf] - https://news.ycombinator.com/item?id=9045574 - Feb 2015 (21 comments)
Lisp as an alternative to Java (2000) [pdf] - https://news.ycombinator.com/item?id=8446368 - Oct 2014 (55 comments)
Lisp as an Alternative to Java - https://news.ycombinator.com/item?id=3447101 - Jan 2012 (37 comments)
Lisp as an Alternative to Java [PDF] - https://news.ycombinator.com/item?id=61320 - Sept 2007 (9 comments)
4 years ago by felideon
From the 2014 incarnation:
> Just to put this paper in an appropriate historical context, I wrote it back when I was trying to convince NASA that flying Lisp on a spacecraft would not be a completely insane thing to do. The Powers That Be had already mostly accepted that it would be OK to fly Java, but they thought Lisp was too big and slow. This study and paper were designed specifically to address those concerns.
4 years ago by sophacles
Thanks dang - i appreciate when you post these, particularly on perennial topics: it's interesting to look back and see how the crowd's wisdom has(n't) changed.
4 years ago by undefined
4 years ago by neilv
> the directions said to code as you would professionally, and that means I should comment my work.
Were this a "professional" component/service, in perhaps the majority of situations today, he'd probably separate his docs into two kinds of documentation: the committed interface/API what, and the internal maintenance how.
The docstring for `print-translations`, for example, conflate these two kinds.
Incidentally, by 2000, Java had emphasized reuse API documentation for a few years, with how it presented Javadoc for both the core Java API and layered development, from the start.
By contrast, Lisp environments that exposed docstrings in IDE hypertext, like Emacs did, did some doc things better than Java for decades before, and are still really well-suited to army-of-one genetically-enhanced supersoldier Lisp hackers.
Enterprise development, SaaSes, microservices, large systems with multiple teams, etc., were arguably better off heading in the more software engineering direction that Java was going.
(Which is not to say that Lisps can't do the what&how docs separation. I've done a few embedded API docs things for Scheme and Racket that initially were inspired by Javadoc, Perl, and some of the less-commonly-used embedded docs setups for other languages. And have worked on a couple large Lisp systems that arguably wouldn't have been possible in a language without some of the Lisp family's other still-unusual strengths, nor without the highly-skilled developers that Lisps seem to attract disproportionately.)
4 years ago by oalae5niMiel7qu
Hunchentoot attempts to do the "what&how docs separation", but when I last used it, I had to look at the implementation to understand what my code was expected to do. At least Emacs and SLIME made it easy to pull up the source code.
4 years ago by abhinav22
Lisp is a wonderful language (Common Lisp in particular, but I am dabbling in Scheme now too), and absolutely fantastic for web development - seriously people should give it a chance in that space, I would totally develop any SPA in Lisp[1].
QuickLisp is simply a joy to use, and the language is very portable with a fantastic specification and many top notch compilers.
IMO, what holds it back is a lack of a top notch IDE. It took me a year of love & hate with Emacs, I can now make pretty good use of the amazing software that is Emacs (where everything can be changed), but honestly at times I want a simple point & click free IDE which is polished and does most things well and out of the box. Portacle is a step in the right direction, but the Emacs dependency IMO does make the language a bit more niche and lose out to other languages for beginners. If some big corporation can mix sublime with slime with paredit with some of the customize ability of Emacs, then Common Lisp could explode in popularity.
Donāt get me wrong - I LOVE Emacs and everything about Emacs & CL combined, but it took me a year to get to this point.
[1] For those interested, I wrote this article covering the basics: https://ashok-khanna.medium.com/lisp-the-web-4c00c88d11f9
4 years ago by Jach
The emacs bias is even part of Lisp advocates mental models, so it's no surprise that a lot of would-be Lispers give up at the thought of having to use it. But there are alternatives, and it might be fruitful for advocates to routinely point them out. vim (my preference) has two slime plugins that work really well, Atom has https://atom.io/packages/slima and as you point out there's lots of Emacs-variants. There's also lem and Second-Climacs might one day be good. And of course there's the two proprietary IDEs with LispWorks and Allegro that both provide trial versions to see if you like them before shelling out money.
Apart from editors, more editor-independent tools would be nice. McCLIM's Clouseau is a pretty cool graphical inspector/variable watcher.
IMO what holds it back is lack of a big company using and promoting it along with tooling (which might be in the form of alternate IDEs or good plugins for popular editors like VS Code or IntelliJ). Clojure has shown what's possible without such, most use emacs but there are popular alternatives too, and for a time it was even as popular as Go, but Go has BigCo backing, and we can see how much further that brought it despite its many shortcomings.
4 years ago by da39a3ee
Do any non-emacses have anything like paredit?
4 years ago by Jach
Slimv comes with a Paredit Mode: https://github.com/kovisoft/slimv Personally I leave it off, though, never been a fan of anything trying to 'help' me automatically while I'm typing apart from indentation. I do appreciate vim-sexp occasionally with these mappings: https://github.com/tpope/vim-sexp-mappings-for-regular-peopl...
https://susam.in/blog/lisp-in-vim-with-slimv-or-vlime/ is a good overview of the differences between slimv and vlime (the two vim plugins) and how to use them.
4 years ago by abhinav22
This is what is holding me back from the other IDEs for Emacs. Also slime is great
4 years ago by neilv
BTW, there's a small small-world coincidence, between a desire for an Emacs-based super IDE, and the original article...
The desire for an Emacs-based out-of-box power-user IDE was how we got Lucid Emacs, aka XEmacs (which was one of the two big forks of GNU Emacs with GUI innovations that GNU took a while to catch up with)...
...from JWZ, et al.'s work on the Lucid Energize IDE for C++...
...and JWZ worked for Norvig early on...
...and Norvig was at Harlequin...
...and Harlequin acquired at least some of Lucid's IP.
4 years ago by pjmlp
XEmacs was the only thing that made lack of IDE culture on UNIX tolerable to me back in the 1990's.
4 years ago by User23
> IMO, what holds it back is a lack of a top notch IDE
I hear good things about Lispworks[1][2], but personally I'm put off by non-free development tools. Especially ones with a 3-4 digit price tag. However, their business model evidently works for them.
[1] http://www.lispworks.com/products/lispworks.html
[2] https://lisp-journey.gitlab.io/blog/discovering-the-lispwork...
4 years ago by vindarel
As mentioned, SLIMA for Atom is pretty good, nearly as good as Slime. More options: https://lispcookbook.github.io/cl-cookbook/editor-support.ht... (VSCode, Jupyter notebooks, a simple Eclipse plugin, an overview of LispWorks etc)
4 years ago by mark_l_watson
He wrote this around the same time that he kindly reviewed and gave me comments on the first edition of my Java AI book. A year later we had lunch: I was using Common Lisp and Java for my work and I think that Peter was mostly using Python by then.
Which programming language you choose really doesn't matter very much. Since 1982 Common Lisp has been my favorite language, but I have recently learned to also love Swift.
4 years ago by eric4smith
No way. The ecosystem is just not there.
All the libraries - both open source and commercial that do a million things - do not exist in the Lisp ecosystem.
Even in 2000
4 years ago by antonvs
The year after he wrote this, Norvig joined Google and decided that Python was a good enough alternative. He posted a web page about it, but I can't find it rn. However, here's a comment of his on HN about it:
4 years ago by Jtsummers
https://norvig.com/python-lisp.html
This essay starts with the context of his choosing Python to express what was formerly pseudocode.
4 years ago by Rerarom
Also see this, in the same topic but not in the same thread:
4 years ago by vindarel
but Python doesn't resemble Lisp at all: https://lisp-journey.gitlab.io/pythonvslisp/ (overview of the workflows and ecosystems)
4 years ago by dimitar
Now you have Clojure which runs on the JVM and interops nicely
4 years ago by elwell
And ClojureScript to interop with JS ecosystem.
4 years ago by bitwize
ABCL and Kawa have that advantage as well, without the strange "Lisp is nice, but..." design philosophy of Clojure.
4 years ago by Scarbutt
I wouldn't call it "nicely", there is lot of stuff that makes it really tedious.
The bigger issue though is wasting time wrapping Java libraries and most comments I see about Clojure interop talk as if there is no cost to it.
Clojure has good foundations but the ecosystem never really developed.
4 years ago by finalfantasia
> The bigger issue though is wasting time wrapping Java libraries and most comments I see about Clojure interop talk as if there is no cost to it.
You are not forced to "waste time" wrapping Java libraries. As a matter of fact, thanks to the interop features that are well thought out, using Java libraries directly via the interop is encouraged and preferred to wrappers (Java Time API is a good example.) You may _choose_ to write wrappers for Java libraries if they make consuming these libraries in your code a bit nicer.
> Clojure has good foundations but the ecosystem never really developed.
There's no separate ecosystem for Clojure(Script). The established ecosystems such as JVM, .NET, and JavaScript _are_ the Clojure ecosystem. The creator of Clojure(Script) realized that it would be practically impossible to build an ecosystem from scratch without significant investment (Sun spent billions of marketing dollars alone in Java) and thus deliberately chose to make Clojure(Script) a language hosted on well-developed platforms such as JVM, .NET, and JavaScript. Also because of this focus on being a hosted language, he went to great lengths to ensure the interop with its hosting platforms is as seamless as possible. If you need an example for awkward interop with Java, try Scala.
4 years ago by dimitar
You are not forced by the language to wrap libraries. In fact "Programming Clojure" by some of the authors says the following:
"Clojure embraces java and its libraries. Idiomatic Clojure code calls Java libraries directly and doesn't try to wrap everything under the sun to look like Lisp. This surprises make new Clojure developers but is very pragmatic. Where Java isn't broken, Clojure doesn't fix it"
So the ecosystem is a superset of the Java and JS ecosystems, which are pretty developed.
I do agree that the cost of required to know 2 or 3 languages is real though.
4 years ago by adamc
Thank you for articulating my (limited) experience. It was a very leaky abstraction. I remember thinking "If this is it, Python wins."
4 years ago by eatonphil
Armed Bear Common Lisp (Common Lisp on the JVM) may be the most obvious choice if you prioritize ecosystem above all else (which isn't a bad thing).
4 years ago by lisper
Actually they pretty much do, much more so now than in 2000. QuickLisp has been a real game-changer.
4 years ago by nabla9
How many of those 1500 QuickLisp libraries work together without extra work?
I seriously tried to use Common Lisp for numerical programming 10 years ago. It was faster and would have been better platform for numerical programming than Python, R or Julia. Just a great language. (Ross Ihaka had plans to port R into Common Lisp to make R fast at one point)
The real problem was the lack of convergence of data structures and conventions above the language standard.
Python has pandas tables and numpy arrays. R has Data frame. Every numerical library for CL had their own conventions, and ways to implement the basic data structure, Some used lists, some just arrays, some had list of vectors, classes, structs, property lists.
The impedance mismatch was not worth it. Either implement numpy equivalent on your own or half of your code is data massaging data between libraries.
--
Perlis epigram: "9. It is better to have 100 functions operate on one data structure than 10 functions on 10 data structures."
4 years ago by varjag
> How many of those 1500 QuickLisp libraries work together without extra work?
I'm not sure what kind of question is that. A whole bunch of them? Certainly not worse ratio than many contemporary or even modern languages. There's a lot less friction to get any random GitHub CL project working than say a Swift one.
4 years ago by dreamcompiler
>Either implement numpy equivalent on your own or half of your code is data massaging data between libraries
I haven't tested this but here you go:
4 years ago by jhgb
> How many of those 1500 QuickLisp libraries work together without extra work?
I'm pretty sure that due to the curated nature of code in QuickLisp, there's really no problem with that. If something doesn't load properly, it's a bug that you should report.
4 years ago by coliveira
I think the whole issue of having a great programming language is a mute point in the current software industry, because average programmers don't know how to use it. That's why the winners have always be languages that appeal to the minimum common denominator, just the bare enough for people to write programers in the simple way they know. Lisp provide a lot of flexibility and power, but if programmers don't know how to use it, it is instead viewed as a liability.
4 years ago by stan_rogers
Tiny niggle about a well-known phrase and a word that is not particularly well-known outside of the phrase anymore: the word is moot. (A moot used to be a meeting or assembly of people who would discuss and decide things, often Very Important Thingsā¢. Nowadays, moot is mostly an adjective referring to things that might be debatable, but the only benefit to debating them would be the debate itself.)
4 years ago by selimthegrim
One can still say "to moot an issue for discussion (bring up an issue)" but what also fascinates me is the other meaning for mute involving bird evacuation. I have to wonder what happened in Latin?
4 years ago by brundolf
Interesting to look back on this in a world where Clojure has carved out a space for itself
4 years ago by vindarel
Lisp as an alternative to Java, still, in 2021 (and C++ and Rust[1]): https://renato.athaydes.com/posts/revisiting-prechelt-paper-...
[1] talking about speed
Daily digest email
Get a daily email with the the top stories from Hacker News. No spam, unsubscribe at any time.