MurphyA/hacker-news huggingface dataset:
by dghf | 2025-12-04 13:33:20+00:00
Similar things:

* Perl MIDI::Score -- https://metacpan.org/pod/MIDI::Score

* Csound standard numeric scores -- https://csound.com/docs/manual/ScoreTop.html

* CsBeats (alternative score language for Csound) -- https://csound.com/docs/manual/CsBeats.html
by stephencanon | 2025-12-04 13:33:39+00:00
Schubfach's table is quite large compared to some alternatives with similar performance characteristics. swiftDtoa's code and tables combined are smaller than just Schubfach's table in the linked implementation. Ryu and Dragonbox are larger than swiftDtoa, but also use smaller tables than Schubfach, IIRC.

If I$ is all you care about, then table size may not matter, but for constrained systems, other algorithms in general, and swiftDtoa in particular, may be better choices.
by throwaway_2494 | 2025-12-04 13:34:09+00:00
> it was the worst debugging experience one could have.

Hard disagree. I'm not going to argue that Java debugging was the best, however:

1. You could remote debug your code as it ran on the server.

2. You could debug code which wouldn't even compile, as long as your execution path stayed within the clean code.

3. You could then fix a section of the broken code and continue, and the debugger would backtrack and execute the code you just patched in during your debugging session.†

This is what I remember as someone who spent decades (since Java 1.0) working as a contract consultant, mainly on server side Java.

Of course this will not convince anyone who is determined to remain skeptical, but I think those are compelling capabilities.

† Now I code in Rust a lot, and I really enjoy it, but the long compile times and the inability to run broken code are two things which I really miss from those Java days. And often the modern 2025 debugger for it is unable to inspect some for the variables for some reason, a bug which I never encountered with Java.
Show HN: Tatfi – A Font Parser in Zig
by asibahi | 2025-12-04 13:34:21+00:00
Hello

I am currently unemployed so I am filling my time porting Rust libraries to Zig. This is a port of ttf_parser [1] which is used by almost the entire Rust ecosystem.

The port is not complete yet, but I think there is enough utility there to build shapers and rasterizer on top of it just fine.

Just like the Rust original, `tatfi` is almost stateless, almost allocation-free, and aims to be completely safe and panic free. Obviously Zig does not have the same safety guarantees as Rust, but I tried my best. It does help that there is almost no allocation in the library.

There is still need to add tests (port the tests), and I will work on those as soon as I finish the API surface.

[1]:https://docs.rs/ttf-parser/latest/ttf_parser/
by potato3732842 | 2025-12-04 13:35:50+00:00
>and there are plenty of developers who'd be happy to make a quick buck by building a cut-rate tower of toothpicks.

There is an equally evil and opposite force of engineering firms looking to make a long buck by convincing permitting authorities that this needs tons of regulation (crafted to also apply to smaller buildings than the layman would consider reasonable, of course) and product supplier who'll egg them on every step of the way.

The more you learn about construction the more it makes sense why organized crime always winds up getting involved in it.
by windexh8er | 2025-12-04 13:37:37+00:00
And that buys you what, exactly? Your point is 100% correct and why LLMs are no where near able to manage / build complete simple systems and surely not complex ones.

Why? Context. LLMs, today, go off the rails fairly easily. As I've mentioned in prior comments I've been working a lot with different models and agentic coding systems. When a code base starts to approach 5k lines (building the entire codebase with an agent) things start to get very rough. First of all, the agent cannot wrap it's context (it has no brain) around the code in a complete way. Even when everything is very well documented as part of the build and outlined so the LLM has indicators of where to pull in code - it almost always cannot keep schemas, requirements, or patterns in line. I've had instances where APIs that were being developed were to follow a specific schema, should require specific tests and should abide by specific constraints for integration. Almost always, in that relatively small codebase, the agentic system gets something wrong - but because of sycophancy - it gleefully informs me all the work is done and everything is A-OK! The kicker here is that when you show it why / where it's wrong you're continuously in a loop of burning tokens trying to put that train back on the track. LLMs can't be efficient with new(ish) code bases because they're always having to go lookup new documentation and burning through more context beyond what it's targeting to build / update / refactor / etc.

