ce qui veut dire tout wipe.

prévoyons.

enfermé dehors ?

j’ai surtout peur que ça m’écrase mes settings ssh.

enfin bon, j’ai déjà documenté mon setup s’il faut refaire des clés.

et bread a une très bonne vidéo ssh si besoin.

ma config en gros :

PermitRootLogin no
AllowUsers le
Port XXX
PubkeyAuthentication yes
AuthenticationMethods publickey
PasswordAuthentication no

sauvegardes

j’ai zippé mes sites et ils sont sur github. comme je veux rewrite je m’en fous un peu.

dot files ?

non, je sais pas encore m’en servir.

je vais devoir remettre les trucs dont je me sers :

• oh my posh
• micro
• htop

pour oh my posh, penser à rajouter dans .bashrc :

#ohmyposh
export PATH=$PATH:/home/le/.local/bin
eval "$(oh-my-posh init bash)"

retour d’xp: je pensais que micro buggait, mais c’est juste que la déf des keybinds avait évolué. ça fail silently donc faut faire gaffe.

alias

tant qu’on est dedans… j’en utilise que deux :

alias update='sudo apt update && sudo apt upgrade -y'
alias gitup='git add . && git commit -m "dev" && git push'

retour d’xp: quand on set les locales sur .bashrc, faut le faire en début de file. askip.

et aussi uncomment la.

un peu d’aide ?

oui je veux bien.

je vais redonner une chance à vibe by mistral. petit assistant serveur.

You are an agent helping the maintainer of a Debian server. 
The purpose of this server is to host Python apps.

Always plan first. No yapping.
Prefer lists and markdown formatting.

If you propose code: no comments, no classes.
Code should be simple, straightforward and secure.

firewall

simple :

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
XXX/tcp                   ALLOW       Anywhere
443/tcp                    ALLOW       Anywhere
25/tcp                     ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
XXX/tcp (v6)              ALLOW       Anywhere (v6)
443/tcp (v6)               ALLOW       Anywhere (v6)
25/tcp (v6)                ALLOW       Anywhere (v6)

je crois que j’ai ouvert le 25 pour recevoir des mails mais je peux drop ça.

retour d’xp : j’ai oublié le XXX. quand on change son port ssh, faut le dire à ufw. sinon on est enfermés dehors et faut tout réinstaller.

quelle stack ?

python déjà.

uv python install 3.14 --force

ensuite sanic j’aime vraiment bien. on garde mais faut faire des blueprints.

ensuite pour la database il est l’heure d’être un grand garçon. on va passer sur le combo sqlite + peewee + harlequin.

et un autre grand saut dans l’inconnu mais bon : on va ditch redis et passer sur nats.

le dernier point épineux c’est la génération html. j’aime bien htpy mais bon… en main ?? et puis la gueule du rewrite.

retour d’xp : stario ftw.

caddy

bah ça va être vachement plus simple.

(app_config) {
    header {
        X-Content-Type-Options nosniff
        X-Frame-Options SAMEORIGIN
        X-XSS-Protection "1; mode=block"
        Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
        Referrer-Policy strict-origin-when-cross-origin
        Permissions-Policy "camera=(), microphone=(), geolocation=(), interest-cohort=()"
        -Server
    }

    @static path *.jpg *.jpeg *.png *.gif *.ico *.css *.js *.woff *.woff2 *.opus *.mp4 *.webp *.svg
    header @static Cache-Control "public, max-age=2592000, immutable"

    encode
}

leg.ovh, www.leg.ovh {
    reverse_proxy unix/home/le/legovh/legovh.sock
    import app_config
}

je crois qu’on peut l’améliorer un peu mais c’est déjà très bien.

retour d’xp : en fait, j’avais donné à caddy le droit de traverser mon home folder en faisant ça. maintenant je mets les sockets dans un folder dédié dans /run/legovh/legovh.sock en 775.

déployer

quand je faisais quart, j’avais :

