LLMs are surprisingly good at reducing crash samples.
I've had success with "this project crashes my static analysis tool with the following command, try to shrink the repro whilst preserving the crash. Commit each smaller version to a branch".
Has the JS ecosystem reached a point where people agree roughly what a good architecture looks like?
I don't see as many blog posts complaining about new framework churn and I'm wondering why.
Rust and RISC-V both feel like they've reached critical mass and I'd guess that they'll be used more in 5 years than they are today.
What other technologies fit this description?
Some excellent safety improvements in C++26: hardening the standard library against out-of-bounds bugs, and a safer semantics for uninitialised local variables: herbsutter.com/2026/03/29/c...
LLMs have been really helpful for me porting some JS projects to TS.
Since the types are erased and annotations are optional, I can go gradually and safely with more minimal human oversight.
(I'm not sure if it'll significantly help robustness, but it's lovely for navigation.)
Reviewing some of my earliest web projects: they have a mix of Postgres, MySQL and Mongo.
These days I just use sqlite for all my personal projects. It's really good at my scale and makes deploying very easier.
The author of rust-analyzer discussing how language features help or hinder fast IDEs.
If you allow `from m import *` you can't analyse files in isolation, and it's even harder in Rust.
matklad.github.io/2026/02/25/a...
My 3.5yo is learning to use a mouse, and it's super interesting.
He's mastered clicks and drags, but he hasn't yet figured out lifting up the mouse when run out of mouse pad. That's a tricky case where you deliberately break the relationship between mouse and cursor movement.
That's fair, any 'convention over configuration' framework probably does really well in an LLM workflow.
That said, I do find myself configuring eslint are lot more aggressively for vibecoded projects, e.g. github.com/Wilfred/troy...
I'm surprised there aren't more tools out there for starting a new project with some default config files.
There's `cargo new` but it's Rust specific and very minimal. create-react-app is React specific.
The only option I know of is cookiecutter. Surely it's a common problem?
Excellent series on Self, both the programming model and the tool chain.
I love how opening an inspector on a value (e.g. nil) then shows a link to all occurrences of the value in other open inspectors!
blog.rfox.eu/en/Programmi...
Thanks! It's a programming language, so the target audience is programmers. The live URL is www.garden-lang.org/keyword:fun.... if you're curious.
I'm trying to balance whimsy (it's a hobby project), usability, and my limited graphical design skills :)
Screenshot today
Screenshot with window UI
I'm experimenting with imitating window UI elements when showing code snippets on my website.
What do you think? Do the familiar dots of the title bar help, or is it just confusing decoration?
First image is the current style, the second image has the window UI.
I've started naming my servers digiocean1.example.com, digiocean2.example.com and so on. I wish I'd done this much earlier.
I already have domain names for the actual deployed services, but it quickly gets confusing when you start moving things around.
I'm adding uptime data to my personal LLM bot. Does this information belong in the system prompt?
That was my initial plan, but I'm thinking that a tool would be better. Tools let me see information provenance ("queried the uptime tool").
There's also a small caching benefit.
Difftastic showing Scala
Difftastic showing Scala
I've released difftastic 0.68! A smaller update, but still worth upgrading:
* Improved Bash, C, Go, Lua, Nix, Perl, Python, Rust, Scala, Swift and YAML parsing.
* Minor display and git compatibility fixes.
github.com/Wilfred/diff...
Really elegant developer tool: Go's inline IDE feature is used with depreciation markers, so call sites are autofixed from OldApi() to NewApi() based on the implementation of OldApi.
go.dev/blog/inliner
Are there any developer experience advantages for `x := 1` over `let x = 1`?
A `let` keyword probably improves parsing error behaviour, and makes declarations more visible.
:= is more concise though.
What is the lowest resolution image that is still recognisable?
I made a space invader craft project at one point and spent a bunch of time wondering if I had enough materials.
Writing type params with <> (e.g. List<Int>) seems the most natural to me: probably because I encountered that syntax first.
Between C++, Java and TypeScript I think it's the most common too.
List[Int] seems to be next most common (Scala, Python) but TIL Gleam uses List(Int)!
Agentic programming workflows rather remind me of genetic programming. The agent has a validation step that looks like a fitness function, and both run iterative trials.
I'm still not sure whether a language should include a "kitchen sink linter" like Rust's clippy or have a package oriented "thousand flowers bloom" linter like eslint for JS and TS.
Clippy is delightful out of the box but eslint makes it so easy to have project specific lints.
Is there a good term for "after using this feature we realised that the best design is different from the current design"?
In casual conversation I generally hear "bug" but there was nothing wrong with the original implementation.
I'm super impressed by how many lint rules can be implemented with just eslint's no-restricted-syntax and selectors. Example:
{
selector: "ExportNamedDeclaration[declaration=null][source=null]",
message: "Add `export` directly to the function instead of a block export."
}
There's something pleasingly self-referential about configuring an agent by talking to it.
> Remember that [fact about data formats].
Agent: Noted.
... realise nothing happened ...
> Write to your rules file that when I say "remember", I want you to write to the rules file.
Should lint suppressions be first class syntax or comments?
Adding a proper metadata system (e.g. Clojure or Rust) is a big design space but it's clear which expressions are affected.
Comments are much easier to implement but it's easy for users to get them wrong.
Thoughts?
I enjoyed this article about personal project programming, but I particularly liked this definition:
"Production code has a phone number to call when it breaks"
hannahilea.com/blog/housepl...
Looks great!
Have you considered reducing the size of the images? E.g. highly-expressive-macros.png is nearly 1 MiB on its own and I can see the images gradually load on my current limited wifi.
One fun way of testing new AI models: take an existing codebase you have and just ask them to "review it and fix bugs".
In principle this should find more issues over time as models get smarter. I've found a few bugs this way at least.
Cleaned up an old git repo of Ansible playbooks and it's amazing how much is just Docker now.
Docker handles process supervision, centralises logging, and containers coexist without issues. It's nice when things get simpler.