So, sure. You can "call an LLM multiple times". But this is hugely missing the point with how these systems work. Because when you actually start to use them you'll find these issues almost immediately.
by chriswarbo | 2025-12-04 13:37:58+00:00
Very nice! One thing I've found useful about MathML is that, since it's XML, it's easy to generate (e.g. from scripts) and transform (e.g. with XSLT).

My preferred workflow at the moment is to programatically-generate "Content MathML", which lets me focus on the structure of things (akin to Lisp's prefix-form s-expressions), e.g. here's "applying plus to identifier x and identifier y":

<apply> <csymbol definitionURL="https://openmath.org/cd/arith1#plus">plus</csymbol> <ci>x</ci> <ci>y</ci> </apply>

Browsers can't display Content MathML, so I use XSLT (adapted from [1]) to convert it to "Presentation MathML". The "MathML Core" discussed in this article is a subset of Presentation MathML. Presentation MathML focuses on the layout of symbols, e.g. the above becomes "identifier x followed by operator + followed by identifier y":

<mrow><mi>x</mi><mo>+</mo><mi>y</mi></mrow>

This separation also lets me choose different notations, without having to alter the underlying data; e.g. on this page which compares two different notations http://www.chriswarbo.net/projects/units/negative_bar_notati... (if you click the "View Source" link at the bottom, you'll see the same data being piped into `math block` and `math block minus`, which just apply a different stylesheet).

[1] https://www.w3.org/Math/XSL/Overview-tech.html
by Sharlin | 2025-12-04 13:38:44+00:00
The reasons are always the same. 20% because some changes are actually improvements, and 80% cargo cultism where if you just build the right containers and chant the correct YAML incantations, you too will become a Google… followed by the phase where everybody just keeps doing these things because they organizationally don’t know any other way anymore, until the next big trendy thing, which does revert some of the issues of the previous trendy thing, but introduced a new set of already solved problems because this profession is incredibly myopic when it comes to history.
by gottheUIblues | 2025-12-04 13:38:46+00:00
I didn't know and not mentioned in the article is that there are two different programs in reverse mathematics, one relating to classical mathematics, the other relating to complexity questions. Claude says this: not sure about accuracy

Let me clarify the relationship between PV₁ and reverse mathematics systems, as there are actually two different research programs here: Two Different Programs 1. Classical Reverse Mathematics (over RCA₀) The standard reverse mathematics program, pioneered by Harvey Friedman and Stephen Simpson, works over second-order arithmetic and studies which set existence axioms are needed to prove theorems of ordinary mathematics. The main systems form the "Big Five": RCA₀ (Recursive Comprehension Axiom) WKL₀ (Weak König's Lemma) ACA₀ (Arithmetic Comprehension Axiom) ATR₀ (Arithmetic Transfinite Recursion) Π¹₁-CA₀ (Π¹₁ Comprehension Axiom) 2. Bounded Reverse Mathematics (over PV₁ or similar) This is a separate program studying computational complexity rather than computability. It analyzes which theorems require which computational resources.
by phantasmish | 2025-12-04 13:38:54+00:00
I had a flash ad take 100% of my cpu back around 2005 or so. It wasn’t even trying to be malicious, just a poorly made ad. That was the day I stopped allowing any site exceptions in my ad blocker.

Of course 100% of that cpu is probably 1/10 of one core on any of my modern machines, so an ordinary and not-broken ad laden page routinely eats several times as many cycles now. Progress!
by swed420 | 2025-12-04 13:39:04+00:00
> This is a form of lazy thinking, because it assumes everyone is equally affected. This is not what we see in reality, and several sections of the population are more prone to being converted by manipulation efforts.

Making matters worse, one of the sub groups thinks they're above being manipulated, even though they're still being manipulated.

It started by confidently asserting over use of em dashes indicates the presence of AI, so they think they're smart by abandoning the use of em dashes. That is altered behavior in service to AI.

A more recent trend with more destructive power: avoiding the use of "It's not X. It's Y." since AI has latched onto that pattern.

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

This will pressure real humans to not use the format that's normally used to fight against a previous form of coercion. A tactic of capital interests has been to get people arguing about the wrong question concerning ImportantIssueX in order to distract from the underlying issue. The way to call this out used to be to point out that, "it's not X1 we should be arguing about, but X2." This makes it harder to call out BS.

That sure is convenient for capital interests (whether it was intentional or not), and the sky is the limit for engineering more of this kind of societal control by just tweaking an algo somewhere.
by pie_flavor | 2025-12-04 13:39:07+00:00
Maven was a great idea. Introduce a high barrier to entry for publishing packages. Paired with a search box operated by carrier pidgeon, this effectively meant what you were looking for didn't exist. Every time you had any kind of quirky need, you had to write it out by hand, or find someone smarter than you to do it for you, or worst of all buy it from a vendor for lots of money at horrible quality. People recite 'DSA is bad for coding challenges, when will I need to write a hash map', but once upon a time you did have to write a hash map here and there. Supply chain vulnerability is a cost, but the product was worth the cost: you can just import the darn package!

I need a map of key ranges to values with intelligent range merging, it is right there on crates.io to import, it has been there since 2016, Maven Central didn't get one until 2018. In the olden days either it was in Apache Commons or it didn't exist. Halcyon days those.
by crote | 2025-12-04 13:39:10+00:00
It's a high-speed vs low-speed thing.

If you're building an audio cable your signal will peak out at a few kHz, so the cable acting as an antenna and picking up a signal in the MHz range isn't an issue. Similarly, you're not transmitting anything significant either. But a ground loop can easily ruin your day.

If you're building a cable for multi-gbps data transmission, that ground loop noise might as well not exist - it's basically DC. But ground your shielding at only one end, and suddenly you're ruining everyone's wifi!

Building a device which needs high-speed data on one side, and analog audio on the other side? Good luck...
by lunias | 2025-12-04 13:39:43+00:00
> We run our k8s cluster in the “Cloud”. It’s a bunch of services that run on Linux, but we don’t run Linux ourselves, we run it on VMs that we rent by the hour for approximately the same cost as buying a computer outright every month. We do this because no one knows how to plug a computer in any more.

My mind struggles with this reality everyday... the "cloud" has to be the most successful rebrand of all time. In 2005: "Be very careful what data you share on the internet". In 2025: "Yeah, I just put all my shit in the cloud".
by deltaburnt | 2025-12-04 13:39:59+00:00
I don't really buy your premise. What you're suggesting is that all code has bugs, and those bugs have equal severity and distribution regardless of any forethought or rigor put into the code.

You're right, human review and thorough design are a poor approximation of proving assumptions about your code. Yes bugs still exist. No you won't be able to prove the correctness of your code.

However, I can pretty confidently assume that malloc will work when I call it. I can pretty confidently assume that my thoroughly tested linked list will work when I call it. I can pretty confidently assume that following RAII will avoid most memory leaks.

Not all software needs meticulous careful human review. But I believe that the compounding cost of abstractions being lost and invariants being given up can be massive. I don't see any other way to attempt to maintain those other than human review or proven correctness.
by mnalli | 2025-12-04 13:40:43+00:00
I like your approach, it is even more minimal :)

In general, I wanted the snippet store to be separate from the history, so that I could use the history as transient "working memory". Working with the history tends to get really messy after a while, at least for me.

msm gives you a bit more than that. The description (comment) has to be one-line only, but the snippet can be multi-line. The selected snippet is injected in the command line, it does not replace the whole buffer. This can be useful e.g. if I have some saved configuration paths (I never remember them) or when working with process substitution commands. Integration with fzf: the preview will show the full multi-line output well formatted. Integration with bat: syntax highlighted output and preview. Multiple snippet stores: plain text files that you can edit with your editor.

Aside from this, msm does not do much... it's just a 100 lines script.
by t43562 | 2025-12-04 13:41:22+00:00
It's horrifying to see someone who started working 10 years after me talking about "when I was young" :-D

Programming was more exciting when you had amazing things to imagine having - like a 256 colour screen or BASIC that ran as fast as machine code (ACORN ARCHIMEDES) or the incredible thought of having a computer powerful enough to play a video and even having enough storage to hold a whole video!

2400bps! Checking email once a day

Everything came true. My screen has 16million colours and I don't notice. I have 12 cores and 64GB of memory and fibre optic internet. The extremely exciting future arrived. That mind-expanding byte article I read about Object Oriented programming came true enough for us to see that it wasn't the answer to everything.

There are 2 problems now - nothing one does is unique. You can't make a difference because someone else already has done whatever you can think of doing ....and of course AI which is fun to use but threatens to make us even more useless.

I just cannot really get my sense of excitement back - which may just be because I'm old and burned out.
by pzo | 2025-12-04 13:41:58+00:00
> Where did it all go wrong?

Just landscape changed significantly comparing to 2010.

Before you didn't have current smartphones and tablets. On desktop you could just support windows only (today probably have to macOS as well). On browser you didn't have to support Safari. You didn't have to worry much about screen DPI, aspect ratio, landscape vs portrait, small screen sizes. Your layout didn't have to be adaptive. There was not much demand for SPA. Back then there was much less people worldwide with access to internet.
by vdupras | 2025-12-04 13:42:09+00:00
Yes, sometimes it's that, but what I've observed in the field is self-inflicted by programmers. It's the impostor syndrome. They don't know, but they don't want to show that they don't know. They look around for clues of what to choose. Monkey see, monkey do. And then, like monkeys, they bash their keyboard until it seems to work.
by Gormo | 2025-12-04 13:42:17+00:00
> So it became more straightforward to release games on Linux? Sounds like a positive.

No, not really. Many of the common game engines already support Linux out of the box. Unity, for example, already makes building for Linux basically equivalent to building for Windows or Mac. Proton has disincentivized building for Linux even in cases where doing so is already as straightforward and low-effort as could be.

> Or, is the gripe about distinction of released for vs playable on?

Yes. Most of these games were already playable on Linux under Wine, even if it took a bit more effort on the part of the user to get things up and running. The rise in Linux usage started motivating native Linux ports for a few years, and there's a large library of native Linux games out there. But Proton has been removing the incentives to build native Linux ports by making that Windows compatibility "just work".

The result is now that there are more games where Linux compatibility still running on top of an emulation layer -- but one that's a bit less straightforward for users to configure directly as they would with Wine -- and a bit less performant than they might otherwise be.

It also means that Linux compatibility for these games is more closely coupled to the Steam ecosystem. Whereas a game with a native Linux build might distribute that build through Steam, GOG, Humble, itch.io, etc., now the non-Steam platforms have only Windows builds. Sure, these can usually still be played under Wine in the traditional fashion, but that represents a regression away from native Linux support.
by ojr | 2025-12-04 13:43:19+00:00
My first text editor for PHP was Komodo Edit, it was super slow and everyone jump shipped to Sublime Text, then VSCode was slower than Sublime but had incredible industry supported extensions like Git and Prettier, programming didn't peak during my PHP days, in fact the PHP frameworks sites I used are still around and incredibly slow.

I am building an AI coding tool that doesn't eat RAM, there are super lightweight alternatives to Electron.
Show HN: ProbeOps Horizon Browser – Test your site from different countries
by kumaras | 2025-12-04 13:43:23+00:00
Hi HN — ProbeOps Horizon is a Playwright-based geo testing browser. It lets you test how a site behaves from different regions using real Chromium sessions routed through regional egress nodes (instead of just header spoofing).

Use cases:

- geo redirects / pricing / localization

- CDN / edge routing differences (Cloudflare/Akamai/Fastly/CloudFront)

- consent banners, payment flows, bot checks

- per-region artifacts: HAR + TTFB/waterfall, screenshots/video, console/network logs

Current: local client (per tab/context region routing).

Links: (demo)

https://youtu.be/jXAnWzLue_c

Feedback I’m looking for:

which regions matter most,

which geo-specific behaviors you need to validate,

local vs cloud mode preference.

Happy to answer technical questions.
by pimlottc | 2025-12-04 13:43:24+00:00
> > DOGE wasn't an audit. It was an excuse to exfiltrate mountains of your sensitive data into their secret models and into places like Palantir

> Do you have any actual evidence of this?

I will not comment on motives, but DOGE absolutely shredded the safeguards and firewalls that were created to protect privacy and prevent dangerous and unlawful aggregations of sensitive personal data.

They obtained accesses that would have taken months by normal protocols and would have been outright denied in most cases, and then used it with basically zero oversight or accountability.

It was a huge violation of anything resembling best practices from both a technological and bureaucratic perspective.
by munksbeer | 2025-12-04 13:44:10+00:00
> The less common successful remote work becomes across the industry

You're presupposing your conclusion. I don't believe remote work is less successful. I think this is driven from angles such as:

* Managers who have made their career by visibility, struggling to adapt to a new normal

* A way to get rid of staff without paying severance

* Pressure from certain types of politician who have made up their mind (regardless of any evidence) that remote working is harmful

And others

It really is a shame that for once it felt like labour had something going their way, and somehow the leaders of capital have convinced us to fight each other on this, while they take it away again.
by Yarden_Bruch_El | 2025-12-04 13:44:36+00:00
We are building a pipeline to convert unstructured documents into normalized Postgres rows.

The core struggle isn't extraction; it's the collision between a probabilistic model and a deterministic database. We are stuck in a vicious cycle:

Strict Schema (FKs, NOT NULL): The LLM gets "scared" of the constraints. To satisfy the schema validator, it starts hallucinating fake Foreign Key IDs or inventing default values just to get the JSON to parse.

Loose Schema (JSONB/Text): The LLM returns garbage data (invented Enums, inconsistent date formats) that requires massive post-processing code to clean up.

We are currently maintaining a 400-line system prompt that is essentially "Postgres constraints re-written in English."

Has anyone solved this reliability problem without a human-in-the-loop reviewing every INSERT?
by bokohut | 2025-12-04 13:46:15+00:00
I have located no accredited scientific studies yet that discuss how the loss of gigatons of ice compressing the entire planets structure from the poles will impact the planet as a whole. With even a basic understanding of mass and physics however one can deduce from that comprehension an irrefutable change will occur in the planets crust. If one were to research the pattern of volcanic activity from the start of human recorded existence alone then one may learn something new. Most of our species fails to think in time, only worried about today, however as the changes in our only planet set in from 'progress' more will be forced to look back over time and reconsider where we failed.
by kace91 | 2025-12-04 13:46:52+00:00
You know what made javascript so common, accessible, and thus later universal?

Putting things on a screen was (is) stupidly simple.

That's the whole thing. It's not the types or npm or whatever. It's that you could start with C/Python/Java and spend your first 6 months as a coder printing and asking values on a dark terminal (which is something a newbie might not even have interacted with before) or you could go the html/css/javascript route and have animations moving in your screen you can show to your friends on day one.

Everything flows from that human experience. UIs are Electron because creating UIs for a browser is an extremely more universal, easy and creative-friendly experience than creating UIs for native apps, particuarly if JS is your native language for the previously stated reason.

The industry failed to adapt to the fact that the terminal wasn't any longer the reality of computer users, and the web kinda filled that niche by default.

Also, React was an answer to the advent of mobile phones, tablets, smart tvs, and basically all the explosion of not-a-desktop computer form factors. You could no longer assume your html was a proper format for everything. So you need an common API to be consumed by a mobile app, a tv app, a tablet app... react was the way to make the web another of the N apps that use the api, and not get special treatment. The idea made sense in context, back then.
by DocTomoe | 2025-12-04 13:47:02+00:00
I feel we have a RAM price surge every four years. The excuses change, but it's always when we see a generation switch to the next gen of DDR. Which makes me believe it's not AI, or graphics cards, or crypto, or gaming, or one of the billion other conceivable reasons, but price-gouging when new standards emerge and production capacity is still limited. Which would be much harder to justify than 'the AI/Crypto/Gaming folks (who no-one likes) are sweeping the market...'