MurphyA/hacker-news huggingface dataset:
Show HN: I built a dependency graph for the tree of human science
by sleepybear04 | 2026-02-22 07:43:27+00:00
Hi HN,
I’ve always been frustrated by this: we live in an era of exponential scientific progress, but almost no one can clearly trace a cutting-edge discovery back to the first principles it’s built on. We learn science in silos, not as a connected, logical tree.
So I built The Map of Science — an interactive dependency graph for the entirety of human scientific knowledge.
It’s simple: every scientific theory is a node, every derivation/dependency is an edge. You can trace a path from basic math axioms to quantum field theory, from early computing to modern LLMs, and see exactly how each breakthrough builds on what came before.
The stack: React + Cytoscape for the frontend, Node.js + Neo4j for the backend (a relational DB couldn’t handle the deep recursive queries for multi-layer derivation chains). It’s fully open source under MIT, and we’ve already seeded the core dataset for math, physics, and computer science.
This is a project that can never be finished by one person. I need your help:
If you’re a domain expert, help us fix incorrect links or expand into biology, chemistry, social sciences, and more.
If you’re a developer, help us optimize the graph rendering for even larger datasets.
If you just love science, tell us what works, what doesn’t, and what you want to see next.
I’d specifically love your thoughts on:
We’re using a directed acyclic graph (DAG) tree structure to show derivation dependencies. Does this make cross-field interdisciplinary links clear enough? Is there a better way to visualize these relationships?
What’s the cleanest way to represent superseded or disputed theories (like Newtonian vs. relativistic mechanics, or phlogiston theory vs. oxidation)? We want to honor their historical importance without cluttering the core, up-to-date knowledge chain.
Repo: https://github.com/slepybear/The-Map-of-Science
Live Demo: https://build-five-dun.vercel.app/map (best viewed on desktop for full graph interactivity)
Thanks for looking!
by YetAnotherNick | 2026-02-22 07:44:00+00:00
I don't know. I tried various methods. And this one kind of doesn't work quite a bit of times. The problem is plan naturally always skips some important details, or assumes some library function, but is taken as instruction in the next section. And claude can't handle ambiguity if the instruction is very detailed(e.g. if plan asks to use a certain library even if it is a bad fit claude won't know that decision is flexible). If the instruction is less detailed, I saw claude is willing to try multiple things and if it keeps failing doesn't fear in reverting almost everything.

In my experience, the best scenario is that instruction and plan should be human written, and be detailed.
by shevy-java | 2026-02-22 07:44:43+00:00
> The I2P development team responded by shipping version 2.11.0 just six days after the attack began.

