There appears to be a rush a disgruntled Linux users switching to NetBSD:

https://mastodon.sdf.org/@netbsd/117451701775023949

They even got a ton of new donations (which, funnily, broke their little progress bar):

Image

https://cannot.understand.computer/kunev/p/1791449917.947134

So… donations for @netbsd@netbsd over the last few years look like this:

2020 - $46k
2021 - $52k
2022 - $44k
2023 - $60k
2024 - $40k
2025 - $79k

And in 2026 $120k so far!

And why is all that? Because of this:

Do not commit tainted code to the repository.

If you commit code that was not written by yourself, double check that the license on that code permits import into the NetBSD source repository, and permits free distribution. Check with the author(s) of the code, make sure that they were the sole author of the code and verify with them that they did not copy any other code.

Code generated by a large language model or similar technology, such as GitHub/Microsoft’s Copilot, OpenAI’s ChatGPT, or Facebook/Meta’s Code Llama, is presumed to be tainted code, and must not be committed without prior written approval by core.

https://www.netbsd.org/developers/commit-guidelines.html

This official guideline is much more “tame” and “diplomatic” than the overall “vibe” (sic) on the Fediverse: NetBSD basically says no to AI as much as possible.

And, apparently, this attracts lots of users and donors. Maybe there’s still some hope after all?

#Galician and #Portuguese: One Language or Two?

https://www.youtube.com/watch?v=pfUXMO6szAE

#Galego #Português #Languages

What’s interesting here… Which is the interesting thing about Mu is the dual runtime. So the above solution for Euler Problem 9 finds the solution in ~429ms with the Go VM and ~327ms natively compiled to darwin/arm64. Not bad for a language I haven’t really done any optimization work on yet (correctness first obviously).

It is such a nice feeling that Mu is such a capable little language 😅 And I decided to write code code in Mu by hand 🤚 haha 🤣 and start solving Project Euler problems, like Problem 8 which works out to be a nice elegant solution in Mu:

#!/usr/bin/env mu

// Largest Product in a Series

import "fp"
import "sys"

fn usage() {
  print("Usage: cat |", args()[0], "<n>")
}

fn products(xs) {
  return fp.reduce(xs, 1, fn(x, y) {
    if y == nil {
      return x
    }
    return x * y
  })
}

fn main() {
  if len(args()) < 2 {
    usage()
    exit(1)
  }

  s := must(sys.read_all(0))
  if len(s) == 0 {
    usage()
    exit(1)
  }

  n := must(int(args()[1]))
  r := fp.max(fp.map(fp.sliding(fp.map(s, int), n), products))
  print(r)
}

main()

“Creator of #Lua: Scripting, Programming Languages, Predictions | Roberto Ierusalimschy”

https://www.youtube.com/watch?v=jCZnFKk6M9A

Germans love consonants – and it’s the opposite with Scandinavian languages, isn’t it? 😅 This is so crazy for me to listen to:

https://translate.google.com/?sl=auto&tl=no&text=good%20morning%2C%20how%20are%20you%20today%3F%20my%20name%20is%20katharina%20and%20I%20am%20eating%20a%20banana%20and%20hopefully%20also%20an%20apple.%20everything%20I%20say%20is%20a%20blur.&op=translate

Love me some Finnish:

https://translate.google.com/?sl=auto&tl=fi&text=good%20morning%2C%20how%20are%20you%20today%3F%20my%20name%20is%20katharina%20and%20I%20am%20eating%20a%20banana%20and%20hopefully%20also%20an%20apple.%20everything%20I%20say%20is%20crystal%20clear.&op=translate

So… my little experimental Mu (µ) OS is now ~8.7k of Mu and ~2k of Assembly, which makes this about an ~80/20 split. I’ve managed to achieve most of the goals I had set out, by ensuring a tiny Nucleus of only ~2k Assembly and all Policy, Services and Userland written entirely in Mu (a language I also deisnged and created, which still has no support for floats LOL)

@david@daiwei.me Yes!

So, a hobby OS, just like Linux was for Linus?

Although this is really an exercise is self-hosting a lagnguage, then self-hosting the language to build a self-hosting OS. It’s all meta-circular.

I just taught the scc SLOC tool I use how to detect and recognize the Mu programming language. So it’s actually a bit worse than your estimate. It’s more like ~60/30 at the moment:

>>> mu = 1445
>>> asm = 2365
>>> T = mu + asm
>>> mu / T * 100
37.9265091863517
>>> asm / T * 100
62.07349081364829

