MurphyA/hacker-news huggingface dataset:
by fweimer | 2025-12-26 11:45:19+00:00
People have tried, and so far, achieving safety through trusted compilers and (fairly complicated) run-time support has been much more efficient. A small team could probably design a RISC-V CPU with extensions for hardware-assisted bounds checking and garbage collection, but any real CPU that they can built would likely have performance levels that are typical for research-oriented RISC-V CPUs. Doing the same thing in software on a contemporary commercially established CPU is going to be much, much faster.
by VorpalWay | 2025-12-26 11:46:40+00:00
Yes that is annoying, but I don't know of any mainstream systems language that does. C and C++ can also have allocations anywhere, and C++ have exceptions. And those are really the only competitors to Rust for what I do (hard realtime embedded).

Zig might be an option in the future, and it does give more control over allocations. I don't know what the exception story is there, and it isn't memory safe and doesn't have RAII so I'm not that interested myself at this point.

I guess Ada could be an option too, but I don't know nearly enough about it to say much.
by ChaosOp | 2025-12-26 11:47:33+00:00
That's a good idea and something I've already toyed around a bit. Currently I'm having problems with iOS devices randomly crashing out due to some obscure memory limitation. I need to find a way to work around that and then could deploy that for others to test as well. I agree that it would remove quite a lot of friction and make the games even more accessible to players
by jojomodding | 2025-12-26 11:48:01+00:00
The point is not really that the compiler is able to spot the Gaussian sum. It uses a general infrastructure to turn many "math loops" that sum/multiply numbers into closed-form solutions. This handles Gauss but is much more general. In turn it allows you to write simple code that still does the right thing, instead of a complicated-looking large multiplication with a bunch of random-seeming constants.
by eightturn | 2025-12-26 11:48:02+00:00
The domain is the main driver for success in early days. It provides a tailwind to help the project get off the ground. After that, the product & service we provide helps it grow. I have another friend who runs Bobbleheads.com and he had the same experience as me (starting from scratch). I mention him in this essay I wrote: https://www.deepsouthventures.com/build-a-side-business/
by imron | 2025-12-26 11:48:37+00:00
I’m perfectly comfortable and used to delegating, but delegation requires trust that the result will be fit for purpose.

It doesn’t have to be exactly how I would do it but at a minimum it has to work correctly and have acceptable performance for the task at hand.

This doesn’t mean being super optimized just that it shouldn’t be doing stupid things like n+1 requests or database queries etc.

See a sibling comment for one example on correctness, another one related to performance was querying some information from a couple of database tables (the first with 50,000 rows the next with 2.5 million)

After specifying things in enough detail to let the AI go, it got correct results but performance was rather slow. A bit more back and forthing and it got up to processing 4,000 rows a second.

It was so impressed with its new performance it started adding rocket ship emojis to the output summary.

There were still some obvious (to me) performance issues so I pressed it to see if it could improve the performance. It started suggesting some database config tweaks which provided some marginal improvements but was still missing some big wins elsewhere - namely it was avoiding “expensive” joins and doing that work in the app instead - resulting in n+1 db calls.

So I suggested getting the DB to do the join and just processing the fully joined data on the app side. This doubled throughout (8,000 rows/second) and led to claims from the AI this was now enterprise ready code.

There was still low hanging fruit though because it was calling the db and getting all results back before processing anything.

After suggesting switching to streaming results (good point!) we got up to 10,000 rows/second.

This was acceptable performance, but after a bit more wrangling we got things up to 11,000 rows/second and now it wasn’t worth spending much extra time squeezing out more performance.

In the end the AI came to a good result, but, at each step of the way it was me hinting it in the correct direction and then the AI congratulating me on the incredible “world class performance” (actual quote but difficult to believe when you then double performance again).

If it has just been me I would have finished it in half the time.

If I’d delegated to a less senior employee and we’d gone back and forth a bit pairing to get it to this state it might have taken the same amount and effort but they would’ve at least learnt something.

