lyse @lyse.isobeef.org
 (21h ago)

Oh great, I received an e-mail that my SMTP credentials have been exposed. Once again, just another shitty scanner that generates garbage reports from tests it doesnā€™t understand. Thank you for nothing!

conf := &Config{
    SMTPHost: "smtp.example.com",
    SMTPPort: 587,
    SMTPUser: "user",
    SMTPPass: "hunter2",
    SMTPFrom: "from@example.com",
}
#eljhddq
lyse @lyse.isobeef.org
 (23h ago)

(#c6rrdzq) @prologic@twtxt.net @movq@www.uninformativ.de A crocodile had bitten the big submarine internet cable that connects Australia to Europe. The investigations revealed that some construction work last week accidentally tore up the protective layer around it. That went unnoticed, unfortunately, so marine life had an easy job today. For just 40 minutes, they were quite fast in repairing the damage if you ask me! These communication cables are fricking large.

Just kidding, I completely made that up. :-D I didnā€™t notice any outage either. But I didnā€™t try to connect to Down Under at the time span in question.

#hsmdvqq
lyse @lyse.isobeef.org
 (1d ago)

(#2hgjg3q) @movq@www.uninformativ.de Very nice! I often wish other languages had something similar. Sometimes, I use lambdas, but that also looks ugly and feels a bit like a misuse. Other times, just the normal blocks are enough, but itā€™s not the same. Especially with the mutability aspects as the article explains. Typically, I just put it in a function or ignore it if itā€™s just a few lines.

#xqyb4ya
prologic @twtxt.net
 (3d ago)

(#dddn3ja) @movq@www.uninformativ.de @kiwu@twtxt.net it just so happens to be a happy coincidence that Iā€™m extending muā€™s capabilities to now include a native toolchain-free compiler (doesnā€™t rely on any external gcc/clang or linkers, etc) that lowers the mu source code into an intermediate representation / IR (what @movq@www.uninformativ.de refers to as ā€œthick layers of abstractionsā€ā€¦) and finally to SSA + ARM64 + Mach-O encoder to produce native binary executables (at least for me on my Mac, Linux may some later?) šŸ¤£

#pyoecwq
movq @www.uninformativ.de
 (3d ago)

(#dddn3ja) @kiwu@twtxt.net Assembly is usually the most low-level programming language that you can get. Typical programming languages like Python or Go are a thick layer of abstraction over what the CPU actually does, but with Assembler you get to see it all and you get full control. (With lots of caveats and footnotes. šŸ˜…)

Iā€™m interested in the boot process, i.e. what exactly happens when you turn on your computer. In that area, using Assembler is a must, because you really need that fine-grained control here.

#eftrlaq
movq @www.uninformativ.de
 (3d ago)

(#iaunzca) @lyse@lyse.isobeef.org Yeah, well, given that I didnā€™t need this for such a long time, itā€™s probably not an essential tool. šŸ˜…

Iā€™ve often wanted to have an outline of text documents, though, and tagbar/ctags can do that as well:

https://movq.de/v/3c6d1a13d6/tagbar-md.png

https://movq.de/v/abc58e6d66/tagbar-latex.png

This isnā€™t as powerful as the ā€œNavigatorā€ tool in StarOffice/LibreOffice (which can be used to rearrange the document), but still pretty useful:

https://www.uninformativ.de/blog/postings/2024-05-23/0/so31.mp4

#e2odebq
movq @www.uninformativ.de
 (6d ago)

(#ftqfrta) I rewrote all my solutions in Rust (except for day 10 part 2) and these are the runtimes on my i7-3770 from 2013 (this measures CLOCK_PROCESS_CPUTIME_ID, not wallclock):

day01/1 [      00.000501311] Result: 1066
day01/2 [      00.000400298] Result: 6223
day02/1 [      00.000358848] Result: 12586854255
day02/2 [      00.000750711] Result: 17298174201
day03/1 [      00.000106537] Result: 17405
day03/2 [      00.000404632] Result: 171990312704598
day04/1 [      00.000257517] Result: 1626
day04/2 [      00.007495342] Result: 9173
day05/1 [      00.000237212] Result: 505
day05/2 [      00.000142731] Result: 344423158480189
day06/1 [      00.000229629] Result: 4076006202939
day06/2 [      00.000279552] Result: 7903168391557
day07/1 [      00.000204422] Result: 1622
day07/2 [      00.000283816] Result: 10357305916520
day08/1 [      00.029427421] Result: 84968
day08/2 [      00.028089859] Result: 8663467782
day09/1 [      00.000310304] Result: 4764078684
day09/2 [      00.015512554] Result: 1652344888
day10/1 [      00.000796663] Result: 375
day10/2 [      --.---------] Result: 15377 (Z3)
day11/1 [      00.000416804] Result: 753
day11/2 [      00.000660528] Result: 450854305019580
day12/1 [      00.000336081] Result: 577
day12/2 [      00.000000695] Result: no part 2

A little under 90 ms total.

On my Samsung NC10 netbook from 2011 with its Intel Atom N455 at 1.6 GHz:

day01/1 [      00.003771326] Result: 1066
day01/2 [      00.003267317] Result: 6223
day02/1 [      00.003902698] Result: 12586854255
day02/2 [      00.006659479] Result: 17298174201
day03/1 [      00.000747544] Result: 17405
day03/2 [      00.002737587] Result: 171990312704598
day04/1 [      00.001263892] Result: 1626
day04/2 [      00.044985301] Result: 9173
day05/1 [      00.001696761] Result: 505
day05/2 [      00.000978962] Result: 344423158480189
day06/1 [      00.001387660] Result: 4076006202939
day06/2 [      00.001734248] Result: 7903168391557
day07/1 [      00.001295528] Result: 1622
day07/2 [      00.001809659] Result: 10357305916520
day08/1 [      00.277251443] Result: 84968
day08/2 [      00.284359332] Result: 8663467782
day09/1 [      00.003152407] Result: 4764078684
day09/2 [      00.071123459] Result: 1652344888
day10/1 [      00.005279527] Result: 375
day10/2 [      --.---------] Result: 15377 (Z3)
day11/1 [      00.003273342] Result: 753
day11/2 [      00.005139719] Result: 450854305019580
day12/1 [      00.002857552] Result: 577
day12/2 [      00.000004421] Result: no part 2

A little over 700 ms total.

I like this. You get performance thatā€™s more or less in the ballpark of C, but without the footguns.

#lkardga
movq @www.uninformativ.de
 (6d ago)

If your very popular project with lots of stars on GitHub is over 10 years old, and youā€™re still at a pre-1.0 version because youā€™re using SemVer and a 1.0 would mean making some kind of commitment and thatā€™s somehow not desirable for you, then I think youā€™re doing something wrong. šŸ¤”

#ltabnaq
movq @www.uninformativ.de
 (1w ago)

Got a nice conspiracy theory for you:

https://mastodon.social/@mcc/115670290552252848

Actually wait I just thought about this and realized that the precise timing of the ACTUAL GitHub seed bank, by which I mean the Arctic Code Vault, on 2020-02-02, makes it more or less a perfect snapshot of pre-Copilot GitHub. Also precisely timed before we all got brain damage from COVID. This is the only remaining archive of source code by people with a fully working sense of smell

(Bonus points because the Arctic World Archive is located in Svaldbard and thatā€™s the name of the AI in Stacey Kadeā€™s ā€œCold Eternityā€.)

#nnftkqa
prologic @twtxt.net
 (1w ago)

I cleaned up all my of AoC (Advent of Code) 2025 solutions, refactored many of the utilities I had to write as reusable libraries, re-tested Day 1 (but nothing else). here it is if youā€™re curious! This is written in mu, my own language I built as a self-hosted minimal compiler/vm with very few types and builtins.

https://git.mills.io/prologic/aoc2025

#4fadlsa
prologic @twtxt.net
 (1w ago)

(#te6p5oa) @movq@www.uninformativ.de I shrank Day 9 Part 2 from ā€œcover the whole mapā€ to ā€œonly track the interesting lines.ā€ By compressing coordinates to just the unique x/y breakpoints, the grid got tiny. I still flood-fill and do the corner-pair checks, but now on that compact grid with weighted prefix sums for instant rectangle checks. Result: far less RAM, way less CPU, same correct answer.

#2qqbk5a
prologic @twtxt.net
 (1w ago)

Day 9 also required some optimizations, if you arenā€™t careful, you end up with really inefficient algorithms with time/memory complexity beyond what a typical machine has šŸ¤£

#te6p5oa
prologic @twtxt.net
 (1w ago)

Day 7 was pretty tough, I initially ended up implementing an exponential in both time and memory solution that I killed because it was eating all the resources on my Mac Studio, and this poor little machine only has 32GB of memory (I stopped it at 118GB of memory, swapping badly!), This is what I ended up doing before/after:

  • Before: Time O(2^k Ā· L), memory O(2^k), where k is the number of splitters along a reachable path and L is path length. Exponential in k.
  • After: Time O(RĀ·C) (or O(RĀ·C + s) with s split events), memory OĀ©, where R = rows, C = columns. Polynomial/linear in grid size.
#6qxqjma