Hacker News Reader

Comment by minerjoe | Hacker News Reader

I gave years using parenscript [1] to create web-apps and as a sole developer on the project it totally won me over. Lisp macros + javascript. There is such joy in being able to mold the language to your needs and to completely eliminate any boiler plate duplicate code. Combined with SLIME + SBCL and you have a completely live javascript exprience. Even pushing code to the browser, no reload necessary.

[1] https://common-lisp.net/project/parenscript/

View on HN

I found Clojurescript https://clojurescript.org/ to have a better ecosystem than parenscript.

You don't need an ecosystem with lisp. That's been both the reason why it's survived for so long and why it will never be popular.

You don't need an ecosystem with lisp.

Is the implication here that people build on top of ecosystems because they're incapable of implementing things themselves in plain JS, and that lisp will make them capable?

That's not the reality I see as a developer. The team I work with are entirely capable of building all the things we need, but we build on an existing ecosystem of open source code because that way we can do more with the available resources. Ecosystems are as much about efficiency as they are about ability.

The implication is that it is trivially easy to implement what is impossible in other languages in lisp.

So you never have to try and follow the moving target of an ever evolving ecosystem. You just pick a language version and build your own with surprising ease. The amount of time you save from breakages upstream is amazing and something no one talks about.

>Is the implication here that people build on top of ecosystems because they're incapable of implementing things themselves in plain JS, and that lisp will make them capable?

Not exactly, but Lisp (specifically Common Lisp but also other lisps) will make far easier to implement whatever is missing thanks to the various features that enable very quick development, quicker than JS or Python. And interfacing with C code is also easy too. Interfacing with Java libs, even easier (using Armed Bear Common Lisp.)

The problem with ecosystems today is that they lack aesthetic due to leaky abstractions. That Worse is better hasn’t been proven definitively and might never be!!!

There is an ecosystem though https://github.com/CodyReichert/awesome-cl

Every time I hear a glowing testimony like this, I get a little hopeful but then I remember the current state of the JavaScript ecosystem. Perhaps you could shed some light on this?

Is it possible to make externs or definitions of library functions? How much time does it take to take a fresh library and write those externs to access them in Parenscript land? And what limitations did you run into?

Cheers.

Parenscript is nice because you don’t need complicated externs: it has a pretty straightforward mapping to JS symbols and no runtime. However, the downside is that it feels more like “JavaScript with a new syntax” than like Common Lisp or another lisp. I personally find the trade-offs acceptable because it’s fees fairly natural to right JS in a lispy style, but it’s not the “pure” experience of something like Clojurescript.

I've heard good things about jscl[1]; since it's bootstrapped from regular cl, it's probably less javascript-y.

1. https://github.com/jscl-project/jscl

The tradeoff is that it actually has a runtime which means it adds to your bundle size and (potentially) makes interop complicated.

Fully agree. Parenscript is a great "compatibility layer" if you already know Common Lisp.

Reply on news.ycombinator.com