Dunno if anyone will find this interesting… But some ~6 months or so ago I experimented briefly with creating a whole bootloader + kernel + userland – Basically an entire OS in the Mu programming language (which as you know I also designed and created) – 6 months later I’ve worked on it some more after spending the last week working on improvements to Mu itself, which is now able to compile itself with its own Mu implemented compiler and now have an os/arch backend called muos/amd64 that boots into a running shell, with a tiny little vfs, UNIX-like semantics, syscalls, read/write, etc. It works pretty nicely, and aside from a small Assembly “nucleus”, most of the Kernel and Userspace is written in Mu.

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

I really think I should go back to Java.

Writing programs in Python is so exhausting. I want a compiler and I want static typing. No, linters and type checkers and IDEs are not good enough. Compilers catch way more errors in advance.

Rust is also exhausting. They’re constantly adding language features and, at the same time, the runtime library remains tiny and you need 3rd party libraries for everything. Many of those are still at version 0.x (SemVer!) and you can’t rely on anything. Often times, you need the latest Rust nightly compiler.

Go is … I don’t like it. And huge binaries.

I like C as a language, but it’s too fragile. I want to have a proper HashMap every now and then.

None of the above have good GUI libraries, at least not on Linux.

And then there’s Java. This is my fractal renderer that I wrote over 17 years ago:

https://movq.de/v/fcd3c4e557/vid-1784121825.mp4

It’s fast. It has a GUI with custom widgets and those weren’t even hard to make. It still works without changing a single line of code. The source code files have timestamps from 2009 and I just noticed that the JAR file I’m using in the video was compiled in 2010.

Java as a language is relatively easy to learn and to master. There are few surprises. The source code organization with packages is good. Java API docs are clear and well written.

The JVM ramp-up times have improved considerably:

https://movq.de/v/e7314e521e/vid-1784121998.mp4

This isn’t like the Dark Ages anymore. Might even be usable for some CLI tools.

The only thing where Java really sucks is anything close-ish to the kernel. Try issuing an ioctl() … I couldn’t have made my TUI framework in Java, but then again, I wouldn’t have needed to because Swing already exists and it just works.

I just read @kat@yarn.girlonthemoon.xyz’s blog post over here:

https://bubblegum.girlonthemoon.xyz/articles/learning-to-code-like-it-s-the-90s

Jesus, it must be so overwhelming for young people to get started with programming.

When I started programming, there was the built-in ROM BASIC of that PC and probably a bit of BASIC on a floppy, and that was it. Nowadays? Millions of libraries and frameworks and languages and what not – and, much worse, there’s the expectation that you need to make something fancy. When I started, printing something and understanding IF was good enough.

@movq@www.uninformativ.de Yeah, that would also be fine with me. I certainly do like the “arbitrary” in your comment.

While writing the article, I also thought about something like that:

date := time.Date(2026, 6, 19,
    17, 0, 0, 0, time.UTC)

Or possibly:

date := time.Date(
    2026, 6, 19,
    17, 0, 0, 0, time.UTC,
)

But it’s four lines for a damn timestamp. I also contemplated whether a comment acting as a separator is all that’s needed:

date := time.Date(2026, 6, 19, /**/ 17, 0, 0, 0, time.UTC)

I might like that the most. Not entirely sure yet. It kinda feels like a hack, but still a little elegant. Add your comment on top and we’re golden. Maybe?

I deliberately excluded them as this only distracted from the points I wanted to make. And I also realized that this example was just not ideal at all. Perhaps I should add them nevertheless?

If I ever invented a programming language, a much more human readable timestamp representation of some sort, RFC 3339 or very close to that would be part of that language. Something along the lines of /pattern/ for regexes in certain languages.

Language learning is the gift we must give our children
Learning a second language comes with cognitive and societal benefits, yet Australian students are abandoning language studies. ⌘ Read more

Instant offers and $20,000 sweeteners: The battle to keep these subjects in NSW schools
Research consistently points to broader cognitive benefits of learning a foreign language but last year just over 250 public school students were in Japanese beginners. ⌘ Read more

Show HN: Mach – A compiled systems language looking for contributions
Hi HN,

