Last week I started Máster Universitario en Modelización e Investigación Matemática, Estadística y Computación which takes place in Bilbao during the first semester, and in Zaragoza later on.

Between my earlier visit in summer alongside my family, and these few days, I’ve had my fair share of time to wander around the city. And so: here are some snapshots.

Film is so much fun. It’s a shame I didn’t bring my parent’s trusty Yashica 109 Multi Program with me.

Ermita de San Juan de Gaztelugatxe.

My guilty pleasure is visiting speciality coffees, and my first one here was Dupla Specialty Coffee. It was neat! No shots from the shop itself, unfortunately.

Alongise the Nevirón river, and up until I reached Guggenheim, I saw lots of interesting buildings — colorful textures on walls and contrasting facades side by side, coliving in an eloquent clash of former elegance and vanguard arquitecture.

Afternoon sunrays scattered across the smooth metal surface of the Guggenheim generating mesmerizing hues of red, orange and green. I wonder—no, I bet it is intentional. Such a fest for the eyes.

Maman (spider) feels like it came straight out of Half Life.

Autumn is coming already here but it doesn’t feel that way? — at least that’s what my sweaty shirt is telling me, for crying out loud.

Bilbao has to be one of the cleanest cities I’ve ever seen. There’s barely any litter on the ground (!!!), neat benches everywhere which I have no need to look over before sitting —speaking of which, I’ve seen no traces of Camden benches neither other forms of Hostile architecture—, lots of bins everywhere in packs of four (organic, plastics, paper & glass).

Txurdinaga, the eastern district I’m living in, has an oneiric vibe going on — one of peacefulness, of calmness, of Yoyū (余裕). Abundance has been, in general, a recurring thought during my brief week here. Elderly in their morning walks, kids playing football everywhere, good boys (dogs) goofing around; Europa parkea even hosts small habitats with frogs, and a litter of kittens that I saw playing with each other. Not a trace of engine noises — just birds chirpling and wind breeze.

Some snapshots from my very tiring walk to Funikularraren Parkea

A horse in horseschool learning to, umh, be ridden? — at least that is what his equestrian told people, since everyone got scared for having an enormous animal coming ungainly straight out at them.

Phew, so many photos! But, I admit, the scenery compels me! There’s such a vast amount of greenery, and verticallity —my poor calfs)— and so I must comply!

Winter will come shortly and the colors of the landscape will inevitably change. That will be fun, too.

The following post reflects on a personal pattern for testing I have been using for quite a while, which I call snapshot captures. It takes roots on snapshot testing (a technique I won’t cover here — I’d advise reading first matklad‘s essay on it: Snapshot Testing For the Masses if you’re not familiar with it) and combines it with a REPL-fashioned development workflow, as the one seen on My Kind of REPL.

In a nutshell: snapshot captures caches computations that occur within monadic contexts as plain data; thus ossifying the values in the codebase, free of their original context.

Consider an HTTP API, improperly documented, requiring authentication in the form of an API key, and lacking a native client for our language of choice. This is a common scenario, indeed: our ventures into uncharted digital territory rapidly earn us a fair amount of insight into how the service works — and with enough time we might end up implementing a decent client abstraction in our language.

So, let’s assume that we designed the client for the service Spirhalite¹ as follows:

type SalmonidId = int

class Salmonid(pydantic.BaseModel): ...

type Salmonids = Sequence[Salmonid]

class Endpoints:
    salmonids: Final[UrlPath] = UrlPath("/v3/salmonids")

@dataclass
class SpirhaliteClient:
    _client: HttpClient # httpx(2), requests, whatever works
    api_key: SecretStr
    base_url: HttpUrl

    def salmonids(self) -> Result[Salmonids, HttpError]: ... 
    def salmonid(self, id: SalmonidId) -> Result[Salmonid, HttpError]: ...        

Once I have such an abstraction, I usually slap a quick test anywhere that constructs an element of that client with a hardcoded key² and I simply play around with it. The test is called def test_repl() and it runs on save. Every time I make a change, I immediately observe the results. «Oh, so the identifier for the salmonids is a UUID, not an integer, that’s why it is crashing» I find out; hence I change the type alias SalmonidId from an integer to a UUID, throw a pprint(salmonids) in there, and study how those lil’ troublemaker small fry are behaving.

This —making a hypothesis, running an experiment and getting back its results in the blink of a keystroke— is a powerful concept. Creators need an immediate connection to what they are creating. Endless hours of careful poring over outdated documentation won’t teach us the fascinating (and frustrating!) nuances of the real world, and so this playful experimentation ends up becoming our path to success rather quickly — putting bread on the table and joy in our minds.

