Everyone: Python is weird, main starts with:
if __name__=="__main__":
main(sys.argv[1:])

Me, side-eye:
(unless (member (program-name) '("chez" "petit" "scheme")) ;; is REPL
(main (command-line-arguments))
)

#scheme #repl

(I also sometimes use (member "--run" (command-line-arguments)) or the like, but program-name is clearer.
Some Schemes call main if you use it as a command-line program, not with load or include, but Chez leaves that up to you. RnRS specs are silent on the issue.)

#ReleaseWednesday — Extracted & extended the LISP-like DSL from an existing #ThingUmbrella example[1] as new small package for better/direct re-use in other projects:

https://thi.ng/lispy

The core language is kept intentionally minimal, aimed at simple sandboxed data transformations/derivations, small code snippets/expressions in GUIs or config settings. However, the language is very easy to extend/customize with new functions or control flow constructs etc. Currently, the language is interpreted and has the following builtins (see screenshots). There's no macro support so far (and not sure if that's even desired here)...

[1] The original #HowToThing example browser REPL this was extracted from (and which has now been updated to use the new package):

https://demo.thi.ng/umbrella/lispy-repl/

#ThingUmbrella #Lisp #DSL #FunctionalProgramming #REPL

Eric Normand on REPL-driven development in Lisp and other languages:

The REPL accelerates learning by increasing the speed and information richness of feedback.

[...]

Fast, rich feedback is essential to achieving a flow state.

https://ericnormand.substack.com/p/repl-driven-development-and-learning

Who in the world though it a good idea putting their custom readtables into libraries intended for outside use? I don't want your hash table syntax, I want MINE. Don't pollute the readtable and other aspects of someone else's image if you're providing a library. The library you're making should be portable and clean #CommonLisp, not some unreadable #DSL you use in your #REPL. It's fine in the REPL, but not in libraries. Keep it clean. Simple courtesy.

Not pointing fingers, but everyone doing that shall be ashamed.

A couple of weeks ago I asked the Fediverse for recommendations about doing async I/O in a Python application which *also* had a REPL-like interface. I got quite a few useful responses, which ended up leading me to Python Prompt Toolkit.

Here is the result: a single-file script with embedded dependencies (thanks to PEP 723 and uv) which opens a serial port, asynchronously writes data to it and reads data from it, all while displaying a prompt and accepting input from the user.

https://forge.km6g.us/kpfleming/muart-failsafe/src/commit/9179da2f6acc30dbead5e54a2de2184b6fe1c7f8/prototest/prototest.py

None of the program's actual functionality is present yet, but having the scaffolding in place makes me happy.

I just discovered Jshell, a Java REPL shell. It's like Python's interactive shell , but in Java ;-)

It's not new. Jshell was introduced in ... Java 9. Shame to me I only learn about it in Java 23!

https://asciinema.org/a/nKxwuTgFPEeHgLfBakhcpomSO

Schemesh: A Unix shell and Lisp REPL, fused together

https://github.com/cosmos72/schemesh

#programming #commonLisp #emacs #repl versus #orgmode for the #fizzbuzz challenge on #medium.
Using #series #lazyEvaluation
https://medium.com/@screwlisp/fizzbuzz-battle-orgmode-versus-the-repl-for-lazy-lisp-series-an-emacs-story-b98f633a20d8
I think it ended up pretty interesting, and what you would expect. The repl is a better interactive experience, but the noweb tangle optimizes in ways the separate repl lines can't, and is already in a disk-persisted file.

Looking forward to feedback and commentary ( @ksaj ;p)

Your web server having an interactive shell (REPL) where you can live update entries in your site/app’s database is pretty neat (if I do say so myself) :)

https://kitten.small-web.org/reference/#kitten-s-interactive-shell-repl

(I’m porting the Small Technology Foundation site¹ from Site.js² – and hence from being a static site generated via Site.js’s integrated Hugo³ – to Kitten⁴. In the process, I’m creating an admin panel⁵ for the news, events, and videos sections, which will make them easier to update, and storing the data in Kitten’s internal JavaScript Database⁶.)

