olvy0

Funny, I'm just reading War and Peace myself (the Anthony Briggs translation) and having the same reaction, gushing occasionally to people I know how approachable it is, and how darkly funny and modern it feels. Well, at least after passing through the first ~200 pages which are a slog. I didn't find even Tolstoy's historical musings boring, although he tends to repeat himself. And I usually suck at names, but the main characters are done so well I find them easy to remember. There aren't that many important ones despite how it seems at the start. It also serves as a fascinating peek into the daily lives of Russians of all stripes in the early 1800s.

I also had the same reaction to Crime and Punishment as the OP did.

Ha, I'm a gardener then, on my 15th year of maintenance. So halfway there according to you. Slowly, very slowly, fixing the thousands of bugs the rockstar left behind 15 years ago.

Closest would be the ACCU Overload journal, freely available here [0].

There'a also Visual studio Magazine but it's obviously Microsoft-centric [1].

Also CODE magazine [2] but it's more lightweight, feels more "commercial".

[0] https://accu.org/journals/nonmembers/overload_issue_members/

[1] https://visualstudiomagazine.com/home.aspx

[2] https://www.codemag.com/magazine/allissues

Exactly. Thank you for saying this.

That's actually pretty close to my own career as well.

I work on an ancient codebase, C# and C++ code spanning over 3 major repos and 5 other minor ones. I'm senior engineer and tech lead of my team, but I also do a lot of actual coding and code reviews. It's a somewhat critical internal infra. I'm intimately familiar with most of the code.

I've become somewhat addicted to using coding agents, in the sense I've felt I can finally realize a lot of fantasies about code cleanup and modernization I've had during the decade, and also fulfill user requests, without spending a lot of time writing code and debugging. During the last few months I've been spending my weekends prompting and learning the ropes. I've been using GPT 5.x and GPT 4 before that.

I've tried both giving it big cleanup tasks, and big design tasks. It was ok but mentally very exhausting, especially as it tends to stick to my original prompt which included a lot of known unknowns, even after I told it I've settled on a design decision, and then I have to go over its generated code line-by-line and verify that earlier decisions I had already rejected aren't slipping into the code again. In some instances I've had to tell it again and again that the code it's working on is greenfield and no backwards compatibility should be kept. In other instances I had to tell it that it shouldn't touch public API.

Also, a lot of things which I take for granted aren't done, such as writing detailed comments above each piece of code that is due to a design constraint or an obscure legacy reason. Even though I explicitly prompt it to do so.

Hand-holding it is a chore. It's like coaching a junior dev. This is on top of me having 4 actual real-life junior devs sending me PRs to review each week. It's mentally exhausting. At least I know it won't take offense when I'm belittling its overly complicated code and bad design decision (which I NEVER do when reviewing PRs for the actual junior devs, so in this sense I get something to throw my aggression against).

