iiinova — where your digital self keeps evolving

laura @laura.viglioni.com · 29/09/2026

Even Claude knows that gender is not binary

Claude snippet in haskell explaining FromField class with a gender example where it sets M, F and NB as possible options

020

laura @laura.viglioni.com · 31/05/2026

Finally doing something I wanted to do for ages: MIT 6001 youtu.be/V_7mmwpgJHU?...

An e-ink tablet displays handwritten study notes in the foreground, while a television in the background plays a lecture from the MIT 6.001 computer science course featuring professor Gerald Jay Sussman.
The handwritten notes on the tablet screen compare programming concepts using text, Lisp-style code snippets, and mathematical formulas.
In the top section, the notes analyze iterative versus recursive processes, showing an expansion of nested parentheses representing deferred operations in a linear recursion alongside arrows indicating big-O notation for space and time.
The middle section contains a handwritten note that reads: The definitions are recursive for both, but the processes are different. Iteration is a process that has all its state on explicit variables. Recursion implies information under the hood.
The bottom section contains differential equations for a circle, dx/dt = -y and dy/dt = x, next to their discrete approximations, x_n+1 = x_n + (-y * dt) and y_n+1 = y_n + x_n * dt. A small sketch of a coordinate plane shows a circle drawn using these state updates, paired with a corresponding def circle code block in Lisp.

5161

laura @laura.viglioni.com · 23/12/2025

Hipster achivement unlocked

A split mechanical keyboard with some keys not assembled

3110

laura @laura.viglioni.com · 02/12/2025

completely steven-wilsed

apple music 2025 replay:
1. steven wilson (2523min)
2. pink floyd (2444 min)
3. black sabbath (2.224min)
4. antonio carlos jobim (1912 min)
5. led zeppelin (1312 min)

albums:
1. steven wilson - the overview (1275 min)
2. di melo - di melo (335min)
3. racionais sobrevivendo no inferno (329min)
4. steven wilson - raven that refused to sing (328 min)
5. porcupine tree - in absentia (313 min)

songs:
1. comfortably numb - pink floyd (54 plays)
2. no quarter - led zeppelin (52 plays)
3. take five - dave brubeck (46 plays)
4. lindo lago do amor - gonzaginha (43 plays)
5. objects outlive us - steven wilson (41 plays)

020

laura @laura.viglioni.com · 27/11/2025

First breaking change in l.el!!! Added arrow syntax and direct values on pattern matching (like in elixir) github.com/viglioni/l-el 1.0.0 is live #emacs #lisp #elixirlang

screenshot of this section https://github.com/viglioni/l-el/blob/main/docs/breaking-changes.org#examples

010

laura @laura.viglioni.com · 26/11/2025