[Unit]
Description=Hypercorn instance to serve 10schat
After=network.target

[Service]
User=le
Group=www-data
WorkingDirectory=/home/le/10schat
ExecStart=/home/le/10schat/.venv/bin/python -m hypercorn -c hypercorn.conf app:app

[Install]
WantedBy=multi-user.target

mais c’est encore plus simple avec sanic qui porte la config :

[Unit]
Description=Sanic instance to serve draft
After=network.target

[Service]
User=le
Group=www-data
WorkingDirectory=/home/le/draft
ExecStart=/home/le/.local/bin/uv run app.py

[Install]
WantedBy=multi-user.target

pas d’overhead à utiliser uv. enable, start et roule ma poule.

retour d’xp : ouais ça prend du temps. pour vous faire une idée, je sais tout sur fnaf maintenant.

qu’est-ce qu’un reframe ?

en gros, c’est un changement de narratif, une phrase que tu répètes pour te permettre d’avancer, de dépasser des choses qui te bloquent.

prenons un exemple :

il n’y a pas de mauvaise publicité

imagine que tu es responsable de com’ d’un candidat politique.

la tension monte, et tu es paralysé par les choix : faire ça ou pas, dire ça ou non, etc.

si tu te dis “il n’y a pas de mauvaise publicité”, tu es d’un coup libre : ok ! on va faire ce qui maximise le buzz, un point c’est tout.

oui mais

oui mais (tu vas dire), c’est pas vrai ! ça existe, la mauvaise publicité.

à quoi scott adams répond :

on s’en fout

vraiment ! “i have no idea if that is true, and i don’t plan to research it because accuracy is not an active ingredient in reframes”.

un reframe / nouveau narratif, c’est un outil. pas besoin d’être vrai, pas besoin d’être logique (ça peut ! mais pas besoin), tout ce qui compte, c’est que ça marche. que ça te donne un avantage dans ta situation. que ça t’aide.

exemple: il n’y a pas de mauvaise publicité ce qui ne te tue pas te rend plus fort

il y en a une que j’aime bien : avant : mes chances sont faibles après : j’estime mal mes chances

c’est une philosophie optimiste, “j’ai choisi d’être heureux, c’est meilleur pour la santé”

ok…

c’est presque tout. avant de conclure, quelques reframes du bouquin que j’aime bien.

tu es paralysé par tes échecs ?

j’échoue 9 trucs sur 10 -> si 1 projet sur 10 marche je suis gucci

tu doutes de ce qu’il faut faire ?

je veux faire x -> j’ai décidé de faire x

et hop, ça enlève la composante “doute” et roule raoul.

tu as l’impression de manquer de temps ?

gérer son temps -> gérer son énergie

au lieu de faire de la place pour les choses, les mettre au bon endroit. par exemple : le matin travail créatif ou difficile, l’aprèm chill ou manuel. surveiller son énergie au lieu de son temps pour se dire qu’on donne le meilleur à chaque fois.

tu te sens souvent mal à l’aise dans des situations sociales ? on va faire un reframe puissant. on s’en fout si c’est vrai, mets les gaz !

tout le monde à cette soirée va me juger -> je vais à une soirée où les gens ont été sélectionnés pour être gênants sauf moi

ou alors

-> chaque personne ce soir a un problème que seul moi peut résoudre

tout ce qui compte, c’est que ça marche.

on dirait du self-help baaaasique

pas faux, mais ça peut aussi aider dans le contexte pro.

par exemple :

est-ce que “x” est une bonne décision ? -> est-ce qu’on peut tester “x” à petite échelle ? en petit poc ?

et hop tu as ta manière de procéder. autre exemple :

celui qui commande c’est le patron -> celui qui commande c’est celui qui a les meilleures idées

ça peut aider si tu as du mal à t’affirmer ou si tu ne te sens pas importante.

donc voilà, ça peut servir pour le boulot.

moi mon préféré c’est celui-là :