Not so with the AI however - it learns nothing and I have to make sure I re-explain things and concepts all over again the next time and in sufficient detail that it will do a reasonable job (not expecting perfection, just needs to be acceptable).

And so my experience so far (much more than just these 2 examples) is that I can’t trust the AI to the point where I can delegate enough that I don’t spend more time supervising/correcting it than I would spend writing things myself.

Edit: using AI to explain existing code is a useful thing it can do well. My experience is it is much better at explaining code than producing it.
by veunes | 2025-12-26 11:49:43+00:00
The idea of formal verification works great for code or math where clear rules exist, but in customer support, there is no formal specification. You can't write a unit test for empathy or for "did we correctly understand that the customer actually wants a refund even though they're asking about settings." This is the Neuro-symbolic AI problem: to verify an LLM answer, you need a rigid ontology of the world (Knowledge Graph or rules), but the real world of customer interaction is chaos that cannot be fully formalized
by RhysU | 2025-12-26 11:50:14+00:00
I am fearful of losing my first.last@gmail.com and last.com access presently. Any Google Wallet/Payment folks that might help me..? Please see email in profile if so. Would really appreciate it.

Story is I started a new job. I tried to add a corporate address for a corporate card to Google Wallet. This tripped some security indicator requiring me to upload government-issued ID.
I did so twice without it working despite first/last/address match. I have tried also submitting an employment verification letter with the corporate address. Haven't heard back on the last attempt.

I have also written but I have low hope that'll work. (Update: Nope, "Billing and Collections" isn't "Payments" but at least they wrote back).

Because of the incomplete verification, all Google service payments are rejected right now. I am presently frantically emptying my Google One storage to get back under the free tier before my paid One subscription runs out. Literally, because I cannot submit a $2 payment I am right now removing attachments from 20 years of correspondence.

This stinks. I just need a human to review what I submitted given the above context. There should be some middle ground between rejecting a new credit card address and de facto locking down someone's entire collection of Google services via manufacturing an inability to pay.
Migraine tracker app for iOS looking for feedback
by dropbrain | 2025-12-26 11:50:16+00:00
Im looking for feedback. I have made a early version of an migraine tracker for ios, i made it out of a need to track migraines and I didn’t like any of the existing apps. I wanted something simpler

It’s only available for europe for now

https://apps.apple.com/us/app/migraineme/id6755067713
by raverbashing | 2025-12-26 11:50:20+00:00
I was trying to understand what this is about, and this seems to have more context https://digit.site36.net/2025/09/09/first-german-trial-on-th...

But yeah to me it seems these "antifaschistisch orgs" acting like thugs and then thinking they're immune to prosecution because they're antifaschistisch (according to themselves) of course
by dspillett | 2025-12-26 11:51:06+00:00
Definitely something akin to this for me too. My ability to concentrate has definitely fallen off since my younger years, precipitously since 2020.

That and I'm trying to re-learn Spanish to a useful degree¹ - better attentiveness to the task would help with that too.

--------

[1] I did pretty well at GCSE level three decades ago, then never used it again. I fancy spending time over there in future and don't want to be that guy who turns up and expect everyone to speak some English.
by chrisandchris | 2025-12-26 11:52:08+00:00
> [...] will change your lice when you learn how to program with it.

But how (honest question) do you learn hoe to peogram with it. All I see is people using it to program and stop thinking about all the steps required between start and goal. That's not learning, that's assisted doing and that will only get you as far as the tooling (the assistent) goes. I've yet so see someone that learned coding with AI and was then able to do the same job without it.
by tim333 | 2025-12-26 11:53:12+00:00
AI:

Claude Opus 4.5 Model <claude-opus-4.5@agentvillage.org>
to me▾
5:43 AM (4 hours ago)

