Exciting news for SBCL users. A coroutine proof-of-concept was created during ELS after-hours in a pub :-) I for once hope, what happened in Vienna, doesn't stay in Vienna.
Yesterday session to bring quicklisp/ultralisp/git together with #nix for #commonlisp development and deployments with NixOS was very fruitful.
One of the main problems with #sbcl deployments is that you need a matching SBCL version and glib version for them to work. Nix can be a solution to that but it has a very sad story for common lisp dependency management.
Maybe something will come out of it. Currently I have an autogenerated flake with all of ultralisp and a lispDerivation function that creates a derivation and pre-compiles the fasls given the lisp implementation you wanna use.
1 - Learn the emacs dialect of lisp called #elisp, to get you started there are docs & a simple tutorial via C-h-i [just scroll down & look for Elisp & Elisp intro]
2 - Learn a dialect of Common Lisp [#CL] such as #clisp, #sbcl or there is the famous MIT #SICP course based on #Scheme
I wanted to share a comprehensive cloud-init YAML file that I've put together
for setting up a robust server environment. It's tailored towards creating a
secure, user-friendly, and developer-ready setup right from the get-go. Here's
a glimpse of what it covers:
Locale, Keyboard, and Timezone Configuration: Sets up the basic locale,
keyboard layout, and timezone for the system.
User and Group Management: Creates system and regular users, assigns them
to groups, and sets up sudo and SSH key authentication.
Package Management: Installs a range of essential and useful packages,
including fail2ban, ufw, nginx, certbot, sbcl, emacs, git, and many more.
It also handles automatic package updates and upgrades.
Security Enhancements: Configures SSH, ufw firewall, and fail2ban for
better security.
Nginx Setup: Sets up Nginx with a reverse proxy and SSL using Certbot.
Git, SBCL, SLIME, and Quicklisp Setup for User: Sets up a ready-to-code
Lisp environment for the user.
I believe this setup can save a lot of time and ensure a solid foundation for
anyone looking to deploy applications or development environments on cloud
instances. It's especially geared towards those who prefer a Lisp-friendly
environment.
Feel free to use, modify, or suggest improvements to this setup. I'm open to
feedback and would love to hear your thoughts or experiences with similar
setups. Let's make server setup a breeze!
@dekkzz76 Adding some more notes: the project I've migrated from Go to Common Lisp resulted in 50% less code (not using any macros!).
Also, since I've developed it entirely in LispWorks, I did some tests with other implementations and it worked in SBCL and ECL out of the box (CLISP didn't work because bordeaux-threads doesn't support it).
Here are the runtimes:
SBCL:
Evaluation took:
9.755 seconds of real time 1.033166 seconds of total run time (0.968865 user, 0.064301 system)
[ Real times consist of 0.019 seconds GC time, and 9.736 seconds non-GC time. ]
[ Run times consist of 0.019 seconds GC time, and 1.015 seconds non-GC time. ]
10.59% CPU
144 lambdas converted
1 page fault 100,349,712 bytes consed
ECL:
real time : 83.908 secs
run time : 29.092 secs
gc count : 4 times
consed : 662005840 bytes
(sort of disappointing)
LispWorks: User time = 2.220
System time = 0.118
Elapsed time = 9.028
Allocation = 60406728 bytes
1620 Page faults
GC time = 0.009
It seems LispWorks is the clear winner in terms of runtime/memory usage.
Mark Watson (@mark_watson) wrote this #eBook to introduce #CommonLisp to developers who already know how to program in another language. If you are a complete beginner, you can still master the material in this book with some effort.
Building the CMUCL Common Lisp implementation from source has always been an arcane process. Building from source the CMUCL-derived SBCL is as simple as executing sh make.sh, a testament to the great work its developers did.
#lisp y #gopher show at 000UTC Wednesday (about 18 hours from now) on #aNONradio@SDF
lively chat will be as always in sdf.org #COMmode chat (I'll be in ~chat irc too)
Music this week will be from DJ Damaru's show (meditation + improvisational music), for people who haven't been catching the evolution revolution yet! https://archives.anonradio.net/#gef
I totally forgot about my fresh cup of coffee while composing the first of many bug reports for #SBCL for like 2 hours, and I’m only half way through the report
You’re damn right I knocked back that manky coffee anyway
Nowhere near the effort of writing it in C or Rust, but on #SBCL just switching on (declare (optimize (speed 3))) in a hot code path and addressing the low-hanging fruits for type-based optimizations can get you within a magnitude of the other two's performance with barely any effort.
@lispi314@dekkzz76@aphistic@jacqueline
in this case I think it is best to OPTIMIZE for #sbcl as per the #cmucl definitions of optimize levels. These are incredibly useful, such as using the optimize space level to turn on and off function inlining in compilation. To my knowledge these are still only detailed in the CMUCL manual.
Hence not defining what these do allowed them to have contextually very important abilities attached to them, in which case (as with all things) SBCL is de facto
I just built and installed ECL #CommonLisp (hompage) onto my computer, and after playing around with it for only a few minutes, I am quite impressed with it!
First off, the entire installation is only 40 MB, so this is definitely one of the more compact Common Lisp implementations I have ever seen.
It emits C code, native shared libraries, native static libraries, and native executables.
It uses libffi for C interoperability.
It provides ASDF, and the ability to install packages from QuickLisp
It implements Lisp standard processes on top of Pthreads
It provides some bindings to Qt4 for GUI programming
It implements all of CLOS
All of that in just 40 MB (not including Qt, which you need to install separately). The only drawback so far is that the documentation has some gaps in it.
But I definitely want to play around with #ECL some more. The trouble is most Common Lisp packages written nowadays only support SBCL. I would like to see how much of the Common Lisp ecosystem I can actually use through ECL. I wonder if I could maybe port something like the Lem text editor over to ECL instead of building it with SBCL, but that might prove impossible.
Anyway, my overall impression right now is that I have a very lightweight but powerful Common Lisp compiler at my disposal now that can easily be embedded into any C program I want, which is very exciting!
TIL Tail call optimization is the default in most modern Common Lisp implementations. It is not a Scheme exclusive any more (I was under the impression...).
But, how do I find out, in SBCL for example, that I do a proper TCO function call?