William J. Bowman

If you read this: https://www.williamjbowman.com/blog/2026/03/05/against-vibes-when-is-a… you will notice that this may not even be the correct workflow (depending on what you want to achieve of course. If you just verifiable web-dev, you can keep on doing what you do; even then there may be counter-args). Generally, I noticed that when I went back to my old work flow of writing rough pseudo code (which aggregated doesn't add a lot of time), I was more efficient. I could then let the LLM translate the pseudo code. What I was missing though was that the LLM also suggested changes to my pseudo code in my pseudo code style as well. This is why I built the following skill (you can use /translate then): https://github.com/HalfEmptyDrum/Pseudo-Code-Flow I have written about it here: https://news.ycombinator.com/item?id=47331647

Preprint: https://williamjbowman.com/resources/wjb2024-ethical-compiler.pdf DOI: https://doi.org/10.1145/3704253.3706135 William J. Bowman. The 2025 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation (PEPM) – Invited Talk. Abstract: "The is-ought gap is a problem in moral philosophy observing that ethical judgments ("ought") cannot be grounded purely in truth judgments ("is"): that an ought cannot be derived from an is. This gap renders the following argument invalid: "It is true that type safe languages prevent bugs and that bugs cause harm, therefore you ought to write in type safe languages". To validate ethical claims, we must bridge the gap between is and ought with some ethical axiom, such as "I believe one ought not cause harm". But what do ethics have to do with manipulating programs? A lot! Ethics are central to correctness! For example, suppose an algorithm infers the type of is Bool, and is in fact a Bool; the program type checks. Is the program correct-does it behave as it ought? We cannot answer this without some ethical axioms: what does the programmer believe ought to be? I believe one ought to design and implement languages ethically. We must give the programmer the ability to express their ethics-their values and beliefs about a program-in addition to mere computational content, and build tools that respect the distinction between is and ought. This paper is a guide to ethical language design and implementation possibilities."

Btw, I got inspired by this: https://www.williamjbowman.com/blog/2026/03/05/against-vibes-when-is-a… Really useful read!

I've been trying to get LLMs to make Racket "hashlangs"† for years now, both for simple almost-lisps and for honest-to-god different languages, like C. It's definitely possible, raco has packages‡ for C, Python, J, Lua, etc. Anyway so far I haven't been able to get any nice result from any of the obvious models, hopefully they're finally smart enough. † https://williamjbowman.com/tmp/how-to-hashlang/ ‡ https://pkgd.racket-lang.org/pkgn/search?tags=language

> Generic things should be parametric most of the time, and non-parametricity should be visible, so that people don't do it accidentally. Economy of mechanism is powerful though, it's one of the reasons C is still so popular. The comptime approach that provides both parametric and ad-hoc polymorphism using a single mechanism seems to fit Zig quite well. I'm still a bit of a typaholic, but I've really come to appreciate economy of mechanism instead of deeply inscrutable types. I think a good language would take something like Zig's approach to comptime, where the template/macro language is the same as the value language, with a deep consideration of TURNSTILE from "Type Systems as Macros": https://www.khoury.northeastern.edu/home/stchang/pubs/ckg-popl2017.pdf You can even get to dependent type systems as macros: https://www.williamjbowman.com/resources/wjb2019-depmacros.pdf