I have tried using it to make 3 big tasks in the last 5 months. I have shelved the first one (modernizing an ancient codebase written more than 20 years ago), as it still doesn't work even after spending ~week on it, and I can't spare any more time. The second one (getting another huge C# codebase to stop rebuilding the world on every compilation) seemed promising and in fact did work, but I ended up shelving it after discovering its solution broke auto-complete in Visual Studio. A MS bug, but still.

The 3rd big task is actually a user-facing one, involving a new file format, a managed reader and a backend writer. I gave it a more-or-less detailed design document. It went pretty ok, especially after I've made the jump to GPT 5.2 and now 5.4. Both of them still tended to hallunicate too much when the code size passed a certain threshold.

I don't use it for bug fixing or small features, since it requires a lot of explaining, and not worth it. Our system has a ton of legacy requirement and backwards compatibility guarantees that would take many days to specify properly.

I've become disillusioned last week. It's all for the best. Now that my addiction has lessened maybe I can have my weekends back.

I've been using Perplexity for small, fast queries almost exclusively for the last year or so. Their Sonar model is Llama running on top of a Cerebras chip, and searches the internet in an incredible speed. Its results are astonishingly good (for a Llama model), although in more niche areas it still makes mistakes, so in those areas I usually double-check its sources or do an extra ddg search myself.

Actually I've never used chat gpt, I went straight to Perplexity after having discovered it. Their free tier is extremely generous (not even requiring an account). Not affiliated.

OP currently doesn't look it will affect that, seems like Open AI touts it for agentic coding only, not as an alternative to chat gpt, although that will probably change.

Except for new files, you'd have to also run git clean -f

Wallace Stevens' excellent book of poems, Harmonium, is also now free on Wikisource [0].

[0] https://en.wikisource.org/wiki/Harmonium_(Stevens)

There's also bflat [0]. Not an official Microsoft product, more of a passion project of a specific employee.

"C# as you know it but with Go-inspired tooling that produces small, selfcontained, and native executables out of the box." Really impressive. Self contained and small build system.

[0] https://github.com/bflattened/bflat

Just wanted to say I enjoyed your post very much. Thank you for writing it. I love D but unfortunately I haven't touched it for several years. I also have some experience writing parsers and implementing protocols.

Original paper: Generative design of novel bacteriophages with genome language models

https://www.biorxiv.org/content/10.1101/2025.09.12.675911v1

C# does support a form of multiple dispatch, through the dynamic keyword. Used it myself for writing a parser.

https://shawnhargreaves.com/blog/visitor-and-multiple-dispat...

Username checks out.

Adding to the comments: Not an American, but like others here watched TNG every day after school, and TOS before that. Many other people my age did, for example my wife.

BTW, we have watched with our sons all of TNG and DS9 for the last 3 years, and our eldest is now deeply familiar with Star Trek as a result. Very few of his peers are familiar with it, though.

Just like $dayjob.

In my experience, it's always been possible to use Visual Studio Community without a Microsoft account. It might recommend that you do, but you don't have to. I've been using it this way for years.

Hear hear

Really good advice there. Thank you for writing this.

I've written several in-house tutorials to our internal product, and I've come to internalize your advice somehow.

IMO it's mostly about empathy. I remember myself as a newbie perplexed by this product and try to write to my younger self. I also make a point to always spend a lot of time with new hires and get their feedback and their viewpoint.

The "Back to Basics" videos from cppcon are pretty good, IMO.

For lambdas: Back to Basics: Lambdas - Nicolai Josuttis - CppCon 2021

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

Back To Basics: Lambda Expressions - Barbara Geller & Ansel Sermersheim - CppCon 2020

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

For auto, this one is short and summarizes some of the gotachs:

C++ Weekly - Ep 287 - Understanding `auto`

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

This looks great, I might use it next time I'm interviewing.

That is a great quote, thank you.

This is exactly what I thought about rust when trying to learn it a few years ago. I'm also an experienced C++ programmer. After trying for 3-4 months and constantly fighting the borrow checker, I lost all motivation and gave up.

Or something written by William S. Burroughs.

Notepad++ also uses Scintilla.

Hi Andrew, just wanted to me and my family really enjoyed Voyage of the Marigold! It's such an excellent little game. We played through it a couple of time, each time discovering new things. Thank you for writing it.

I've played Star Trek: Resurgence a couple of months ago, and I must say I enjoyed your game much more than Resurgence, which is incredible considering that it was written just by you. IMO your game stays very close to spirit of the classic Trek I grew up with.

For me, the most useful part of LINQ is neither the IQueryable syntax tree based extension mechanism, nor the language integrated part (which I dislike), but simply the IEnumerable extensions. Originally known somewhat confusingly as linq to objects. Those allow me to write c# in functional style, keeping the code concise.

The post I submitted refers mostly to optimizations to those extension methods.

This clicked for me after having learned Haskell. It also shares some of Haskell's features/pitfalls, such as laziness.

There are pitfalls, sure, and honestly I wouldn't advise a team having no one somewhat experienced with basic functional idioms (including laziness) to use it. It can lead to obtuse and slow code if used indiscriminately. I try to lead by example myself.

Hi! we don't do schema validation, yet.

The json storage we currently use is kind of "secondary" to the database, and so there currently we don't verify it. The relational database we use does have a schema, of course.

Not verifying the json schema is something that is sorely missing, since the files get corrupted from time to time and this is discovered only during deserialization. Unfortunately this is something I don't have enough time to add, as we're swamped with other work (our app is huge and we are a very small time). We just tell our internal users to re-serialize the database to fix these corruptions, which is unfortunate and costly, but the best we can do at the moment.

I wrote more about that aspect of my internal app here.

https://news.ycombinator.com/item?id=25005993 https://news.ycombinator.com/item?id=38111860

Like I wrote, when in a future version we'll drop the database completely, and work only off those json files, I'll also introduce schema validation. That won't happen for some time though.

Thanks for your answer, I understand now why you didn't measure the performance of simdjson etc. into account.

I have thought in the past about using BinPack for my json documents, but: I want them to remain as human readable as possible, since the reason to move to json from a DB, was to make database diffs into readable diffs, and BinPack isn't readable. I also want users to be able to use existing tools on the json files (e.g. the jq tool), but existing tools don't understand BinPack (yet?).

I think BinPack would shine in an RPC/IPC setting. Just recently there was this big discussion here about systemd replacing D-BUS with a json-based IPC and a huge discussion around the waste of using plain json to do that.

https://news.ycombinator.com/item?id=41687413

I think it's a shame that BinPack wasn't even considered, as it would have made moot some of the arguments there.

I might get in touch with you in the future through your github.

Don't know if you'll see this, but I really like your work. I read your dissertation at least twice, it's well written and informative.

In my day job I have multiple large json files, used in an internal in-house application, into which I serialize a database, and working with them is much faster than using the database (for some workloads). Although the main reason to do so is just for using git for source control.

In the future I plan on migrating all the code to working off the json files, but that won't happen for some time yet.

I was looking for a fast json library and that's why I discovered your paper and your project, although that was some months after I have started working on that project and it was too late to change.

Currently I use the (very slow) json.net library for most serialization/deserialization, it's fast enough for the specific places where I use them, but for some specific workload that has to be fast I use RapidJson (the code in that part is already c++), but only its streaming parser, which blazingly fast, at the cost of some development. I tried using simdjson but had trouble compiling it at the time.

By the way, in your dissertation you don't mention RapidJson, nor json.net, nor simdjson. Is there a reason why you didn't compare them?

My bus also leaves at 7 AM, with 40 minute commute, but unfortunately I have a very bad case of internet / youtube addiction, plus I'm basically a night person.

So I go to sleep around 12:30 AM each night (sometimes even after 1 AM), and I wake up at 5:50 AM.

That's not enough sleep at all. I do sleep till very late during the weekend.

I've been doing this for 20 years now, and some day it's probably going to catch up on me.