MurphyA/hacker-news huggingface dataset:
by swores | 2025-08-21 09:34:27+00:00
"In Europe" is technically true but makes it sound more widely used than I believe it to be... though maybe my knowledge is out of date.

Their website lists 24 supported countries (including some non-EU like UK and Norway, and missing a few of the 27 EU countries) - https://www.itsme-id.com/en-GB/coverage

But does it actually have much use outside of Belgium?

Certainly in the UK I've never come across anyone, government or private business, mentioning it - even since the law passed requiring many sites to verify that visitors are adults. I wouldn't even be familiar with the name if I hadn't learned about its being used in Belgium.

Maybe some other countries are now using it, beyond just Belgium?
by tygra | 2025-08-21 09:34:51+00:00
Yo! You’re a serious guy, Jonah!

I run Qwen3 locally for coding and writing. It’s a solid model.

Framework Desktop is becoming really popular. The one with the Max+ 395 and 128GB of RAM is an absolute beast. I might buy a Beelink GTR9 Pro (Max+ 395 with 128GB RAM), which costs around $2,000.

llama.cpp is the real deal. I’m using it as the engine for the product I’m building right now (https://tygra.ai/).
by IanCal | 2025-08-21 09:34:59+00:00
How do you pull out the call? Parse the response? Deal with invalid calls? Encode and tie results to the original call? Deal with error states? Is it custom work to bring in each new api or do you have common pieces dealing with, say, rest APIs or shelling out, etc?

Lots of this isn’t project specific in what you suggest as a better approach.

If your setup keeps working better then it’s probably got a lot of common pieces that could be reused, right? Or do you write the parsing from scratch each time?

If it’s reused, then is it that different from creating abstractions?

As an aside - models are getting explicitly trained to use tool calls rather than custom things.
by brap | 2025-08-21 09:35:22+00:00
You know I really don’t get it. I must be missing something obvious.

Any “tool protocol” is really just a typed function interface.

For decades, we’ve had dozens (hundreds? thousands?) of different formats/languages to describe those.

Why do we keep making more?

Does it really matter who is calling the function and for which purpose? Does it matter if it’s implemented by a server or a command line executable? Does the data transport protocol matter? Does “model” matter?

interface HelloSayer { /** Says hello **/ String sayHello(); }

Here’s your tool protocol bro
by serf | 2025-08-21 09:35:23+00:00
there is more to it than that. it's about modularization as well.

I run LLMs against a 500k LoC poker engine and they do well because the engine is modularized into many small parts with a focus on good naming schemes and DRY.

If it doesn't require a lot of context for an LLM to figure out how to direct effort then the codebase size is irrelevant -- what becomes relevant in those scenarios is module size and the amount of modules implicated with any change or problem-solving. The LLM codebase 'navigation' becomes near-free with good naming and structure. If you code in a style that allows an LLM to navigate the codebase via just an `ls` output it can handle things deftly.

The LLMification of things has definitely made me embrace the concept of program-as-plugin-loader more-so than ever before.
by dns_snek | 2025-08-21 09:35:48+00:00
> You should not make up an enemy that does not exist.

Maybe not by that name, but that enemy is classism and it transcends geography. Many people are quick to make extremely serious moral judgements about less fortunate people because they haven't been in that position.

> There are many otherwise "sane" people that like punishment, many of these people are the ones that has led a life of struggle.

There are many people who don't want others to have it easier than they had it, even when the solution is harmless. Many people even endure unnecessary hardship by choice because it allows them to feel morally superior to everyone else. It may feel compelling but it's not right, and it's not beneficial to society.
by dcanelhas | 2025-08-21 09:35:50+00:00
I think that makes sense and I can tell that you understand the distinction. Formally I believe they're different concepts and think it may cause confusion in some cases to use them interchangeably.

The chaotic nature of a system is one thing.

Our lack of knowledge of the governing laws, initial conditions, feasibility of simulation forcing us to use the mathematical tools of probability (i.e. randomness) to describe our uncertainty about said system is another thing.

The reason why it matters is that a statement like "a double inverted pendulum behaves randomly" is just wrong as it would imply that you couldn't even do a simulation of one in theory without throwing some dice.

However, it is totally uncontroversial that if someone gave you a measured initial position and velocity of one with 'really good' precision and asked you to predict its state 5 seconds forward you would likely have a big smeared-out probability density function to deal with.
GoDaddy misrepresented my $95,000 domain purchase (evidence inside)
by jorikschroder | 2025-08-21 09:35:51+00:00
Yesterday I acquired a premium .ai domain through GoDaddy’s brokerage service for USD 95,000. Their written statements do not align with the reality of the transaction.

What GoDaddy told me (in writing):

“No commission fees are involved in this transaction.”

“The only charges from GoDaddy will be the domain registration fee and the domain price as listed by the seller.”

“The seller’s final asking price [was] USD 95,000.”

What I paid: USD 95,298.98 (95,000 domain + 298.98 registration) by American Express credit card.

The problem: American Express withholds ~3% in merchant fees. Unless GoDaddy itself covers that fee (unlikely), the seller cannot have received USD 95,000.

After the purchase, a GoDaddy manager told me on the phone that “the price of the domain seller is between GoDaddy and the domain seller.” This directly contradicts their earlier written statements that the seller’s final asking price was USD 95,000 and that the only charges from GoDaddy were registration plus the seller’s price.

Why this matters: GoDaddy positions itself as negotiating on behalf of the buyer, but in practice they take the buyer’s maximum, pay the seller less, and keep the difference. If this were disclosed, it would be a different story — but their own emails explicitly say otherwise.

Attached below is part of the email chain (names and domain anonymized, but text intact).

---------

Hi Jorik,

I’m writing to finalize the details regarding the acquisition of the domain [Domain].ai. After extensive negotiations—ranging from offers of $30,000 to $70,000 USD—we did our utmost to secure the domain at a competitive rate. Despite our efforts, the seller declined to accept any offers below $95,000 USD.

After careful consideration and consultation with my sales partner, we’ve agreed to proceed with the purchase at the seller’s final asking price of $95,000 USD.

The seller justified this valuation by noting that single-word .AI domains are increasingly rare and regularly sell for six figures, with many exceeding $150,000 USD. [Domain].ai stands out as a highly versatile and brandable asset—ideal for [Domain] AI, remote work platforms, or automation tools. Its simplicity and memorability add significant value for any forward-looking brand.

To clarify a few key points: No commission fees are involved in this transaction. The only charges from GoDaddy will be the domain registration fee and the domain price as listed by the seller. Our only ask from you is your continued trust and partnership as a valued client.

Your confirmation number for the transaction as we both agreed to charge you in USD currency “3827086014”

Thank you again for your trust and collaboration. Should you have any further questions or require assistance, feel free to reach out.

Cheers to your success!

[Broker Name] Inbound Sales
by dsign | 2025-08-21 09:37:14+00:00
I won't deny your point, but I think we are missing something. China's economy has more cutthroat competition than at least where I live. As such, strict QC is a must for any brand there that wants to survive and have a presence in the West, of which there are quite a few. And those brands still manage to beat domestic ones in price, often with higher quality. My point being, QC and legislation alone can account for the price difference; there has to be other economic factors at play.

Also, I recently watched this: https://www.youtube.com/watch?v=t2TfbN3v8h8 , which may be smoke and mirrors and have me slightly biased. Also, my iphone is made in China.
by fariszr | 2025-08-21 09:38:57+00:00
It matters when the phone is supposed to last more than two years.

Poor battery life is a symptom of a slow CPU, things that don't require full performance on a snapdragon 8 elite take double the time in a pixel while needing full turbo performance.

Don't get me started on the terrible modem efficiency.

These issues are there since the Pixel 6, and Google clearly just doesn't care.
by seba_dos1 | 2025-08-21 09:41:53+00:00
> How is it going to hurt those?

In an endless cat-and-mouse game, it won't.

But right now, it does, as these bots tend to be really dumb (presumably, a more competent botnet user wouldn't have it do an equivalent of copying Wikipedia by crawling through its every single page in the first place). With a bit of luck, it will be enough until the bubble bursts and the problem is gone, and you won't need to deploy Anubis just to keep your server running anymore.
by tucnak | 2025-08-21 09:42:00+00:00
This is insane! We've been training models to write and edit code, and now this? These guys should read this (CodeAct) paper https://arxiv.org/abs/2402.01030

> LLM agents are typically prompted to produce actions by generating JSON or text in a pre-defined format, which is usually limited by constrained action space (e.g., the scope of pre-defined tools) and restricted flexibility (e.g., inability to compose multiple tools). This work proposes to use executable Python code to consolidate LLM agents' actions into a unified action space (CodeAct). Integrated with a Python interpreter, CodeAct can execute code actions and dynamically revise prior actions or emit new actions upon new observations through multi-turn interactions. Our extensive analysis of 17 LLMs on API-Bank and a newly curated benchmark shows that CodeAct outperforms widely used alternatives (up to 20% higher success rate). The encouraging performance of CodeAct motivates us to build an open-source LLM agent that interacts with environments by executing interpretable code and collaborates with users using natural language. To this end, we collect an instruction-tuning dataset CodeActInstruct that consists of 7k multi-turn interactions using CodeAct. We show that it can be used with existing data to improve models in agent-oriented tasks without compromising their general capability. CodeActAgent, finetuned from Llama2 and Mistral, is integrated with Python interpreter and uniquely tailored to perform sophisticated tasks (e.g., model training) using existing libraries and autonomously self-debug.
by ForHackernews | 2025-08-21 09:42:51+00:00
I'm not commenting on the value of this project (I wouldn't characterize captchas as DRM, but I see why you have that negative connotation) and I tend to agree with the OP that this is simply wasting energy, but the amount of seething over "anime catgirls" makes me want to write all the docs for my next projects in UwU text and charge for a whimsy-free version. (o˘◡˘o)
by skrebbel | 2025-08-21 09:43:11+00:00
Cool story! If I may rant off topic a bit though, it boggles my mind that people put stuff like this:

> [This patch] fills holes in executable sections with 0xd4 (ARM) or 0xef (MIPS). These trap instructions were suggested by Theo de Raadt.

into commit messages, but not in the code. What's the cost? What's the downside to having a 2 to 3 line comment above a constant in a C file? Why pretend like all this is super obvious when clearly it isn't?

There seems to be some unwritten cultural rule, particularly in FOSS land, that you're supposed to write code as if you're an all-knowing oracle, as if everything is obvious, and so comments are for losers (as are descriptive variable names). I simply can't understand how and why that developed.
by Symbiote | 2025-08-21 09:45:12+00:00
When the EU [1] implemented these systems they announced it years in advance, delayed the deadline due to Covid disruption, and it's still optional — the alternative is for the receiving post carrier to charge the taxes and an administration fee.

But using this system, I can order something from Ali Express for €10 + €2.50 VAT, pay Ali Express €12.50, and they send the VAT to Denmark. The tracking number on the package proves the VAT was paid, and the package sails through customs.

(There's also a UK system, very similar, but I have forgotten the name of it.)

[1] https://vat-one-stop-shop.ec.europa.eu/index_en
by JdeBP | 2025-08-21 09:45:12+00:00
It's not exploitable. It's an exploit mitigation, in fact. It's not a bug; it's intentional that it works this way. And Nathan Michaels didn't think that if you want to find Theo de Raadt writing on some subject, better try OpenBSD discussion fora, not the LLVM mailing list. (-:

This was put into OpenBSD back in 2017. It's not "trap instructions". It's "trapsleds". The idea is to trap the sleds (a.k.a. slides) of NOP instructions that linkers used to put in between compiled code for alignment, and which could be exploited with "return-oriented programming" where an attacker could cause execution to jump to any address in the padding range (possibly needing the inexactitude because of constraints upon byte substitutions) and slide along all of the NOPs to the target function.

* https://undeadly.org/cgi?action=article;sid=20170622065629

* https://isopenbsdsecu.re/mitigations/trapsled/
by thecupisblue | 2025-08-21 09:45:39+00:00
But now you're limited by the model, provider and the model's adherence to the output.

While using structured outputs is great, it can cause large performance impacts and you lose control over it - i.e. using a smaller model via groq fix the invalid response often times works faster than having a large model generate a structured response.

Have 50 tools? It's faster and more precise to just stack 2 small models or do a search and just pass in basic definitions for each and have it output a function call than to feed it all 50 tools defined as JSON.

While structured response itself is fine, it really depends on the usecase and on the provider. If you can handle the loss of compute seconds, yeah it's great. If you can't, then nothing beats having absolute control over your provider, model and output choice.
by pablo-chacon | 2025-08-21 09:46:39+00:00
Less than a day after I released UrbanOS someone had already cloned it and started experimenting with it. That was a very humbling moment for me. My only hope is that the project spreads and becomes useful for people. The goal of UrbanOS has always been to remain free and serve humanity, so every time I see it picked up or adapted it feels like confirmation of that vision.

For anyone interested, here's the link to the clone repo: UrbanOS PoC NYC adoption: https://github.com/jjiburg/UrbanOS-POC-NYC
by spiderfarmer | 2025-08-21 09:46:42+00:00
I recently tried building something with Meta’s APIs again for the first time in a while.

What a mess. The UI is confusing, the structure makes little sense, and the documentation is often outdated or even contradictory. To top it off, paying for WhatsApp’s Cloud API only works with Visa or Mastercard, while ad payments support many more methods.

I’ve had the same frustrating experience with Microsoft, Google, and Apple. In the end, whichever tech giant offers the best AI APIs will likely still lose ground if their developer experience continues to be this poor.
by rasz | 2025-08-21 09:46:43+00:00
Variable/exempt VAT on certain goods often leads to funny exploitation. In Poland we got a ton of media (games, movies, pr0n) sold as magazines/books to get 8% instead of 22% VAT.

Here an example from CD Project (Witcher and Cyberpunk guys) https://gamerweb.pl/gry-z-serii-gamebook-w-sieci-sklepow-bie... Gamebook, a book bundled with "free" game :)
by CoastalCoder | 2025-08-21 09:46:45+00:00
I understand the sentiment, and I can't control how fine of a distinction you're making.

In fact, you could legitimately blame people like me for not going further to stop the madness.

In my particular case, that could cost me my job, which means losing health insurance for my family and myself. That's a choice I'm making, for sure. To that extent I'm culpable for this situation.
by FuturisticLover | 2025-08-21 09:49:10+00:00
I find IMDb better than RT. RT even though it has an Audience score. It tends to give priority to the Critics' score, which in most cases we know is influential in one way or another.

IMDb score doesn't rely on a group of people, but on all users. It may give a little more weightage to the US users, but that's fine. Its top movies and TV shows make a lot more sense, unlike RT.
by brabel | 2025-08-21 09:50:24+00:00
That's also Clojure's approach. It's very nice to program with immutable data at a high level, but for certain things, you just need to use the computer's primitives as they actually are, with all the mess that entails. So, I would say we need languages like C++ and Java (but perhaps we should all be using Rust, which makes the mess much more manageable, despite bringing in a lot of complexity that programmers need to wrap their head around, by for example, making it really easy to represent data, and defaulting to immutability) even if it would be "nice" to avoid them where possible.

Erlang and Elixir (and Clojure), however, lack a static type system, which makes it really difficult to use them at large scale (I am happy if you can provide convincing evidence to the contrary - I just haven't seen any). There's Gleam, which is a beautiful, simple language, that has a very good type system, but unfortunately, it's a bit too simple and makes certain things harder, like serialization (e.g. https://hexdocs.pm/gleam_codec/).

Haskell and Ocaml are more usable, but for some reason are extremely niche. I don't think there's any popular language that's in the "statically typed, functional" school, which I think shows that humans just don't prefer using them (they have been hyped for decades now, yet they just never stick). Perhaps a new generation of these languages will change things, like Unison for example (which stays away from Monads but provide an arguably superior abstraction, Abilities - also known as Effects). I think I would love for that to happen, though as I said before: sometimes you still need to reach out for bare metal performance and you have to use Rust/C++/D or even Java.
Show HN: DDNS-go – Over-engineered DDNS service with native OS integrations
by database64128 | 2025-08-21 09:50:39+00:00
I have this tendency to over-engineer things, and sometimes it can be a good learning opportunity. ddns-go is what happens when you take DDNS seriously, and try to do everything in the most efficient way possible.

On Linux it opens a netlink socket and listens for network interface changes. If you use WireGuard for all outgoing traffic, and still want to be able to handle incoming connections from the physical interface, ddns-go can even help you maintain the policy routing rules (see ip-rule(8)).

On the BSDs it opens a route(4) socket for the same thing, except it is a bit more complicated here because for historical reasons the messages do not contain IPv6 address flags. You have to call ioctl(2) to retrieve the flags, if you want to filter out deprecated and temporary IPv6 addresses.

On Windows ddns-go uses the IP Helper API to get notified for interface address changes. Of course the API does not behave quite like how the documentation describes, so there needs to be workarounds.

ddns-go also speaks asuswrt's web API and can get the WAN IPv4 address directly from the router.

As a result of working on this project, I sent 3 separate CLs to the x/sys module.

[1] https://go-review.googlesource.com/c/sys/+/597915

[2] https://go-review.googlesource.com/c/sys/+/598895

[3] https://go-review.googlesource.com/c/sys/+/603755
by comrade1234 | 2025-08-21 09:51:06+00:00
The article is mostly about duties. If you buy from someone outside of Switzerland that doesn't take care of the customs fees it's a pain for you. I once bought something that was only around 40chf from someone in the eu but then had to pay an extra ~40chf to Swiss customs for tax + plus handling fees (they had to open the box, inspect it, repackage it and send it to me).
by thecupisblue | 2025-08-21 09:52:10+00:00
You parse it. Invalid calls you revalidate with a model of your choice. Parsing isn't a hard to solve thing, it's easy and you can parse whatever you want. I've been parsing responses from LLM's since days of Ada and DaVinci where they would just complete the text and it really isn't that hard.

> Deal with invalid calls? Encode and tie results to the original call? Deal with error states? Is it custom work to bring in each new api or do you have common pieces dealing with, say, rest APIs or shelling out, etc?

Why would any LLM framework deal with that? That is your basic architecture 101. I don't want to stack another architecture on top of an existing one.

>If it’s reused, then is it that different from creating abstractions?

Because you have control over the abstractions. You have control over what goes into the context. You have control over updating those abstractions and prompts based on your context. You have control over choosing your models instead of depending on models supported by the library or the tool you're using.

>As an aside - models are getting explicitly trained to use tool calls rather than custom things.

That's great,but also they are great at generating code and guess what the code does? Calls functions.
by lazyasciiart | 2025-08-21 09:52:23+00:00
Every business that wants to send something to the UK is required to register with the British government and collect VAT on items shipped to Britain. So yes, the US could have a system like that - just get a couple DOGE kids to vibe code it tomorrow, huh.

https://taxsummaries.pwc.com/united-kingdom/corporate/other-...
by mschuster91 | 2025-08-21 09:52:33+00:00
> As such, strict QC is a must for any brand there that wants to survive and have a presence in the West, of which there are quite a few.

The thing is, there are three ways to survive as a company. The one way is establishing a brand like Ecoflow, DJI, Anker, and do what you suggest. The second one is to produce directly for some large Western brand (either as contract manufacturer or ODM). The final way is to just flood the Western markets with cheap garbage and alphabet-soup brands, and make up the lower margins in sales volume. There can't be that many companies making and selling PL259 adapters as there are "brands" on Amazon selling them, after all.
by __MatrixMan__ | 2025-08-21 09:53:01+00:00
I think that the overwhelming majority of orgs are too inflexible to just insert LLM access, step back, and ask of it was an improvement.

I think you're more likely to see an effect if you can somehow capture how far a solo founder gets before they need to bring on the second employee. Because LLMs aren't better than me at my job, but they are better than me at many jobs which I can tolerate being done poorly.

If there is a significant technological shift, it'll be when those startups start outperforming the ones for which LLMs weren't available at the start.