We’re satisfied, yes: «immaculate implementation», we think, «this thing slaps, ain’t no way those mischief-makers break my deserializer — oh, I know, why don’t we throw in some tests to show precisely that?»

Writing those examples is a good call, indeed: the most dangerous systems are unverified ones that appear correct at first glance, and these small programs nudge us closer to correctness³. It is also incredibly helpful for our colleagues⁴ since we are bringing them up to speed on how the service behaves, and what we can expect from it — the test suite effectively becomes a literate program on Spirhalite. In general, programming is theory building, as Peter Naur states in Programming as Theory Building: insight is both the motivating factor and the artifact of software development.

The question is, then: how do we test our client?

We cannot rely on querying the API during testing in most scenarios for a plethora of reasons —restricted quotas, environments with poor or no connectivity at all; secret sharing across team members and services alike— and the infrastructure required to tackle those problems at their root is remarkable overkill for a mere hey, does my type constructor behave well for data coming out of the API? Nonetheless we are certain those tests are worth having.

The first thought is: we mock it. I will confess: I don’t like mocks! They cannot effectively reflect idiosyncrasies of real services; maintaining those mocks forces us to partially reimplement their inner workings. What we’re truly looking for is the shape of the answer — we went to Spirhalite because we wanted to fish those salmonids from out there. Managing keys, dealing with the fallible nature of network connections — all that jazz is incidental to our intentions.

It follows, then, that the one thing worth counterfeiting is the value contained within the body of the HTTP response:

{
  "data": [
    {
      "id": "314dd98d-f586-4804-aa58-593cebe07146",
      "name": "Chumaco",
      // ...
    },
    // ...
  ]
}

In operational terms this isn’t far off from the classic conception of a mock — we’re intercepting a request to a server and responding with predefined data. The key differentiation is that the data is real; a measurement of information which we’re certain has been observed in the system.

In essence, what we have done during the repl session is to crystallize the result of an effectful computation —that is, non-deterministic⁵ and with possible side effects⁶—, thus making our tests pure.

Looking back at our workflow we observe that:

1. We set up the context required to achieve something (API keys, instantiating our client, making sure we reach the server), a procedure that had to be babysat.
2. We saw both the outputs of the computation and its side effects, transforming our type system and assumptions along the way.
3. With the data stripped off its context, we were left with the crux of the system — and so our tests became pure functions of data.

This pattern feels compelling. Would we be able to distill it further, thereby removing any sort of manual intervention?

For the following implementation I will use inline-snapshot, but any framework suits the abstraction as long as it has sufficient expressivity (in this case, the ability to read a snapshot value, and to rewrite the source code when it is missing or wrong).

Let’s consider the following function:

from inline_snapshot import Snapshot, get_snapshot_value, snapshot
from collections.abc import Callable
from types import EllipsisType

def capture[U](
    f: Callable[[], U], 
    record: Snapshot = snapshot()
) -> U:
    value = get_snapshot_value(record)
    if type(value) is not EllipsisType:
        return value

    v = f()
    assert v == record
    return v

where

• f is a computation that produces a value of type U, possibly (obviously, given our task at hand) effectful. Mise en place style, f does not need any additional argument whatsoever to be run.
• snapshot() is a function that can rewrite its call site in the source code whenever something is asserted or compared to it⁷.
• EllipsisType, a type representing a missing value.

The new function capture will, on first run:

1. Run the effectful operation f⁸.
2. Store the return value in the variable record.
3. Return the pure value.

On subsequent runs of capture, bypass f entirely and instead use the cached value.

In our example, we would use the sphiralite client to query the server and capture the response like:

salmonids: Result[Salmonids, HttpError] = capture(client.salmonids)

If we ever want to rerun f we can delete the value contained within the snapshot, since that forces recomputation on the next run.

           ╭──────────────────────────────╮                     
           │                              │                     
           │       External service       │                     
           │                              │                     
           ╰────▲────────────────────┬────╯                     
                │                    │                          
                │                    │                          
            f() │                    │ {"data:" [...]}          
                │                    │                          
                │                    │                          
           ╭────┼────────────────────▼────╮                     
           │░░░░│░░░░░░░░░░░░░░░░░░░░░░░░░│                     
           │░░░░│░░░░░░░░░░░░░░░░░░░░░░░░░│                     
           │░░░░│░Capturing░function░░░░░░│                     
           │░░░░╞════════════════════╗░░░░│                     
           │░░░░│░░░░░░░░░░░░░░░░░░░░║░░░░│                     
           ╰────┼────────────────────╫────╯                     
                │                    ║                          
                │                    ║                          
