News for hackers. Stuff that matters.
Re:Hell Is Other REPLs by rightbyte on Sunday August 29, 2021 @08:18AM (#28346108)
> Commony Lisp is a deeply opinionated language

How so? You can do whatever paradgim you want in CL. There is no policing involved. Not in the sense of Haskell or Rust at least. CL will let you modify globals or share data willy nilly just fine.

Mixing functions and values in lists is not really a restriction either, it opens up for all kinds of shenanigans.

Re:Hell Is Other REPLs by ekidd on Sunday August 29, 2021 @08:42AM (#28346239)
The deepest and most radical opinions of Lisp are:

- You should be able to implement Lisp-in-Lisp within a few pages of code. This a profound and remarkable design constraint. (See http://languagelog.ldc.upenn.edu/myl/llog/jmc.pdf (PDF) for an introduction.)

- Syntax would only hide the fact that code is a simple data structure that can be manipulated like any other data structure.

Just like Rust's strong opinions buy you stress-free threading and bit-banging, Lisp's opinions ensure that it's an almost ideal environment for inventing domain-specific language extensions.

But Rust is poorly suited to object graphs where everything mutates everything else, and Common Lisp is poorly suited to proving that a large program obeys certain strict rules.

I love opinionated tools, but I try to choose ones with the "right" opinions for the task at hand.

Re:Hell Is Other REPLs by User23 on Sunday August 29, 2021 @10:15AM (#28346864)
> Common Lisp is poorly suited to proving that a large program obeys certain strict rules

As I'm sure you know, a Lisper would probably design a domain specific language that was well suited for such proofs. One of the projects I'd like to get around to one day is a Lisp hosted general purpose DSL[1] based on predicate transformer semantics[2] that combines writing specification and program text into a single interactive experience. Think something along the lines of smartparens[3] strict mode, where the editor doesn't allow you to make an edit that will violate the count("(") == count(")") invariant and you modify the tree structure with operations like slurp and barf, but a bit more general.

[1] Haha, I know.

[2] https://en.wikipedia.org/wiki/Predicate_transformer_semantic...

[3] https://ebzzry.com/en/emacs-pairs/

Re:Hell Is Other REPLs by cwilkes on Sunday August 29, 2021 @02:04PM (#28348984)
Write a DSL … and now you have two problems.
Re:Hell Is Other REPLs by roca on Sunday August 29, 2021 @07:12PM (#28351357)
The thing is, the sea-of-objects-where-everything-mutates-everything-else programming model is fundamentally bad. It's too hard to reason about. Programs and data need structure. There certainly are structures that do not easily fit into Rust's constraints (e.g. when you're modelling an arbitrary graph), but when you choose a sea-of-objects design when not absolutely required by the problem domain (and it almost never is), you choose poorly.

Even if you do need to model an arbitrary graph (for example), though a traditional programming language would make it a lot easier than in Rust, I still wouldn't necessarily let that dictate the choice of programming language. Most likely your program will end up doing a lot more than just banging on the graph and those parts may benefit from a more disciplined programming language.

Re:Hell Is Other REPLs by int_19h on Sunday August 29, 2021 @11:33PM (#28352575)
You can structure mutation just fine by organizing those objects into hierarchies of abstraction, such that a sea of objects on one level becomes a single black box on the next. This keeps the "seas" small enough to reason about.
Re:Hell Is Other REPLs by pharmakom on Sunday August 29, 2021 @09:38AM (#28346587)
The object graph problem really hurts Rust imo. In C# I can just mutate and forget about ownership. In Haskell I can solve this using an immutable graph and a state monad. In Rust it gets pretty awkward.
Re:Hell Is Other REPLs by db48x on Sunday August 29, 2021 @10:39AM (#28347054)
Yea, but in those languages you have a garbage collector working in the background to clean up after you. You don’t always want to pay that cost. From time to time I work on an open source application that spends 60–70% of its time in garbage collection, at least on jobs at the extreme end of the size we can handle. I’m starting to think about ridiculous hacks like combining millions of moderately–sized objects into a giant arena. With no pointers into the arena (just indicies), I can eliminate a huge chunk of the time wasted scanning the heap over and over again. But at that point, why am I writing this in Go? My Rust prototype is very incomplete, but for the parts that are implemented it uses way less memory and completes a lot more quickly. And I haven’t done _any_ performance optimization or ridiculous hacks there yet.
Re:Hell Is Other REPLs by pitaj on Sunday August 29, 2021 @11:28AM (#28347484)
And in Rust you can always drop down to reference counted heap allocated stuff as well.
Re:Hell Is Other REPLs by tsimionescu on Sunday August 29, 2021 @12:19PM (#28347995)
Reference counting has completely different properties than other forms of automatic garbage collection. In particular, reference counting still requires some amount of ownership tracking, whereas this concept just doesn't exist (for memory resources) with tracing garbage collection.

This is particularly relevant for certain algorithm, such as atomic initialization, that get significantly more complex with in-line ownership tracking.

Re:Hell Is Other REPLs by db48x on Sunday August 29, 2021 @01:04PM (#28348450)
On the other hand, Rc turned out to be just what I needed for a particularly complicated data structure that we use.

http://db48x.net/reposurgeon/rust-port-docs/reposurgeon/path...

Also, because of Rust’s wonderful type system it will be fairly straight forward to replace the string keys in this code with interned strings instead. (The amount of strings we use for paths in a large repository is pretty astounding.) That might now be almost possible in Go, if I learn the new generics.

Re:Hell Is Other REPLs by db48x on Sunday August 29, 2021 @11:50AM (#28347659)
That’s true; the prototype uses Rc/Arc for things where I don’t yet know for sure how the ownership should really work out, and doubtless a fair amount of that will stay.
Re:Hell Is Other REPLs by pjmlp on Monday August 30, 2021 @03:36AM (#28353486)
In those languages you also have the features to do C++ like coding if felling so inclined to do so.
Re:Hell Is Other REPLs by chrismorgan on Sunday August 29, 2021 @12:21PM (#28348007)
Rust has been my favourite language since 2013. I constantly miss its ownership model when working in other languages (which most commonly means JavaScript for me).

Certainly not everything is a good fit for Rust’s ownership model, but honestly most code benefits from it at least a bit, and steadily more and more is being figured out about how to mesh other models into it without too much pain. It’s very liberating, protecting from various mistakes that are too easy in other languages (and that’s specifically where I miss it).

Ownership modelling can require more effort initially if the problem doesn’t match Rust’s capabilities very well (or put another way, if the problem doesn’t match how hardware works without garbage collection), but subsequently it’s liberating to not need to worry about various problems that are ubiquitous in other languages.

I reckon it similar to the debate of static versus dynamic typing, though more subtle. For toys, dynamic typing is adequate and static typing a burden, but as you scale a system up, dynamic typing makes life harder and requires more discipline to avoid ossification or drowning from technical debt. It’s taken time, but there has been a significant resurgence in static typing as people slowly come to realise its value through bitter experience in dynamic typing. Like static typing, a strict ownership model requires more effort initially, but makes life easier down the path, and I expect that at least the basic concepts of it will be picked up in more languages new and old over time (this has started already, actually, with Swift and D springing to mind), though it’s probably a harder concept to beneficially retrofit to a language than static typing.

You may want to mutate and forget about ownership, but Rust doesn’t let you do this, and it’s for your own good ;-). In time you get more of a feeling of why it is the way it is and learn to appreciate it.

Re:Hell Is Other REPLs by zetalyrae on Sunday August 29, 2021 @08:23AM (#28346141)
There is a fairly high bedrock of abstraction, mostly because the compiler is available at runtime, the blurring of the distinction between compile-time and run-time, and image-based development. Common Lisp programs can be as fast as Java, but the executables are huge because they have to bundle the entire image inside. And tree-shaking is less effective because the language is so dynamic it's hard to guarantee some code won't ever be called.

And if the abstraction bedrock is high, then problem domains below that bedrock can't be approached with the language.

Re:Hell Is Other REPLs by lispm on Sunday August 29, 2021 @08:34AM (#28346206)
Contrary to popular believe, image support is common, but actually not required by the Common Lisp standard.

Various Common Lisp implementations like ABCL (Common Lisp on the JVM), ECL, CLASP, mocl, ... don't support saving and starting images.

> And tree-shaking is less effective because the language is so dynamic it's hard to guarantee some code won't ever be called.

That depends on the delivery system. For example in LispWorks I can manually remove a lot of functionality:

http://www.lispworks.com/documentation/lw71/DV/html/delivery...

Re:Hell Is Other REPLs by zetalyrae on Sunday August 29, 2021 @08:46AM (#28346263)
Yes, LispWorks has a powerful tree shaker and I think SBCL now has one as well. Arguably images could get even smaller by distributing the runtime as a shared library. I admit this is an implementation detail.
Re:Hell Is Other REPLs by lispm on Sunday August 29, 2021 @08:56AM (#28346308)
It was already years ago a problem for some companies or organisations wanting to deploy Common Lisp software on tiny (embedded) machines or without GC. IS Robotics (later called iRobot) developed L, a small Common Lisp, for robots with small embedded computers - I think it also has been used on the Roomba devices.
Re:Hell Is Other REPLs by zetalyrae on Sunday August 29, 2021 @08:57AM (#28346317)
Is this a stripped down Common Lisp, or something like Naughty Dog's GOAL[0], basically an embedded assembly DSL?

[0]: https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp

Re:Hell Is Other REPLs by lispm on Sunday August 29, 2021 @09:11AM (#28346400)
It's Common Lisp. See "L - A Common Lisp for Embedded Systems" https://www.researchgate.net/publication/2949173_L_--_A_Comm...

Another one was CLICC : https://github.com/hoelzl/Clicc which has a language definition for CL0 : https://github.com/hoelzl/Clicc/tree/master/doc

There are or were a bunch of such small delivery oriented implementations: Oracle bought one years ago, Gensym has one, mocl is derived from CLICC, ...

Re:Hell Is Other REPLs by ekidd on Sunday August 29, 2021 @10:10AM (#28346827)
Hello, former minor L contributor here! (I last worked on it in the late 90s, and I'm only going to talk about stuff that iRobot has mentioned publicly.)

L was actually a subset of Common Lisp. It would run pretty nicely on a machine with 1 MB total RAM and a 16 MHz CPU. All the basics were there: lambdas and macros and symbols and modules, and they all worked how they did in Common Lisp. (Or they were close enough that you could write and test in Common Lisp and then cross-compile.) There was a REPL that could run most code, and an ahead-of-time compiler.

It was a fantastically nice environment for embedded systems too small to run something like Alpine Linux. You could compile a program, load it onto actual hardware, and then tweak things interactively using the REPL. And you could invent all kinds of macro DSLs.

Of course, all this becomes moot once your system is large enough to support Alpine Linux and an SSH server. If you can run Linux, then you can use Lisp or Python or PLT Scheme or Rust or anything else you want, and you have half a million open source libraries available.

Still, L is proof that Lisp is a great embedded language for anything with a MB of RAM. You can have a pleasant development environment and tons of flexibility, with an excellent REPL.

Re:Hell Is Other REPLs by guenthert on Sunday August 29, 2021 @01:03PM (#28348436)
"CLiCC is a Common Lisp to C Compiler. [..] CLiCC supports a subset of Common Lisp + CLOS." Isn't it then made obsolete by ECL (a decade or so later)?
Re:Hell Is Other REPLs by lispm on Sunday August 29, 2021 @02:01PM (#28348945)
ECL is based on earlier compilers, which go back to KCL from 1984.

The idea of CLICC was to compile programs to small static C programs. Really small and with little or no dynamic features of Lisp (code loading, runtime compilation, eval, redefinition, ...). It did not have all the bells and whistles of ECL (virtual machine, runtime code loading, debugging, full dynamic Common Lisp, ...).