remix logo

Hacker Remix

Show HN: A Common Lisp implementation in development, supports ASDF

89 points by andreamonaco 1 day ago | 53 comments

Implementation of the standard is still not complete, but breakpoints and stepping work quite well! It also has some support for watchpoints, that no implementation has.

Now it ships with ASDF and is capable of loading systems!

Let me know if you like it. Support on Patreon or Liberapay is much appreciated

whartung 1 day ago

At what point does a CL implementation need to be before it can start hoovering up the available library code from other implementations (license permitting).

How many LOOP macros does the community need, particularly when bootstrapping an implementation, as an example.

Similarly with, arguably 70-80% of the runtime. The CL spec is dominated by the large library which, ideally, should be mostly portable CL, at least I would think.

klibertp 1 day ago

You're not the first one to think so: https://github.com/robert-strandh/SICL

I'm unsure how complete it is, but it seems to cover much of the standard.

v9v 1 day ago

Here's a recently-written summary of the different libraries in SICL (including each library's purpose and status) http://metamodular.com/SICL-related-libraries/sicl-related-l...

g2963 8 hours ago

a hypothetical portable layer exists, but it starts diverging once deployed, because of cleanups, refactoring, or implementation specific hacks.

LOOP is a great example, because all loop is just MIT LOOP version 829, originally cleaned up by burke. but nobody can resist deploying their personal architectural touch, so while the basic framework of loop remains identical across impelementations, there's superficial refactoring done by pretty much everyone. if you take SBCL and franz lisp as state of the art in free software and commercial respectivaly, they have equally solid improvements on original loop, that actually produce incompatible behavior in underspecified corners of spec. respective developer communities are very defensive about their incompatible behavior being the correct behavior of course. beach's SICL from sibling comment is the xkcd joke about standards "20 standards? we need a new standard the unifies them all! -- now we have 21 standards"

LOOP in this case is a very simple example, but for example CLOS was originally implemented on top of PCL, Portable CommonLoops, an interlisp system, that was massaged into being compliant CLOS over years. for example sbcl uses a ship of theseus PCL, but franz lisp did from scratch rewrite. the hypothetical portability of that layer is significantly trickier than LOOP since clos is is deeply tied to the type system, and the boundary between some hypothetical base system common lisp and its clos layer becomes complicated during system bootstrapping. but that's not all! of course clos has to be deeply tied to the compiler, the type system, all kinds of things, to provide optimizations. discovering the appropriate slicing boundary is difficult to say the least.

danilor 1 day ago

Hey I'm curious as why you chose nongnu to host your project instead of github/gitlab! I don't know much about it, hence my curiosity ;)

andreamonaco 1 day ago

I don't like sites with heavy Javascript, especially if it's non-free. (Though recently I started using Github for a different project.)

Savannah is very basic, perhaps too much, but it's okay for my project.

kazinator 1 day ago

I hosted the TXR git on nongnu first, starting at around late 2009 or early 2010 maybe?

I abandoned that when I discovered there's no control. I seem to recall having to wait like over a week for someone to enable non-fast-forward pushes. Overly strict and understaffed. I opted for self hosting.

I kept the project web page there, though.

volemo 1 day ago

Tbh, this is the first time I see nongnu.org used for something other than Emacs packages (I know that’s on me), so much so that I even thought this was a solution to substitute Emacs Lisp with Common Lisp. :O

badmonster 1 day ago

+1

WalterGR 1 day ago

> a debugger with stepping, a feature that most free CL implementations lack.

I think most free CL implementations have a stepper. Which ones do not?

andreamonaco 1 day ago

I tried stepping in various free implementations, but I couldn't really follow the source forms and execute them one by one. Also, I couldn't find much information online. Maybe your experience is different?

WalterGR 1 day ago

I haven’t used CL recently so I can’t speak from experience. But it looks like:

CMU CL, SBCL, and LispWorks have steppers.

Clozure does not. (Edit: an answer on https://stackoverflow.com/questions/37754935/what-are-effici... suggests it does...)

As I understand it, those are the big 4.

Clisp, ABCL, and Allegro also appear to have steppers.

Always cool to see a new implementation, though!

klibertp 1 day ago

In most of those implementations (certainly in SBCL) it's either you break or step; you can't start stepping from a breakpoint. SBCL got some support for that this year, see https://news.ycombinator.com/item?id=43791709. It, however, doesn't allow stepping into any functions called after the break.

Also, the compilers are allowed to make the code unsteppable in some cases, depending on optimization declaration: generally, debug needs to be >=2 and > speed/compilation-speed/space. In some circumstances, you land in decompiled/macroexpanded code, which is also quite unhelpful.

Anyway, it's not that source-level stepping isn't there at all, it's just quirky and somewhat inconvenient. A fresh implementation that does comparatively little optimization and is byte-code based can probably support debuggers better. I hope such support won't go away later when the native code compiler is implemented.

WalterGR 21 hours ago

Thanks!

If I recall correctly, there are macros to control the level of code optimization? And some implementations can turn it off entirely for interactive use?

Or am I off-base?

klibertp 14 hours ago

> If I recall correctly, there are macros to control the level of code optimization?

Yup, you can either `(proclaim (optimize (debug 3) (speed 1)))` somewhere, which will take effect globally, or you can `(declare (optimize ...))` inside a particular function. It sounds great in theory - and it is great, in some respects - but this granularity makes it harder to ensure all interesting code is steppable when you need it.

eadmund 1 day ago

Congratulations! Always good to see another Lisp in the world.

Have you thought about writing up your experience?

andreamonaco 1 day ago

Also, my Patreon page (https://www.patreon.com/andreamonaco) has behind-the-scenes posts, some even in the free tier

andreamonaco 1 day ago

Thanks! Maybe I could do that, if I see that people are interested