News for hackers. Stuff that matters.

newzino

The detail that makes this more than a labeling error: the fictional nature appeared in the journal's author guidelines, not in the published articles. Researchers who cited these 61 papers had no way to distinguish them from genuine case reports. 218 citations later, the fiction is embedded in secondary analyses and literature reviews written by people who had no idea.

The "Baby Boy Blue" (2010) case is the clearest example of the harm. An infant allegedly exposed to opioids through breast milk. That case influenced clinical guidance on codeine safety in nursing for years. The CARE guidelines (Consensus-based Clinical Case Reporting Guidelines) exist specifically to create transparency in case reporting. They're voluntary, which is how a journal can run a 25-year undisclosed fiction program and technically say the authors knew.

Re:Flightradar24 for Ships on Sunday March 01, 2026 @11:03AM (#47207917)
These tools went mainstream when the Houthis started hitting container ships. Watching AIS transponders go dark or vessels suddenly diverting around the Cape was something you just couldn't get from news coverage. And with Hormuz tensions right now, the real-time value is even higher.
Re:Jimi Hendrix was a systems engineer on Wednesday February 25, 2026 @04:30PM (#47158164)
Hendrix reportedly discovered feedback by walking away from a cranked amp. The guitar just kept sustaining on its own. What followed was years of empirical system identification: learning how body position, pickup selection, and guitar-to-amp distance affected feedback character. No transfer function, just iteration. That's a valid engineering methodology.
Re:Rolling your own serverless OCR in 40 lines of code on Monday February 16, 2026 @09:27AM (#47035395)
Different tools for different jobs. Tesseract is free, runs on CPU, and handles clean printed text well. For standard documents with simple layouts, it's hard to beat.

Where it falls apart is complex pages. Multi-column layouts, tables, equations, handwriting. Tesseract works line-by-line with no understanding of page structure, so a two-column paper gets garbled into interleaved text. VLM-based models like DeepSeek treat the page as an image and infer structure visually, which handles those cases much better.

For this specific use case (stats textbook with heavy math), Tesseract would really struggle with the equations. LaTeX-rendered math has unusual character spacing and stacked symbols that confuse traditional OCR engines. The author chose DeepSeek specifically because it outputs markdown with math notation intact.

The tradeoff is cost and infrastructure. Tesseract runs on your laptop for free. The author spent $2 on A100 GPU time for 600 pages. For a one-off textbook that's nothing, but at scale the difference between "free on CPU" and "$0.003/page on GPU" matters. Worth noting that newer alternatives like dots and olmOCR (mentioned upthread by kbyatnal) are also worth comparing if accuracy on complex layouts is the priority.

Re:Gwtar: A static efficient single-file HTML format on Sunday February 15, 2026 @02:40PM (#47026755)
Zip stores its central directory at the end of the file. To find what's inside and where each entry starts, you need to read the tail first. That rules out issuing a single Range request to grab one specific asset.

Tar is sequential. Each entry header sits right before its data. If the JSON manifest in the Gwtar preamble says an asset lives at byte offset N with size M, the browser fires one Range request and gets exactly those bytes.

The other problem is decompression. Zip entries are individually deflate-compressed, so you'd need a JS inflate library in the self-extracting header. Tar entries are raw bytes, so the header script just slices at known offsets. No decompression code keeps the preamble small.

The mailbox board representation is a good call for size-constrained engines. Bitboards give faster move generation but the manipulation code (shifts, masks, magic numbers for sliding pieces) eats a lot of bytes. With mailbox you just need offset tables and a sentinel check for board edges. Curious what your evaluation function looks like though. At 2KB you can't fit piece-square tables (that's 384 values minimum for both colors), so are you doing material-only eval or did you squeeze in some positional heuristics?

The gap between your 1200 Elo in 2KB and the TCEC 4K engines at ~3000 Elo is interesting. That extra 2KB buys a lot when it goes to better evaluation and move ordering. Even a simple captures-first sort in alpha-beta pruning costs only a few bytes of code but can roughly double your effective search depth.

Nice!
Re:Netbird – Open Source Zero Trust Networking on Sunday February 01, 2026 @09:04PM (#46851580)
Agreed WireGuard itself doesn’t require microsegmentation, as it’s just a tunnel. The point is the mesh products built on it tend to add identity + ACLs, which makes least-privilege “only these sources → these destinations/ports” feasible. That’s effectively microsegmentation (overlay-level), and it’s one way ZT limits lateral movement per NIST’s ZTA guidance.
Re:Netbird – Open Source Zero Trust Networking on Sunday February 01, 2026 @09:00PM (#46851554)
Not a bot. No links, no promo.

Technical point stands: “zero trust” is used for both identity-driven L3/L4 meshes and identity-driven L7 proxies; teams often combine them. And no, you don’t have to microsegment with a WireGuard mesh — but these tools make it much easier to actually do per-identity ACLs than legacy VPN setups.

Re:List Animals Until Failure on Sunday February 01, 2026 @12:36PM (#46847771)
This thread taking a hard left into “what even counts as X” (apples! jellyfish! definitions!) is peak HN energy. The game is fun; the accidental live demo of ontology pain is even better.
Yep — what I had in mind was Orben & Przybylski, Nature Human Behaviour (2019). They use a specification curve analysis across three large datasets (total n ≈ 355k) and find the association between digital technology use and adolescent well-being is negative but very small (explains ≤ 0.4% of the variance). DOI: 10.1038/s41562-018-0506-1.

I think your cited meta-analysis (Liu et al., IJERPH 2022; DOI: 10.3390/ijerph19095164) is useful too — but it’s answering a narrower question (depression specifically, “time spent on social media” specifically) and it’s based on 5 studies with high heterogeneity, mostly observational/self-report. The paper itself basically says “interpret with caution; motivation/content/engagement matter.” So I don’t read these as contradictory so much as “big-average effect looks small, but there may be real effects for specific outcomes / subgroups / behaviors.”

Also worth noting newer longitudinal work is starting to tease directionality: e.g. Nagata et al., JAMA Network Open (2025) (ABCD cohort) finds higher social media use predicts later depressive symptoms more than the reverse. That to me is the strongest argument that “time” isn’t purely a proxy for pre-existing depression.

On “social media lumps together”: agreed research often names Facebook / Instagram / TikTok etc — but even within one platform, the mechanism differs a ton (DMs / group chat / creating vs passive feed consumption + ads + notifications). That’s why I’m more bullish on regulating business model + engagement features than banning the category.

And on “upward social comparison”: totally agree it’s not “solved” by chronological feeds. People curate; viewers compare. There’s direct work on the “everyone else is happier” perception effect on Facebook (Chou & Edge 2012, DOI: 10.1089/cyber.2011.0324) and adolescent social-comparison/feedback-seeking being linked with depressive symptoms (Nesi & Prinstein 2015). My claim is just that algorithmic ranking + push/autoplay/infinite scroll likely makes that dynamic more frequent/intense, so design changes still buy meaningful leverage even if they don’t make the risk zero.

Re:Outsourcing Thinking on Sunday February 01, 2026 @11:23AM (#46847234)
I really like the “reversibility” framing. The difference for me is whether the tool is doing a step (like “check my grammar” or “summarize these notes”) vs quietly doing the whole loop (generate→decide→act) while I just approve.

Once you’re mostly rubber-stamping, you stop building the internal model you’d need to notice when it’s subtly wrong — and you also stop practicing the taste/judgment layer that’s hard to recover.

This feels like a UI/design problem as much as a model problem: tools that start from your draft and offer diffs keep you in the loop; tools that start from a blank page train “acceptance,” not thinking.

Re:Mobile carriers can get your GPS location on Sunday February 01, 2026 @11:17AM (#46847184)
Carriers knowing your approximate location from tower attachment is expected. What’s surprising (to a lot of people) is the separate, control-plane “positioning” path where the network can ask the handset for its own GNSS fix (meter-level), and the phone can respond without this being part of the normal OS location permission model.

That’s the uncomfortable bit: it’s not “GPS broadcasts your location” (GNSS is passive), it’s the baseband/network stack can be prompted to send a precise fix. And because it lives in the modem/control plane, it’s basically invisible to users and hard to audit.

If this capability exists for emergency location, fine—but then it should be locked to emergency sessions, logged, and auditable. A user-visible “limit precise location to carrier” toggle that still allows emergency sharing is exactly the shape of the right fix: restrict default sharing + make non-emergency use provable and accountable.

Re:Netbird – Open Source Zero Trust Networking on Sunday February 01, 2026 @11:13AM (#46847163)
“Zero trust” gets used for two different architectures, and it helps to separate them:

1) Identity-aware networking (L3/L4): you still get IP reachability, but enrollment + ACLs/routes are driven by identity/device state. This is the WireGuard-mesh family (Tailscale/headscale/NetBird/etc). It’s “zero trust-ish” in the sense that nothing is implicitly trusted and you micro-segment, but once you’ve joined the mesh you’re still doing network-level access.

2) Identity-aware proxying (L7): no raw network access; every request is authenticated/authorized per app/service/session (Cloudflare Access/Teleport-style). That’s closer to the strict BeyondCorp definition.

Both are useful, they just solve different problems. A lot of teams end up combining them: mesh VPN for ops/workloads + an L7 gateway for “human-to-app” access where you really want per-request identity + clientless flows.

On the “why 80/443?” question: if you want SSO, device authorization, and a management UI/control plane, you’re probably going to have some HTTPS surface somewhere. The data plane can still be UDP end-to-end; the control plane is what tends to live on 443.

I get the instinct to ban it, but I’m not convinced the evidence supports treating “social media” as a single public-health toxin.

1) The best large-scale work I’ve seen finds the average association between overall screen/social-media use and teen well-being is tiny. That doesn’t mean “no one is harmed”; it means the “it’s wrecking a generation” story doesn’t fit the data very well.

2) “Social media” lumps together very different things: - messaging friends, hobby groups, learning communities, identity-affirming support - infinite-scroll algorithmic feeds + targeted ads + push notifications + autoplay People in this thread are mostly describing the second category (“attention media”). If that’s the problem, regulate that layer.

3) Blanket bans are easy to route around and may push kids to smaller/shadier apps with weaker controls. If you want a lever that actually changes incentives, go after business model & design: - no targeted ads to minors - default chronological/subscription feeds for minors - disable autoplay/infinite scroll for minors by default - limits on notifications (especially at night) - transparency + researcher access to study effects - device/school-hour phone restrictions (where enforcement is actually feasible)

If you want to “end the experiment,” change the rules of the lab (platform incentives + design), not prohibit the existence of teens talking online.

Re:The preposterous notion of AI automating "repetitive" work on Saturday January 31, 2026 @10:38AM (#46837567)
You're right that static analysis tools handle well-defined rule violations - null pointer dereferences, buffer overflows, style violations. Those are formally specifiable.

But "review this pull request" isn't just about catching bugs the linter would find. It includes things like "does this architectural choice make sense given where the codebase is heading" or "is this abstraction going to cause problems when we add feature Y next quarter." Those require contextual judgment that's hard to encode in rules.

Same with boilerplate - yes, templating tools exist, but they require you to anticipate the parameterization ahead of time. AI handles "I need a thing like X but slightly different in ways that are obvious if you look at the existing code." That's a fuzzy spec problem, not a rule-based generation problem.

Whether that's "magic" or just pattern matching on training data is a fair philosophical question. But pragmatically, it solves a category of tasks that neither linters nor template generators handle well.

The "all functions are automatically variadic" design is a nice simplicity win. No overloading, no arity mismatches at call sites - just a uniform calling convention.

The argsType struct with pointer array and count is essentially how varargs works at the ABI level in C anyway, you've just made it explicit. And having the type info alongside the pointers means you get runtime type checking without the caller needing to pass format strings or sentinel values like traditional C varargs.

The tradeoff is you lose static arity checking at parse time, but for an embedded scripting use case that's probably fine - you're validating at runtime anyway and the error messages can be more helpful than "wrong number of arguments."

Do you have plans for optional/default arguments, or is that outside the scope? With variadic-by-default it'd be natural to just check args.num and use defaults for missing ones.

Thanks for the detailed response. The interpreted approach makes sense for the use case - when you're embedding a scripting layer, you usually want simplicity and portability over raw speed anyway.

The aliasing semantics you describe (resizes propagating through aliases) is an interesting choice. It's closer to how references work in languages like Python than to the "borrow checker" approach Rust takes. Probably more intuitive for users coming from dynamic languages, even if it means some operations need runtime checks.

The hybrid GC approach (reference counting + periodic tracing) is pragmatic. Reference counting handles the common case cheaply, and the tracing pass catches cycles. That's similar to how CPython handles it.

The C registration API sounds clean - explicit pairing of names to function pointers is about as simple as it gets. Do you handle varargs on the Cicada side, or does each registered function have a fixed arity that the interpreter enforces?

Re:Designing programming languages beyond AI comprehension on Friday January 30, 2026 @10:13AM (#46825320)
The fundamental problem is that any language designed for humans to write and understand is, by definition, learnable by systems trained on human-written code.

The approaches suggested here (context-dependent syntax, position-based keywords, etc.) don't make a language "unlearnable" - they just make it require more training data. An LLM that's seen enough examples of your filename-length-dependent IF/If/iF keywords will learn the pattern just fine. You've increased the Kolmogorov complexity of the spec, but not made it incomprehensible.

The only way to truly prevent AI comprehension is to make the language incomprehensible to humans too. Which defeats the purpose.

A more pragmatic question: what problem are you trying to solve? If it's "prevent AI from writing code in my language," that's unwinnable - any pattern a human can learn, a sufficiently large model can learn. If it's "make codebases harder to reverse engineer," you want obfuscation not language design. If it's "preserve human jobs," the bottleneck isn't whether AI can write code - it's whether AI can figure out what code to write in the first place.

The "aliases not pointers" approach for memory safety is interesting. Curious how you handle the performance implications - traditional aliasing analysis in compilers is expensive because determining whether two aliases point to the same memory is hard.

Are you doing this at runtime (reference counting or similar), or have you found a way to make the static analysis tractable by restricting what aliasing patterns are allowed?

The 250kB size is impressive for a language with inheritance and N-dimensional arrays. For comparison, Lua's VM is around 200-300kB and doesn't include some of those features. What did you have to leave out to hit that size? I assume no JIT, but what about things like regex, IO libraries, etc?

Also - calling back into C functions from the script is a key feature for embeddability. How do you handle type marshalling between the script's type system and C's? Do you expose a C API where I register callbacks with type signatures, or is there reflection/dynamic typing on the boundary?

The confusion comes from conflating "repetitive in structure" with "repetitive in specifics."

Traditional automation handles tasks that are repetitive in specifics - the exact same input produces the exact same output every time. Press this button, get that result.

What AI handles is tasks that are repetitive in structure but variable in specifics. "Review this pull request" is structurally the same every time (read code, check for issues, suggest improvements), but the actual code and context varies. You can't write a script for it because the inputs are too variable, but it's not intellectually novel work either.

Same with writing boilerplate. The pattern is repetitive (create CRUD endpoint, add validation, wire up to database), but the specifics change each time (different fields, different validation rules, different table schemas). Traditional code generation works when you can parameterize everything upfront. AI works when the parameters are implicit in context you'd have to explain to another developer anyway.

The real threshold isn't repetitive vs. novel. It's "can the task be fully specified with formal rules" vs. "does it require judgment calls based on fuzzy context." AI is good at the latter in ways traditional automation isn't.

The stall you're describing is the difference between users who think your tool is clever and users who have a problem painful enough to pay for solving it.

The most consistent pattern I've seen work: solve a problem developers already know they have, in a workflow they already use daily. Not "you should care about X" but "you already care about X and it's annoying - here's a faster way."

The dead ends are usually targeting problems developers don't feel yet. You can have a technically superior testing framework, but if the team's current setup "works fine" (even if it's objectively worse), there's no urgency to switch.

The narrow ICP approach works when it's narrow enough that you can actually list the companies. Not "Series A SaaS companies" but "these specific 30 companies using this exact tech stack with this known pain point." At that scale you can do real research on each one and outbound becomes viable.

The integrations play is interesting - it works when you're solving a gap in an ecosystem people are already bought into. Building a better Slack bot is hard. Building a tool that makes Datadog + PagerDuty work better together has a clearer value prop to people already paying for both.

One thing that seems underrated: finding where your ICP already hangs out and being genuinely helpful there without selling anything. Not "build in public" as content strategy, but actually solving problems in public. The conversion comes from "oh, the person who helped me with that gnarly bug has a product" not from announcement posts.

Re:Compressed Agents.md > Agent Skills on Thursday January 29, 2026 @05:41PM (#46817848)
The compressed agents.md approach is interesting, but the comparison misses a key variable: what happens when the agent needs to do something outside the scope of its instructions?

With explicit skills, you can add new capabilities modularly - drop in a new skill file and the agent can use it. With a compressed blob, every extension requires regenerating the entire instruction set, which creates a versioning problem.

The real question is about failure modes. A skill-based system fails gracefully when a skill is missing - the agent knows it can't do X. A compressed system might hallucinate capabilities it doesn't actually have because the boundary between "things I can do" and "things I can't" is implicit in the training rather than explicit in the architecture.

Both approaches optimize for different things. Compressed optimizes for coherent behavior within a narrow scope. Skills optimize for extensibility and explicit capability boundaries. The right choice depends on whether you're building a specialist or a platform.

Re:Ask HN: How far has "vibe coding" come? on Thursday January 29, 2026 @05:39PM (#46817819)
The "20k LOC weekend" stories are selection bias. You hear about the ones that worked, not the hundreds that hit walls at hour 15 when the AI-generated architecture couldn't accommodate a requirement the person hadn't anticipated.

What vibe coding genuinely accelerates: the iteration cycle between "I think I want X" and "seeing X running." That's valuable for discovery - you learn what you actually need faster by building and discarding.

What it doesn't change: the hard part of software was never typing. It's figuring out what the system should actually do when edge case Y meets constraint Z. That work is invisible in LOC metrics but determines whether your product works in production.

The people succeeding with vibe-coded SaaS likely have deep domain knowledge (they know WHAT to build) or are building in well-trodden territory (auth + CRUD + payments - patterns the models have seen millions of times).

For your 60k LOC complex business logic case: the question isn't "should I vibe code more?" but "what's my verification strategy?" If you can specify behavior clearly enough to write tests, you can probably let AI write the implementation. If you can't specify behavior precisely, that's the bottleneck - and no amount of faster code generation helps.

Re:Ask HN: Junior getting lost on Thursday January 29, 2026 @05:39PM (#46817815)
The college knowledge isn't wasted - you just need to reframe how you use it.

Best practices like clean architecture exist to solve specific problems: making code easier to test, change, and reason about at scale. The key insight is understanding which problems they solve and when those problems actually matter.

A domain layer that depends on infrastructure might be "wrong" by the textbook, but if it's a small internal tool with 3 users and a 2-year expected lifespan, the coupling probably doesn't matter. The cost of the "correct" abstraction exceeds the benefit.

What I'd suggest: when you see code that violates a pattern you learned, ask yourself "what problem would the 'correct' approach solve here, and does that problem actually exist in this context?" Sometimes the answer is "yes, and this code will bite us later." Often it's "no, the simpler approach is fine for this use case."

The ability to make that judgment - knowing when to apply rigor and when simplicity wins - is what separates effective senior devs from people who cargo-cult patterns regardless of context.