HNHacker News
TopNewBestAskShowJobs

KallDrexx

1,149 karma · joined March 15, 2015

[ my public key: https://keybase.io/kalldrexx; my proof: https://keybase.io/kalldrexx/sigs/qkBbNoq0xe9Q7BOQVT-kqAK1h7DIwRjJ436YCkj93MM ]
submissionscomments
KallDrexx··on Zig's New Async I/O
This is my main frustration with the push back against visibility modifiers. It's treated as an all or nothing approach, that any support for visibility modifiers locks anyone out from touching those fields.

It could just be a compiler error/warning that has to be explicitly opted into to touch those fields. This allows you to say "I know this is normally a footgun to modify these fields, and I might be violating an invariant condition, but I am know what I'm doing".

KallDrexx··on How much Anthropic and Cursor spend on Amazon Web Services
Fwiw that's not necessarily true, because if Sonnet ends up using reasoning, then you are using more tokens than GPT-4 would have used for the same task. Same with GPT-5 since it will decide (using an LLM) if it should use the thinking model for it (and you don't have as much control over it).
KallDrexx··on Zed's Pricing Has Changed: LLM Usage Is Now Token-Based
I don't know about for people using CC on a regular basis, but according to `ccusage`, I can trivially go over $20 of API credits in a few days of hobby use. I'd presume if you are paying for a $200 plan then you know you have heavy usage and can easily exceed that.
KallDrexx··on DeepMind and OpenAI win gold at ICPC
It's important to look closely at the details of how these models actually do these things.

If you look at the details of how Google got gold at IMO, you'll see that AlphaGeometry only relies on LLMs for a very specific part of the whole system, and the LLM wasn't the core problem solving system in play.

Most of AlphaGeometry is standard algorithms at play solving geometry problems using known constraints. When the algorithmic system gets stuck, it reaches out to LLMs that were fine tuned specifically for creating new geometric constraints. So the LLM would create new geometric constraints and pass that back to the algorithmic parts to get it unstuck, and repeat.

Without more details, it's not clear if this win is also the Gpt-5 and Gemini models we use, or specially fine-tuned models that are integrated with other non-LLM and non-ML based systems to solve these.

Not being solved purely by LLM isn't a knock on it, but with the current conversations going on today with LLMs, these are heavily being marketed as "LLMs did this all by themselves", which doesn't match with a lot of the evidence I've personally seen.

KallDrexx··on Jujutsu for everyone
I wonder by your last comment if this is just is talking past each other.

I try very hard to keep my PRs very focused on one complete unit of work at a time. So when the squash happens that single commit represents one type of change being made to the system.

So when going through history to pinpoint the cause of the big, I can still get what logical change and unit of work caused the change. I don't see the intermediary commits of that unit of work, but I have not personally gotten value out of that level of granularity (especially on team projects where each person's commit practices are different).

If I start working on one PR that starts to contain a refactor or change imthat makes sense to isolate, I'll make that it's own pr that will be squashed.

KallDrexx··on Jujutsu for everyone
Yeah I don't have much experience outside of GitHub for team projects, so maybe gitlab works better. For GitHub it just gives up and claims it can't give you diff since the last review
KallDrexx··on Jujutsu for everyone
Not the OP but for me, no I don't actually.

In a PR branch, my branches usually have a bunch of WIP commits, especially if I've worked on a PR across day boundaries. It's common for more complex PRs that I started down one path and then changed to another path, in which case a lot of work that went into earlier commits is no longer relevant to the picture as a whole.

Once a PR has been submitted for review, I NEVER want to change previous commits and force push, because that breaks common tooling that other team mates rely on to see what changes since their last review. When you do a force push, they now have to review the full PR because they can't be guaranteed exactly which lines changed, and your commit message for the old pr is now muddled.

Once the PR has been merged, I prefer it merged as a single squashed commit so it's reflective of the single atomic PR (because most of the intermediary commits have never actually mattered to debugging a bug caused by a PR).