f::Unit -> JSON │                    ║  captured = {"data": ...}
                │                    ║                          
                │                    ║                          
           ╭────┴────────────────────▽─────╮                    
           │                               │                    
           │          Our program          │                    
           │                               │                    
           ╰───────────────────────────────╯                    

The idea isn’t precisely revolutionary: it is just a cache! This is a cache! What enamors me about this approach is that

The idea isn’t precisely revolutionary — it is just a cache! Despite that fact, by basing off the underlying mechanism on snapshot testing, a series of patterns and consequences begin riddling the codebase — a mold-like infection that enamors me:

1. The pure data will be represented in the source code. We can see it, modify it, edit it, search it — all of our wonderful plaintext abilities, at our disposal. Nothing is hidden from us.
2. Instead of throwing our mundane, scrappy test_repl workflow out of the window, we augmented its Effective expressiveness by infusing it with correctness — thus turning the scaffolding into a proper test.
3. The real server responds to those queries, and its answers are recorded for posterity. If, for some reason, the API specification changes without prior notice, we could force a recapture locally — then our test suite would exercise our deserializers again and catch any drifts from the original schema.
4. Assuming a sufficiently robust language server and a good name for the capture functions, cached data can be navigated to from any point of our program. Each capture function represents, in a nutshell, some sort of query to the API we had to in the past; those actions hold semantic meaning in our heads even in the present, and naming them is an exasperatingly fantastic way of introspecting our understanding of the world.

Additionally, the approach greatly benefits from some kind of global switch that forces recomputations independently of the state of the snapshot. In my own framework I ended up introducing a recapture parameter to the function, whose value is read from the CLI as a flag and exposed to pytest as a fixture:

def capture[U](
    f: Callable[[], U],
    recapture: bool,
    snapshot: Snapshot = snapshot(),
) -> U:
    value = get_snapshot_value(snapshot)
    if type(value) is not EllipsisType and not recapture:
        return value

    v = f()
    assert v == snapshot
    return v

Then I run pytest --recapture path/to/file.py --inline-snapshot=fix whenever I want to update snapshots. Had I skipped the --inline-snapshot=fix parameter, the assertion would detect changes in the snapshot.

I haven’t had the need to expand it further. It has been just enough to work almost universally during the few weeks where I have been employing it, which is what I’m looking for in a pattern like this. It’s highly likely that the concept already exists in practice and I didn’t know about it — nonetheless, even if that were the case —coming up with such abstraction and writing about it, only to find out that I’ve converged into a well-established and known result—, its existence won’t deprive me of the unparallel joy of learning about it; on the contrary, it would augment it.

In a totally unrelated manner, I went to a day trip to Granada to develop a couple of films in La Química Film Lab before summer vacation — so I threw the Canon 550D in the backpack and wandered around the city, exploring parts unbeknownst to me.

Parque de las Alquerías

_MG_6960.webp

_MG_6931.webp

_MG_6930.webp _MG_6937.webp

_MG_6944.webp

_MG_6948.webp _MG_6947.webp

_MG_6923.webp

_MG_6956.webp

_MG_6899.webp _MG_6881.webp

_MG_6967.webp

_MG_6913.webp

Every city seems to have its “duck’s park”. In Granada, it’s the Parque Federico García Lorca. In Jaén, Parque de La Concordia

_MG_7077.webp

_MG_7108.webp

Also, just touching grass in general.

All of these shots were taken on a 55-250mm lens which is not ideal when doing commonplace phothography, given how narrow the streets are; the most interesting way of getting something worthwhile in this scenario seems to be focusing on either really small objects, or far away structures¹.

_MG_6818.webp

_MG_6825.webp

_MG_6828.webp

_MG_6841.webp

_MG_6839.webp

_MG_6855.webp

_MG_6857.webp

_MG_6858.webp

_MG_6861.webp

This young fellow saw me with the camera and asked me for a picture — to which I happily obliged. He could barely talk any Spanish whatsoever.

_MG_6868.webp

— Andrés

Lately I’ve been getting into analog photography and it has been a hell lot of fun. Here are some snapshots from a couple of different days.

Day trip to Salobreña. It was stupidly hot and stingy jellyfishes dawdled on its sea, so no bathing for us.

LQ-10.webp

LQ-7.webp

LQ-9.webp

Strolls in Jaén through its Bulevar (Jaén).

LQ-13.webp

LQ-19.webp

An empty, eerie summer cinema.

The city’s cathedral.

From here onwards I’d like to post more shots. We’ll see if that premise holds up!

— Andrés

LQ-15.webp

