vindarel
Joined 9 years ago
Karma
1,508
Submissions
603
Member since
Jul 7
Recent submissions
Comment · 3 days ago
(or LispWork$ and its Java interface)
Comment · 26 days ago
mmh but the rest of my examples, you can't do them in Python (:
Comment · 26 days ago
You can use the features as little and as safely as you want:
> can be useful in extreme situations
it's already useful in development, it's one of those things that shorten the dev loop and make development in CL a breeze. For production, you choose. Connect to the live image to inspect the state without modifying anything or debug while it's live.
> recorded nowhere
you can connect to a running program and have the source under VCS. The thing to do isn't to copy-paste new function definitions in the live image's REPL, but to connect to the image, make changes to the source files, and re-compile them (a C-c C-c in Slime) (sending changes to the running program).
> safer
yep, some things are safer. Advanced features are useful even for simple things (introspection, etc).
Comment · 26 days ago
No debugging window opens up for anybody by default^^ The web server (ex: Hunchentoot) will crash the request's thread and print the backtrace by default. Change a server's variable and print the backtrace in the browser (= dev mode), change another variable and get the interactive debugger (= dev mode++). All this without stopping/restarting the server. Or just restart it if you want.
Comment · 26 days ago
no, the app isn't frozen (thinking about the Hunchentoot web server).
Also of course the default is to not get the debugger but let the server thread crash and print the backtrace. With a user setting, you can choose to get the debugger, and have this request wait (the connection may time out, which isn't an issue during development). Another setting is to print the backtrace in the browser (= dev mode).
Comment · 26 days ago
In Python, can you fix the buggy function, re-compile it, and resume execution from the stack you want? I don't think so. That's common practice in CL, useful both during development and in production if necessary. In Python, you edit the file, your webserver restarts and reloads everything. In CL, the change is in. Nothing is restarted. The function was compiled and the next call will use it.
Python REPL and CL's are very different!
In CL: you can install new dependencies from the REPL. You can change a class definition, the existing objects will take the changes at the next invocation. You can control how this happens, etc. TLDR; CL is built around live programs. Buuut we can also do it the dumb (and safe) way following the industry's best practices.
Comment · 3 months ago
here:
I’m curious: was Arc running Racket BC or CS? I understand it got a big performance boost after switching to Chez Scheme.
dang: It was running BC. I had high hopes for switching to CS because I'd heard the same thing you had, but when I tried it, HN slowed to a crawl. This stuff is so unpredictable.
Comment · 3 months ago
Use `C-c C-]` (`slime-close-all-parens-in-sexp`) in SLIME ;)
Comment · 3 months ago
I collected the disparate words of Dang here: https://lisp-journey.gitlab.io/blog/hacker-news-now-runs-on-...
Comment · 3 months ago
> Common Lisp lacks some conveniences that have become common in newer languages, such as concise literals for a wider variety of data structures, persistent immutable collections, lazy sequences and built-in general-purpose pattern matching.
we can explore libraries on https://github.com/CodyReichert/awesome-cl/
concise literals: serapeum's dict or other libraries bring you { } for hash tables and the like.
persistent collections: FSet (and more)
lazy sequences: series, gtwiwtg (generators) (and more)
pattern-matching: Trivia
many libraries are shipped in CIEL: https://ciel-lang.org/ (shameless plug)
---
> It’s currently used in …
more example companies: https://github.com/azzamsa/awesome-lisp-companies/
also: https://lisp-screenshots.org/
---
> at the cost of slightly slower startup times
that means ±30ms, not the Java-esque slow startup time ;)
---
editors: don't miss https://lispcookbook.github.io/cl-cookbook/editor-support.ht... and the new Mine, OLIVE for VSCode, ICL repl (terminal and browser).
Comment · 3 months ago
So let's try: SBCL with
* [clj-coll](https://github.com/dtenny/clj-coll) - Clojure collection and sequence APIs in Common Lisp, with optional Clojure collection syntax.
* provides immutable Cons, Queue, PersistentList, capabilities as well as Vector, Set, and Map analogues built on FSet (but accessed entirely via Clojure APIs).
* optional read syntax so you can type `{:a 1 :b 2}`, `#{1 2 3}`, and `[1 2 3]`.
* [clj-re](https://github.com/dtenny/clj-re/) - Clojure-style regular expression functions.
* [clj-arrows](https://github.com/dtenny/clj-arrows) - Clojure-compatible threading/transformation/arrow macros for Common Lisp.
editor: https://coalton-lang.github.io/20260424-mine/
type system: Coalton
Comment · 3 months ago
What about this one? https://github.com/dotcl/dotcl
> Common Lisp implementation on .NET. Lisp source is compiled to CIL (Common Intermediate Language) and runs on the .NET JIT — so the same Lisp image runs on Windows, macOS, and Linux across x86-64 and ARM64 without per-platform porting work.
Comment · 3 months ago
Reminds me of https://scorecloud.com/ "ScoreCloud Songwriter takes recordings of voice and instruments and turns it into Lead Sheets, with melody, lyrics and chords." except there is no live demo (but a free download for W$ and Mac, and an iPhone app) (didn't try)
(It's built in Common Lisp (LispWorks))
Comment · 3 months ago
Start here with Common Lisp 8-) https://lispcookbook.github.io/cl-cookbook/getting-started.h... To learn the language, look at the good books out there (Touretzky's etc).
ps: you don't need to learn Emacs. A terminal even is enough. See the Cookbook/ Editors section.
Comment · 3 months ago
Don't miss out, we had new excellent editors and tools being released in the last months:
Mine: a complete, single-download application that comes with everything needed to experience the interactive and incremental development programming workflow, including hot-reloading and on-the-fly debugging. For CL and Coalton.
https://coalton-lang.github.io/20260424-mine/
OLIVE: a new hand-made plugin for VSCode.
ICL: a new REPL for the terminal and the browser with advanced features.
as a bonus: a JupyterLite kernel based on JSCL that runs 100% in the browser.
find them all: https://lispcookbook.github.io/cl-cookbook/editor-support.ht...
https://lisp-journey.gitlab.io/pythonvslisp/
I run CL apps in production.
CL, batteries included, fast scripting: http://ciel-lang.org/
I create a Common Lisp course in videos. It's a progressive and structured course, where everything that was hard for me (especially hard to find) is made easy for you. Check it out! https://www.udemy.com/course/common-lisp-programming/?referralCode=2F3D698BBC4326F94358
---
@ vindarel mailz.org