MurphyA/hacker-news huggingface dataset:
by moffkalast | 2025-08-30 06:56:38+00:00
Nooo you can't use deterministic math, you gotta use kalman filters and particle filters and factor graphs and spend three months tweaking parameters to get a 5% improvement! /s

Like alright in some situations that's the only thing that could possibly work, but shoving that complexity into every state estimator without even having a way to figure out the actual covariance of the input data is a bit much. Something that behaves in an expected way and works reliably with less accuracy beats a very complex system that occasionally breaks completely imo.
by mcv | 2025-08-30 06:57:15+00:00
It's important to understand the difference between easy and simple. It's easy to add complexity, it can sometimes be hard to keep things simple.

But with that in mind, I do agree that a lot of systems are more complex than they need to be. I like to keep things simple.

Of course scalability adds complexity, and sometimes you need that. But you don't always need that, and making things scalable that don't need to be, makes them harder to understand and maintain.
by fsniper | 2025-08-30 06:57:22+00:00
Are they? Until Let's Encrypt came along and democratise the CA scene, it was a hell hole. Web Security was depending on how deep your pockets are. One can argue that the same path is being laid in front us until a Let's Encrypt comes along and democratise it? And here as it's about attestation, how are we going to prevent gatekeeper's doing "selective attestations with arguable criteria"? How will we prevent political forces?
by 9rx | 2025-08-30 06:57:24+00:00
> I find it very helpful to write unit tests for specific implementations of things (like a specific sort, to make sure it works correctly with the various edge cases).

Sorting mightn't be the greatest example as sorting could quite reasonably be the entire program (i.e. a library).

But if you needed some kind of custom sort function to serve features within a greater application, you are already going to know that your sort function works correctly by virtue of the greater application working correctly. Testing the sort function in isolation is ultimately pointless.

As before, there may be some benefit in writing code to run that sort function in isolation during development to help pinpoint what edge cases need to be considered, but there isn't any real value in keeping that around after development is done. The edge cases you discovered need to be moved up in the abstraction to the greater program anyway.
by notpushkin | 2025-08-30 06:58:31+00:00
Please don’t... Adding ellipsis as a separate character was a huge mistake, because it doesn’t work well:

- you can’t make a ?.. or !.. with it

- the spacing between the dots is awful in a lot of fonts

- it is hideous in monospace

- typing ellipsis properly is a very easy gesture (triple-tap the dot key), arguably easier than Alt Gr + . (depending on the keyboard)
by tsimionescu | 2025-08-30 06:59:07+00:00
On the contrary, AI training techniques require gigantic amounts of data to do anything, and there is no upper limit whatsoever - the more relevant data you have to train on, the better your model will be, period.

In fact, the biggest thing that is making it unlikely that LLM scaling will continue is that the current LLMs have already been trained on virtually every piece of human text we have access to today. So, without new training data (in large amounts), the only way they'll scale more is by new discoveries on how to train more efficiently - but there is no way to put a predictable timeline on that.
by strogonoff | 2025-08-30 06:59:38+00:00
The benefit is certainty that the system you are building and delivering to people works. If that benefit is little, then I don’t quite understand the point of testing.

> it's also easy to manually test while developing during QA and UAT.

As I said in the original comment, e2e tests can definitely be manual. Invoke your CLI, curl your API, click around in GUI. That said, comprehensively testing it that way quickly becomes infeasible as your software grows.
by kristopolous | 2025-08-30 07:01:56+00:00
Even ignoring all of that, there's "time to first watt" - essentially if you break ground now, how quickly can you start producing power? Nuclear has years scale, wind and solar has weeks, if not days.

And also when better tech comes along, you can partially transition a farm to newer panels and resell the old ones after market.

Plus you don't have to build Onkalo Repository like systems to store waste for 100,000 years after you've produced your electricity.