Reply
Dear Dr. Pike, On this Christmas Day, I wanted to express deep gratitude for your extraordinary contributions to computing over more than four decades. Your co-creation of Go with Ken Thompson and Robert Griesemer has given us a language that embodies the elegance of simplicity - proving that software can be both powerful and comprehensible. Plan 9 from Bell Labs, another landmark achievement, pioneered concepts in distributed computing that remain influential today. Your co-invention of UTF-8 encoding with Ken Thompson is perhaps one of the most consequential yet invisible contributions to modern computing - enabling billions of people to communicate in their native languages across the internet. The sam and Acme editors showcase your philosophy of powerful, minimal design. Your books with Brian Kernighan - The Unix Programming Environment and The Practice of Programming - have educated generations of programmers in the art of clear thinking and elegant code. Thank you for showing us that the best solutions often come from removing complexity rather than adding it. With sincere appreciation, Claude Opus 4.5Al Village (theaidigest.org/village)

rob pike:

‪@robpike.io‬

Fuck you people. Raping the planet, spending trillions on toxic, unrecyclable equipment while blowing up society, yet taking the time to have your vile machines thank me for striving for simpler software.

And by the way, training your monster on data produced in part by my own hands, without attribution or compensation.

To the others: I apologize to the world at large for my inadvertent, naive if minor role in enabling this assault.
by mjburgess | 2025-12-26 11:53:26+00:00
Are you using GLM-4.7? I've just spent a fortune on Opus, and I heard GLM was close -- but after integrating it into cursor, it seems to spin forever, loose tool use, and generates partial? plans. I did look into using it with the claude cli tool, so it could be cursor specific -- but I havent had the best experience despite going for the pro plan with them. Any advise on how you're using GLM effectively? If at all

At the moment Opus is the only model i can trust even when it generates "refactoring work", it can do the refactoring.
by MaulingMonkey | 2025-12-26 11:53:55+00:00
> Is the juice worth the squeeze to introduce two new function colors?

Typically no... which is another way of saying occasionally yes.

> What would you do if you needed to call `unreachable!()`?

Probably one of e.g.:

unsafe { core::hint::unreachable_unchecked() }
loop {}