I’m the creator of Mach ( https://github.com/octalide/mach or https://machlang.org). Two days ago, we finally achieved full self hosting. I wanted to make a post here to show off the language since this is a big milestone for us.

## TL;DR about the language for those curious:

- There are no external dependencies anywhere in the pipeline. This includes LLVM, libc bindings, or anything of the sort … ⌘ Read more

Babbel Promo Code: Up to 65% Off in June 2026
Master a new language with expert-led courses. Use our verified Babbel coupon codes to save up to 65% on student plans and 60% on 6-month subscriptions. ⌘ Read more

The Ü Programming Language
Article URL: https://github.com/Panzerschrek/U-00DC-Sprache/

Comments URL: https://news.ycombinator.com/item?id=48391838

Points: 3

# Comments: 0 ⌘ Read more

Elixir v1.20 released: now a gradually typed language
Article URL: https://elixir-lang.org/blog/2026/06/03/elixir-v1-20-0-released/

Comments URL: https://news.ycombinator.com/item?id=48388324

Points: 79

# Comments: 14 ⌘ Read more

Why Are Large Language Models So Terrible at Video Games?
Article URL: https://spectrum.ieee.org/ai-video-games-llms-togelius

Comments URL: https://news.ycombinator.com/item?id=48354405

Points: 6

# Comments: 3 ⌘ Read more

It’s one of the reasons in fact I’ve been working on bob so I have a very concrete and strong foundation for how these things work, how they behave and how bad or good they can be. I am on-purpose building bob to be not only a decent coding tool and general task completion tool, but with serious security boundaries, sanitation, auditing and compliance. If I’m going to succeed at building autoonmous agents that can cope with a wider array of varying inputs (mostly natural language, some structural language) then it needs to be both a) Safe and b) Robust

@prologic@twtxt.net Ahh, I see. Okay, I’m with you there. On this high level, I can understand how the thing works.

Maybe my wording isn’t good. 🤔 Let’s take a real life example from what we do at work.

There’s this AI chatbot. It gets support requests from users, so the user says something like “I need access to a particular system”. This triggers the bot to “run” the instructions stored in a large Markdown file, like “check if the user is authorized to do this, then issue the following API requests”, and so on. This is essentially like running a little script, except it’s written in natural language (German) and there’s no “script interpreter” but just the AI.

Now, suppose that the AI doesn’t quite do what was intended. There’s some subtle bug. How do you debug this? How do you find out how the AI came to the “conclusion” to run step A instead of step B? And how do you find out how exactly you have to change your prompt so this doesn’t happen again next time?

If this was an actual script/program instead of AI, you could repeat the request and attach a debugger or throw in some printf() or whatever. How do you do that kind of thing with AI? How do you pinpoint exactly what the problem was?

(Or is this just a stupid idea? Do we have to give up that way of thinking when using AI? Is the era of debuggability over?)

Of course, @movq@www.uninformativ.de! Most of my points are also included in your list.

First of all, programming is what I really do enjoy the most. So, it doesn’t make any sense at all to not do this anymore. “But you could use your now free time to do something much cooler and more valuable!”, others might reply. Fuck no, I don’t want to waste my time with other shit that doesn’t fulfill me, why on earth would I want to do that?

All this hallucination reduces quality badly. In my experience, it’s also happening much more rapidly than I expected. Even though developers are still supposed to own and understand whatever has been generated under their name and even be responsible for that, the sad reality is that teammates often blindly trust the AI output. “But I asked the AI and it told me that $this was impossible”, “I’ve no idea either, but the AI just generated it” are responses I get more often. What really makes my angry is when I point out a flaw and suggest an alternative and this is the reaction. It happened several times that just trying it out and seeing it clearly work to proof my point only took me half a minute, but people still did something handwavy else instead.

The learning effect is drastically reduced. The more time I spend on a topic, the better the odds that whatever I learned actually makes it over into long-term memory. It’s like if a collegue just says “do it like that” or “this solves your problem”, but neither explains the why or how. Somehow, people are still convinced that it’s a completely different story when you replace the human counterpart with a computer program in this equation.

Skills are unlearned. It’s like with automation in general, just much worse. You end up in a state where you’ve no clue how anything works under the hood or how to actually find out important information that are needed to solve your problem. You’re screwed when a process breaks out of the blue. Even though it can become also rather terrible, with classical automation you’re typically still be able to decipher how exactly the thing was supposed to do something.

The energy consumption is sooo high, I absolutely do not want to be a part in burning down our planet. I’m sure I find (and probably have long found without knowing) other ways to contribute to worsen our climate crisis.

The scraper part is already covered in detail in your list. :-)

I’m convinced that license and copyright violations are only played down or even refused entirely because companies want to make big money quickly. With the work of others of course. Their double standards are obvious, they still try to actively keep their own stuff secret and out of any training sets. At most for internal use only. Virtually noone in charge is interested in good long-term solutions. Short-term for the win, when disaster eventually strikes, the causers are long gone, the responsibilities in other hands.

Vendor lock-in is something that lots of folks are only realizing very slowly. It’s completely crazy to me. This drug dealer routine should be well-known by now. It’s fucking everywhere. Yet, people are always surprised when they found themselves caught in it.

Adding new AI stuff only increases complexity. But complexity is the enemy that everybody should fear and reduce as much as possible. Of course, this is not limited to AI at all. And everywhere I look around, people in charge looooove to make things way more complicated than they ever need to be. Yet, simplicity is the real art and much harder to achieve.