¹ https://small-tech.org
² https://sitejs.org
³ https://gohugo.io/
⁴ https://kitten.small-web.org
⁵ It’s trivial to create authenticated routes in Kitten. You just add a lock emoji () to the end of your route’s name. e.g., admin.page.js or /admin/index.page.js (see https://kitten.small-web.org/reference/#sessions-and-authentication).
⁶ https://codeberg.org/small-tech/jsdb

(Towards):
A #sidescrolling #textAdventure #game as the host of a Pratt Grammar #Parser:
https://lispy-gopher-show.itch.io/lispmoo2/devlog/870779/a-sidescrolling-game-as-a-pratt-parser
#itch #itch_io #gameDev #lisp #commonLisp #repl

Sharpsign lengthy and wandering. Sharpsign happy 2025

Basically, I was having trouble imagining parsing a grammar at all. So I imagined input tokens as a sidescroller level I could cdr-code speedrun passes of. And you know, when lisp people imagine things it happens in real life too.

So my question is, what's an intuitive way to use dropping-in- #fortran from the #lisp #repl ?
Reading a .f file ~ into a let* form which I'm currently doing seems kind of bland. #f( this(1) = is(2) + a / fortran * line) seems kind of uninspiring (who would want to express themselves like this). Maybe Enter "fortran mode" and read lines of fortran from *standard-input* with normal interactive evaluation hacked in?

The fortran becomes #series expressions in lisp.

Guix Social next Thursday (January 16th). There will be a talk by @abcdw about his Guile Scheme IDE for Emacs, and the underlying Nrepl project that can be used by any editor. For all the details:

https://www.meetup.com/guix-social/events/304634420/

Andrew also has many other projects, including RDE an extension to Guix. Come along and ask him questions!

@fnat

Ever wanted to live REPL part of a linux terminal command? Can't remember where I found it, but this is awesome:

https://github.com/pawelduda/fzf-live-repl

Basically, put this in your .bash_aliases & `exec bash`:

```bash
repl() {
preview="${1}"; # MAKE SURE THIS HAS the substring {q} in it for where you want the thing to go!
echo '' | fzf --print-query --preview "${preview}";
}
```

Use it e.g. like this:

```bash
repl 'cat data.jsonl | jq -C {q}'
```

Despite ample evidence to the contrary, #Ilive (hmm, if I were also #evil, that would be a pallindrome as well as a visual collision)
Fascinating (if I do say so) #lispgames #gamejam #gamedev #retrospective on #itch_io
https://lispy-gopher-show.itch.io/lispmoo2/devlog/834615/princess-revisited
I am enormously happy with the
{ verb [ dobj [ prep iobj ] ] } x
language dynamic, and how it shares your #lisp #repl, and their concerns are just... Different so they don't collide.
I guess I get my #languageDesign friends a little better now.
Thoughts?

I your Europython live coding #MIDI demo talk!

I have always found working with a #REPL
and iteratively building interestingly dynamic systems to be one of the most under-sold aspects of modern computing!

https://www.youtube.com/watch?v=dK6HGcSb60Y

New blogging engine written in #clojure required a post about clojure, so here. Following up on the constant question of monitoring file changes vs #repl driven development:

https://myke.blog/posts/clojure-interactive-development-101

Just added basic server/process stats to Kitten’s interactive shell (REPL).

Use the new `.stats` command to see them.

Also, documented the shell better in the Kitten Reference:

https://kitten.small-web.org/reference/#kitten-s-interactive-shell-repl

Łukasz Langa is giving the closing keynote of the EuroPython 2024 conference, entitled "Live coding music with PyREPL in Python 3.13" in Prague

Info
https://ep2024.europython.eu/session/live-coding-music-with-pyrepl-in-python-3-13

#EuroPython #EuroPython2024 #Python #REPL #Music

CC @europython @ambv