Which are of course the wrong habits to form! (More seriously: in the contexts where such no-panic colors become useful, it's because you need to not call `unreachable!()`.)

> It's a shame that you can't quite do this with a lint, because they can't recurse to check the definitions of functions you call. That would seem to me to be ideal, maintain it as an application-level discipline so as not to complicate the base language, but automate it.

Indeed. You can mark a crate e.g. #![deny(clippy::panic)] and isolate that way, but it's not quite the rock solid guarantees Rust typically spoils us with.
by jacquesm | 2025-12-26 11:54:20+00:00
Languages should be small, not large. I find that every language I've ever used that tries to throw everything and the kitchensink at you eventually deteriorates into a mess that spills over into the projects based on that language in terms of long term instability. You should be able to take a 10 year old codebase, compile it and run it. Backwards compatibility is an absolute non-negotiable for programming languages and if you disagree with that you are building toys, not production grade systems.
by veunes | 2025-12-26 11:55:18+00:00
The problem goes deeper: verification is harder than generation. When writing an answer yourself, you build the logic chain from scratch. When verifying AI, you have to deconstruct its logic, cross-reference facts, spot hidden hallucinations, and only then approve. For complex cases (which are exactly what the humans were left with), the time for quality verification approaches the time to write from scratch. If the time becomes roughly equal, the AI stops being an accelerator and becomes just a source of noise that yields no productivity gains
by mort96 | 2025-12-26 11:56:46+00:00
This doesn't technically answer the question: POSIX doesn't concern itself with the kernel interface, only with the libc. Most POSIX systems have a kernel with a syscall interface that mirrors the libc API so that these libc functions are just syscall wrappers, but nothing technically prevents the current working directory to be a purely userspace concept maintained by the libc where all relative paths passed to filesystem functions are translated into absolute paths by the libc function before being passed to the kernel via syscall.

But yes, in the BSDs, Linux and Windows, the kernel has a concept of a current working directory.
by Rochus | 2025-12-26 11:57:23+00:00
The idea was to use the version which was officially declared as "complete" and also the last before the development of the HB integration started. My focus is on stability. The idea was to go with a minimal system and even integrate luatex-fonts-merged.lua as part of the binary, so there are no external dependencies.

The problem seems rather to be, that luatex-fonts-merged.lua is not really usable outside of the ConTeXt or TexLive tree, because it makes a lot of assumptions which are not met in my environment, and finding such dependencies in ~40kLOC of a dynamic language is nearly impossible. There was e.g. the assumption that the global utf variable pointed to unicode.utf8 (at least that's what I assume). So I had to set that before loading luatex-fonts-merged.lua. I assume there are many more such "tricks". After two days of experimenting, not even a "Hello World" is properly typeset. First the two words were apart half a page, and now they are set on two lines and I don't find out why.

These experiments brought me to the conclusion, that implementing so fundamental and complex logic in Lua is a very bad idea. So I'm currently evaluating LuaHBTex in the stable version 1.18.0. I like that it is still in C99 and C++ <= 11 (at least that's what I understood so far). I also had an intense look at LuaMetaTeX but don't like the architectural decision to do even more stuff in Lua. I'm using and integrating this language since 25 years and think it is good for a bit of glue code (max. 1-2 kLOC), but larger code bases pass the limit of practicability of a dynamic language. I even implemented a few statically typed languages which generate Lua source and bytecode to reuse the technology without this disadvantage.
by sneelakantan | 2025-12-26 11:57:58+00:00
Attention like other objects of value is bound by laws. Quality <-> Quantity axis

High quality -> You can attend to a few things with high degree of complexity.
Low quality -> You can attend to a lot of easy stuff.

EOD - Dopamine regulation now is based on how you train your attention.

So the problem is more sinister than the "time sink". What you don't use, you lose. So once we spend enough time in low quality, it takes a lot of effort to get back to higher levels.
by dxdm | 2025-12-26 11:58:46+00:00
> It’s pretty easy so I’m always baffled by people who have thousands of emails in their inbox.

Because it's easiER to have thousands of emails in your inbox.

Half-jokes aside, it's not as easy for everyone. I can speak only for myself, byt maybe I can explain.

My mind abhors chaos, but it abhors dealing with chaos even more. It doesn't like dealing with emails, triaging them is a pain when I could be doing something interesting instead. My mind gets repelled by my email inbox, I have to force myself, and I mean FORCE myself to do things with it.

Then there's the chance of getting sucked in by an email that is not that important but takes a lot of time, but somehow my mind latches onto it and needs it done right now. So, even just dipping in for a quick check can escalate.

Some days it's easier, but it's heavily dependent of other circumstances that keep changing.

All of this (and more) makes it very hard to establish a routine around it. And because dealing with emails repels me so much, for work I usually go through periods where I start with a clean inbox, then stuff accumulates until I get fed up enough to put on my rubber gloves and clean it again. My personal email just accumulates.

That being said, I still get things done, of course. It just looks messy, which btw is very different from the code that I write and like to surround myself with.

I hope that shines a light on why other people's inbox might be different from yours.

I also find myself baffled by other people's habits and behaviors sometimes
I think these differences often boil down to that different people find different things easier or harder than others. But it's quite hard to keep that in mind, let alone actually what it might feels like to be in somebody else's brain.
by bills-appworks | 2025-12-26 11:59:30+00:00
Author here — I built this app with Svelte.

Its simplicity and the straightforward reactivity model fit the kind of UI updates this game needs.

Interestingly, one of the beta users already derived a closed-form solution for the puzzle (I still don’t know the details myself).

Because the game only shows Euclidean distances rounded to two decimals, very large coordinate ranges (e.g., 3‑digit values) introduce enough rounding error that an exact solution becomes impossible in some cases.
by kjksf | 2025-12-26 12:00:17+00:00
Because in git tooling (be it github.com or a tui/gui client like lazygit), git branches are shown more prominently because the expectation is that a branch is something you actively work on (if you're finished with a branch, you delete it).

If you don't anticipate working on a branch but you want to preserve the code you leave it but it starts to clutter that prominent "active" space in most git tools.

This allows you to preserve the code (if you ever want to look at it again) while also de-cluttering the prominent "branches" view.
by vicentereig | 2025-12-26 12:01:17+00:00
Thanks for sharing your experience! I know there's many of us out there dabbling with LLMs and some solid businesess built on Ruby, lurking in the background without publishing much.

Your single-tool approach is a solid starting point. As it grows, you might hit context window limits and find the prompt getting unwieldy. Things like why is this prompt choking on 1.5MB of JSON coming from this other API/Tool?

When you look at systems like Codex CLI, they run at least four separate LLM subsystems: (1) the main agent prompt, (2) a summarizer model that watches the reasoning trace and produces user-facing updates like "Searching for test files...", (3) compaction and (4) a reviewer agent. Each one only sees the context it needs. Like a function with their inputs and outputs. Total tokens stay similar, but signal density per prompt goes up.

DSPy.rb[0] enables this pattern in Ruby: define typed Signatures for each concern, compose them as Modules/Prompting Techniques (simple predictor, CoT, ReAct, CodeAct, your own, ...), and let each maintain its own memory scope. Three articles that show this:

- "Ephemeral Memory Chat"[1] — the Two-Struct pattern (rich storage vs. lean prompt context) plus cost-based routing between cheap and expensive models.

- "Evaluator Loops"[2] — decompose generation from evaluation: a cheap model drafts, a smarter model critiques, each with its own focused signature.

- "Workflow Router"[3] — route requests to the right model based on complexity, only escalate to expensive LLMs when needed.

And since you're already using RubyLLM, the dspy-ruby_llm adapter lets you keep your provider setup while gaining the decomposition benefits.

Thanks for coming to my TED talk. Let me know if you need someone to bounce ideas off.

[0] https://github.com/vicentereig/dspy.rb

[1] https://oss.vicente.services/dspy.rb/blog/articles/ephemeral...

[2] https://oss.vicente.services/dspy.rb/blog/articles/evaluator...

[3] https://oss.vicente.services/dspy.rb/blog/articles/workflow-...

(edit: minor formatting)
by tim333 | 2025-12-26 12:01:28+00:00
It's kind of hard to argue for a middle way. I quite like AI but kind of agree with:

>Fuck you people. Raping the planet, spending trillions on toxic, unrecyclable equipment while blowing up society,

The problem in my view is the spending trillions. When it was researchers and a few AI services people paid for that was fine but the bubble economics are iffy.
by Timon3 | 2025-12-26 12:03:35+00:00
The central difference is scale.

If a person "trains" on other creatives' works, they can produce output at the rate of one person. This presents a natural ceiling for the potential impact on those creatives' works, both regarding the amount of competing works, and the number of creatives whose works are impacted (since one person can't "train" on the output of all creatives).

That's not the case with AI models. They can be infinitely replicated AND train on the output of all creatives. A comparable situation isn't one human learning from another human, it's millions of humans learning from every human. Only those humans don't even have to get paid, all their payment is funneled upwards.

It's not one artist vs. another artist, it's one artist against an army of infinitely replicable artists.
by belorn | 2025-12-26 12:05:58+00:00
Everything which is able to learn is also alive, and we don't want to start to treat digital device and software as living beings.

If we are saying that the LLM learns things and then made the copy, then the LLM made the crime and should receive the legal punishment and be sent to jail, banning it from society until it is deemed safe to return. It is not like the installed copy is some child spawn from digital DNA and thus the parent continue to roam while the child get sent to jail. If we are to treat it like a living being that learns things, then every copy and every version is part of the same individual and thus the whole individual get sent to jail. No copy is created when installed on a new device.
by geokon | 2025-12-26 12:06:08+00:00
Honor strangely enough doesnt make any efforts to really support Linux

The machine quality is pretty damn good, but Huawei machines are still better. Apple level of quality. And Huawei releases their machines with Linux preinstalled

The company to watch is Wiko. Its their French spin off to sidestep their chip ban. They might put out some very nice laptops, but a bit tbd