borar

Huge themes of my personal state of software engineerig art: * (pure) FP in back-end and front-end * the Onion architecture * REST

@johncrickett Only the first, obviously.

Software engineers six months ago: "An engineering manager has to be technical. How would they understand what the team is doing if they can’t build software?" Software engineers today: "Coding is basically solved. Non-technical people can just manage AI agents and build software now." Which is it?

@zero_to_seed @0xglitchbyte And in order to do that design of the architecture and "patterns" one needs to know how to design and program...

Design the rules and the architecture and the pattern you want and put in checks to ensure they happened and then make sure they happened. That is the new coding. nobody writes binary anymore because higher level languages were invented. The quality of the lower level code still matters but nobody writes it.

Because these codebases need to architected and maintained You cannot maintain a large codebase with full confidence unless you yourself are in said codebase doing the work. The more you allow LLMs to code for you, the less you understand of your own codebase, and the less youre able to maintain in the long term.

@devabram @mimivalsi @ChShersh @JustDeezGuy Close, but a bit different: PureScript. A perfect balance of pure FP, much smaller language surface and many "mistakes" of Haskell taken into acccount. Usabe both for Web and Node-like environments.

@mimivalsi @Savlambda @ChShersh @JustDeezGuy Haskell, prob.

OCaml is Golang of functional programming.

@mimivalsi @devabram @ChShersh @JustDeezGuy It is a "bad" language if you want to learn pure FP (which is _the_ FP, but it's already too subtle for many :)) Otherwise OCaml and its cousin F# are great FP-first languages.

@devabram @ChShersh @JustDeezGuy Ah… I have little knowledge on that point. Is it a bad language to learn functional programming? I think this question is better

Cool

In the new Interlude, we’re joined by Peter Thiemann. Peter is a professor at the University of Freiburg, and he was doing functional programming right when Haskell got started. Come with us on a trip down memory lane! haskell.foundation/podcast/79/

🚀 Serde.FS alpha.9 — Deterministic RPC for F# No reflection. No controllers. Just compile‑time RPC clients + routing. Includes: • [<RpcApi>] • ASPNET RPC server • Deterministic JSON backend github.com/serde-fs/Serde… #fsharp #rpc #aot #serde #dotnet

@davidfowl Nah, slop in one language is not the same as slop in another. So my language is still better than yours.

So when programming languages are all irrelevant because we’re slopping out code in any language, what are we going to replace “my language is better than yours” discussion? Will it be agent harnesses?

@rahulj51 Not those specs, but CS meaning of specification.

I don't know. Hard for me to agree with the spec-is-code argument. Specs are low fidelity. They aren't a common shared DSL. Have very low signal to noise. Not verifiable or deterministic. They don't encourage iterative work. Almost always written by an agent, thus prone to more slop. Lose their inherent value as soon as they are converted to code. Specs are throwaway. They are a way to temporarily express behavior intent - an agent translates that to a version of code. That's the thing that lives forever. If you are convinced that spec is code then you should be able to confidently delete all code and regenerate from specs.

New blog post: "A sufficiently detailed spec is code" I wrote this because I was tired of people claiming that the future of agentic coding is thoughtful specification work. As I show in the post, the reality devolves into slop pseudocode haskellforall.com/2026/03/a-suff…

@TansuYegen Saw this in Japan 20 years ago. Guys were filling vending machines at a railway station with these. "Came out in China" my ass.

Electric lifts that climb stairs on their own just came out in China, carrying up to 180 kg for 60 to 80 floors, totally changing the game for delivery people...

@pikuma @smartnakamoura And even then, C feels more appropriate.

@smartnakamoura Something is off. Why would a university teach web dev? Did you mean vocational school?

Nigerian uni is giving us C programming in 2026. Not React. Not cloud. Not even basic web dev. C for that matter omoo who are we building for 😭

@raimeyuu Fine, as long as it is literally :)

@Savlambda One day, next version of #csharp will be announced as #fsharp.

Answer: something which should have been a simple and principled #fsharp program from the beginning.

@davidfowl x.com/savlambda/stat…

One of the best takes I've read on minimal APIs #aspnetcore #dotnet

@WillEhrendreich @fresheyeball The project looks very cool indeed!

@fresheyeball @Savlambda I bet it's great. Haven't tried it yet. But I know that fsharp is killer for vibe coding and I used it to make this: github.com/WillEhrendreic… Which ironically helps both vibe coders and non vibe coders immensely. I'm very proud it.

Haskell is the best language for vibe coding and it's not even close.

@WillEhrendreich @fresheyeball Yeah, same principle applies in both cases. Haskell probably provided an even stronger effect of the "funnel of success".

@fresheyeball I noticed that when vibing Haskell or Purescript even Copilot/Claude uses a different tone when "speaking", it's more precise and analytical

@allenholub What does this mean, practically speaking? That it's ok for a factory to stand still for a few day, a couple of people to die, a large financial transaction to be incorrect, all part of embracing imprecision while we "accept fuzzyness"?

One common critique of AI is that it's imprecise and nondeterministic. We programmers have held too long to the notion that precision—in algorithms, in the programming languages we use, in the data we collect—is essential. We think that if our specifications and implementations are precise, our problems are solved. Our eternal quest for ever greater precision has failed us. We simply cannot write precise enough code. There are always bugs. That precise spec turns out to describe something nobody wants, and the details are wrong. Computers don't need to be this precise. Analog computers worked very well for the classes of problems they solved. Aviation and naval navigation, for example, were entirely analog until just a few years ago, and the planes and ships got where they needed to go. Precision is perhaps not as important as some of us think. It seems to me that our attempts to impose precision on a chaotic, fuzzy world have failed us. Algorithms often fail. E.g., problems like chaotic turbulence or traffic-flow patterns are easy to model, but no algorithm can predict them. Even physics is not as precise as some imagine; the location of an electron is probabilistic, not precise. We programmers want the world to be Newtonian, subject to precise mathematics, but it's a quantum world. We need to figure out ways of working that reflect that reality. The original Agile challenged the idea that a precise up-front plan was viable. It assumed the world was complex, not simply complicated, and we needed to work in a way that recognized that complexity. We dumped the precise plan and instead built small, got feedback, then adjusted. That worked surprisingly well. Agile failed when we reverted to the idea of precision. Estimates, backlogs, burn-down charts, prescriptive meetings—all of that is an attempt to reimpose precision onto an imprecise activity. That thinking destroyed Agile, but the original thinking was correct. We now need to extend the original thinking further, to the coding itself. So, AI. LLMs fly in the face of precision coding, approaching programming in a more natural, almost analog way. The haters want our tools to create MORE precise results, so they are deeply suspicious of AI's fuzziness. They think they must correct that fuzziness by a detailed after-the-fact analysis that injects precision into the generated code. Disaster strikes when people who think that way are forced to use AI. Just look at Amazon. The solution is not to fight the fuzziness, but to work with it and develop ways to write effective systems in a fuzzy way. That thinking leads to guardrails as our primary tool rather than inspection. Things like a modular component architecture, emphasis on testability, static analysis, testing in production, etc., all become critical. So, my advice is: Embrace fuzziness. But add guardrails. It's time to rethink how we work. Instead of "that's nuts," think "what innovative guardrails solve the problem?"