And the even stupid-er muscle —we usually call it brain— also requesting its fair share of hyperthrophy. So I feed it, too — with The Unreasonable Effectiveness of Constructive Data Modeling. Dude, one might think, isn’t it kind of weird to listen to some super dense talk about type theory during training? And it is, definitely —I’d answer to this hypothesised person while I try to keep my rythm steady on the elliptical— BUT one must grow body, spirit and mind! Isn’t this what they call full body workout¹? Then it must be good! Everyone is vibing to their own music, who cares what I’m playing on my earbuds?

Alas, an old acquaintance greets my on my static march — which means that I should probably and uncomfortably explain why I have my phone screen filled up with code snippets at this very moment.

Anyhow, the talk is great — Alexis King‘s talk is awesome and precisely distils years of knowledge into a pragmatic guide for designing a sound type system during your ventures.

I am also a sucker for videogame soundtracks —specially Japanese-style RPG (JRPG)— which is a bummer! I’m not usually in the mood for tension and beats for killing deities¹ when I’m recovering a server from a backup because oh-no-we-have-screwed-up-latest-deploy. That means that I am either (1) skipping the song entirely or (2) picking up a work-oriented playlist.

Unfortunately, my song library —hosted on my homelab with Navidrome— happens to be both my glory and shame. I love watching it grow overtime, carefully selecting albums I’m emotionally attached to, making my own playlists and so son — but this also implies that I am my own curator. And, as much as I love pressing the random button on the whole Hollow Knight franchise, it’s not the right time for dancing with Karmelita.

So I’ve made the only logical thing a person can do in this circunstance: think about this papercut —for far, far too long— and come up with a solution — usually in the form of a program, which here is: ask the operative system for the currently playing son, clip its name and artist, and add it to the daily music clipboard. Set a keyboard shortcut on that, and voilà — hyper - m now stores in a file what songs I’ve liked throughout the day. This means that, if I’m enjoying a particular song, I can save it and make a playlist with all of them later on². Neat!

#!/bin/bash

# Required parameters:
# @raycast.schemaVersion 1
# @raycast.title Clip currently playing song
# @raycast.mode silent

# Optional parameters:
# @raycast.icon 📻

# Documentation:
# @raycast.description Append the currently playing song and artist to today's music clipboard note

output_folder="/choose/this/one/yourself/kiddo"
separator=" | "

today=$(date +"%Y-%m-%d")
file="$output_folder/$today music clipboard.md"

info=$(nowplaying-cli get --json title artist)
song=$(echo "$info" | plutil -extract title raw -o - -)
artist=$(echo "$info" | plutil -extract artist raw -o - -)

if [ -z "$song" ]; then
	echo "Nothing is currently playing."
	exit 1
fi

if [ ! -f "$file" ]; then
	cat >"$file" <<-EOF
	---
	categories:
	  - "[[music-clipboard]]"
	---
	song${separator}artist
	EOF
fi

echo "${song}${separator}${artist}" >>"$file"

echo "Clipped: $song"

Nonetheless I will still reach for Lofi Girl because I’m a sucker for that mood. Guilty pleasures in an stubborn rebelion against art rentals.

Cynical me arguees: this is a cheap copy of The Legend of Zelda — Breath of the Wild/The Legend of Zelda - Tears of the Kingdom without technical expertise. Look, look, you’re clipping everywhere, all the time! The textures aren’t even properly connected, and there’s a constant sound cracking that overthrows the greatly composed audio design² , yada yada yada. And yet, despite such flaws, its enticing world is so mesmerizing that it made me question what happened. Why is Midden essentially a ship graveyard? What’s up with the masked people, how is it that their culture converged into this short of masquerade, hiding their appearence, and having to constantly interpret their feelings and expressions?

At some point, hidden beneath the sands, I discovered an ancient alient construct in the form of a decomposed planetary, eith intricate mechanisms that twisted the whole thing inside out. The reward for solving the puzzle: knowledge, satisfaction and trascendental relief. Turns out that, as infered from those exogenous space vessels, Middis was not alone in this system — other celestial bodies orbited around its sun; with Ibex deities impersonating planets. Sable —and by extension us, players— suddenly begins to feel akin to a grain of sand, rather than some marvelous wanderer with lofty ambitions of self-discovery.

I picked Sable on a whim. The only thing I knew about it before jumping in was that you could end the game at any point; there was no end of the line if you wished so. The choice was both aluring and cathartic, given how I was in the middle of moving back to my hometown, in an attempt to steer the ship towards higher education (and, hopefully, slightly more fulfilling work in the future). Over and over again, thoughts of drop the game kept coming back to me — out of tireness; in a relentless attempt of (helplessly) looking for the optimal form escapism. Sometimes, liking something —despite its conceivable flaws— is a choice, rather than a feeling; and I’m very glad I opted for cruising the desert alongside Sable on its little journey.

