Life is Tetris @tetrislife@qoto.org

I’m still pissed at Elon for two things:

1) making me learn how to spell Mastodon
2) that he didn’t buy and ruin LinkedIn instead

The definitive guide!

#FreudianTypoOfTheWeek

Ecomimics (adj.): The social science of blindly copying economic policy from another country.

The new #LFE site looks great! With a cornucopia of learning and reference material.
https://lfe.io/
#Erlang #Lisp

@choanmusic

As it turned out, reverting to distro #orgmode was a simple matter of deleting the site-list/org and restarting, and magically #orgroam is working again, so that's a plus. Lilypond will just need to wait.

I spent years coding in #Prolog, so my general solution to problematic things is "revert back to before your last decision, and make a different one" 🤣

@LordCaramac still using smalltalk every day.

Regarding #email, screw the old #filesystem-centric non #transactional approach btw.

Both #mbox and #maildir suck.

Program crashed while you were modifying a mail? Who knows what the on-disk file looks like now. You had it git-versioned? Good. If all goes well and git or the computer itself doesn't crash while updating things, that might be enough.

Even key-value #databases like #BerkelyDB do it better, and they did so before #SQLite even existed.

So why can't I have tools using DBs?

This is such a simple and useful SQLite hack.

Get the best out of #git and #sqlite by having your database versioned in a human-readable format:

```
# Create a local git repo and a db file
$ git init
$ sqlite3 ./test.db
sqlite> create table test(id int primary key, value text);
$ git add test.db

# Set the diff format for *.db files
git config diff.sqlite3.binary true
git config diff.sqlite3.textconv "echo .dump | sqlite3"
echo '*.db diff=sqlite3' >> .gitattributes

# Do some stuff with the db
$ sqlite3 ./test.db
sqlite> insert into test values(1, 'a');
sqlite> insert into test values(2, 'b');
sqlite> insert into test values(3, 'c');
sqlite> update test set text = 'aaa' where id = 1;
sqlite> delete from test where id = 3;

# Check the diff
$ git diff
diff --git a/test.db b/test.db
index 9d6e6db..c9a7a08 100644
--- a/test.db
+++ b/test.db
@@ -1,4 +1,6 @@
PRAGMA foreign_keys=OFF;
BEGIN TRANSACTION;
CREATE TABLE test(id int primary key, text text);
+INSERT INTO test VALUES(1,'aaa');
+INSERT INTO test VALUES(2,'b');
COMMIT;
```

https://garrit.xyz/posts/2023-11-01-tracking-sqlite-database-changes-in-git

@nixCraft I go a call yesterday asking for help on a system I had deployed on a TV operator 11 years ago. It was a hardware glitch. Unfortunately they rebooted the operating system: 3588 days of uptime. The software in question had been restarted in 2015.

Mostly #erlang and some C.

@Natanox @juliobiason @borisanthony It's still not great.

More for reasons that ergonomically-speaking, it's the Perl of web development.

What’s sad is realising you live in a world where every exaggerated analogy you used to make a point is actually happening:

Having Google in schools is like having McDonalds in nutrition class. (I find out that McDonalds does, in fact, sponsor nutrition classes in US schools.)

Having a surveillance capitalist sponsor a conference on free and open source/human rights is like having an oil company sponsor a climate conference. (Forget sponsoring, turns out head of #Cop28 runs an oil firm.)

🤬

my cold take on the Threads federation thing is: if you simply consider them not as some mystical "platform" but as any other "instance", then they're an over-sized under-moderated data-scraping instance housing many vile users right up to the point of "technically legal free speech"... and we've all suspended instances before for much less.

I run my own #selfhosted Mastodon server, so hadn't really felt the need for domain blocking. However, the whole Threads stuff got me looking into it.

I feel that there is a quite a bit of risk in using aggregated block lists. Given that the sources seem to be only a handful of instances, it feels that one could easily over block using these lists.

Remember back before systemd how when something went wrong on a computer it put text into a log file and you could find out what happened? That was neat. We should do that again.

@letoram I've been following the project for a while, but I never had a compelling reason to switch, and I'm way past the point where I enjoy fiddling about with OS components just for the sake of it. So, given my time constraints (or lack of time management skills) , I never gave it a go. And I'm not saying that my current setup will simply stop working because IBM/RH decided to stop supporting Xorg, but in the medium/long term I expect to need an alternative now.

"#Clojure’s immutable, persistent data structures make it easier to write correct concurrent programs, and the language and runtime have excellent concurrency support...I also considered languages (like Haskell) with more rigorous control over side effects, but decided that #Clojure’s less-dogmatic approach was preferable."

I'd make a similar argument for #Erlang. There's a sweet spot on the imperative to functional spectrum that both these languages occupy.

https://aphyr.com/posts/367-why-is-jepsen-written-in-clojure

@haiku also available over xmpp using the jabber.fr biboumi irc bridge

(please don't give free advertising to matrix...)