frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

Show HN: Terminal UI for AWS

https://github.com/huseyinbabal/taws
209•huseyinbabal•7h ago•97 comments

Why does a least squares fit appear to have a bias when applied to simple data?

https://stats.stackexchange.com/questions/674129/why-does-a-linear-least-squares-fit-appear-to-ha...
169•azeemba•7h ago•46 comments

Lessons from 14 Years at Google

https://addyosmani.com/blog/21-lessons/
902•cdrnsf•12h ago•417 comments

During Helene, I just wanted a plain text website

https://sparkbox.com/foundry/helene_and_mobile_web_performance
33•CqtGLRGcukpy•1h ago•23 comments

The unbearable joy of sitting alone in a café

https://candost.blog/the-unbearable-joy-of-sitting-alone-in-a-cafe/
472•mooreds•13h ago•287 comments

The Showa Hundred Year Problem

https://www.dampfkraft.com/showa-100.html
24•polm23•5d ago•5 comments

Street Fighter II, the World Warrier (2021)

https://fabiensanglard.net/sf2_warrier/
329•birdculture•13h ago•56 comments

Linear Address Spaces: Unsafe at any speed (2022)

https://queue.acm.org/detail.cfm?id=3534854
125•nithssh•4d ago•86 comments

The year of the 3D printed miniature and other lies we tell ourselves

https://matduggan.com/the-year-of-the-3d-printed-miniature-and-other-lies-we-tell-ourselves/
111•sagacity•6d ago•75 comments

Ripple, a puzzle game about 2nd and 3rd order effects

https://ripplegame.app/
90•mooreds•9h ago•24 comments

I charged $18k for a Static HTML Page (2019)

https://idiallo.com/blog/18000-dollars-static-web-page
182•caminanteblanco•2d ago•45 comments

Millennium Challenge: A corrupted military exercise and its legacy (2015)

https://warontherocks.com/2015/11/millennium-challenge-the-real-story-of-a-corrupted-military-exe...
25•lifeisstillgood•4h ago•20 comments

Eurostar AI vulnerability: When a chatbot goes off the rails

https://www.pentestpartners.com/security-blog/eurostar-ai-vulnerability-when-a-chatbot-goes-off-t...
101•speckx•6h ago•29 comments

Six Harmless Bugs Lead to Remote Code Execution

https://mehmetince.net/the-story-of-a-perfect-exploit-chain-six-bugs-that-looked-harmless-until-t...
30•ozirus•3d ago•1 comments

Show HN: An interactive guide to how browsers work

https://howbrowserswork.com/
184•krasun•12h ago•29 comments

Web development is fun again

https://ma.ttias.be/web-development-is-fun-again/
311•Mojah•12h ago•395 comments

Agentic Patterns

https://github.com/nibzard/awesome-agentic-patterns
84•PretzelFisch•8h ago•9 comments

The baffling purple honey found only in North Carolina

https://www.bbc.com/travel/article/20250417-the-baffling-purple-honey-found-only-in-north-carolina
11•rmason•4d ago•1 comments

The great shift of English prose

https://www.worksinprogress.news/p/english-prose-has-become-much-easier
37•dsubburam•4d ago•26 comments

Moiré Explorer

https://play.ertdfgcvb.xyz/#/src/demos/moire_explorer
136•Luc•14h ago•17 comments

Show HN: Hover – IDE style hover documentation on any webpage

https://github.com/Sampsoon/hover
41•sampsonj•9h ago•18 comments

Show HN: An LLM-Powered PCB Schematic Checker (Major Update)

https://traceformer.io/
34•wafflesfreak•6h ago•15 comments

Anti-aging injection regrows knee cartilage and prevents arthritis

https://scitechdaily.com/anti-aging-injection-regrows-knee-cartilage-and-prevents-arthritis/
216•nis0s•12h ago•78 comments

Bison return to Illinois' Kane County after 200 years

https://phys.org/news/2025-12-bison-illinois-kane-county-years.html
127•bikenaga•5d ago•39 comments

FreeBSD Home NAS, part 3: WireGuard VPN, routing, and Linux peers

https://rtfm.co.ua/en/freebsd-home-nas-part-3-wireguard-vpn-linux-peer-and-routing/
148•todsacerdoti•15h ago•8 comments

Trellis AI (YC W24) is hiring engineers to build AI agents for healthcare access

https://www.ycombinator.com/companies/trellis-ai/jobs/ngvfeaq-member-of-technical-staff-full-time
1•macklinkachorn•10h ago

Using Hinge as a Command and Control Server

https://mattwie.se/hinge-command-control-c2
95•mattwiese•13h ago•46 comments

How I archived 10 years of memories using Spotify

https://notes.xdavidhu.me/notes/how-i-archived-10-years-of-memories-using-spotify
89•xdavidhu•12h ago•40 comments