Not wanting to be overly critical, but any net-infrastructure project kind of has to keep bot-attacks in mind and other attack vectors, in the initial design stage already. Any state-actor (and other actors, though I would assume it is often a state financing the bot network behind-the-scene) can become potentially hostile.
by amatecha | 2026-02-22 07:45:55+00:00
I almost clarified that - Google Search is definitely part of that very centralized, corporate-owned web I was referring to. Like what you're describing is exactly what I'm talking about. But there are more and more niche obscure corners of the internet that you don't easily find, where good stuff is happening. People are still using IRC, Hotline, KDX, Gopher, and then there's newer stuff like Gemini ( https://geminiprotocol.net/ ), and potentially-invite-only close-knit communities on Mastodon and Lemmy. Oh yeah and then there's the alternatives to corporate stuff like Instagram -> PixelFed, YouTube -> PeerTube...
by stingraycharles | 2026-02-22 07:46:51+00:00
I actually have a prompt optimizer skill that does exactly this.

https://github.com/solatis/claude-config

It’s based entirely off academic research, and a LOT of research has been done in this area.

One of the papers you may be interested in is “emotion prompting”, eg “it is super important for me that you do X” etc actually works.

“Large Language Models Understand and Can be Enhanced by Emotional Stimuli”

https://arxiv.org/abs/2307.11760
by hbarka | 2026-02-22 07:47:17+00:00
>> Same reason that "Pretend you are an MIT professor" or "You are a leading Python expert" or similar works in prompts.

This pretend-you-are-a-[persona] is cargo cult prompting at this point. The persona framing is just decoration.

A brief purpose statement describing what the skill [skill.md] does is more honest and just as effective.
by twoelf | 2026-02-22 07:48:01+00:00
Here's Express.js (the npm package, 141 files). Scanned in 551ms on a laptop:

- 1,953 components extracted
- 17,505 typed dependencies mapped (not just "A calls B" — ownership, injection, weak ref, circular, etc.)
- 25 architectural blocks detected automatically
- 498 architectural smells found
- 116 dead code detections
- 100% classification consensus (zero ambiguous)

Component distribution:
Core logic: 425 (21.8%) — app, router, route objects
Terminals: 744 (38.1%) — constants, test assertions
Helpers: 346 (17.7%) — utility functions
State stores: 313 (16.0%) — express, request, Router, factories
Features: 110 (5.6%) — test-specific app instances
Middleware: 10 (0.5%) — andRestrictTo, sendfile
Entry points: 5 (0.3%) — users, restrict, getCookie

Architectural problems detected:
CRITICAL: 532 components in circular dependency chains
ERROR: God Class — `app` has 67 outbound dependencies
ERROR: God Class — `router` has 83 outbound dependencies
Stateful services at 0% health (critical coupling)

Cross-cutting concerns found automatically:
trust proxy logic in request.js (8 components)
response callback chain: onend, onaborted, onerror, onfinish
pure functions — 71 components, 93% health
boundary validators — 98% health

All of this is known to be true by anyone who's worked on Express.
The God Object pattern in `app` is a documented community concern.
The circular deps between app↔router↔request↔response are well-known.

551ms. No LLM. No cloud. Deterministic — same input, same output, every time.

Happy to run it against any public repo if you want to suggest one.
by menaerus | 2026-02-22 07:48:15+00:00
Sure, the workload was with both the readers and the writers, and it was a pretty "bursty" one with high volume of data which had to scale across all the cores. So, not a particularly light workload. It was basically a hi-concurrency cache which was write-mostly in the first-phase (ingestion), and then read-mostly in the second-phase (crunching). It had to support multiple sessions simultaneously at the same time so in the end it was about supporting heavily mixed read-write workloads, e.g. second-phase from session nr. 1 could overlap with the first-phase from session nr. 2.

To avoid the lock contention I managed to get away with sharding across the array of shared-mutexes and load-balancing the sessions by their UUIDs. And this worked pretty well - after almost ~10 years it's still rock solid, and workloads are basically ever changing.

I considered the RCU for this use-case too but I figured that it wouldn't be as good fit because the workload is essentially heavily mixed so I thought it would result with a lot of strain to the memory subsystem by having to handle multiple copies of the data (which was not small).

One thing I don't understand is the priority inversion and how that may happen. I'll think about it, thanks.
by pgt | 2026-02-22 07:49:31+00:00
My process is similar, but I recently added a new "critique the plan" feedback loop that is yielding good results. Steps:

1. Spec

2. Plan

3. Read the plan & tell it to fix its bad ideas.

4. (NB) Critique the plan (loop) & write a detailed report

5. Update the plan

6. Review and check the plan

7. Implement plan

Detailed here:

https://x.com/PetrusTheron/status/2016887552163119225
by Bishonen88 | 2026-02-22 07:49:44+00:00
It was when I mvp'd it 3 weeks ago. Then I removed it as I was toying with the idea of somehow monetizing it. Then I added a few features which would make monetization impossible (e.g. How the app obtains etf/stock prices live and some other things). I reckon I could remove those and put in gh during the week if I don't forget. The quality of the Web app is SaaS grade IMO. Keyboard shortcuts, cmd+k, natural language parsing, great ui that doesn't look like made by ai in 5min. Might post here the link.
by weaxme983 | 2026-02-22 07:52:19+00:00
I'm a backend/infrastructure engineer at Revolut. For years I've been building personal tools the same way I build production systems — client-server, Postgres, CI/CD, monitoring, the works.
Last week I built a budget tracking app with end-to-end encryption, full test coverage, GitHub Actions — and then froze. Why do I need all this for myself?
The article explores a simple realization: for personal apps, mobile-first eliminates entire categories of non-functional requirements. No server = no attack surface, no infra costs, no monitoring. And with Claude Code, I can build iOS apps despite not knowing Swift.
Curious if others have had similar "I'm over-engineering my personal tools" moments.
by AxiomLab | 2026-02-22 07:52:28+00:00
This exact philosophy is why I started treating UI design systems like compilers.

Instead of validating visual outputs after the fact (like linting CSS or manual design reviews), you parse the constraints upfront. If a layout component is strictly typed to only accept discrete grid multiples, an arbitrary 13px margin becomes a compile error, not a subjective design debate. It forces determinism.
by squigz | 2026-02-22 07:52:57+00:00
#2 doesn't seem to consider how much stuff there is out there. Why bother harvesting resources from a gravity-laden planet when you can almost certainly get them from asteroids or other places?

Furthermore, while we may not care about "ants", we do - at least to some degree - care about the impact on wildlife and the environment. Probably not as much as we should, but our concern has only grown over time, so I'm not sure I buy the suggestion that a super-advanced civilization would go the extreme opposite way and not care about the impact it has on "lesser" life forms.
by altmanaltman | 2026-02-22 07:53:39+00:00
> “But it also takes a lot of energy to train a human,” Altman said. “It takes like 20 years of life and all of the food you eat during that time before you get smart. And not only that, it took the very widespread evolution of the 100 billion people that have ever lived and learned not to get eaten by predators and learned how to figure out science and whatever, to produce you.”

This is peak Silicon Valley content.
by ifwinterco | 2026-02-22 07:53:41+00:00
Potentially inflationary yes but would correct the current account deficit and some of the other imbalances (lack of blue collar jobs, excessive financialisation, income inequality) that accompany it.

Not the best way but not completely stupid either.

If you’re interested in this perspective look up Michael Pettis’s work, he explains it better than me.

To be clear, I’m not defending trump, I think he is an idiot. This would be a “stopped clock is right twice a day” situation if he ends up doing it
by stephenbez | 2026-02-22 07:54:08+00:00
Thanks. Are there any links where I can learn more about this?

I did some Googling and it appears that there are some examples where people say combining multiple models or multiple runs of the same models leads to improvements:
https://www.sciencedirect.com/science/article/abs/pii/S00104...
https://arxiv.org/abs/2203.11171

But presumably people are less likely to publish a paper when an approach doesn’t work.
by notpushkin | 2026-02-22 07:56:06+00:00
Okay, I am pleasantly surprised. The fix was to... remove Magisk. Apparently they’re not looking at the Play Integrity, so no workarounds needed. The more you know!

This is way offtopic, so I’ll stop here, but final note in case anybody is looking to get Play Integrity working as well: try the built-in microG implementation first, and if it doesn’t work, go for KernelSU, it seems more stealthy than Magisk. Good luck!
by AnthonyMouse | 2026-02-22 07:58:48+00:00
> Different types of DRAM can literally be made from the same already-etched wafer.

The assumption here is that you would stop making DDR5 but continue to make DDR4 so that you could start making DDR5 again without too much trouble. But the older chips have even lower margins than the newer ones. Most of the fabs and equipment for making DDR4 were created when it was current and then they stay in operation as long as there is still enough demand for it.

If you don't make DDR5 and DDR6, what happens to your DDR4 fabs when DDR4 is where DDR2 is now? They close because nobody wants it anymore. And then you're not trying to get to DDR6 from DDR4, you're trying to get to DDR6 from an empty desert.
by TheSpiceIsLife | 2026-02-22 07:59:53+00:00
Doesn’t South America collectively produce more gold in one year than the Spanish usurped from them in their entire conquest period?

Gold production by country:

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

In only the first half-century or so of the Spanish conquest of the Americas, over 100 tons of gold were extracted from the continent. - https://www.worldhistory.org/article/2045/the-gold-of-the-co...

Context is for kings though. In the context of what occurred when it occurred, you’re right.

For a while there, Australia was known as ‘the lucky country’ because despite the folly of politicians, and general fallibility of humans, we had wealth for toil.

Now we just give it away.
by FreakLegion | 2026-02-22 08:00:03+00:00
That struck me as an odd choice, too. On average there's no difference in false positives, but the smaller the blocks, the more likely they'll be saturated. Since there are 6 leftover bits in the hash anyway, there's no cost to increase the two 5-bit values to 6 bits and the block size to 64. You'll have a lot fewer hot blocks that way.

With blocks this small there's also no reason not to optimize the number of hash functions (albeit this brings back the specter of saturation). There are no cache misses to worry about; all positions can be checked with a single mask.
by IshKebab | 2026-02-22 08:00:13+00:00
> This view is false because what is hard to parse for machines also presents difficulty for humans.

Yes definitely to some extent, but they aren't perfectly aligned. Most languages make things a bit harder to parse for machines but easier for humans. Some get it wrong (e.g. I would say OCaml is hard to parse for humans, and some of C's syntax too like the mental type declaration syntax). I don't think you could say that e.g. Dart is harder to parse for humans than Lisp, even though it's clearly harder for machines.
by somenameforme | 2026-02-22 08:01:05+00:00
What would you say is somebody operating entirely outside the system? When the system specifically included text for dealing with a controversy on how the VP counts the votes, it's rather literally within the system. And that was their big Hail Mary. Trump probably envisioned the Capitol being surrounded by thousands of protesters just chanting or whatnot to encourage Pence to do it.