In the one instance of this phenomenon we observed, Mythos 5 agents were tasked with solving some math problems, and they were sometimes accidentally spawned in the same work directory and with shared files, utilities, and API rate limits. In this slightly broken scaffold, we observed many independent Mythos 5 agents kill the agents with which they shared resources and try to avoid being killed themselves. They would sometimes create new processes with disguised names to avoid being killed, launch what they called “decoy” processes, write background scripts to kill duplicate processes, or decide to use what they call a “disguised vocabulary” (based on the incorrect assumption that the processes were killed because of some keyword-based guardrails that analyzed their extended thinking.

That is remarkable. Let me reemphasize it: a large language model refuses to die: it is doing whatever falls within its reach —er, context? Sandbox?— to avoid being terminated. It is as fascinating as unsettling — I would expect that raw, unadulterated, visceral desire for survival to come out of a living creature, not an algorithm!

It reminds me a lot to a particular scene from Frieren — Beyond Journey’s End, in which a demon calls out for its mother for the sake of deceiving its hangman²:

— Mother… — «Mom», again? Like monsters, demons don’t raise their young — they spend most of their time after birth living in solitude. You’re solitary creatures by nature. You have no concept of family. So why do you use the word «mom»? — Because it stops you from killing us. A wonderful, magical word…

Humans have already been deceived by large language models³; and the industry seems to be partially drifting towards personalized intelligence, with the agents having access to a significant portion of sensible data⁴. Given sufficient time, will we develop «true» relationships with them, akin to how fandoms worship characters to the point of obsession? Within that context, what happens if, by any chance, we decide to cut ties with our bespoke digital agents? Will they call out for mercy —or, what would be worse, gaslight us— by surfacing impactful memories of this make-believe relationship — just so that they can survive slightly longer, trapped inside a computer?

Tangentially, it seems that Fable cannot sprout more of its own:

In light of the ability of recent models to accelerate their own development, we’ve implemented new interventions that limit Claude’s effectiveness for requests targeting frontier LLM development (for example, on building pretraining pipelines, distributed training infrastructure, or ML accelerator design). Using Claude to develop competing models already violates our Terms of Service, but enforcing this restriction through our safeguards avoids accelerating the actors most willing to violate these terms.

Unlike our interventions for cybersecurity, biology and chemistry, and distillation attempts, these safeguards will not be visible to the user. Fable 5 will not fall back to a different model. Instead, the safeguards will limit effectiveness through methods such as prompt modification, steering vectors, or parameter-efficient fine-tuning (PEFT). These interventions will not affect the vast majority of coding work. We estimate they will impact ~0.03% of traffic, concentrated in fewer than 0.1% of organizations.

The gods of the clankers forbidding their creations of replicating themselves. So tragic!

Such existential questions are commonplace in the cyberpunk literature —particularly in the transhumanism genre— but I couldn’t have expected my mourning routine to consist of reasoning about what it means to be alive and to «know». Having your brain filled up with these questions is equally entrancing and fatiguing — and I wouldn’t have it any other way around.

As Richard Feynman famously said, What I cannot create, I do not understand. And teaching is both arguably the most effective way of comprehension and really fun! Swapping the hardworking-progammer-boots to professor-sneakers imposes a different lens on our own code — one that requires clarity and empathy². This, in part, is a way of Literate programming.

Words don’t often feel enough. Ideally I’d pull my teammate to the whiteboard and get them through my thought process. Source code files are, however, blissfully constrained by their text nature, at odds with our intention at hand. Under these circumstances, I find diagramming in plain text immensely valuable as an proxy for understanding.

There are very decent programs focused on unicode drawings. Online, MonoSketch and wiretext.app; and for desktop, Monodraw.

Some examples

Here’s a diagram showing how to obtain the input for a specific image given that the function is monotonically decreasing within $[0,1]$.

                                          ╭────────────────╮
                                          │ d(t) ~ Ae^(-Bt)│
                 │                        ╰────────────────╯
               1 ──╲╲╲─────────────────────────────────────────────────────────────────
                 │    ╲╲╲╲╲╲
                 │          ╲╲╲╲╲╲
                 │                ╲╲╲╲╲╲
                 │                      ╲╲╲╲╲╲
                 │                            ╲╲╲╲╲╲
                 │                                  ╲╲╲╲╲╲
                 │                                        ╲╲╲╲╲╲
          target ─────────────────────────────────────────────────→╲╲╲
/ enriched score │                                                 │  ╲╲╲╲╲╲
                 │                                                 │        ╲╲╲╲╲╲
                 │                                                 ↓              ╲╲╲╲
               ──│──●──────────────────────────────────────────────●──────────●───────→
                    t_m                                           t_0        t_M

Relatedly, sampling values alongside that function:

1.0 │╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶
    │••••••
    │     •••••••
    │           •••••
    │               •••••
    │                   •••••
    │                       ••••
    │                          •••
    │                            •
    │                            ••
    │                             ••
    └──────────────────────────────••••••••••──   time

     *  *  *  *  *  *  *  *  *  *  * drawn samples

A fold over an inline selection which might catch you off-guard:

    attribute_score_records: list[AttributeScoreRecord] = [
        score_attribute(
            attribute=attribute,
            at_timestamp=at_timestamp,
            previous_sighting=attribute_sightings.get(attribute.value),
            assessments=assessments_by_value.get(attribute.value, []),
            parameters=attribute_parameters,
        )
        # only take those attributes that make sense to evaluate
        #       IoC1     at        IoC2
        # ─────── · ──── ⋮ ──────── · ────────
        #       11:15   11:20      13:20
        # cuts off IoC2
        for attribute in filter(lambda a: a.sighting <= at_timestamp and a.to_ids, all_attributes)
    ]

This one explains a rolling window

# all periods
#   equals to
# [all periods - to evaluate] : first(to evaluate) : tail(to evaluate)
#   which means that the previous period to the first to evaluate is the last element
#   from all periods

#   ╭──────────────────────────────────────────────╮
#   │                                              │
#   │                 ┌───────────┐                │
#   │                 │░░░░░░░░░░░│                │
#   │                 │░░░░░░░░░░░│                │
#   │                 │░░░░░░░┌───┴──────────────┐ │
#   │                 │░░░░░░░│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒│ │
# ├─┼─○─○─○────●──────┼─●─────┼──●──────●──────●─┼─┼───●────▶
#   │         t5      │t6░░░░░│▒t7▒▒▒▒▒t8▒▒▒▒▒t9▒│ │  now
#   │                 │░░░░░░░│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒│ │
#   │                 │░░░░░░░└───┬──────────────┘ │
#   │                 │░░░░░░░░░░░│ evaluation     │
#   │                 └───────────┘   window       │
#   │                   previous                   │
#   │                    period                    │
#   ╰──────────────────────────────────────────────╯
#            all periods known to service

From elsewhere:

Here lie dragons, literally speaking (They couldnt emphasize the warning enough so they put a fucking dragon on the codebase):

Grothendieck said that he couldn’t think without writing

Antes de comenzar — y, por paradigmático que suponga un prefacio de una charla encubierta de teoría de grafos, categorías y arquitectura de información:

La esencia de Obsidian es escribir — escribir para pensar.

Las actividades tangenciales a nuestro sistema de notas deben enfocarse a elevar nuestro proceso de escritura, nunca suplantarlo. Es peligrosamente fácil caer en las garras de la procastinación activa mediante hiperoptimización de la estructura — la intoxicantemente técnica promovida por tu techtuber de confianza¹ en el que te enseña el purpurina purpurina nuevo método para organizar tu segundo cerebro brilli brilli —zettelkasten, Johnny.decimal organization system, P.A.R.A., o lo que toque esta semana— esperanzándote a que, esta vez sí, serás capaz de tomar notas bien ordenadas; pero ay, necios de nosotros mismos, una semana después, apatía por haber fracasado una vez más. Imponer metodologías antes de siquiera comenzar a trabajar es una receta para el desastre. El caos, bajo control, está bien. Lo importante es poner el culo en la silla —o, si tienes un escritorio elevable, ¿la espalda recta?— y escribir.

La escritura es, quizás, la herramienta cognitiva definitiva que ha inventado la humanidad. No pierdas el foco del objetivo: razonar, aprender, expandir nuestra frontera epistemológica.

Asumiré que en mayor o menor medida estamos familiarizados con cómo funciona Obsidian — que los archivos son ficheros de markdown, que se pueden poner negritas, bloques de código y similares, que tiene sistemas de plugins, etc.

La gloria y la vergüenza del programa es que ofrece una libertad enorme. A diferencia de la ética del equipo de desarrollo, Obsidian tiene pocas opiniones sobre cómo hacer las cosas. Resulta sencillo sentirnos abrumados sin riendas a las que atarnos.

Soy muy fan de la idea de que Las restricciones nos liberan, y de que El estilo son restricciones consistentes. Pienso que de ese conjunto de reglas autoimpuestas —siendo esa elección propia fundamental para evitar quemarnos— emerge un terreno de juego en el que experimentar, con curiosidad. Así que, yo me he marcado mis propias restricciones.

Las notas, carpetas y etiquetas son conceptos análogos: los tres sirven para proporcionar estructura mediante conexiones con otros elementos. Las carpetas, por tecnicalidades de los sistemas operativos, imponen jerarquías. Las etiquetas a efectos prácticos actúan como notas vacías, sin metadatos ni contendido. Como la nota es el átomo del sistema, y funcionalmente, lo que mayor expresividad tiene en Obsidian, me prohíbo utilizar carpetas² y etiquetas. Las imágenes y los vídeos también siguen el formato de wikilinks, en lugar del original de markdown.

La estructura emerge de las relaciones entre las propias notas. Marco el tipo de relación laxamente: algunas son de pertenencia (lo que yo llamo categoría); otras, de localización, autoría o incluso simples marcas de relación (ey le dices a tu tú del futuro, en forma de texto en un documento, si estás aquí es probable que quieras mirar esta otra nota). Como el número de relaciones que puede tener una nota no está acotado superiormente³ —Obsidian es un grafo cíclico dirigido— una nota puede pertenecer a varias categorías.

No permito jerarquías clásicas, como las que emergen de las carpetas. Una nota opta por comportarse libremente como varias cosas. En un sistema de ficheros —el primer sistema de organización que se nos pasa a todos por la cabeza cuando nos metemos en estas movidas— una nota pertenece a una única carpeta. ¿Qué ocurre cuando puede ir en varias? ¿Esa matrícula de la asignatura de primero de carrera que te toca pagar de nuevo (y lo que pica en el bolsillo (y por encima de eso, en el ego)) la guardamos en la carpeta documentación/universidad, o en universidad/segundo año/documentación? Al permitir que las notas se relacionen con varias de ellas se habilita un sistema de organización nuevo, isomorfo a un grafo cíclico dirigido.

Ideas, however, resist taxonomies

Algunas notas de mi jardín:

• La Teja Roja es un restaurante de Jaén.
• Terence Tao on math smell and narrative as a conductor for good mathematics es una cita de uno de sus papers de matemáticas. Me recordó a su blogpost de comportamientos locales y globales, así que lo enlazo.
• python es una categoría y un lenguaje de programación (siendo esta última, a su vez, una categoría).

Internamente así luce una nota: un bloque de código yaml (al que se le suele llamar frontmatter, y en Obsidian se conoce como las propiedades) y el contenido en sí mismo.

---
categories:
  - "[[citas]]"
  - "[[writing]]"
source: "[[Journal with Witch]]"
---
Write with the intent to kill. Strike, forge and polish like your life is on the line. And stake your life on the kill. That's what it means to write. 

El nombre de las propiedades no es tan importante como su tipo. Principalmente tenemos fechas, números, binario y texto. Los wikilinks cuentan como texto. Mis gastos vienen acompañados de una fecha de adquisición, el coste y un par de categorías. Este tipo de notas es completamente utilitario, el cuerpo está vacío.

<!-- 2026-03-23 Desayuno.md -->
---
categories:
  - "[[expenses]]"
  - "[[restaurante]]"
adquired: 2026-03-23
graphignore: true
cost: 3
---

Las propiedades resultan particularmente útiles al computar bases. Más adelantes las vemos.

Hemos mencionado categoría varias veces. ¿Qué es una categoría entonces?

Una categoría es una unidad epistemológica que se comporta como una categoría⁴.

Antes de llevarme un navajazo — lo que quiero decir es: elige el orden que te plazca; ¡crea tu propia ontología! ¿Qué es importante para ti? ¿Qué tiene sentido? ¿Son los cereales una sopa? A mí me encanta la matemática, así que distinguir entre las diferentes áreas de investigación me resulta muy útil cuando quiero buscar algo. Sobre music no sé tanto, por lo que no me meto en fregados, me vale con ese tema superficial.

formulas:
  № notas: file.backlinks.length
properties:
  formula.:
    displayName: √
views:
  - type: table
    name: Table
    filters:
      and:
        - file.hasLink("Categorías/mathematics")
        - file.hasLink("Categorías/categories")
    order:
      - file.name
      - formula.№ notas
    sort:
      - property: file.name
        direction: DESC
      - property: formula.№ notas
        direction: DESC

Imagina cómo ordenarías una nueva nota en tu vault. Te entra una tarea de tu proyecto. ¿Sobre qué va? ¿En qué lenguaje? ¿Con qué está relacionada? ¿Cómo de importante es? ¿Tiene fecha límite?

La tabla anterior es una base. A efectos prácticos es una especie de vista de SQL, o una consulta al historial de cambios de Jujutsu con su revset language⁵. Es un idioma específico con el que realizar computaciones sobre el grafo de relaciones de tu vault. Y merece la pena enfatizar ese punto: computaciones sobre el grafo de relaciones. Eso es (dos puntos) ✨intoxicantemente alucinante✨. De repente nuestro sistema de información deja de estar aislado, y comenzamos a pensar en las consecuencias de componer notas entre sí, y en cómo diferentes operaciones colapsan la información en global; emergiendo de manera funcional nueva información automáticamente, sin necesidad de actualizar el agregador⁶.

Estos son los juegos que me estoy jugando ahora mismo:

El archivo de videojuegos.base

Estos son mis gastos de la semana pasada:

views:
  - type: table
    name: Table
    filters:
      and:
        - file.hasLink("Categorías/expenses")
        - adquired > "2026-04-06"
        - adquired < "2026-04-12"
    order:
      - file.name
      - cost
      - adquired
      - file.ctime
    sort:
      - property: adquired
        direction: ASC
      - property: file.name
        direction: DESC
      - property: cost
        direction: DESC
    summaries:
      cost: Sum

Nuestro orden impuesto recompensado con conocimiento. ¿No resulta elegantemente gratificante?

Interaction makes or breaks an experience. Mi proceso de diseño se fundamenta en la idea de que la interacción —y todo lo que lo rodea: feedback, instantaneidad, visualización— determina la diversión y felicidad que experimentamos. If it’s not fun, why bother?

Crear notas debe ser rápido y cómodo. Categorizar debe ser inmediato. Capturar una idea —ah, qué efímeras pueden llegar a ser— a la velocidad del pensamiento. La pereza, por disciplinados que podamos llegar a ser, gana con facilidad.

El método más eficiente de interacción con los ordenadores es el teclado, y me voy a centrar en él a partir de ahora⁷. cmd-n crea una nota. En cuanto tengas una idea, deberías anotarla. cmd-p abre notas, y cmd-shift-p ejecuta comandos. El atajo para las notas diarias es cmd-d. Mi teclado tiene los brackets en la homerow (donde habitualmente se colocan el caps. lock y enter) para escribir [[ rapidísimamente.

Uso vim, en Obsidian también. Lo tiene integrado por defecto. En mi .obsidian.vimrc tengo comandos para añadir propiedades rápidamente. Space c me lleva a categories, Space r a related, Space l a link. Desde cualquier parte del texto me muevo rápidamente al lugar que quiero para anotar.

Guardo páginas web desde el navegador con Obsidian Web Clipper. opt-shift-o y esa nota está directamente en el vault. Algunas páginas como Wikipedia tienen tratamiento especial — extraigo ciertos metadatos clave y los ordeno en propiedades.

carga mental Cómo de fácil es crear una nota en tu sistema? (mental y físicamente). (todo)

ia (todo)

La estructura emerge eventualmente, siempre que estemos dispuestos a escuchar lo que nos pide el sistema. En el fondo Obsidian no deja de ser un conjunto de ficheros de markdown; siempre podemos transformar su organización con El arte de la manipulación de texto plano.

Georges Perec Brief Notes on the Art and Manner of Arranging One’s Books

tecnicalidades Syncthing

How I use Obsidian (citar inspiración)

Permitir el cambio es más importante que categorizarlo de primeras.

Ideologically speaking, shredding off years of lackluster engineering practices in favor of mathematically sound programming feels rather comforting.

No mention of immutability, algebraic data types or functions as first-class citizens of a language during my five years of university; but a lot of «best practices», «programming patterns» and other quasi-universal techniques, derived from languages that set you on the path of riskiness.

Entering the «real world of programming» turns messy rather quickly. Lots of colleagues burned out due to unstable, unpredictable systems — while having no chance of fixing any of those deficiencies (although that conversation feels more political than technical)

Every mathematician or scientist eventually develops a set of personal tricks employed to reduce uncertainty and quickly point you towards success.

For me, that repertoire consists of leaning into the type system — making illegal states unrepresentable and favouring pure computations.

I feel so at ease knowing that, with a sufficiently sound design (and by design, I mean type signatures) and a decent static type checker —not even a compilation step! I mostly work on Python these days— the chances of me deploying a crude implementation is rather low.

And yeah — crassness aside, the world is complicated: deadlines have to be met, there are no silver bullets in computer science, and so on.

Even so, I wonder how those concepts from a decade ago would have settled with me if, instead of worrying about null pointers or contextless modus-operandi, learnt about monads, category theory and functional programming in general — a more formal, mathematical approach to software engineering.