Claude Code On-the-Go

https://granda.org/en/2026/01/02/claude-code-on-the-go/
232•todsacerdoti•7h ago•162 comments

Stop Forwarding Errors, Start Designing Them

https://fast.github.io/blog/stop-forwarding-errors-start-designing-them/
81•andylokandy•8h ago•47 comments
Open in hackernews

Scaling Latent Reasoning via Looped Language Models

https://arxiv.org/abs/2510.25741
78•remexre•1d ago

Comments

kelseyfrog•1d ago
If you squint your eyes it's a fixed iteration ODE solver. I'd love to see a generalization on this and the Universal Transformer metioned re-envisioned as flow-matching/optimal transport models.
kevmo314•1d ago
How would flow matching work? In language we have inputs and outputs but it's not clear what the intermediate points are since it's a discrete space.
Etheryte•1d ago
One of the core ideas behind LLMs is that language is not a discrete space, but instead a multidimensional vector field where you can easily interpolate as needed. It's one of the reasons LLMs readily make up words that don't exist when translating text for example.
kevmo314•1d ago
Not the input and output though, which is the important part for flow matching modeling. Unless you're proposing flow matching over the latent space?
cfcf14•16h ago
This makes me think it would be nice to see some kinda child of modern transformer architecture and neural ODEs. There was such interesting work a few years ago on how neural ode/pdes could be seen as a sort of continuous limit of layer depth. Maybe models could learn cool stuff if the embeddings were somehow dynamical model solutions or something.
the8472•1d ago
Does the training process ensure that all the intermediate steps remain interepretable, even on larger models? Not that we end up with some alien gibberish in all but the final step.
oofbey•1d ago
Training doesn’t encourage the intermediate steps to be interpretable. But they are still in the same token vocabulary space, so you could decode them. But they’ll probably be wrong.
the8472•23h ago
token vocabulary space is a hull around human communication (emoji, mathematical symbols, unicode scripts, ...), inside that there's lots of unused representation space that an AI could use to represent internal state. So this seems to be bad idea from an safety/oversight perspective.

https://openai.com/index/chain-of-thought-monitoring/

oofbey•22h ago
What is a bad idea? Allowing reasoning to happen in continuous space instead of discrete token space? This paper can be seen as a variant of the Coconut models (continuous chain of thought). Continuous reasoning is certainly more efficient when it works. Lack of interpret ability makes certain safety systems harder to enforce. Is that your point?
the8472•16h ago
Yes. Coconut has the same issue. See also: a joint statement by researchers from several labs about CoT monitorability: https://arxiv.org/abs/2507.11473
oofbey•9h ago
Interesting. Thanks for the reference!

It's hard to know which way this will go. Discrete/text reasoning has many advantages. Safety as you note. Interpretability, which is closely related. Interoperability - e.g. the fact that you can switch models mid-discussion in Cursor and the new model understands the previous model's CoT just fine, or the ability to use reasoning traces from a larger model to train a smaller model to reason.

Continuous latent reasoning is a big hassle, but wins on efficiency, and in some situations I'm sure people will decide that benefit is worth the hassle. Because efficiency is fighting physics, which is hard to argue with on small devices with batteries. So my guess is that we'll see some of each approach in the future - with most cloud stuff being discrete, and a few highly-tuned edge applications being continuous.

Safety is a multi-faceted problem. I think it's easy to over-index on it because the impacts can be so huge. But there are so many different ways to approach the problem, and we must not rely on any one of them. It's like cyber-security - you need to use defense in depth. And sometimes it makes sense to sacrifice one kind of protection in order to get some convenience. e.g. if you decide to use continuous reasoning, that probably means you need to write a custom classifier to detect mal-intent rather than relying on an off-the-shelf LLM to analyze the reasoning trace. So I wouldn't ever take a position like "nobody should ever use continuous reasoning because it's too dangerous" - it just means that kind of safety protection needs to be applied differently.

lukebechtel•1d ago
so it's:

output = layers(layers(layers(layers(input))))

instead of the classical:

output = layer4(layer3(layer2(layer1(input))))

oofbey•1d ago
Yeah if layers() is a shortcut for layer4(layer3(layer2(layer1(input)))). But sometimes it’s only

output = layers(input)

Or

output = layers(layers(input))

Depends on how difficult the token is.

remexre•10h ago
Or more like,

    x = tokenize(input)
    i = 0
    do {
      finish, x = layers(x)
    } while(!finish && i++ < t_max);
    output = lm_head(x)
oofbey•3h ago
That’s closer still. But even closer would be:

    x = tokenize(input)
    i = 0
    finish = 0
    do {
      p, x = layers(x)
      finish += p
    } while(finish < 0.95 && i++ < t_max);
    output = lm_head(x)
Except the accumulation of the stop probabilities isn’t linear like that - it’s more like a weighted coin model.