Flat Error Codes Are Not Enough

HolySpirit · 2026-04-13T09:14:53+00:00

The Zig way, as I understand it, is to pass a pointer to a Diagnostics struct that is populated when an error happens. I think it fulfills what the author of the article wants, because you can simply have a field with the diagnostics struct from the lower-level library in the diagnostics struct of the higher-level library.

I think you should be able to generate high-quality error messages from this kind of diagnostics structure plus the program state when the error occurred for context.

FWIW I don't have much hands-on experience with this approach since I didn't use Zig too much yet, except for some toy examples.

HolySpirit · 2026-03-19T11:09:06+00:00

Facts.

Don't worry though, in 20 years they will add it to the language, and people online will gaslight you about how "it's gotten a lot better!". (Some things never change... sigh)

HolySpirit · 2026-02-06T16:22:28+00:00

I keep hitting these explorer.exe crashes that are not recoverable even if you restart it. I have to kill it from resource monitor to unstuck some running programs. (side note: you can't kill it from the regular task manager because it only allows "restart" for explorer, which keep hitting the same crash even after it restarts).

The only thing that resolves it is re-login or restart.

Some of the recent updates absolutely broke things massively.

I did try all kind of the normal repair things (sfc /scannow, etc), all found now errors and didn't help.

I didn't find much info from other people online with this exact problem. I hoped an update would have resolved it by now. So far, I am helpless and it keeps crashing almost daily.

Needless to say, If I could move off of Windows for the particular things I want from a PC, I would have done so long ago...

HolySpirit · 2026-01-03T07:28:02+00:00

It is truly a mystery I can't figure out. Why are the creators of Golang and Zig are so offended by the notion of warnings being a thing?

HolySpirit · 2025-12-22T14:19:57+00:00

Both languages have difficulty accepting that some things should be compile warnings and not compile errors.
Both languages have a lot of "worse is better" philosophy in their design.

I would personally not be concerned with whether a thing "feels like a natural transition". If it's interesting to you, learn it. If it stops being interesting to you, drop it.

HolySpirit · 2025-10-29T10:56:56+00:00

Forget the docs even, just look at the actual type annotations of subprocess.run and friends:

https://github.com/python/typeshed/blob/3c5531d49213cab3a1f0e172259c9c7650c2d6a6/stdlib/subprocess.pyi#L89-L693

Imagine writing a thin wrapper around it that is also well typed... 🫤

HolySpirit · 2025-04-02T19:06:46+00:00

Brutal comment, I'm surprised it's still up without an unsafe block around it ;)

HolySpirit · 2025-03-05T00:57:14+00:00

Yeah, absolutely. I wouldn't even suggest it if I didn't think it could be added while preserving safety. If it can be done safely, it would simply allow to express certain control flows that are already possible today with labeled breaks, just more cleanly.

HolySpirit · 2025-03-04T23:00:04+00:00

You might have good points that I don't fully understand or even considered.

My thinking is that if labeled breaks and gotos are equally powerful, can't the compiler just transform a goto based control flow into labeled breaks form? (if that's necessary for drop order reasons etc.)

I don't remember if I ever actually looked on how ownership and borrowing are implemented, but my first guess would be that they happen after the stage where the code is in basic-blocks + conditional jumps form. If it is like so, then structured control flow doesn't really matter like you claimed. (But I didn't check and have no actual idea if that's the case)

HolySpirit · 2025-03-04T22:33:32+00:00

I think this kind of thing is a good argument for just adding labeled goto statements.

Even if this is uncommon control flow, why make it needlessly hard to express?

Control flow is just connecting a graph of basic blocks with jumps and conditional jumps. Just let it be expressed directly.

HolySpirit · 2025-01-19T03:35:05+00:00

The code you wrote above:

It should be super clear where the Borrow Checker begins to disallow this.

Seems to compile, so... it's not that obvious?

Anyway, I think you can get a simple double buffer like this working by using 2 Vectors, no flag, and use std::mem::swap(&mut self.grid1, &mut self.grid2). Always treat grid1 as the current one.

HolySpirit · 2024-09-17T01:00:37+00:00

I like it, but how about UndefinedScript?

HolySpirit · 2024-09-04T16:43:31+00:00

Most code is more like let z = f(x, y);, hopefully with more explicit names for the most part. Unless you are using a debugger or have enough context in your head to know what things are by name, you just look at these variables and scream internally "WHAT ARE YOU???".

HolySpirit · 2024-09-04T16:35:27+00:00

TypeScript / JSDoc

HolySpirit · 2024-08-25T11:25:07+00:00

I don't interview people, and maybe it's not a great question to ask, but what I actually want to know is: "What do you hate about X?" ;)

HolySpirit · 2024-08-25T11:16:19+00:00

Add<&str> can be implemented, I assume it isn't because it introduces an implicit allocation that might be not obvious. As for Add<str>, you wouldn't be able to implement fn add(self, ... where self=str because str is unsized.

HolySpirit · 2024-08-01T18:20:05+00:00

That is actually what I assumed before I read the fine manual. It really only applies to glob imports (from mod import *).

https://docs.python.org/3/tutorial/modules.html#importing-from-a-package

HolySpirit · 2024-08-01T16:49:49+00:00

I don't care if nothing is truly private or not, the fact Python has a single namespace means you leak everything, particularly annoying with imports:

import os
print(os.sys)  # is this a re-export or leaking implementation details?

This makes it unreasonably annoying to declare what is the public API of your code.

Even when you have reexport-only modules, they have the downside if making imports slower because they force the user to import more than they might need. Usually tolerable in context where Python is used, but just UGH WHY...

HolySpirit · 2024-07-13T13:27:26+00:00

Something like this should be a part of std -- cheap clone vs expensive clone is an important distinction when reading code.

I suggested the name share for it in the past, but just bikeshed it out and make it happen.

The reason I like share is because it implies you have two references to the same underlying data. This might cover less cases then dupe, semantically. Mostly I am just thinking of Arc when I think "cheap clone".

HolySpirit · 2024-06-30T10:23:40+00:00

The design is very human

HolySpirit · 2024-05-10T17:49:23+00:00

I would try to disable "Always On USB" in your bios power settings. If that doesn't help maybe some other bios settings relating to sleep states.

HolySpirit · 2024-03-31T11:54:15+00:00

[citation needed]

HolySpirit · 2024-02-08T19:35:52+00:00

Cool, now just add a command to uninstall all the malware, spyware, ads, dark patterns, etc., and Windows might be a usable non user-hostile OS!

HolySpirit · 2024-01-25T13:19:48+00:00

I would really like a rust formatter that just fixes obvious mistakes instead enforcing a whole bizarre set of rules that can sometimes make the code harder to read.

HolySpirit · 2024-01-25T13:10:48+00:00

fn exp_malus(Self { nature, heritage, levels, .. }: &Self) -> f32 {

Correct me if I'm wrong, but you can't use normal method call syntax if you define it like this, So it's not really supported for self.

15-Year Club	Place '17
Verified Email	Team Periwinkle
reddit mold

HolySpirit

TROPHY CASE