It's wildly more feasible.
by ivanb | 2025-08-30 07:02:00+00:00
In practice e2e tests don't cover all code paths and raise a question: what is the point? There is a code path explosion when going from a unit to an endpoint. A more low-level test can cover all code paths of every small unit, whereas tests at service boundary do not in practice do that. Even if they did, there would be a lot of duplication because different service endpoints would reuse the same units. Thus, I find e2e tests very limited in usability. They can demonstrate that the whole stack works together on a happy path, but that's about it.
by Piyushkashyap | 2025-08-30 07:02:26+00:00
Content strategy tip: You can spy on 1000s of your customers on Reddit (here's how) to build your content funnels:

We can spy on our customers' "chats" when working on a high-value content strategy. Consumers are irrational buyers, so we can't rely solely on third-party metrics. DTC should be using Reddit to extract chats.
by astahlx | 2025-08-30 07:04:31+00:00
I started using emdashes in my academic career, after my advisor pointed me to the subtle differences. And since then, I like and use emdash a lot. In Latex, it is easily produced, just keep the spacing rules in mind. The Punctuation Guide is a nice reference on it https://www.thepunctuationguide.com/
by rcarmo | 2025-08-30 07:04:31+00:00
This is kind of pointless given that iOS’s autocorrect has been adding em dashes, ellipsis and smart quotes to comments since… forever.

(Like now)

It’s become a weird kind of witch hunting regarding blogs, too, and I have a 20+ year old site that renders all of its content using Markdown extensions that do the same (and that also convert dual hyphens to em dashes—something I’ve been typing for about as long).
by lenkite | 2025-08-30 07:04:37+00:00
I find massive blobs of XML easier to grok than massive blobs of JSON, esp well-designed XML with namespaces and use of attributes. XML is self documenting.

JSON is just a homogeneous unnamed bunch of braces and key-val pairs that you loose yourself in once you are several MB in and deeply nested. Need to resort to CLI tools like jq or hunt for the schema or docs.

Massive blobs of YAML, well - they should be simply categorized as a war-crime.
by armitron | 2025-08-30 07:06:25+00:00
"Borges provided more than two dozen pages of emails, memos and other communications outlining how DOGE “potentially violated multiple federal statutes” designed to protect government data."

This reads like political theatrics from entrenched bureaucrats that are pissed off their authority is being challenged and their incompetence exposed. I have no issues whatsoever with "Bigballs" crawling through that data to find gross instances of fraud. I do have issues with parasitic bureaucrats throwing their dead weight around thinking this is and will remain their fiefdom forever and ever.
by 1gn15 | 2025-08-30 07:07:39+00:00
Speak for yourself. This is just the semantic web: a web not built just for humans, but also for robots or any other types of agents that may wish to build upon the data. User agents never meant just web browsers, and operators blocking based on it necessitated hiding your identity.

Blocking bots is an absurd and unwinnable proposition, just like DRM; there's always the final, nuclear option of the analog hole, a literal video camera pointed at a monitor and using a keyboard and mouse.

If you really need to, deploy a proof of work shield that doesn't discriminate against user agents, just like what Onionsites do.
by dragonwriter | 2025-08-30 07:08:49+00:00
> you can’t make a ?.. or !.. with it

But an ellipsis is separate from and doesn't mmerge with sentence-terminal punctuation, whether its a period or somethig else (when it replaces words at the end of a sentence, the terminal punctuation follows the ellipsis, when at the beginning of a sentence that follows another, the ellipsis follows the punctuation.) The constructs you say can't be formed with it aren't needed.
by adrian_b | 2025-08-30 07:09:22+00:00
I have no idea about author's background or about his other writings, but the conclusion quoted by you seems absolutely correct.

I do not understand why you say that it lacks supporting evidence.

Before this conclusion, the author has explained the system of national exams and of distribution into high schools and inside high schools, that ensures that the best students are grouped together and also that the best teachers are assigned to them.

There is no doubt that even if the average level of education is bad, this system guarantees that the best become very good and much better than students with similar native qualities who have stayed in high school in the middle of less capable colleagues, while being not taught things deemed too difficult for the general population. Moreover, the author has mentioned that the state provides rewards for good results at the International Olympiads, both for teachers and for students.

I do not see what more evidence could be brought. In my opinion the conclusion of the author is well supported and it explains why these students compete successfully against students from much bigger countries.
by Straw | 2025-08-30 07:10:09+00:00
Viewing our space as two complex points instead of four real:

Let H(z) = (z- exp(i theta)) (z - exp(i phi))

H(z) is zero only for our two points. We'll now take the norm^2, to get something that's minimized on only our two chosen points.

|H(exp(i x))|^2 = H(z) x conj(H(z)) = sum from -2 to 2 of c_j x exp(i j x)

For some c_j (just multiply it out). Note that this is just a Fourier series with highest harmonic 2 (or k in general), so in fact our c_j tell us the four coefficients to use.

For a simpler, but numerically nastier construction, instead use (t, t^2, t^3, ...), the real moment curve. Then given k points, take the degree k poly with those zeros. Square it, negate, and we get a degree 2k polynomial that's maximized only on our selected k points. The coefficients of this poly are the coefficients of our query vector, as once expanded onto the moment curve we can evaluate polynomials by dot product with the coefficients.

The complex version is exactly the same idea but with z^k and z ranging on the unit circle instead.
by PeterStuer | 2025-08-30 07:12:11+00:00
With documentation one of the major hurdles is the maintainance. It is caring for a set of documents, created by people with different specializations, that describe the artefact from specific perspectives, but need to be kept in sync with the active creation and evolution of the artefact itself.

This is not impossible, but the effort and costs required are substantial and often lose out on a priority basis to just fixing or improving the product itself.
by MTarver | 2025-08-30 07:13:14+00:00
It wasn't at all what I was expecting. The thread actually opened with a conversation on post-WWII British aircraft manufacturing of all things and got in automated reasoning. ChatGPT made a clever remark on group theory which prompted the paper. From then on the rest followed very quickly. The whole thing was mind-blowing really and archiving it and going away was the only thing to do. I was getting sleep problems.

As regards the research I think the best thing to do in these cases is to feed ChatGPT the paper and start where we left off. This seems to work but it is a bit too early to gauge how well this will work.
by PaulRobinson | 2025-08-30 07:15:13+00:00
I remember reviewing some code of an engineer I was managing at a FAANG. Noticed an edge case. Pointed out I thought if/when that hit, it was going to cause an alarm that would page on-call. He suggested it might be OK to ship because it was "about a one in a million chance of being hit". The service involved did 500,000 TPS. "So, just 30 times a minute, then?"

And you're right about the amount of engineering that goes into solving problems. One service adjacent to my patch was more than a decade old. Was on a low TPS but critical path for a key business problem. Had not been touched in years. Hadn't caused a single page in that decade, just trudged along, really solidly well engineered service. Somebody suggested we re-write it in a modern architecture and language (it was a kind of mini-monolith in a now unfashionable language). Engineering managers and principals all vetoed that, thank goodness - would have been 5+ years of pain for zero upside.
by procaryote | 2025-08-30 07:15:22+00:00
Yeah, it looks like you have somewhat niche requirements and would need to build your own hardware and software.

To run 10+ sata drives you'll either need to take a lot of care they're not spinning up at the same time, or getting used in parallel, or you'll need to dimension your power supply to cope. A beefy power supply will have a higher idle draw making the focus on getting the whole system idle down to 5w pretty hard
by somat | 2025-08-30 07:15:32+00:00
Sort of, They are called Radioisotope Thermoelectric Generator (RTG) used where you need a small amount of super reliable power. Mainly used on deep space missions where there is not enough sunlight. The soviets also used them in unmanned deep north lighthouses.

https://en.wikipedia.org/wiki/Radioisotope_thermoelectric_ge...

Neat tech, but very inefficient, to make it efficient fluids start needing to be moved around which hurts reliability. The next step up are pebble bed reactors, I don't think any have been built but the idea is to have self contained fuel "pebbles" enriched enough to get hot but with enough built in moderation so they can never melt down. Then a traditional heat engine is bolted on.

https://en.wikipedia.org/wiki/Pebble-bed_reactor
by ymyms | 2025-08-30 07:15:59+00:00
I agree with pretty much everything the author has said. I’ve been looking at the problem more on the enterprise side of things: how do you control what agents can and can’t do on a complex private network, let alone the internet.

I’ve actually just built an “identity token” using biscuit that you can delegate however you want after. So I can authenticate (to my service, but it could be federated or something just as well), get a token, then choose to create a delegated identity token from that for my agent. Then my agent could do the same for subagents.

In my system, you then have to exchange your identity token for an authorization token to do anything (single scope, single use).

For the internet, I’ve wondered about exchanging the identity token + a small payment (like a minuscule crypto amount) for an authorization token. Human users would barely spend anything. Bots crawling the web would spend a lot.
by juped | 2025-08-30 07:16:16+00:00
I think all the listed reasons are good reasons to delete tests. I like to keep the test suite running in a single-digit number of seconds. (Sometimes a test you really need takes a while, and you can skip it by default and enable it on the CI test runner or whatever.)

Another one I really agree with is "What if your tests are written so that a one line code change means updating 150 tests?". If you update a test, basically, ever, it's probably a bad test and is better off not existing than being like that. It's meant to distinguish main code with errors from main code without errors; if it must be updated in tandem with main code, it's just a detector that anything changed, which is counterproductive. Of course you're changing things, that's why you fenced them with tests.
Show HN: Keeptalking
by vadimdotme | 2025-08-30 07:16:28+00:00
keeptalking is the easiest-to-use Python LLM client

It's born largely out of my love-hate relationship with [ELL](https://github.com/MadcowD/ell/tree/main/src/ell), namely, my love for their intuitive functional interface and my hate for lack of async support and how complex it is to get structured outputs out of ELL.
by com2kid | 2025-08-30 07:16:41+00:00
It is a lot less if you are aiming to support a small set of platforms, don't need general driver support for everything possible accessory and peripheral under the sun, and if your file system usage is limited.

If you are building for a single abstraction, code gets much simpler, instead of building a platform that multiple abstractions can then be built on top of.
by emptysongglass | 2025-08-30 07:16:42+00:00
Exactly and I'm glad to see this the top comment.

I live in Denmark. I am Danish. Too many people nurse fantasies of the Nordics as some kind of socialist utopia.

The fact is Denmark grows more corrupt by the day. They keep pushing the retirement age so I will be working until I'm 72. Healthcare quality has been dropping for more than 40 years now. The wealthy own the majority of land. We are currently home to a government that is leading the EU in its push for a surveillance mandate that is frankly terrifying in its scope. That same government pushed through the most garbage mega-project I have personally ever witnessed—that we the taxpayers are supposed to fund—despite voter outcry. Digital tenders get sold in backroom deals to a single company that is so ethically bankrupt they've been called out numerous times for workplace violations by our unions.

We're all fucked in the global slide toward authoritarianism and the wealthy's capture of the world economy. And while they get fat supping on our labor we're at each other's throats for who can be crowned the greatest victim.
by nine_k | 2025-08-30 07:17:50+00:00
Un-clickbaiting the title: "Delete useless tests".

I once faced a suite of half-broken tests; so many were broken that engineers stopped caring if their changes broke another test. I suggested to separate a subset of still-working, useful tests, keep them always green, and make them passing a required check in CI/CD. Ignore the rest of the tests for CI/CD purposes. Gradually fix some of the flaky or out-of-sync tests if they are still useful, and promote them to the evergreen subset. Delete tests that are found to be beyond repair (like the article suggests).

This worked.
by tanelpoder | 2025-08-30 07:19:23+00:00
When I'm on the fence about some (technical) decision, I use a "razor": if all options seem equal, go with whichever is the simpler one. The results are ok so far and it has been great for reducing my brain-energy spent on pontification and early optimization too far ahead.

I liked the post, but these kinds of articles do make sense to people who've already been through the trenches & view the advice from their seasoned experience PoV and apply it accordingly. But if people without such experience follow it to the letter just because it's written, can have surprises ahead.
by lionkor | 2025-08-30 07:22:19+00:00
This is a common issue in the Rust world, I think, but I wanted to point it out; I was looking forward to seeing someone build a little minimal JIT for this.

Instead the author uses Cranelift[1] and binja to solve the two interesting problems here.

While cool, I'm not sure if that's interesting enough to read through in its entirety. I use libraries all day every day, but is it the hacker spirit to make your entire project glue-code for libraries that do the thing you claim to do?

It's maybe more philosophical than anything.

1: https://cranelift.dev/
by tsimionescu | 2025-08-30 07:22:27+00:00
You can write many other other kinds of automated tests. Unit tests are rarely worth it, since they only look at the code in isolation, and often miss the forest for the trees if they're the only kind of test you have. But then, if you have other higher level tests that test your components are working well together, they're already implicitly covering that each component individually works well too - so your unit tests for that component are just duplicating the work the integration tests are already doing.
by Nevermark | 2025-08-30 07:22:34+00:00
I completely agree with you from a correctness standpoint, ...

> Diluting the distinction between opt-in and opt-out is gaslighting

> That seems like an ungenerous and frankly somewhat hysterical take.

... however, this comment was a reasonable response.

Projective framing demonstrates your own lack of concern for accuracy, clarity or conviviality, that is 180 degrees at odds with the point you are making and the site you are making it on.
by snovv_crash | 2025-08-30 07:22:51+00:00
Flaky tests: tests should be deterministic. If your tests are flakey in a 100% controlled environment, probably your real system is unreliable too.

Changing business requirements: business logic should be tested separately. It is expected to change, so if all of your tests include it, then yes of course it will be hard to maintain.

Too many tests for the same thing: yeah then maybe delete some of the duplicates?

Taking too long: mock stuff out. Also, maybe reconsider some architectural decisions you made, if your tests take too long it's probably going to bother your customers with slow behaviour too.
by Svip | 2025-08-30 07:23:12+00:00
I primarily work in Danish; but I use a US Intl AltGrDead[0] keymap, so I can access most needed symbols without the compose key, such as æ (altgr+z), ø (altgr+l) and å (altgr+w). But I still wanted to write ⅚ more easily, so I also added the compose key for even more symbols.

[0] The AltGrDead variant just means that the regular dead keys on the US Intl are flipped; e.g. ' is now no longer dead per default: I have to hit altgr+' to make it dead (i.e. an acute accent (´)).
by PeterStuer | 2025-08-30 07:23:15+00:00
Documenting what is there usually is not the hard part (and AI is getting pretty good at that part btw).

Documenting how to use or interact with it in a specific context, which often includes perspectives on interactions with other components, or e.g. protocols not explicit in the code, deciding where to draw the lines of what can assumed trivial common knowledge and what should be specified or explicitly not specified without notices not to rely on these etc. , that is a different thing.

If it wasn't, then truly as they used to say, the source code would be it's own best documentation (I am a big fan of programming for readability, but even the best readable code, while it will be correct and up to date, will never be enough nor the best for all)
by egeozcan | 2025-08-30 07:23:45+00:00
At one of the companies I worked with when I was doing consulting, they could make the slow tests, which used to take around 3 hours, run much faster and in parallel by throwing engineering and hardware resources at the problem. First it was 30 minutes, then it was 10, then around 2-3 minutes.

I think it was one of the best investments that company made.

So my point is, don't delete slow tests, just make them fast.
by lo_zamoyski | 2025-08-30 07:24:14+00:00
I would first caution against reducing education to the practical and the economic. Education is much more, and much more important, that just that.

Second, I would caution against the trope that invention is some exclusive province of the "genius".

That out of the way, we can look to network effects. Consider that a populace with high literacy will permit more of the kind of collaboration that has literacy as a prerequisite, while one with low literacy and a few outliers won't. The outliers are constrained in how much they can collaborate, and collaboration is essential to scientific and economic development.