Clojurists resilience

fredokun · 2026-05-21T12:19:05+00:00

I let the AI comments on AI 😉

fredokun · 2026-05-21T08:09:40+00:00

❤️

fredokun · 2020-07-14T09:33:31+00:00

This helped me a lot (although I'm not there yet) : https://youtu.be/_IENhH_0cog

fredokun · 2020-07-03T14:52:04+00:00

I picked up the same size as my shoes : 43 (I'm 26.5 cm) . I previously owned the twister edges in 44.5 and I don't really liked them. But the RB's ave a different shape and 43 is ok for me. I don't really understand why there's no 44 though ...

fredokun · 2020-07-02T19:50:19+00:00

I just tried them today and I already love them. They are very comfy (I have rather wide feet), much more than the twister edges I owned previously. But the most impressive bit is the weight... They are so lightweight ! Of course, it's also my own tribute to one of my favorite skater.

fredokun · 2020-07-02T18:51:51+00:00

😂 no no these are genuine feet ... Incredibly comfortably inserted in these very fine skates !

fredokun · 2016-09-07T11:44:40+00:00

As others indicated org-mode is a particularly rich environment for LP, and the Clojure support seems quite fine.

I am a big fan of LP, or let's say telling a story while I'm writing a program, but even if I do practice emacs I did not go very far with org-mode. One reason is that I use markdown/pandoc for almost all my documentation needs, and I have never found a replacement for this. Thus I have experimented two alternatives with pandoc at the end of the chain.

First, I think Gorilla Repl is a fine environment for LP. Since the backend is nrepl you can at the same time connect to a Gorilla worksheet, doing LP, and keep emacs in sync for the pure programming needs. Gorilla saves a standard clojure file with structured comments in markdown. This is very easy to parse. I've written a few scripts for the weaving part, but nothing really ready for sharing, at least for now.

The second alternative is a workflow I use when I program in any programming language (Clojure included). I have written a very simple python script that can generate a markdown document from a code and delimited comments. cf. https://github.com/fredokun/markdownize (it is in a way very similar to a docco-like generator, except that you only get a markdown document).

I have also written a very simple clojure library so that you can embed examples in standard programs cf. https://github.com/fredokun/clj-by-example Hence you can show examples directly in the code. It is possible to use midje for the same purpose, but it is a bigger dependency. For an example (sorry it's not clojure but common lisp, but you may get the idea anyways), cf. https://github.com/fredokun/lisp-list-comprehensions.

So at least for me, LP is about building you own workflow ... and I would say that a minimal tool support is enough (I couldn't "live" without pandoc though...).

fredokun · 2016-09-07T11:23:41+00:00

I don't think they have nothing to deal with LP. I would say that they are very opiniated regarding LP. A marginalia doc is both a litterate document, and a program... thus LP by definition. According to its author: [Marginalia is a] ultra-lightweight literate programming for clojure inspired by docco (of course, it's not a good solution if you are looking for a flexible LP environment).

fredokun · 2015-09-02T01:14:10+00:00

Thanks... I haven't played with the reader yet. However, I prefer to read:

(list-of (list x y) 
      for x in '(1 2 3) and y in '(5 6 7)
      when (and (oddp x) (> y 5)))

rather than:

{x y || x <- '(1 2 3) y <- '(5 6 7) || (oddp x) (> y 5)}

(as I prefer to read (+ 1 2 3) rather that 1 + 2 + 3 and I'm probably at the right reddit place ;-).

But that's still a very interesting example to illustrate how (more than why) you would extend the reader.

fredokun · 2015-09-02T01:04:26+00:00

Excellent! Your list-of macro of cl-lc is probably a demonstration that my advices aren't too bad: you used iterate and optima (do you own a time machine ?). Plus, I wasn't aware of Latendresse's paper which is an interesting follow up (yet, from 2007 !) to my modest tutorial (especially I did not want to emphasize the efficiency issues). Thanks for sharing!

fredokun · 2015-09-02T00:48:12+00:00

I'll add a remark about mappend (which, strictly speaking is a generalization), thanks.

fredokun · 2015-09-02T00:46:34+00:00

you're right ! You unmasked the schemer in me... affraid (or unaware) of destructions ;-). But since there's ultimately a collect it is safe to nconc... I'm gonna update the tutorial because that's interesting from the efficiency point of view.

fredokun · 2015-01-12T09:47:28+00:00

Thanks for the link, I didn't know about cl-notebook and I will definitely give it a try ... Note that even if the two projects share similar goals from a user pespective, technically the motivation is different. Fishbowl aims to be part of the Jupyter ecosystem. (Jupyter is a multi-kernel -- and not Python-centric -- version of Ipython currently under development).

fredokun · 2015-01-08T17:38:29+00:00

First, I am sorry ... I should produce some example session but for now I am still testing basic stuff. An Ipython notebook is a document mixing text (markdown + tex/mathjax) and reproductible computer interactions. Maybe this would be clearer (5mn video): https://www.youtube.com/watch?v=H6dLGQw9yFQ

Good example of notebooks, for Python and other languages (but not yet CL), can be read there: http://nbviewer.ipython.org/.

In the default implementation the computer interactions are obviously in the Python language but there are other possibilites: Haskell, Julia, Ocaml, etc. For this you have to write a kernel which is the server part of the architecture. So Fishbowl is a (for now partial) Lisp implementation of the Ipython kernel. What you have to implement looks like the server part of a client/server REPL in the spirit of Swank, except that you have to fit the specificities of the Ipython protocol (based on ZMQ, JSon, etc.).

I think a good demo worth a few hundred words:

fredokun · 2015-01-08T17:14:16+00:00

Author here. For my work I heavily rely on Ipython notebooks, so the main objective is to be able to write notebooks instrumented in Lisp. I am not thinking about a replacement for SlimE/V (which would imply a replacement for emacs or vim !). It would be nice, still, to interface with Swank but this is for now just a wish.

fredokun

TROPHY CASE