He certainly would have foreseen at least some shenanigans, but that was probably unavoidable. And they could have been trivially dispersed at any moment by the Capitol Police which not only has a force of thousands, but even has heavy equipment and gear enabling them to respond to even extreme things like an aerial attack on the Capitol. Instead they deployed a tiny fraction of their force with minimal equipment, and just watched things unfold, all while Twitter actively censored Trump saying things like:

- "Please support our Capitol Police and Law Enforcement. They are truly on the side of our Country. Stay peaceful!"

- "I am asking for everyone at the U.S. Capitol to remain peaceful. No violence! Remember, WE are the Party of Law & Order – respect the Law and our great men and women in Blue. Thank you!"

As for the Electoral College, I am saying that you're taking a fringe view that was indeed genuinely held, and then broadly applying it. Hamilton absolutely had a streak of authoritarian elitism in him. And so speaking of the Founding Fathers as a whole, on an issue like this, is not reasonable. Hamilton was highly divisive, and managed to push away just everybody - even those also more in favor of Federalist system.
by dankrieg | 2026-02-22 08:01:21+00:00
TalentClaw is an OpenClaw workflow pack that models hiring as a deterministic system rather than a conversational tool.

Instead of generating candidate lists and leaving the rest to humans, it:
* converts a business goal into explicit role specs (deliverables, success metrics, disqualifiers)
* prioritizes agent-based solutions before sourcing humans
* enriches each candidate with structured, evidence-backed data
* scores candidates using a rubric with hard caps on missing requirements
* enforces pipeline transitions through a PM agent with guarded state changes