And if I've already merged a commit to main, then I 100% don't want to rewrite the history of that other commit.

So personally I have never found the commit history of a PR branch useful enough that rewriting past commits was beneficial. The commit history of main is immensely useful, enough that you never want to rewrite that either.

KallDrexx··on Are OpenAI and Anthropic losing money on inference?
Since DeepSeek R1 is open weight, wouldn't it be better to validate the napkin math to validate how many realistic LLM full inferences can be done on a single H100 in a time period, and calculate the token cost of that?

Without having in depth knowledge of the industry, the margin difference between input and output tokens is very odd to me between your napkin math and the R1 prices. That's very important as any reasoning model explodes reasoning tokens, which means you'll encounter a lot more output tokens for fewer input tokens, and that's going to heavily cut into the high margin ("essentially free") input token cost profit.

Unless I'm reading the article wrong.

KallDrexx··on The current state of LLM-driven development
Hah my bad, I misread your original comment as you saying you usually get the chance to do multiple passes on a prototype to productionalize it :)
KallDrexx··on The current state of LLM-driven development
I'm not the OP and I"m not saying you are wrong, but I am going to point out that the data doesn't necessarily back up significant productivity improvements with LLMs.

In this video (https://www.youtube.com/watch?v=EO3_qN_Ynsk) they present a slide by the company DX that surveyed 38,880 developers across 184 organizations, and found the surveyed developers claiming a 4 hour average time savings per developer per week. So all of these LLM workflows are only making the average developer 10% more productive in a given work week, with a bunch of developers getting less. Few developers are attaining productivity higher than that.

In this video by stanford researchers actively researching productivity using github commit data for private and public repositories (https://www.youtube.com/watch?v=tbDDYKRFjhk) they have a few very important data points in there:

1. There's zero correlation they've found between how productive respondants claim their productivity is and how it's actually measured, meaning people are poor judges of their own productivity numbers. This does refute the claims on the previous point I made but only if you assume people are wildly more productive then they claim on average.

2. They have been able to measure actual increase in rework and refactoring commits in the repositories measured as AI tools become more in use in those organizations. So even with being able to ship things faster, they are observing increase number of pull requests that need to fix those previous pushes.

3. They have measured that greenfield low complexity systems have pretty good measurements for productivity gains, but once you get more towards higher complexity systems or brownfield systems they start to measure much lower productivity gains, and even negative productivity with AI tools.

This goes hand in hand with this research paper: https://metr.org/blog/2025-07-10-early-2025-ai-experienced-o... which had experienced devs in significant long term projects lose productivity when using AI tools, but also completely thought the AI tools were making them even more productivity.

Yes, all of these studies have their flaws and nitpicks we can go over that I'm not interested in rehashing. However, there's a lot more data and studies that show AI having very marginal productivity boost compared to what people claim than vice versa. I'm legitimately interested in other studies that can show significant productivity gains in brownfield projects.

KallDrexx··on The current state of LLM-driven development
I would love to work at the places you have been where you are given enough time to throw out the prototype and do it properly. In my almost 20 years of professional experience this has never been the case and prototype and exploratory code has only been given minimal polishing time before reaching production and in use state.
KallDrexx··on “ZLinq”, a Zero-Allocation LINQ Library for .NET
This is neat, but how does this get away with being zero allocation? It appears to use `Func<T,U>` for its predicates, and since `Func<T>` is a reference type this will allocate. The IL definitely generates definitely seems like it's forming a reference type from what I can tell.
KallDrexx··on DotnetSnes: Library allowing to use C# to create SNES ROMs
Also, I would point out that there are cases where it doesn't change significant amount of the language or hamper things.

The transpiler also works for Linux eBPF kernel side applications without unsafe pointers and other odd things I need to do for SNES.

Since you can have methods on c# struct instances, things can still work pretty idiomatically.

You also do have statically sized arrays, or heap allocated arrays (the latter is only supported if host C application passes it in before hand, and is responsible for free ing it).

KallDrexx··on DotnetSnes: Library allowing to use C# to create SNES ROMs
It's not clear that Fable would fit the constraints, especially since F# heavily relies on reference types for discriminated unions and lots of other features. It's possible that Fable wouldn't be able to compile down to lower end embedded platforms, or even things like Linux eBPF applications (like my transpiler can do).
KallDrexx··on DotnetSnes: Library allowing to use C# to create SNES ROMs
Strings become `char*` so they are supported as long as they are not dynamically generated (no concatenation for example, but some things like `printf()` templates do work.

e.g. https://github.com/KallDrexx/DotnetSnes/blob/master/src/Dotn...

KallDrexx··on DotnetSnes: Library allowing to use C# to create SNES ROMs
In theory, allocation could be hacked in with an arena allocator. I just need to add in reference type support and custom allocation strategies into the transpiler.

Then again, that's only viable if you don't use enough memory to require rom bank switching, or have better control over which class gets placed in which rom bank.

KallDrexx··on Making SNES ROMs using C#
Feel free to write up any issues in the repo if you encounter them. It's likely to encounter MSIL opcodes that my transpiler is missing support for.

Also the pvsneslib docs will probably be crucial for working with the SNES in general.

The Maven 2 SNES emulator was pretty useful for debugging. If you are on windows there's also a no$sns emulator that pvsnseslib has console message support for debugging.

I'm not going to promise it's a super polished effort in its current state :)

KallDrexx··on Making SNES ROMs using C#
Yep, in the current restrictions `T` has to be a struct (no heap allocations means no reference types are supported).

Huh, interesting idea with the `Self` generic dependency for the `Create<T>`. That's an interesting angle I hadn't thought of, thanks.

KallDrexx··on Making SNES ROMs using C#
Author here.

One thing it potentially buys you (besides things mentioned in other posts) is faster iteration cycles.

The C stubbed methods can potentially be populated with logic that sets up a fake SNES logic in it, and makes calls to a custom rendering and input handling (monogame calls for example).

This means you can test a bunch of your logic in a monogame app for easier logic debugging, then use the transpiler to test it on a real system.

KallDrexx··on Making SNES ROMs using C#
Author here.

When I started this journey I had a hard time figuring out how open source il2cpp actually was, and it seemed to be heavily tied to unity. All the docs seemed heavily geared towards unity usage as well.

Likewise, some of my long term goals with the project involve writing code that can run on low end embedded platforms that may not have the C++ standard library available to it. So I had two main goals:

1. Create a system where C# could be run on very low end systems (esp32, arduino, etc...) 2. Allow the C# code to be easily referenced in a non-C# project for platforms that don't allow it.

So I ended up making my own system, as il2cpp and others didn't quite fit some of these bills. I targetted C to make sure that any C compiler could be used, so if an embedded platform has a custom gcc based compiler it could still be used (I think that's the case with the compiler that PVSnesLib uses for its `tcc` compiler).

KallDrexx··on Making SNES ROMs using C#
Author here, yes I am on an insane quest to get C# to run anywhere and SNES was just a random side tangent to that :D.

So the code in the game example is very much a "port directly from the example C code to make sure it's possible and it works". The next step was to start looking at where things can be made more idiomatic.

For example, C# supports static methods in interfaces now. This means instead of passing function pointers around for things you can create a class that implements an interface and call `InitObjects<T>()` instead of `InitObjects(&initFunction, &updateFunction, null)`, and I think I can do that in a no overhead way.

There are some other ideas I have for making things more idiomatic, but I really wanted to make sure I had a working ROM first before I started mangling the examples and trying to figure out if it's my transpiler or my logic that's breaking things.

There is a limit to how idiomatic I can make it though. Since the SNES has limited memory, any stack variable you create risks accidentally overwriting other memory. So it seems like you want to limit how many stack variables you use, which ends up meaning storing things in pointers and globals when using them.

There are some other slight advantages, like better enums, but yeah. At the end of the day this is a usecase of my transpiler allowing C# to be used on non-standard platforms.

KallDrexx··on Are electric cars that much cheaper to operate?
my bad, I'll update
KallDrexx··on Are electric cars that much cheaper to operate?
Electrical charging on the road is expensive, because those are fast chargers, and not normal chargers a home would have.

A ~7kw charger you'd install in a home or a business has is relatively cheap wiring electrically, and the stalls are not that expensive.

Rivian adventure network uses chargers that have to output 220kw into the car. This requires significantly higher cost for getting electricity to each stall, the stall needs to be able to handle that much power transfer, and they must be actively cooled (since that much power causes a significant amount of heat). They also require a decent amount of maintenance.

These stalls can cost upwards of $100k per stall for installation.

This is all done so you can charge in ~20 minutes (as opposed to several hours it would take at a normal 7kwh one).

That's why fast chargers cost significantly more. They also need higher profit margins to make back the installation and maintenance cost depending on utilization rates they expect, otherwise installing these chargers doesn't make a lot of sense for businesses.

KallDrexx··on Why was there a wall near runway at S Korea plane crash airport?
It might not have been slowing down much in that time due to a thing called Ground Effect. Since the wheels weren't down, the flat body of the bottom of the aircraft + wings would have actually reduced drag and cushioned the plane for a bit, causing it to not slow down as much as you would assume.
KallDrexx··on Tiny Tapeout VGA Playground
I was worrying about debuggability if I started with a higher level Verilog transpiler and didn't have a good foundation of Verilog experience.

But maybe I should just do it.

KallDrexx··on Tiny Tapeout VGA Playground
This is awesome, and I really want to learn enough verilog to do a tiny tape out VGA chip design.

But man, 8bitworkshop really burned me out on trying to do verilog in a web IDE, and trying to set up verilator properly for local simulation with a proper IDE became such a hassle.

Ended up moving away from verilog for the moment back to normal software projects. I really want to get back in, but I really don't want to spend my limited coding time fighting IDEs and tooling.

KallDrexx··on Rust for Filesystems
Maybe I'm reading something wrong but the discussion this HN posting is about sounds very much about trying to make a Linux subsystem and API in Rust, so that Rust's type system can enforce conformance to safety mechanisms via its abstraction.

That's fundamentally different and harder than a driver being written in rust that uses the Linux's subsystems C APIs.

I can see a lot of drivers taking on the complexity tax of being written in Rust easily. The complexity tax on writing a whole subsystem in Rust seems like an exponentially harder problem.

KallDrexx··on Recruiters are going analog to fight the AI application overload
Two wrongs don't make a right.

AI being weaponized on the application side hurts us all, and leads to an environment that's extremely difficult to get noticed in as a job seeker. Yes, networking helps but that's not always possible, especially if you are trying to change industries or have generally worked with smaller companies where your networking doesn't expand out much.

It also leads to less diverse environments where hiring managers only look at resumes given by friends or friends of friends.

KallDrexx··on Logik: Open-source FPGA toolchain by Zero ASIC
Theres the open source Digital (https://github.com/hneemann/Digital) which can run simulations but then export Verilog. If you have an ICE40 based GPU then in theory you can then use open source tools (like apio) to get that onto your FPGA. I've seen some impressive fpga tasks being generated by that.

I'm early in my learning of FPGA and have done nandgame and some other non-HDL circuit learnings. I have gone back and forth if I want to design my project via HDL or via something like Digital. There's not an easy pro/con either way.

For example, everything I've read is that the verilog block diagram tools kinda create isn't behavior, which makes optimization by FPGA compilers hard, because it can't automatically infer optimal feature gate usage if you are giving transistor level HDL vs behavior HDL. Likewise, it's not totally clear if block diagramming tools can facilitate test bench behavior, which I think I want to prevent regressions.

KallDrexx··on FuryGpu – Custom PCIe FPGA GPU
That's good to know actually. I'm still very very early in my FPGA adaption (learning the fpga basics) and I am intending to start with standard 640x480 VGA before expanding.
← PreviousPage 2 of 10Next →