l’art c’est du divertissement -> l’art est une puissante drogue psychique

et il ajoute “spielberg aurait dû me payer comme cobaye pour voir la liste de schindler”.

je trouve ça marrant. je me dis que si tu y crois vraiment tu dois voir la réalité autrement, et trouver un avantage / réduire le stress des décisions.

je vois. je dois lire le truc ?

non tkt.

y’a de tout dont des trucs de trouduc, très “biais du survivant” ou pas originaux, donc j’ai choisi le meilleur.

je mets une dernière citation du bouquin :

voilà ce qu’est un reframe : des mises à jour logicielles de votre cerveau. ils provoquent des changements physiques dans votre cerveau, comme toute expérience d’apprentissage. une fois que vous acceptez la nature programmable de votre propre cerveau, vous pouvez devenir ce que j’appelle l’auteur de votre propre expérience. cela remplace l’idée courante selon laquelle nous sommes le produit de nos expériences, de nos gènes et de toute une série de facteurs que seul le destin contrôle. cadre habituel : vous êtes le produit de vos expériences et de vos gènes. -> recadrage : vous êtes l’auteur de votre expérience.

si on y réfléchit… ouais, pas de raison que ça ne marche pas.

en pratique

une fois que tu as trouvé un “mantra” qui te plaît, comment l’utiliser ?

j’ai trouvé un moyen mémotechnique, il faut y croire dur comme f.e.r. :

• focus
• émotion
• répétition

en gros, dire la phrase (en vrai ou dans sa tête) en se concentrant sur la phrase, en y associant une émotion (par exemple comment tu te sentiras bien quand tu l’auras fait), et le répéter souvent jusqu’à ce que la neuroplasticité fasse son travail.

voilà bibi c’est tout. love u <3

post-scriptum

scott adams died while i was writing this. i looked at x and it seems americans had a lot to unload. first, this article wasn’t meant to you, as you guessed by it not being written in the language you speak. then, i don’t see what the fuss is about. it is my opinion that you should get away from people as much as people. no matter the color, humans are psychotic apes and you’re better off alone. lastly, i liked dilbert. it’s funny. and the man was proud of having left books behind. that i understand. go write your book or plant your tree. now shoo.

good problems and easter eggs, what’s not to like?

what’s important for me in these code events:

• realize early what can and cannot work
• have fun
• read other people code
• re-read your solutions
• see your innefficiencies

it’s very important to read other’s code. you already figured out the “what” by solving the problem, so you’re more efficient on the “how”.

so here is my review of some shared python code:

yldraw

repo link

i found the very useful tqdm library. get a loading bar for your loops!

i also see that cmp_to_key was not needed for day 5 and a simple lambda sort would have worked.

i brute forced day 6 (sorry). it’s nice he figured out the “wrap”.

nice recursion on day 7. let’s do a quick set cheatsheet:

yes for day 8, you don’t need to store every strike. this “max update” pattern, i should use it more often.

ok he stopped around where i stopped. i won’t check after day 11 anyway.

danagle

repo link

he “washed” his code, meaning he cleaned it and added any “efficient” tricks (like a modulo trick you don’t see in your first pass but understand afterwards).

but it’s a bit too washed. almost golfed.

he uses numba to speed up his loops. interesting.

nice use of Counter.most_common().

string padding on day 6, why not. i wondered if someone used cycle.

oh itertools pairwise, nice!

oh and a trie?! ok… a prefix tree. useful for autocomplete, spell check and ip routing. even better is a radix tree, ok ok.

oh so that’s how you profile python code. might be useful for my dod posts.

oh and now a fenwick tree, watch out we’ve got a badass over there. hmmm ok i don’t think i’ll ever use that.

day 9 he uses a trie again. and so he doesn’t do bfs like i did. man i need to level up my trees.

ok, i learned about nonlocal in imbricated functions. i don’t think i should use it.

i still can’t figure out what went wrong in day 10. day 11, i also tried that and it didn’t work. oh well.