I don’t understand why we have to go back full force to the ambiguity of natural languages. This alone should be more than enough to realize what a stupid idea all that is. Linked to that is that the “instruction set” is interpreted differently with newer model versions. I mean, is has to be. Why else would somebody want to upgrade in the first place than to get more Powerful™ Features™?

Some people argue that with AI the democratization is empowered. However, in my view, the exact opposite is the case. Models are getting so large that you can basically not run them locally or even train them. So, you have to rely on whatever the vendor offers you and runs for you. In the end, this only gives the owners more power, the multi billionaires. Not exactly what I understand by democratization.

Finally, technology assessments are missing completely. Or they are faked such that mostly only the (questionable) benefits are listed. But all the negative impact is just ignored.

Let’s keep some popcorn around for when this all explodes. :-)

Why Is Vivado 2026.1 Dropping Linux Support for Free Tier?
Article URL: https://adaptivesupport.amd.com/s/question/0D5Pd00001YQLdMKAX/why-is-vivado-20261-dropping-linux-support-for-free-tier-?language=en_US

Comments URL: [https://news.ycombinator.com/item?id=48254309](https://news.ycombinator.com/ … ⌘ Read more

A Forth-inspired language for writing websites
Article URL: https://robida.net/entries/2026/05/21/a-forth-inspired-language-for-writing-websites

Comments URL: https://news.ycombinator.com/item?id=48236887

Points: 5

# Comments: 0 ⌘ Read more

How Handheld Translators Work and Why They’re Handy for Travel
Your cell phone can handle basic language translation, but bespoke tools can offer a much more immersive experience. ⌘ Read more

Babbel Promo Code: Up to 65% Off in May 2026
Master a new language with expert-led courses. Use our verified Babbel coupon codes to save up to 65% on student plans and 60% on 6-month subscriptions. ⌘ Read more

This Indigenous Language Survived Russian Occupation. Can It Survive YouTube?
YouTube’s search and recommendation algorithms are driving children to Russian-language content even when they seek out videos in Kyrgyz, creating a cultural shift that concerns some parents. ⌘ Read more

@movq@www.uninformativ.de that’s the way large language models work, with a prompt. Rather than entering the prompt, most inference providers allow for specific files to be created that define the scope of what’s been requested, the skills the model is supposedly to posses, the stuff to “remember”, etc. Some will “learn” and add that “knowledge” to the proper files.

Another AI rant:

One of the “key features” of LLMs is that you can use “natural language”, because that is supposed to be easier than having to learn a programming language. So, when someone says to me, “I automated this process using AI!”, what they mean is: They have written a very, very large Markdown document. In this document, they list what the AI is supposed to do.

In prose.

This is a complete disaster.

Programming and programming languages have one crucial property: They follow a well-defined structure and every word has a well-defined meaning. That is absolutely brilliant, because I can read this and I can follow the program in my head. I can build a mental model. I can debug this, down to the precise instructions that the CPU executes. This all follows well-defined patterns that you can reason about.

But with these Markdown files, I am completely lost. We lose all these important properties! No debugging, no reasoning about program flow, nothing. It’s all gone. It’s a magic black box now, literally randomized, that may or may not do what you wanted, in some order.

People now throw these Markdown files at me … and … am I supposed to read this? Why? It’s completely random and fuzzy.

Sadly, these AI tools are good enough to be able to mostly grasp the authors intentions. Hence people don’t see the harm they cause, because “it works”.

We already have a ton of automations like this at work: Tickets get piped through an LLM and these Markdown files / prompts determine what will happen with the ticket, and maybe they trigger additional actions as well, like account creation or granting permissions. All based on fuzzy natural language – that no two humans will ever properly agree on.

Jesus Christ, we’re now INTENTIONALLY bringing the ambiguity of legal texts and lawyers into programming.

Using natural language is NOT easier than using a programming language. It is HARDER. Have you people never read a legal contract? And that stuff can STILL be debated in a court room.

I can’t begin to comprehend why we, tech folks, push this so hard. What is wrong with you? Or me?

(And, once again, we’re ignoring other factors here. LLMs use a ton of energy and ressources, that we don’t have to spare. It’s expensive as fuck. It doesn’t even run locally on our servers, meaning we give all these credentials and permissions to some US company. It’s insane.)

@aelaraji@aelaraji.com hey, hey! I saw you tinkering with ActivityPub, so I know you were well.

Glad to have you back here! No much has happened on twtxt.net-world. @prologic@twtxt.net is quite busy with large language models, and seeking further independence through capitalistic ways. @lyse@lyse.isobeef.org continues dazzling us with his clicks, @movq@www.uninformativ.de brings us interesting music, videos to see, and a sprinkle of home made computing here and there, and me… well, I continue bending (or trying to) things! 😂

Aww man, I need to pick up learning Finnish again. I just love the sound of that language.

Surprisingly, I still understand quite a bit of what she’s saying here: https://www.youtube.com/watch?v=Wfnt5-7QBvQ

Rogue dolphins that attack boats have their own language, study finds
The discovery is so unexpected that it has been likened to ‘suddenly finding a new [human] language in the middle of Europe’. For several years now, a… ⌘ Read more

Scientists develop ‘universal language’ to help them talk to aliens
Even if we did happen to come into contact with intelligent extraterrestrials, how would we communicate with them ? Scientists in Australia have come … ⌘ Read more

@bender@twtxt.net They’re not completely impossible, but C makes it much easier to run into them. I think the key point is that in those “safe” languages, buffer overflows are caught and immediately crash the program (if not handled otherwise) instead of silently corrupting memory, not being noticed right away and maybe only later crashing at a different location, where it can be very hard to find the actual root cause. This is a big improvement in my book.

Some programmers are indeed horrible. I’m guilty myself. :-)