Now l.el has a way nicer type system for pattern matching :D Even with list checks (elixir doesn't have it 👀) to be release today or tomorrow, but the code is there already github.com/viglioni/l-el

Screenshot of this page https://github.com/viglioni/l-el/blob/main/docs/api.org#list_of showing list_of and list_of_instances

030

laura @laura.viglioni.com · 23/11/2025

After some time without touching l.el, I finished the compose macro that allows my custom lambda notation and placeholder! ((lcomp (l x -> (length x)) (reverse __) #'cdr) '(1 2 3 4)) which translates to (funcall (lambda (x) (length x)) (reverse (cdr '(1 2 3 4)) #emacs #lisp

screenshot showing a few tests of lcomp, for instance:

(lcomp
(l x -> (length x))
(reverse __)
#'cdr)

010

laura @laura.viglioni.com · 03/09/2025

{{ stares in molchat doma }} Rio de Janeiro, 🇧🇷

Brutalist building all in concrete showing open passagens from one side to the other on every floor

1131

laura @laura.viglioni.com · 16/07/2025

spoilers of next release: documentation elixir like and l-mode based on emacs-lisp mode that highlight the @doc part :D This is a runnable code with eval-buffer! in the buffer bellow you can see the result of eval-buffer

emacs lisp code defining a function composition and the documentation is elixir like and the function has pattern match

@doc "the documentation"
(ldef lcomp ((f :function)) f)
(ldef lcomp ((f :function) (g nil)) f)
and two other cases of this recursion

a print call using this function composition

there is a second buffer showing with the result of the call

060

laura @laura.viglioni.com · 05/07/2025

Also works with cl structs!

the following code:

ELISP> (cl-defstruct person name)
person
ELISP> (setq ani (make-person :name "anakin"))
#s(person :name "anakin")

ELISP> (ldef explain ((p :person)) (format "It's a person! %s!" (person-name p)))
explain
ELISP> (explain ani)
"It's a person! anakin!"
ELISP> (explain 100)
"100 is an integer!"

020

laura @laura.viglioni.com · 05/07/2025

Also pattern match with types!!

The following code:

ELISP> (ldef explain ((x :integer)) (format "%s is an integer!"))
explain
ELISP> (ldef explain ((x :integer)) (format "%s is an integer!" x))
explain
ELISP> (ldef explain ((x :float)) (format "now %s is a float!" x))
explain
ELISP> (explain 10)
"10 is an integer!"
ELISP> (explain 10.0)
"now 10.0 is a float!"
ELISP> (explain "string?")
*** Eval error *** No applicable method: l-----explain-impl-, "string?"

240

laura @laura.viglioni.com · 04/07/2025

Using my syntax without directly using with-laurisp

The following code:

;; -*- laurisp-syntax: t; -*-

(ldef test-add (a b) (+ a b))

((test-add 1) 2)

And the execution returning 3

150

laura @laura.viglioni.com · 04/07/2025

Pattern matching working with strings and with autocurry! I love lisp I love emacs

the following emacs lisp code:

ELISP> (ldef greet ((name "Ada") surname) (format "Hello, %s %s" name surname))
greet
ELISP> (ldef greet (name surname) (format "Hi, %s %s" name surname))
greet
ELISP> (greet "Ada" "Lovelace")
"Hello, Ada Lovelace"
ELISP> (greet "Lord" "Byron")
"Hi, Lord Byron"
ELISP> (with-laurisp ((greet "Ada") "Lovelace"))
"Hello, Ada Lovelace"

220

laura @laura.viglioni.com · 04/07/2025

Pattern Matching is working!!!!!!!!!!

following code in elisp:

(ldef fib ((n 0)) 1)
(ldef fib ((n 1)) 1)
(ldef fib (n) (+ (fib (- n 1)) (fib (- n 2))))
(mapcar 'fib (number-sequence 1 10))

with the result
(1 2 3 5 8 13 21 34 55 89)

160

laura @laura.viglioni.com · 03/07/2025

In the past I created several elisp functions/macros to make my life easier while implementing features in my emacs. Now I'm taking a step further, I'm creating my own syntax to run in emacs i For now I have autocurrying (even outside the macro) And the macro allow the syntax ((fn arg1) arg2)

the following code running in IELM:

ELISP> (with-laurisp
((((add3) 1) 2) 3))
6
ELISP> (add3 1 2 3)
6
ELISP> (funcall (add3 1 2) 3)
6

140

laura @laura.viglioni.com · 21/05/2025

for instance searching for the subset of my notes with math tag:

screenshot of emacs with a search for org-roam nodes that have the math tag on it

110

laura @laura.viglioni.com · 19/05/2025

Trying here... it is harder than I thought, lots of _gambiarras_ to make things work but the counter is working, though

screenshot showing elixir code to control a counter with functions of increase, decrease, and assigns to DOM elements

pic of a web application of a counter, showing the number 3 in the counter display and a increase and a decrease button

120

laura @laura.viglioni.com · 19/05/2025

I wasn't there physically, but I was indirectly via my colleagues 😀 #elixirConfEU #elixir #elixirlang

pic showing two men presenting in elixir conf eu and in the slides a bunch of pictures of the team, including me

060

laura @laura.viglioni.com · 28/03/2025

the problem of being too expressive sometimes is that all the pics are funny-face material

series of pics of this day every pic im making a different face expression and gestures

1141

laura @laura.viglioni.com · 11/02/2025

this good boi was playing indiana jones

Pic of a black labrador showing his tong and with a little bit of sand on his face

0170

laura @laura.viglioni.com · 04/02/2025

Im running deepseek LOCALLY here (7b) and I provided a clisp file and asked deepseek about its content, i am really impressed with the answer The lisp file and the answer: #clisp #lisp #deepseek #math

screenshot of clisp code defining monoids, groups etc
the full code:

(defun undef-error (val)
(error (format nil "unity not implemented for ~a"
(car (type-of val)))))

;; Binary ops
(defmethod <> (a b) (undef-error a))
(defmethod +. (a b) (undef-error a))
(defmethod *. (a b) (undef-error a))

;; Unity
(defmethod unity (val) (undef-error val))
(defmethod unity+ (val) (undef-error val))
(defmethod unity* (val) (undef-error val))

(defmacro def-unity (type val)
`(defmethod unity ((_ ,type)) ,val))

(defmacro def-unity+ (type val)
`(defmethod unity+ ((_ ,type)) ,val))

(defmacro def-unity* (type val)
`(defmethod unity* ((_ ,type)) ,val))

;; Inverse
(defmethod inverse (val) (undef-error val))

(defmacro def-inverse (type inv-fn)
`(defmethod inverse ((a ,type))
,inv-fn))

;; semi group
(defmacro def-semi-group (type bin-op &optional (func-name '<>))
`(defmethod ,func-name ((a ,type) (b ,type))
,bin-op))

;; monoid
(defmacro def-monoid (type unity-val bin-op
&optional
(unity-macro 'def-unity) func-name)
`(progn
(def-unity ,type ,unity-val)
(def-semi-group ,type ,bin-op ,func-name)))

(defun mconcat (lst)
(reduce '<> lst :initial-value (unity (car lst))))

(defun mconcat+ (lst)
(reduce '+. lst :initial-value (unity+ (car lst))))

(defun mconcat* (lst)
(reduce '*. lst :initial-value (unity* (car lst))))

;; group
(defmacro def-group (type unity-val bin-op inv-fn)
`(progn
(def-unity ,type ,unity-val)
(def-semi-group ,type ,bin-op)
(def-inverse ,type ,inv-fn)))

;; semiring
(defmacro def-semi-ring (type unity+-val unity*-val bin-op+ bin-op*)
`(progn
(def-monoid ,type ,unity+-val ,bin-op+ 'def-unity+ +.)
(def-monoid ,type ,unity*-val ,bin-op* 'def-unity* *.)))

(defmacro def-ring (type unity+-val unity*-val bin-op+ bin-op* inv-fn+)
)

(defmacro fn-maker (name)
`(defun ,(intern (string-upcase (format nil "my-~a" name))) ()
:hello))

Question:
what bla.lisp does?

Answer:

The bla.lisp file defines various mathematical operations and algebraic structures using the Common Lisp programming language. Here’s an explanation of its contents:

Error Handling (undef-error) :
This function raises an error for a specific condition, likely used to enforce certain constraints within the system.
Binary Operators :
Functions like defun <>, defun +., and defun *. define operators <, +., and *.. These operators are part of algebraic structures such as groups, rings, and semirings.
Algebraic Structures :
Monoids : Defined using def-monoid with operations for combining elements.
Groups : Utilized via def-group, which likely combines monoids with inverse operations.
Semigroups/Rings : These are defined with specific binary operations, creating algebraic systems with closure properties.
Utility Functions :
mconcat, mconcat+, and mconcat* : These functions use the reduce method to apply their respective operators across a list of elements, effectively accumulating results in an algebraic structure.
Inverse Operations :
The inverse function (inverse) is used within these structures to find the element that neutralizes another when combined under the defined operation.
In summary, while this file doesn’t contain traditional "functions" as seen in languages like JavaScript or React, it sets up an environment for defining and working with abstract algebraic systems. It provides a framework for users to extend with custom operations and structures if needed.

391

laura @laura.viglioni.com · 14/01/2025

Leaked photo of heaven is going viral on social media. No wonder programmers are so determined to get there 😍

screenshot of GNU Emacs default start page

2417

laura @laura.viglioni.com · 02/12/2024

October (posting 1mo late..)

apple music replay screenshot showing the artist list:
1. john coltrane
2. tom jobim
3. arrigo barnabé
4. the beatles
5. tristania

song list:
1. lilás - djavan
2. mas, que nada - jorge ben
3. nego dito - itamar assumpção
4. a vida em seus métodos diz calma - di melo
5. aceito tudo - di melo

album's list:
1. my favorite things - john coltrane
2. claras e crocodilos - arrigo barnabé
3. os afro sambas - baden powell
4. di melo - di melo
5. works vol 1. - emerson lake and palmer

020

laura @laura.viglioni.com · 24/10/2024

Example: This is exported directly from my org to a directory where I have the js/css

screenshot of a spaghetti recipee in org mode, with tables, headings etc

screenshot of a web page showing a kitchen table and over it a piece of paper with the spaghetti recipee

2161

laura @laura.viglioni.com · 22/10/2024

Im so proud 😭 I did this with css, js and html without frameworks :D This will be the home page of my personal recipees website, generated from my org-mode files Thanks to @lixeletto.bsky.social @eduardopereira.dev @demenezes.bsky.social for the CSS tips

colorful page with the title "ricetti", a ratatatoulli meme framed and several postits with recipees titles

4272

laura @laura.viglioni.com · 22/10/2024

@lixeletto.bsky.social amg MESTRE do CSS Vc sabe se tem como dado um elemento grande e uma lista de elementos menores eu conseguir renderizar assim com flex? (ou sem flex)