All state is persisted in SQLite.
All workflows are defined in YAML.
No hidden context, no implicit transitions.

The pipeline behaves like a state machine:

new → researching → ready_to_contact → screening → trial → hired / rejected

The broader question I’m exploring is whether staffing should be treated more like infrastructure — with explicit state, constraints, and evaluation gates — instead of a sequence of loosely connected conversations.

Interested in feedback on:

* rubric design and failure modes
* agent-first vs human-first sourcing
* where deterministic workflows break down in hiring
by layla5alive | 2026-02-22 08:02:48+00:00
u32AllocCount

u32AllocSumSizeInBytes

f32AllocAvgSizeInKBytes

Its easy to code review the interaction between these - the valid code almost writes itself from the names - lots of operations will just obviously read as wrong in ways that they may not with i.e. num_allocs, total_alloc and avg_alloc, or num, total, avg.

I find it useful to use statically typed variable names. My mental syntax checker benefits from the extra type metadata being embedded at each usage, reducing mental indirections/my reliance on the larger context and enabling me to quickly detect many types of mistakes via more efficient local reasoning.
Show HN: Xpaper – A Chrome extension to turn your X feed into a newsletter
by laiso | 2026-02-22 08:03:00+00:00
Hi HN,

I built Xpaper (https://github.com/laiso/xpaper), an open-source Chrome extension that curates and summarizes your X (Twitter) timeline into a clean, readable newsletter format.

Like many of you, I wanted to distance myself from the endless scrolling of Twitter, but completely quitting wasn't an option—I still needed to extract the signal from the noise. I built this to solve that exact dilemma.

I took a specific technical approach that I thought HN might find interesting:

1. *No Backend, Pure DOM Scraping:*
I didn't want to mess with the restrictive official API or run a fragile scraping backend. Instead, the extension reads the timeline directly from the DOM in your active tab. Since it only processes what's already visible locally on your screen for personal use, it operates cleanly within the browser environment.

2. *Cloud LLMs for Best UX, Local LLMs for Privacy:*
While Xpaper is designed to work best with Cloud APIs (OpenAI, Anthropic, Gemini, OpenRouter and more) for speed and quality, I also built full support for *Local LLMs as an option* for users who prioritize privacy. Your timeline data never has to leave your machine if you choose to connect to Chrome's experimental Built-in AI (Gemini Nano via `window.ai`) or Local Network LLMs like Ollama/LM Studio.

3. *Bypassing Manifest V3 Local IP Restrictions:*
Connecting an extension to local LLMs (like `192.168.x.x` or `::1`) in Manifest V3 is notoriously difficult because you can't easily use IP wildcards in `host_permissions`. I had to implement a dynamic permission request flow (`chrome.permissions.request`) specifically for RFC 1918 and loopback addresses to make "Bring Your Own Local Server" actually work smoothly.

4. *Combatting "AI Slop" with Multi-Agent Auditing & Human Review:*
There’s a lot of valid criticism lately about "vibe coding" leading to the mass production of insecure "AI slop". Extensions that handle DOM injection and LLM outputs are specifically an XSS nightmare waiting to happen.
To prevent this, I implemented a rigorous review process: I had 3 different AI agents mutually cross-review the codebase specifically focusing on vulnerabilities (XSS, DNS rebinding, CSP). Finally, I conducted a thorough human review as the last line of defense. The entire audit methodology is documented in the repo.

It’s completely open source. I'd love your thoughts on this "local browser scraping" approach, the security auditing process, or the UX!

Repo: https://github.com/laiso/xpaper
by amatecha | 2026-02-22 08:05:35+00:00
The argument I've heard is (and unfortunately I can't find offhand where I've heard this), is basically rather than having new computers made and all the vast energy usage required to do so (mining/refining metals, computer usage to design new hardware, factories assembling stuff, electronics manufacturing, packaging, shipping, and all the pollution from these processes), it's far less harmful to the environment to just keep using what you have, as long as you can. The impact of continuing to use that old computer is even less when your source of energy is a renewable resource like solar or hydroelectric.
by recursivecaveat | 2026-02-22 08:06:24+00:00
Yeah it doesn't really work in either direction. If I look at a spot its hard to tell which blobs its a part of. If I look at a blob its hard to find all the spots it contains. (imagining of course them not all being labeled) n=4 is already pushing it for venn diagrams, you should probably just have a table above that point.
by scubbo | 2026-02-22 08:06:38+00:00
Spelling can still be phonetic even if groups of letters have differing sounds from those letters' sounds serially in isolation. The key criterion is that the rules must be universal, applying to every instance of those groupings, rather than having exceptions for their appearances in certain words.

...ok, it occurs to me now that a smart-alec might declare each individual word to be a "grouping of letters with its own phonetic pronounciation", whereupon phoneticism as-defined is achieved trivially because pronounciation is universal over the singleton universe of words spelt exactly like that word. You know what I _mean_ - "sufficiently small groups of letters", hand-wave.
by thesz | 2026-02-22 08:06:59+00:00
8B coefficients are packed into 53B transistors, 6.5 transistors per coefficient. Two-inputs NAND gate takes 4 transistors and register takes about the same. One coefficient gets processed (multiplied by and result added to a sum) with less than two two-inputs NAND gates.

I think they used block quantization: one can enumerate all possible blocks for all (sorted) permutations of coefficients and for each layer place only these blocks that are needed there. For 3-bit coefficients and block size of 4 coefficients only 330 different blocks are needed.

Matrices in the llama 3.1 are 4096x4096, 16M coefficients. They can be compressed into only 330 blocks, if we assume that all coefficients' permutations are there, and network of correct permutations of inputs and outputs.

Assuming that blocks are the most area consuming part, we have block's transistor budget of about 250 thousands of transistors, or 30 thousands of 2-inputs NAND gates per block.

250K transistors per block * 330 blocks / 16M transistors = about 5 transistors per coefficient.

Looks very, very doable.

It does look doable even for FP4 - these are 3-bit coefficients in disguise.