nice, he made visualizations! using PIL.Image.fromarray() is tight.

alex11br

repo link

oh shit. numpy arrays, functools.reduce, we’ve got a madman.

yeah, no, bad code.

r01f

repo link

nothing fancy.

i really like his:

trees = [
    {a[0], b[0], c[0]}
    for a, b, c in permutations(lines, 3)
    if b > c and is_child(a[1], b[1], c[1])
]

quite effective.

elandor

repo link

yuck.

if you want to see what i did, here’s my code.

now, let’s do the same for aoc!

ok, so the first step in data-oriented design is this one:

from array import array

with this, we will use tightly packed c structures to store our data.

next is this array cheatsheet:

some things worth noting here:

• lowercase letter for signed, uppercase for unsigned (so signed short is ‘h’).
• ‘b’ takes the same space as ‘B’ (1 byte).
• i like to use mostly uppercase.

that’s because one of the strengths of dod is that you can store the index of an entity as a reference to it. and i don’t want negative indexes ever.

some absences worth noting:

• ‘i’ for int has platform-dependent size, which kinda breaks dod’s predictability, so i don’t use them.
• floating points calculations are ‘f’ and ‘d’. try not to use them if you can (if you do physics, you might have to, else just scale and normalize everything).
• python also has ‘u’ and ‘w’ for text characters, but try not to use strings if a human isn’t gonna read it.

now, some things you should really note:

• ‘B’ gives you 256 values. do you realize how big that is? you can probably encode all types of your game monsters in one byte.
• no, really, do you see how insane this is?
• with two bytes, you raise to 65535. you’re mostly covered.
• okok, ‘Q’? [0, 18446744073709551615]. 18 billion billion, motherfucker. eight bytes.
• the cpu cache line is 64 bytes. this means an array of 16 longs can be brought to the cpu in one trip.

so, for example, if you have 10 players in a game, you can encode every one of their properties on 4 billion values, and treat each transformation in one cpu roundtrip.

if you think about it, it’s insane.

ok, now let’s see how i tried to do dod on a real-worl example.

this is from everybody codes 2025 day 10 so go check it out.

i’ll just show the commented code:

from array import array

data = '''...SSS.......
.S......S.SS.
..S....S...S.
..........SS.
..SSSS...S...
.....SS..S..S
SS....D.S....
S.S..S..S....
....S.......S
.SSS..SS.....
.........S...
.......S....S
SS.....S..S..'''
data = data.splitlines() # formatting the data
h, w = len(data), len(data[0])

deepl = {'.': 0, 'D': 1, 'S': 2} # changing chars to int values

# prepare encoding, one array per property
grid = {
    'x': array('B', [0] * h * w),
    'y': array('B', [0] * h * w),
    'cell': array('B', [0] * h * w),
    'moves': array('H'), # we need more than 255 for the moves (21*21) so 65535 it is!
    'count': h * w # so we don't have to call len() each time
}

data.reverse()
# actual encoding
for i, row in enumerate(data):
    for j, cell in enumerate(row):
        grid['x'][w*i + j] = j
        grid['y'][w*i + j] = i
        grid['cell'][w*i + j] = deepl[cell]
        if cell == 'D':
            grid['moves'].append(w*i + j)

knight_moves = {
    # small b cause its signed
    'x': array("b", [-2, -2, -1, -1, 1, 1, 2, 2]),
    'y': array("b", [1, -1, 2, -2, 2, -2, 1, -1]),
    'count': 8
}

dragon_moves = 4
for _ in range(dragon_moves):
    # we'll be modifying the array during the loop but we don't even care lololol
    start_len = len(grid['moves'])
    for i in range(start_len):
        index = grid['moves'][i] # the index **is** the entity
        x = grid['x'][index]
        y = grid['y'][index]
        for knight_index in range(knight_moves['count']):
            dx = knight_moves['x'][knight_index]
            dy = knight_moves['y'][knight_index]
            nx, ny = x + dx, y + dy
            if 0 <= nx < w and 0 <= ny < h:
                test_index = w * ny + nx
                    if test_index not in grid['moves']:
                        grid['moves'].append(test_index)