I like the article.

I came across this on “Why Is SQLite Coded In C”, which I found interesting:

“There has lately been a lot of interest in “safe” programming languages like Rust or Go in which it is impossible, or is at least difficult, to make common programming errors like memory leaks or array overruns.”

If that’s true, then encountering those issues means the programmer is, simply, horrible?

@lyse@lyse.isobeef.org A “Hello World” binary is ~372KB in size. I currently have peephole optimization and deac code optimizations in play, and a few other performance related ones, but nothing too fancy. I have a test case that ensures fib(35) doesn’t regress too badly as I continue to evolve the language.

mu (µ) now has builtin code formatting and linting tools, making µ far more useful and useable as a general purpose programming language. Mu now includes:

• An interpreter for quick “scriptinog”
  
• A native code compiler for building native executables (Darwin / macOS only for now)
  
• A builtin set of developer tools, currently: fmt (-fmt), check (-check) and test (-test).

Well, you girls and guys are making cool things, and I have some progress to show as well. 😅

https://movq.de/v/c0408a80b1/movwin.mp4

Scrolling widgets appears to work now. This is (mostly) Unicode-aware: Note how emojis like “😅” are double-width “characters” and the widget system knows this. It doesn’t try to place a “😅” in a location where there’s only one cell available.

Same goes for that weird “ä” thingie, which is actually “a” followed by U+0308 (a combining diacritic). Python itself thinks of this as two “characters”, but they only occupy one cell on the screen. (Assuming your terminal supports this …)

This library does the heavy Unicode lifting: https://github.com/jquast/wcwidth (Take a look at its implementation to learn how horrible Unicode and human languages are.)

The program itself looks like this, it’s a proper widget hierarchy:

Image

(There is no input handling yet, hence some things are hardwired for the moment.)

I just fixed another bug in tt where the language hint in multiline markdown code blocks had not been stripped before rendering. It just looked like it was part of the actual code, which was ugly. I now throw it away. Actually, it’s already extracted into the data model for possible future syntax highlighting.

@shinyoukai@neko.laidback.moe Nah it’s more like there’s a lot of repeated code, because when you go from source language to intermediate representation to machine code, well you just end up writing a lot of the same patterns over and over again. I need to dedupe this I think.

@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.

@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.

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

I finished all 12 days of Advent of Code 2025! #AdventOfCode https://adventofcode.com — did it in my own language, mu (Go/Python-ish, dynamic, int/bool/string, no floats/bitwise). Found a VM bug, fixed it, and the self-hosted mu compiler/VM (written in mu, host in Go) carried me through. 🥳

I just completed “Gift Shop” - Day 2 - Advent of Code 2025 #AdventOfCode https://adventofcode.com/2025/day/2 – But again, I’m solving this in my own language mu that I had to build first 🤣

I’m seeing crashes in the 3D subsystem. (Gallium? Glamor? Whatever other Mesa thing they have? No idea.) In the logs I find this:

malloc(): unaligned tcache chunk detected

And that’s why I still care about Rust and want to learn more about it, even though it’s giving me so much headache and I’ve given up so many times. Because Rust currently seems to be the only popular systems programming language that tries to eliminate these error classes.

And of course “the Rust experiment” in the Linux kernel has recently been concluded as “successful”, so that alone is reason enough for me:

https://lwn.net/Articles/1049831/

I just completed “Secret Entrance” - Day 1 - Advent of Code 2025 #AdventOfCode https://adventofcode.com/2025/day/1 — However I did it in my own toy programming language called mu, which I had to build first 🤣

That’s the right answer! You are one gold star closer to decorating the North Pole. [Continue to Part Two]

Whoo! Making progress! With AoC 2025 solutions implemented in my own toy language 🤣

Ahh that’s because I forgot to call main() at the end of the source file. mu is a bit of a dynamic programming language, mix of Go(ish) and Python(ish).

