• Rust will save Linux from C's inherent security weaknesses.
• Linux, faced with a flood of AI-discovered security problems, could use the help.
• Going forward, more and more Linux code will be written in Rust.

I'm interested in finding out what people think when they see something GNU. What do you associate with it? Do you tend to be more or less interested in the project if.it is GNU or not? What is your perspective?

I use speckit, and while I like the spec/clarify/plan/task/analyze/implement loop (although it can get a bit overwhelming at times), I don't like that I have to start with writing a spec and implement it to begin with. I am looking for a more of a design phase before the spec phase, where I can talk about the overall application architecture, and then start writing specs for implementing pieces of it.

For instance, let's say I want to build a github repo provisioner that 1. creates repos with desired setup, and 2. bulk edit repos with secret updates, yaml updates, etc. I don't want to build both the features at the beginning. I want to first build only the create portion, and then do the bulk edit feature later on. With speckit, I can do this by only telling it to create the spec for the build portion, but later if I want to build the bulk edit portion, the whole application might need to be changed in important places, because it wasn't a 'planned' feature when it was first designed. I want instead to have a design phase where I describe and maintain a doc with the whole application, and when I start the spec for the create portion, the agent can understand that this create portion is only part of a bigger application and can design/implement the create portion accordingly.

Have you come across a situation like this? how do you handle your big applications? Please advise.

Someone I know asked me for a favour. They made an agreement with a software firm for some custom software for basically inventory on a web interface, generic DB+webserver. They need me to do updates to it as a favour.

It's handoff time. The guys are giving him some trouble. I let them know if I need to do maintainence and whatnot, I need the source code. The guys are saying no. I recommended we use a licence that basically says "Buyer can modify the software and source code, but not distrobute it. Creator can distrobute the software and whatever they want".

I've looked around, and I saw recommendations for :

• source code escrow
• internal-use license
• Modified Source Code License
• custom Restricted Source Code License
• internal modification only licence

anyone have recommendations of specific licences?

I scanned the public repos of 128 YC-backed dev tools companies, 6,195 repos in total. I expected the companies building our tooling to enforce the basics on themselves. Only 2 of the 128 require any status check to pass before merging.

Internet learned to speak gibberish that doesn’t always coincide with literary text. But it can be converted back to that. Here’s my experiment along these lines.

This is a devlog from my learning of a quick prototype, I hope it can fit in this space too. It's partially code, partially archtecture and a fair lot of notes and discussion with myself. Maybe this can be the cup of tea of someone reading this.

Has anyone tried in organization to use self hosted llm models for agentic programming?

Im curious if it makes any sense. My organization spends fortune on tokens from us companies. I want to recommend something…

Nell’articolo precedente abbiamo visto come si possono mettere le note a piè di pagina in una pagina web. Ora vediamo, invece, come possiamo inserire un separatore.

Apriamo l’editor OneCompiler e dopo aver cancellato tutto, digitiamo: L’HTML è un linguaggio di markup che serve a creare ed abbellire una pagina web

Topics Covered:

Ratty 3D Terminal https://ratty-term.org/
TheyLive Adblocker https://github.com/davmlaw/they_live_adblocker
TerminalPhone https://gitlab.com/here_forawhile/terminalphone
Cuda Oxide https://nvlabs.github.io/cuda-oxide/index.html
Wario Synth https://www.wario.style/
Jmail & EpstienExposed https://epsteinexposed.com/
Wikipedia Doomscroller https://xikipedia.org/
Puter https://github.com/HeyPuter/puter
Honker https://github.com/russellromney/honker

Voiden is an offline-first, git-native API tool built on Markdown.

Instead of keeping API requests inside a cloud workspace, Voiden stores them as .void files that can live with your codebase, be versioned in Git, reviewed in PRs, and reused across a team.

We have now released the beta of @voiden/runner, a headless CLI for running those .void files outside the desktop app.

The runner executes the request, prints the result, and exits with a standard exit code that CI systems can use.

Important bits:

• runs on Node.js 18+
• works in terminal, CI/CD, Docker, and cron jobs
• supports REST, WebSocket, gRPC, and GraphQL
• supports JSON and CSV output
• supports request chaining through runtime variables
• works with core Voiden plugins like scripting, assertions, faker, - - advanced auth, and GraphQL

This is still beta, so APIs and flags may change.

The goal is to make .void files executable API workflows, not just files used inside the desktop app.

Github: https://github.com/VoidenHQ/voiden

Voiden CLI Runner : https://github.com/VoidenHQ/voiden/tree/beta/packages/voiden-runner

Visit Voiden here : https://voiden.md/

One of the tenets from a software-craft site I've been building. The idea is to keep state and dependencies as local as you can, and only promote something to a wider scope (module, shared, then global) once it's actually used widely enough to earn it. Most of the 'shared' code I've had to untangle started local and got hoisted up a tier too early.

Running Code in a Programming Language Nobody Knows

Last month, I ran code in a programming language that nobody knew.

I'm not the first to do a thing like that. Ben Olmstead created Malbolge in 1998. It's a deliberately incomprehensible programming language that's likely impossible for anyone to really know; it took a search algorithm to generate the first program for it. Finding examples of an old, obscure language with no surviving practitioners is another potential method I imagine has been done a few times.

Nobody had ever known Nucleus when its compiler bootstrapped. Since it's 2026, I imagine many readers have already guessed large language models were involved. I gave a sample program and output to an LLM tool and told it to write a compiler in C. I then told the tool to add features to the language until it could rewrite the Nucleus compiler in Nucleus, resulting in a language that I did not know. LLMs do not "know" things and aren't somebody, so at that point, nobody knew Nucleus, yet there were about 4000 lines of it running in the compiler, able to produce real binaries that run on real computers.

Someone I mentioned this to asked why I would want to design a programming language without designing a programming language. I don't actually want to do that, but just as the compiler needed an initial implementation in another language in order to bootstrap, I found it much easier to work from a minimal working language than a blank slate. I had the idea for Nucleus for a long time and have not yet read the Dragon Book and written a compiler from scratch like I told myself I was going to.

As for the language itself, the basic idea is a language for manipulating memory at a low level like C, but with Lisp-like syntax and structural macros providing compile-time abstractions and safety-enhancing constructs with no runtime overhead. By the time it hits 1.0, Nucleus should be usable as a drop-in replacement for C anywhere C is used. I'm not the first to do a thing like that either, but other implementations I've seen actually compile a Lisp-like language to C. Nucleus targets LLVM directly.

@programming

@programming@programming.dev

#lisp #LanguageDesign #compilers