ChrysaLisp VS McCLIM

Inspired by the TaOS Virtual Processor[0]:

"ChrysaLisp is a 64-bit, MIMD, multi-CPU, multi-threaded, multi-core, multi-user parallel operating system with features such as a GUI, terminal, OO Assembler, class libraries, C-Script compiler, Lisp interpreter, debugger, profiler, vector font engine, and more. It supports MacOS, Windows, and Linux for x64, Riscv64 and Arm64 and eventually will move to bare metal. It also allows the modeling of various network topologies and the use of ChrysaLib hub_nodes to join heterogeneous host networks. It has a virtual CPU instruction set and a powerful object and class system for the assembler and high-level languages. It has function-level dynamic binding and loading and a command terminal with a familiar interface for pipe-style command line applications. A Common Lisp-like interpreter is also provided."[1]

More HN discussion, with links to more discussion[2].

[0] https://news.ycombinator.com/item?id=9806607

[1] https://github.com/vygr/ChrysaLisp

[2] https://news.ycombinator.com/item?id=34415936

Thanks, this saved me some time. I was just debugging why the project I work on (LibHunt) hadn't logged the mention of https://github.com/vygr/ChrysaLisp on this post... the reason being - you've updated the URL after it was submitted.

I'll give another OS project to contribute to where the developers will help you a lot with your understanding of OS development: https://github.com/vygr/ChrysaLisp

One of the projects I've enjoyed working on in the past is: ChrysaLisp OS/Lang

It’s no grand work of coding but: https://github.com/vygr/ChrysaLisp/lib/date/date.inc

ChrysaLisp is portable assembler in () more than Lisp - any other Lisp system wouldn't have comments about clobbering registers.

There's also Drei that comes with McClim as the editor substrate that can be included like a widget in any app. https://github.com/McCLIM/McCLIM/tree/master/Documentation/Drei

0 https://github.com/McCLIM/McCLIM

I've been really happy with slimv. There are a few things missing that I'd like to have were I to find myself working on a really large program with a bunch of other programmers, though I suspect the commercial Lisps offer a good approximation. Besides the trivial things like more auto-refactoring tools (thanks to cross-referencing I can at least get a list of all the locations something is used and jump to edit them one by one if necessary) and project organization tools (I've started using @export from https://github.com/m2ym/cl-annot rather than going back to my package definition to keep adding symbols to the export list) I'd like a better line debugger. It hasn't been a hurdle so far because what's there is good enough (as the article describes, when you hit the debugger you get your stack, you can inspect stuff in the frame, you can recompile and then restart computation from a frame instead of aborting the whole thing). If your declaim settings are right you can also step your code and so on within vim but it's kind of clunky, I'd rather launch a dedicated GUI that's at least as nice as the old Insight GDB wrapper. When inspecting complex data I've started to use the McCLIM app Clouseau: https://github.com/McCLIM/McCLIM/tree/master/Apps/Clouseau I bound ,ci to call (clouseau:inspect) on the symbol and that launches a nice enough GUI to explore it. (Repeated periodically in a thread also serves as a poor man's variable watcher...) A handful of other vim plugins make the full experience even better (even when not writing lisp).

It's been pretty amusing watching the LSP landscape evolve for other languages, it's almost like swank for CL. But it's rather nice to have the server be embedded in the process itself. On my personal web server I have a compiled lisp binary running, but I shipped it with swank listening on a local port, so if I want to change something without rebuilding and redeploying I can just SSH in while forwarding port 4005, connect to the lisp image with my local editor, and recompile functions or whatever. At my last job I also inserted ABCL into the huge Java app on my dev box and had it start a swank server, letting me connect with vim and mess around -- it was mostly useful for quickly launching system tests which otherwise had a dedicated clunky browser UI, and writing some code to quickly extract or insert data. I had some designs to write some webdriver tests in Lisp and demo how the debugging experience when one fails can be much better (not having to restart the whole flow because a UI element changed its class name or whatever and threw an exception) so as to introduce the language to the broader company officially, but never got around to it before I left.

Currently, the only officially supported backend renders directly to an X server. Until another backend matures that either wraps native controls or draws more modern looking controls using OpenGL, I don't consider it production ready. It might have a really nifty API, but it comes down to would I want to put a GUI made with McClim in front of someone who paid for the app I created.

But I don't want to have a net negative contribution to this thread, so I'd also recommend looking at some of the McCLIM applications, including the inspector Clouseau, editor Climacs and the CLIM interactor, which are very much Lisp machine-inspired.

Regarding HiDPI there are some ideas, but right now they are not implemented (see i.e https://github.com/McCLIM/McCLIM/issues/827). I'm writing a vt100 terminal backend to reveal some underlying assumptions about the pixel size.

Thank you for working on McCLIM back then! If you feel motivated to join development efforts please don't hesitate joining #clim @ freenode :)

Remembered this post when github suggested me this project: https://github.com/McCLIM/McCLIM