$ ./bin/mu examples/aoc2025/day1.mu 
Execution failed: undefined variable readline

Come back from my trip, run my AoC 2025 Day 1 solution in my own language (mu) and find it didn’t run correctly 🤣 Ooops!

$ ./bin/mu examples/aoc2025/day1.mu
closure[0x140001544e0]

@prologic@twtxt.net Using your own language?! That’s really nice! I hope you get home soon so you can give the code a try. 😅

The most interesting part about mu is that the language is actually self-hosted and written in itself. There is a stage zero compound written and go on a stage one compiler written in mu

Thinking about doing Advent of Code in my own tiny language mu this year.

mu is:

• Dynamically typed
  
• Lexically scoped with closures
  
• Has a Go-like curly-brace syntax
  
• Built around lists, maps, and first-class functions
  

Key syntax:

• Functions use fn and braces:
  

fn add(a, b) {
    return a + b
}

• Variables use := for declaration and = for assignment:
  

x := 10
x = x + 1

• Control flow includes if / else and while:
  

if x > 5 {
    println("big")
} else {
    println("small")
}

while x < 10 {
    x = x + 1
}

• Lists and maps:
  

nums := [1, 2, 3]
nums[1] = 42

ages := {"alice": 30, "bob": 25}
ages["bob"] = ages["bob"] + 1

Supported types:

• int
  
• bool
  
• string
  
• list
  
• map
  
• fn
  
• nil
  

mu feels like a tiny little Go-ish, Python-ish language — curious to see how far I can get with it for Advent of Code this year. 🎄

@movq@www.uninformativ.de sorry dude I think we’re getting our language confused. I think I actually meant private Internet connections.

@threatcat@tilde.club unwritten etiquette (by me, and for me, but one can hope, right?).

• Proper grammar (in any language).
  
• Correct capitalisation, and punctuation.
  
• Subject extension support.
  

Anything else doesn’t matter. ☺️

Ignite Realtime Blog: Helping Dutch Healthcare Speak the Same Language with XMPP

The XMPP Standards Foundation (XSF) has put out a call to action: it’s time for the community to help make secure, interoperable chat a reality - especially in healthcare. Here at Ignite Realtime, we’re excited to support this effort. Our projects, … ⌘ Read more

UK toughens English language rules for migrants
Migrants will need to be able to speak English to an A-level standard, the government announces. ⌘ Read more

Dijkstra on the foolishness of natural language programming (1978)
Comments ⌘ Read more

It happened.

“Can you help me debug this program? I vibe coded it and I have no idea what’s going on. I had no choice – learning this new language and frameworks would have taken ages, and I have severe time constraints.”

Did I say “no”? Of course not, I’m a “nice guy”. So I’m at fault as well, because I endorsed this whole thing. The other guy is also guilty, because he didn’t communicate clearly to his boss what can be done and how much time it takes. And the boss and his bosses are guilty a lot, because they’re all pushing for “AI”.

The end result is garbage software.

This particular project is still relatively small, so it might be okay at the moment. But normalizing this will yield nothing but garbage. And actually, especially if this small project works out fine, this contributes to the shittiness because management will interpret this as “hey, AI works”, so they will keep asking for it in future projects.

How utterly frustrating. This is not what I want to do every day from now on.