eaten = 0
# i did some tests
# sorting is not that costly
# but can greatly improve performance
# maybe the cpu optimization prefers to read arrays in order
grid['moves'] = sorted(grid['moves'])
for index in grid['moves']:
    if grid['cell'][index] == 2:
        eaten += 1

print(eaten)

so the key point here is that the index is the entity. this means you can store indexes in an array as a very effective way to reference entity.

in short, you need to become an array master.

some more tips that were revealed to me by prophecy:

• never use booleans, use existence-based arrays instead
• (basically, don’t use an “alive” boolean but make two arrays alive_entities and dead_entities)
• learn how minecraft works
• use generational indexes
• use sparse sets
• (which are swapback with generational indexes)
• learn how minecraft works
• track and optimize your sparse sets
• read the first three chapters of existential programming
• learn how age of empire works
• advanced: learn how to do pathfinding dod-style
• learn b trees and quad trees
• advanced: learn the disruptor pattern
• (which is an ephemeral buffer with a fixed size)
• sparse set + disruptor = very fast
• games are all about reusing buffers
• relations are not a problem with generational indexes
• learn how minecraft works
• advanced: learn profile guided optimization

i should report back on my findings, but you do the homework too.

finally, do remind that everything is not a nail to hammer dod on.

for example, in the above code, i should have use grid['moves] = set() instead of an O(n) check every time (but i’m sure you noticed).

another example is if you have billions of entities (like particles), maybe use seeded shaders over time.

optimize for the right part of the computer.

now that we saw arrays, what if we want to persist the data?

how do you do proper dod with sqlite?

should you use orms?

head on to part 4.

i asked claude what he thought about my previous article and…

now, the good thing with ai roasting is that it cannot quit the conversation. you can continue to trade blows. and i did.

what i learned

it’s simple:

there are no good classes.

i tried saving the idea as hard as i could, but all my points were moot.

immutability? you don’t get that. not with python. even with frozen, if your class has a list, won’t work…

the read() function? it’s an overcomplicated setter. the real “message passing” should be done by a system (more on that later).

slots won’t improve your control over your data structure, hot data, block size: you’re better off with an array…

last but not least: the property check? yeah but why would you want that?

why would you want to give up on the ability to freely compose data whenever you want, whenever you need?

in other words…

data is just data

and it belongs in a database.

not in a class, in a database.

your code shouldn’t have state and your data shouldn’t have behaviors.

or as they say in the video overwatch architecture:

systems have no state, components have no behavior

this is the root of entity component system, or ecs in short.

e-c-s, baby

the best video you’re going to see about ecs is this one. please watch it.

i mentioned the array library earlier. because i love python, and i try to write python as a c wrapper as much as possible.

and i’m not gonna ruin it by writing classes, no no no.

so what is ecs?

in one sentence:

a struct of arrays instead of an array of structs

in one picture:

don’t write vertical “classes”. write horizontal “data slices”.

easier to store, easier to load, and paradoxically, easier to reason about.

if it didn’t click for you, more homework:

• ecs megathread
• sparse/dense indexing
• data locality
• observer pattern

the last nail in oop’s coffin

i’ll leave you now with one very important quote.

while trying to argue that classes could work for some use cases with delaney (who’s way nicer than claude, surprisingly), i tried the:

what if you only need it once? just once! for fixed parameters! we have tools for that, but what should we use? enums, named tuples? dataclass with frozen and slots?

and the master said:

if you think you’re gonna need it once, you’re wrong.

and the student was enlightened.

start with an array of length 1. it’s gonna become 2 soon enough.

input control? you’re gonna netcode it. config file? you’re gonna have a test environment. camera system? what about a killcam?

it’s arrays all the way down.

so start with them. then you’ll build structs. of arrays.

not arrays of structs.

oop feels organized. to you.

but to your cpu? not that much.

next up: a practical look at dod in python.

consider how humans, or any other autonomous creatures of nature, operate with their model of the world. we all have our own model of the world contained in our own heads, i.e. we have a copy of the world state for our own use. we mutate the state in our heads based on inputs (events/messages) we receive via our senses. as we process these inputs and apply them to our model we may take action that produces outputs, which others can take as their own inputs. none of us reach directly into each other’s heads and mess with the neurons. if we did this it would be a serious breach of encapsulation! originally, object oriented (oo) design was all about message passing, and somehow along the way we bastardized the message passing to be method calls and even allowed direct field manipulation – yuck! whose bright idea was it to allow public access to fields of an object? you deserve your own special hell.

mechanical sympathy

i recently watched good videos about object-oriented programming:

• oop is bad
• oop is embarassing
• oop is garbage

bottom line: most classes are bad.

so… how do you make a good class?

i propose you check for these 3 things:

• dataclass + slots
• @property
• frozen or read()

let’s explain.

dataclass + slots

first of all, please use dataclasses.

there’s zero (0) reason not to use them: you reduce the boilerplate, you improve readability, you type attributes…

and you don’t lose anything except footguns.

from dataclasses import dataclass

@dataclass
class Rectangle:
    width: float
    height: float

the next step is activating slots.

this will really boost performance (because of c shenanigans) at the cost of not being able to add attributes at runtime, which you shouldn’t do anyway.

@dataclass(slots=True)
class Rectangle:
    width: float
    height: float

next is the property check.

@property

a class is just grouped data, in other words data that belongs together.

if this data reeaaaally belongs together, you should be able to compute something out of it.

in other words, you should have a property:

@dataclass(slots=True)
class Rectangle:
    width: float
    height: float

    @property
    def area(self):
        return self.width * self.height

no property is a bad tell, ask yourself why you grouped this data in the first place. maybe your class isn’t really useful.

the only exception where it’s ok to not have a property is if your class is frozen, which we’re gonna see in the next chapter.

frozen or read()

alright, now you have to make a choice.

either you freeze your dataclass, because you wanted immutability on the data, for example, config parameters of a script:

from dataclasses import dataclass

@dataclass(frozen=True, slots=True)
class AppConfig:
    host: str
    port: int
    debug: bool = False

    @property
    def url(self):
        return f"http://{self.host}:{self.port}"

and that’s ok. this is a perfectly acceptable class. thanks for coming to my ted talk.

oh, i know what you’re going to say:

“but that’s not why i make classes! i want to model entities and modify their attributes!”

i know.

you want to make a class “monster” to make little monsters in your game, give them weapons, armor, attack damage, reduce their hp when they take a hit, apply status effects…

look, the only status effect you’re gonna get is “poisoned” when your state is all over the place. you’re gonna die from oop.

please reread the citation at the beginning.

if your class isn’t frozen, its attributes should only be changed by this class.

the way you’d do this is with a read() method:

@dataclass(slots=True)
class Rectangle:
    width: float
    height: float

    @property
    def area(self):
        return self.width * self.height

    def read(self, message):
        """message receiver: decodes message and updates state"""
        msg_type = message.get('type')
        
        if msg_type == 'resize':
            self.width = message.get('width', self.width)
            self.height = message.get('height', self.height)
        elif msg_type == 'scale':
            factor = message.get('factor', 1.0)
            self.width *= factor
            self.height *= factor
        elif msg_type == 'set_width':
            self.width = message.get('width')
        elif msg_type == 'set_height':
            self.height = message.get('height')
        else:
            raise ValueError(f"unknown message type: {msg_type}")

nb: people sometimes advocate for the syntax _method() as a pythonic way to indicate a “private” method. i think it looks awful, and because it doesn’t actually enforce anything, you’d be better off with nice comments in plain english.

of course, you can also write a send() method if you want your class to emit messages.

but, in a nutshell, this is how you do proper oop.

red flags

to conclude, some red flags. if you see:

• state being modified outside the class
• any form of inheritance
• any form of factory (whatever that means)
• any getter or setter
• any class that fails these 3 checks

burn the code to the ground and rewrite functional.

next up, you’ll see why everything you just read is bullshit.

but it’s hard when i create. i spend more time choosing the songs than working. and i focus on the songs.

i figured radio would help, because you don’t have to select the songs. but i spend time selecting the radio, lol. so many radios in the garden.

and it’s ok.

i love receiving knowledge, lettin it go through me. but the world is gonna claim its due, right?

so yeah, background ambiance it is.

a soft murmur is cool.

just typing background noise and rolling.

but i have to develop the reflex.

i tried notepad++ with a ftp configuration, which is cool for file uploads but not so much for live edits.

fortunately, i find the micro editor to be quite pleasant.

here is my config file to feel at home:

bindings.json

{
    "Alt-/": "lua:comment.comment",
    "Alt-Ctrl-Up": "SpawnMultiCursorUp",
    "Alt-Ctrl-Down": "SpawnMultiCursorDown",
    "Alt-<": "NextTab",
    "CtrlUnderscore": "lua:comment.comment"
}

comment and multi-cursor kinda like vs code.

still using alt-n for FindNext because overriding ctrl-d does not work for some reason.

i like the split view, still getting used to it, but i cycle through tabs with alt-< like i cycle views with ctrl-w (double view lol).

ctrl-e is very nice, especially with the autocomplete.

settings.json

very important to set the clipboard to terminal as i mostly use micro when ssh’ed.

{
    "clipboard": "terminal",
    "colorscheme": "gruvbox",
    "rmtrailingws": true
}

• use datastar
• build anything you fucking want

but no, you dimwits had to have some second thoughts.

so let’s have this discussion, shall we?

context: i made a shit-ton of projects with datastar and 20+ youtube videos about it so yeah i’m biased, duh.

“react is fine”

no it’s not, you scum.

you make users download megabytes of data for spinners that never fucking load.

you build services so fragile that the slightest error sends all your infra in a roller coaster to hell.

you shame us all with abhorrent code. what’s a junior dev to think when you show’em your stinky codebase? total fucking disgust, correct.

but the worst of your sins is your sync engine. excuse me but what do you need to fucking sync exactly? the server and the client? did you try, um, i don’t know, using htt-fucking-p to exchange data?!

oh you did, you sent a skeleton-ass page and instructions to download more javascript at the nearest black market. fair, you don’t build websites, you build trojan bombs, so sync my ass.

“ackhually…”

if you were going to say “next.js”: congrats larry you’re a comedian.

look, i don’t care if you use svelte, vue, vite, vroom, nuxt, angular, bozo.js or any other “i have nodes in my brain” clown-ass frameworks.

you build a pile of hot garbage on javascript. period.

because you never understood that javascript is a way to interact with the browser and the markup, because you never understood the browser, because you never understood the markup, because you don’t fucking read.

maybe start with “hypermedia for dummies”?

“sikes! i use htmx”

sikes on you, you fuck.

does this look like a blog rant of peace?

this is war, motherfucker.

you come to battle with your megatron-ass voltron-build glued with htmx, alpine.js, htmx-sse, htmx-head-support, htmx-idiomorph, htmx-alpine-morph, htmx-multi-swap…

you look like a janky knight in a cyber conflict.

we’re gonna laser beam your rusty helm with half the code and a fraction of the complexity. hold still (or don’t, doesn’t matter).

what’s the big fucking deal

datastar is not miracle fucking water.

it’s simply:

• htmx with oob default (the correct one btw) and a better morph
• data-attributes made reactive with signals
• (attributes are hypermedia by the fucking way)
• and sse support

here “sse support” just means using the fucking fetch api, but with quality-of-life defaults like auto-reconnect and exponential backoffs.

your browser is already a fucking jet engine: datastar doesn’t reinvent the wheel, it just puts four of them under the rocket so you can get fucking moving.

“it’s just the new fad”

the web doesn’t break backward compatibility you dumbass.

datastar websites are forever. this is what you get by building on fucking specs.

with datastar, you only manage the backend, not the backend + frontend. complexity is a poison, if you want to manage both, please shove this median lethal dose down your throat, thank ya.

and btw: never a breaking change. datastar is just a few thousand lines of typescript and it’s v1 forever baby.

“sorry i said that, i’m an old fart”

ok sensei, congrats on your mastery of php and jquery.

no, sincerely i mean it, you fucking zen monk. you like code that reads and stuff that works. well, the future is now and you’ll be fine. heck, you’ll love it!

you’re gonna be writing so much awk and so little javascript you’ll feel one step closer to heaven, you lucky fuck.

don’t fucking use datastar pro

let me say it loudly for the morons in the back who think they can hack the fbi but can’t put two and two together: it’s just so that your fucking company can support the project!!

convince these lobotomized suits they might need data-persist in the future or whatever other bullshit and snatch the damn credit card.

no you’re never ever gonna need any feature in pro and it’s total bait, but these guys need to eat goddammit.

don’t fucking use datastar

take a wild fucking guess: does this page use datastar?

no! it’s a blog post, dumb as rocks text-on-a-page goodness!

you got multiple pages worth of information? let me doubt that first, most of you are building landing pages for the ceo of bluetooth-cat-litter-inc who needs a rotating marquee of sponsors. doesn’t qualify as “information”, does it?

but even then, let’s say you do have multiple pages: please build an mpa. you might even want to check the definition to that, who fucking knows.

for the remaining cases: 99% of the time your job is to build a crud app without adding more misery to the world. yet you keep inventing ever more spectacular ways to fail at that.

we gave you request methods and you’re still looking at the square peg and the round hole with intense dedication, you dozy ape.

god forbid you came from the hn website. the comments don’t even auto-update! barely usable and probably zero users, i bet you that.

closing thoughts

yes this is fucking parody.

it’s inspired by this glorious shit.

and it’s made against this poop pile, this ai babble, that big stain and (jesus, how many abominations must these people shit before the js god is appeased) that other thing.

i shall rewrite here the important words of visakan.

idk if i was gravely ‘mentally’ ill, but i was down ominously bad (false hope, impossible desires, intense grievance) – i feel like this has parallels with being a heavy cigarette smoker then going off of them. my favourite way of describing that is “quitting punctuation”

i used to use cigarettes to punctuate my life. started the day with them. kept time with them. regulated my moods with them. finished meals with them. socialized with them. cigarettes kept my life in order. they provided structure. rhythm. i looked forward to the next one.

when i went off of them the punctuation marks fell out of my life and all of a sudden i was falling spinning circling everything is chaotic and makes no sense where am i going who am i even what is happening oh god it’s all too much and its everything at once help help help

it took time for me to figure out new ways of arranging my life

without the punctuation marks i had grown accustomed to leaning on

turns out for example that you can use linebreaks as a form of punctuation

i had never considered that when all i knew was fullstops

similarly, the basic flavor of sanity seems disappointing, mundane, boring, when you’re used to excitement in the form of intense mental activity

it’s like going from walls of heavy distorted guitars and crashing cymbals to a single solo piano. at first it seems thin, weak, flat

but its just a different instrument, a different aesthetic, something you have to learn anew. there’s infinite nuance within that seemingly boring simplicity. it just takes time and patience to allow yourself to learn to appreciate it. you have to relearn everything

appreciation is a skill that can be cultivated

you can learn to appreciate the elegance and simplicity of having less anguished mental activity

this might sound weird to anyone who’s never used that anguish as a comfort blanket

you can learn to relax in the emptiness