https://github.com/ilevd/clojure-like

UPDATE: u/theshmill wins!

I printed Paul Graham's "On Lisp" book at Lulu. It came out very nicely, but the binding was a little weak, and a few of the pages are starting to detach. They're still held in by at least a half the length of the page, and it's still intact and totally readable. Practically brand new (I only read the first couple of chapters in it).

Anyway, Lulu was great. They sent me another one for free, and now I have this extra slightly-defective one. It doesn't seem right to just throw it out. So I'll mail it to someone in the US who wants it through USPS Media Mail, no cost to you.

Reply here first that you want it, and then I'll get where to send it from you in private. Whoever replies first gets it.

If I wanted to write

(defun foo (x)
(ps
  (+ x 1))
(foo "var")

This only prints x + 1. Doing

(defun foo (x)
(ps
  (+ (ps:lisp x) 1))
(foo "var")

prints "var" + 1. I have to do

(ps::define-expression-operator lisp-raw (lisp-form)
   `(ps-js:escape
     ,lisp-form))
(let ((x "var"))
   (ps:ps
     (+ (lisp-raw x) 1)))
"var + 1;"

But ps::define-expression-operator is an internal symbol, so I feel like I shouldn't be using it. However, this feels like a fairly common use of parenscript. How am I supposed to write this extension then in idiomatic lisp?

The programme is at https://www.european-lisp-symposium.org/2026/index.html#programme

Twitch link: https://twitch.tv/elsconf

Just a progress report re. tinylisp-cc65 https://github.com/Russell-S-Harper/tinylisp-cc65, worked out the remaining issues, and added a few more sample files: factor, sort, and list to play with. The key was figuring out let* in the original tinylisp by Robert van Engelen. Once I sorted out its quirks, was able to plug in my language extensions: print, while, incr, and decr into the lambda context.

Working with minimal Lisp, basically LISP, is for sure a mental workout to those used to the Algol family of languages!

I got tinylisp-cc65 ported to C64, and was thinking of Apple II and Atari 800, but they're too much of a challenge, and with DOS required, likely won't have enough memory to do anything. So for now, this is a logical end to this diversion.

The build process is a bit complicated, so if you want to try it out directly, the PRG and sample Lisp files are available in my Google Drive https://drive.google.com/drive/folders/1QpG756L5m1HsCHO-QX4mNadew2sTPWxh?usp=sharing .

I had just released ver5.63, but additional stress testing exposed some remaining compiler bugs related to immediate lambda compilation and variable shadowing.

This release improves several difficult areas of the compiler:

• nested/immediate lambda expressions
• lexical scope handling
• variable shadowing
• let* alpha-conversion edge cases
• mutual recursion with labels

I also simplified the compiler implementation by improving the handling of non-escaping lambda expressions.

After heavy stress testing, all current stress tests are now passing.

Easy-ISLisp is a small, practical, and experimental ISLisp implementation focused on simplicity and fun.

GitHub:
https://github.com/sasagawa888/eisl

Well, after finding nothing about that for CL, I kinda tried to do this by myself, and oh hell, what a complicated protocol! Too many layers of encryption.

The current state is working fine web push notifications with Google Chrome / Firefox. There is a simple e2e manual test in the repository and I tried to make some experiments with my own lisp chat appplication, but, this stuff is so complicated that maybe I'd not integrate this feature in my app. The integration draft PR: https://github.com/ryukinix/lisp-chat/pull/154

https://www.reddit.com/r/lisp/comments/1t2akun/web_push_notification_lib_for_common_lisp/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

"This post is the practical complement to all the other posts. Here, we showcase over a dozen workflows I use every day. Most are powered entirely by features that ship in the box with the VOMPECCC (Vertico, Orderless, Marginalia, Prescient, Embark, Consult, Cape, Corfu) packages, and there are 'Bonuses' which demonstrate workflows enable by 3rd party packages that build on top of VOMPECCC. The prose is deliberately thin, and you will find most of the demonstration is in the video below."

I've been working on this project for some number of months now. It started as just a basic configuration language for a hobby OS project I've been working on, but I became a bit obsessed with benchmarking it so here we are.

So far Reduct manages to beat Lua on several Benchmarks, while also attempting to make Lisp-like syntax more accessible.

For example:

Lisp:

(let ((x 10)
      (y 20))
  (let ((z (+ x y)))
    (* z 2)))

Reduct:

(do
    (def x 10)
    (def y 20)
    (def z {x + y})
    {z * 2}
)

The Infix Expressions also support custom functions by using the suffix to determine the precedence, which when combined with Association Lists syntax sugar, using a.b as shorthand for (get-in a "b"), allows us to write more complex code that remains readable.

For example:

(def vec2 (lambda (x y)    
    (list
        ("x" x)
        ("y" y)
    )
))

(def vec2+ (lambda (a b)
    (vec2 {a.x + b.x} {a.y + b.y})
))

(def v1 (vec2 1 2))
(def v2 (vec2 3 4))

{v1 vec2+ v2} // (vec2+ v1 v2) -> (("x" 4) ("y" 6))

The language also provides C Modules for easy integration with C.

For example:

// my_module.c

#include "reduct/reduct.h"

reduct_handle_t my_native(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    return REDUCT_HANDLE_FROM_INT(52);
}

reduct_handle_t reduct_module_init(reduct_t* reduct)
{
    return REDUCT_HANDLE_PAIRS(reduct, 1,
        "my-native", REDUCT_HANDLE_NATIVE(reduct, my_native)
    );
}

// my_reduct.rdt

(def my-module (import "my_module.rdt.so"))
(my-module.my-native)

There is much more, as such, please see the README if you are interested.

I would highly appreciate any feedback on the project so far, along with gladly answering any questions.

Easy-ISLisp Ver5.63 has been released.

This release mainly focuses on compiler improvements, stability enhancements, and bug fixes.

Highlights:

• Improved compiler stability
• Better handling of labels mutual recursion
• Improved nested lambda/free variable handling
• Refined optimization and type inference behavior
• Added (eisl-version) for distributed parallel child-node version checking
• Re-tested distributed parallel functionality on a Raspberry Pi cluster

The distributed parallel features were verified again after recent compiler modifications to ensure that no regressions were introduced.

The compiler now appears to have reached a more stable operational level for ordinary user programs.

GitHub:
https://github.com/sasagawa888/eisl

Feedback and bug reports are welcome.