Lobsters Interview with Zdsmith
I had the pleasure of interviewing, befriending @zdsmith whose passions are very close to my heart. He explores the different forms of notation (Iverson, Naur), makes combinatory programming approachable, ported J to Janet, created an ergonomic notation for requirements gathering, designed his own [shorthands](https://blog.zdsmith.com/series/sh … ⌘ Read more

[$] Gccrs after libcore
Despite its increasing popularity, the Rust programming language is still
supported by a single compiler, the LLVM-based rustc. At the 2025 GNU Tools\
Cauldron, Pierre-Emmanuel Patry said that a lot of people are waiting
for a GCC-based Rust compiler before jumping into the language. Patry, who
is working on just that compiler (known as “gccrs”), provided an update on
the status of that project and what is coming next. ⌘ Read more

LoRA Explained: Faster, More Efficient Fine-Tuning with Docker
Fine-tuning a language model doesn’t have to be daunting. In our previous post on fine-tuning models with Docker Offload and Unsloth, we walked through how to train small, local models efficiently using Docker’s familiar workflows. This time, we’re narrowing the focus. Instead of asking a model to be good at everything, we can specialize it:… ⌘ Read more

10 Unique Ancient Peoples Whose Cultural Footprints Still Shape the World
History has a funny way of remembering the loudest voices—the emperors, conquerors, and generals whose names echo through textbooks and tourist guides. But for every Caesar or Alexander, countless quieter civilizations shaped the world we live in today. Their contributions hide in plain sight, etched into our laws, our languages, our festivals, and even the […]

The post [10 Unique Anci … ⌘ Read more

HUML :: Human-oriented Markup Language
Comments ⌘ Read more

[$] Upcoming Rust language features for kernel development
The
Rust for Linux project has been good for Rust, Tyler Mandry, one of the
co-leads of Rust’s language-design team, said. He
gave a talk at
Kangrejos 2025 covering upcoming Rust language features and thanking
the Rust for Linux developers for helping drive them forward. Afterward, Benno Lossin and Xiangfei Ding
went into more detail about their work on the three most important language
features for kernel development: … ⌘ Read more

Generative design of novel bacteriophages with genome language models
Comments ⌘ Read more

Unlocking Local AI on Any GPU: Docker Model Runner Now with Vulkan Support
Running large language models (LLMs) on your local machine is one of the most exciting frontiers in AI development. At Docker, our goal is to make this process as simple and accessible as possible. That’s why we built Docker Model Runner, a tool to help you download and run LLMs with a single command. Until… ⌘ Read more

Stealing Part of a Production Language Model (2024)
We introduce the first model-stealing attack that extracts precise, nontrivial information from black-box production language models like OpenAI’s ChatGPT or Google’s PaLM-2. Specifically, our attack recovers the embedding projection layer (up to symmetries) of a transformer model, given typical API access. For under $20 USD, our attack extracts the entire projection matrix of OpenAI’s ada and babbage language models. We thereby confirm, for the first time, that these black-box … ⌘ Read more

Missing accents in Vim in none English language ⌘ Read more

Python 3.14.0 released
Version\
3.14.0 of the Python language has been released. There are a lot of
changes this time around, including official support for free threading, template string literals, and much more; see
the announcement for details. ⌘ Read more

Python 3.14.0 (final) is here
This is the stable release of Python 3.14.0
Python 3.14.0, the newest major release of the Python programming language is here!

Comments ⌘ Read more

IBM Granite 4.0 Models Now Available on Docker Hub
Developers can now discover and run IBM’s latest open-source Granite 4.0 language models from the Docker Hub model catalog, and start building in minutes with Docker Model Runner. Granite 4.0 pairs strong, enterprise-ready performance with a lightweight footprint, so you can prototype locally and scale confidently. The Granite 4.0 family is designed for speed, flexibility,… ⌘ Read more

Mysterious signs on Teotihuacan murals may reveal an early form of Uto-Aztecan language
More than two millennia ago, Teotihuacan was a thriving metropolis in central Mexico with up to 125,000 inhabitants. The city had gigantic pyramids and was a cultural center in Mesoamerica at the time. ⌘ Read more

PEP 810: Explicit lazy imports
This PEP introduces syntax for lazy imports as an explicit language feature: ⌘ Read more

Spec-driven development: Using Markdown as a programming language when building with AI
I coded my latest app entirely in Markdown and let GitHub Copilot compile it into Go. This resulted in cleaner specs, faster iteration, and no more context loss. ✨

The post [Spec-driven development: Using Markdown as a programming language when building with AI](https://github.blog/ai-and-ml/generative-ai/spec-driven-development-using-markdown-as-a-p … ⌘ Read more

«Welcome to the #AutomatingGIS processes course! Through interactive lessons and hands-on exercises, this course introduces you to #GeographicDataAnalysis using the #Python programming language. If you are new to Python, we recommend you first start with the Geo-Python course (geo-python.readthedocs.io) before diving into using it for GIS analyses in this course.

Geo-Python and Automating GIS Processes (‘#AutoGIS’) have been developed by the Department of Geosciences and Geography at the University of Helsinki, Finland. The course has been planned and organized by the #DigitalGeographyLab. The teaching materials are openly accessible for anyone interested in learning.»

https://autogis-site.readthedocs.io/en/latest/

#GIS #geoPython #geopandas #shapely #osmnx #networkx

«Welcome to the #AutomatingGIS processes course! Through interactive lessons and hands-on exercises, this course introduces you to #GeographicDataAnalysis using the #Python programming language. If you are new to Python, we recommend you first start with the Geo-Python course (geo-python.readthedocs.io) before diving into using it for GIS analyses in this course.

Geo-Python and Automating GIS Processes (‘#AutoGIS’) have been developed by the Department of Geosciences and Geography at the University of Helsinki, Finland. The course has been planned and organized by the #DigitalGeographyLab. The teaching materials are openly accessible for anyone interested in learning.»

https://autogis-site.readthedocs.io/en/latest/

(via Paul Walter no linkedin)

#GIS #geoPython #geopandas #shapely #osmnx #networkx

Beyond Containers: llama.cpp Now Pulls GGUF Models Directly from Docker Hub
The world of local AI is moving at an incredible pace, and at the heart of this revolution is llama.cpp—the powerhouse C++ inference engine that brings Large Language Models (LLMs) to everyday hardware (and it’s also the inference engine that powers Docker Model Runner). Developers love llama.cpp for its performance and simplicity. And we at… ⌘ Read more

@movq@www.uninformativ.de Nice Jacob’s ladder. ;-) I had to look up this term, I also found Zig Zag. What do you folks call this in your languages? In German, it’s Hexentreppe (lit. Witch’s Staircase).

The Apache Software Foundation Drops the “Apache”
“As a non-Indigenous entity, we acknowledge that it is inappropriate for the Foundation to use Indigenous themes or language.” ⌘ Read more

Sleeper Agents in Large Language Models - Computerphile ⌘ Read more

@kat@yarn.girlonthemoon.xyz Completely off-topic, I didn’t know that the English language picked up the German word “Ersatz”. Discovering things like that always brings me joy. It has some interesting other properties, though: https://en.wikipedia.org/wiki/Ersatz_good#Etymology

** To the surprise of literally no one, I’m working on implementing a programming language all my own **
Inspired by conversation at a recent Future of Coding event, I decided I’d write up a little something about the programming language I’ve been working on (for what feels like forever) before I’ve gotten it to a totally shareable state. I have a working interpreter that I’m pretty pleased with, but I don’t yet have an interact … ⌘ Read more

@xuu@txt.sour.is I see you’re already a big fan of that language!

@movq@www.uninformativ.de Curious what you would define as “suck less” software? (language agnostic of course!)

I did a “lecture”/“workshop” about this at work today. 16-bit DOS, real mode. 💾 Pretty cool and the audience (devs and sysadmins) seemed quite interested. 🥳

• People used the Intel docs to figure out the instruction encodings.
  
• Then they wrote a little DOS program that exits with a return code and they used uhex in DOSBox to do that. Yes, we wrote a COM file manually, no Assembler involved. (Many of them had never used DOS before.)
  
• DEBUG from FreeDOS was used to single-step through the program, showing what it does.
  
• This gets tedious rather quickly, so we switched to SVED from SvarDOS for writing the rest of the program in Assembly language. nasm worked great for us.
  
• At the end, we switched to BIOS calls instead of DOS syscalls to demonstrate that the same binary COM file works on another OS. Also a good opportunity to talk about bootloaders a little bit.
  
• (I think they even understood the basics of segmentation in the end.)
  

The 8086 / 16-bit real-mode DOS is a great platform to explain a lot of the fundamentals without having to deal with OS semantics or executable file formats.

Now that was a lot of fun. 🥳 It’s very rare that we do something like this, sadly. I love doing this kind of low-level stuff.

@movq@www.uninformativ.de Considered building your own language and compiler? 🤔

Ish: Grep-like text search with optimal alignment, built with Mojo
Associated preprint: https://www.biorxiv.org/content/10.1101/2025.06.04.657890v1

The “built with Mojo” is there because this tool exists specifically to test run Mojo as a language for bioinformatics tool development.

Comments ⌘ Read more

Supreme Court tosses Mexico’s lawsuit against American gun manufacturers
Josh Gerstein,  Staff Writer  -  Politico

_Stephan: In Mexico, the drug cartels use American-made weapons for their crimes, and the Mexican government wanted to have the gun companies that make these weapons, knowingly being sold in Mexico – note they even have Spanish language sayings and graphics carved or etched on the weapons – held responsible. Sadly, in the United States, i … ⌘ Read more

How can one write blazing fast yet useful compilers (for lazy pure functional languages)?
I’ve decided enough is enough and I want to write my own compiler (seems I caught a bug and lobste.rs is definitely not discouraging it). The language I have in mind is a basic (lazy?) statically-typed pure functional programming language with do notation and records (i.e. mostly Haskell-lite).

I have other ideas I’d like to explore as well, but mainly, I want the compiler to be so fast (w/ optimisations) that … ⌘ Read more

Small Programs and Languages
Comments ⌘ Read more

No More Shading Languages: Compiling C++ to Vulkan Shaders
Comments ⌘ Read more

[ On | No ] syntactic support for error handling - The Go Programming Language
Comments ⌘ Read more

A tour of upcoming RFCs for the Hare programming language
Comments ⌘ Read more

Which New Language Should I Learn for Web Development?
Comments ⌘ Read more

A break from programming languages
Comments ⌘ Read more

Large Language Models can run tools in your terminal with LLM 0.26
Comments ⌘ Read more

For context, this is a funny
Interaction between an engineer and copilot on Microsoft’s core programming Language 🤣🤯

How I Replaced Next.js for My App with HMPL.js
Comments ⌘ Read more