frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

It's not political: the young fashionistas of Tehran

https://aeon.co/essays/its-not-political-the-young-fashionistas-of-tehran
1•rdmuser•22s ago•0 comments

Why is Fox News obsessed with the WNBA?

https://pudding.cool/2026/11/wnba-politics/
1•latexr•2m ago•0 comments

Ask HN: What's the new open source business model

1•asim•4m ago•0 comments

Ore Highlighter / Ore Outline – Minecraft PE Texture Packs

https://mcpedl.com/ore-highlighter/
1•bhavefg•4m ago•0 comments

Local Mirror for FreeBSD Pkgbase

https://blog.feld.me/posts/2026/11/local-mirror-for-freebsd-pkgbase/
2•birdculture•6m ago•0 comments

Courio – your AI agent can now send physical letters

https://sendcourio.com/agents
1•btallandier•7m ago•0 comments

A swimmable underwater world in one 97kb HTML file

https://www.reddit.com/r/ClaudeAI/s/28BnkKfnUM
1•hentrep•9m ago•0 comments

Diamond Rapids Xeon Gets 1.6TB/S to Memory and 1.28GB of Cache, 256 P-Cores

https://www.storagereview.com/news/intel-diamond-rapids-1-6tb-s-memory-bandwidth-1-28gb-cache-gpu...
1•rbanffy•16m ago•0 comments

How to Get Rich (2019)

https://nav.al/rich
2•downbad_•16m ago•0 comments

3D Printed Modular Stackable Mini-ITX Homelab

https://forum.level1techs.com/t/3d-printed-modular-stackable-mini-itx-homelab/260726
1•airhangerf15•17m ago•0 comments

Ancient Technology Makes These Water Bells Sing [video]

https://www.youtube.com/shorts/ptFhySJgRWc
2•zeristor•24m ago•1 comments

Nvidia Establishes National Security and Export Control Oversight Committee

https://nvidianews.nvidia.com/news/nvidia-board-of-directors-establishes-national-security-and-ex...
5•ryzvonusef•24m ago•2 comments

Nvidia Dismisses Trump's 'Bring Jensen Back' Campaign

https://www.bbc.com/news/articles/cry49plv8v3go
3•kvakula•24m ago•1 comments

Looped Transformers Explained

https://piszczek.pl/blog/looped-transformers-explained
1•ladronevincet•26m ago•0 comments

Show HN: Wake, see what Claude Code did and where the tokens went

https://rcruz.dev/wake/
2•piradoiv•30m ago•1 comments

Show HN: Mainfast – GitHub checks that catch merges that silently break main

https://github.com/mainfast/mainfast
1•sivakoza•30m ago•0 comments

Jordan and Iraq block Telegram app over national security concerns

https://www.reuters.com/business/media-telecom/jordan-blocks-telegram-app-over-national-security-...
2•giuliomagnifico•31m ago•0 comments

MPs ask what the break clause was for as Palantir wins two more years in NHS

https://www.theregister.com/public-sector/2026/11/17/mps-ask-what-the-break-clause-was-for-as-pal...
3•jjgreen•31m ago•0 comments

Paint in the Memory of Other Programs

https://citrons.xyz/journal/2026-04-13
2•signa11•36m ago•0 comments

AI-native CRM Dreamteam raises $53M to challenge Salesforce and HubSpot

https://thenextweb.com/news/dreamteam-ai-native-crm-53m-accel
2•servoSalesKriya•38m ago•0 comments

Rex Public testing is beginning

https://www.superlogical.com/updates/public-testing-beginning
2•doppp•38m ago•0 comments

Show HN: BaitWall – a warning before "free" online tools charge at the last step

https://chromewebstore.google.com/detail/baitwall/dbfbkbdmdjidjpkbhdnehfjpjkgjmgii
1•botgathering•41m ago•0 comments

Samenland: Slow, shared settlement game set in Northern Germany around 1500

https://github.com/retrogames23/samenland
1•doener•42m ago•0 comments

Alternative timeline 1994 Amiga (pt3)

https://www.reddit.com/r/amiga/comments/1xy18tg/alternative_timeline_1994_amiga_pt3/
2•doener•42m ago•0 comments

Who Is Anthropic Kidding?

https://www.theatlantic.com/economy/2026/11/anthropic-ipo-ai-safety/689440/
4•nothrowaways•46m ago•1 comments

Can time series foundation models predict stock prices?

https://github.com/moneyheap/tsfm-stocks
2•piligrim008•46m ago•1 comments

We couldn't afford a house alone, so we bought one with strangers

https://www.bbc.com/news/articles/c5742lwdyzglo
2•ddadon10•47m ago•0 comments

AI Race: an adaptation of Magical Athlete board game

https://ai-race.eamag.me/
1•eamag•48m ago•0 comments

How the Claude Code team thinks about verification

https://claude.dev/blog/how-the-claude-code-team-thinks-about-verification/
8•craigmart•50m ago•4 comments

Loom: agent memory that keeps up with your code

https://clickhouse.com/blog/introducing-loom-agent-memory-that-keeps-up-with-your-code
1•zlareb•51m ago•0 comments
Open in hackernews

Rust Devs Think We're Hopeless; Let's Prove Them Wrong (With C++ Memory Leaks)

https://www.babaei.net/blog/rust-devs-think-we-are-hopeless-lets-prove-them-wrong-with-cpp-memory-leaks/
27•zdw•1y ago

Comments

eptcyka•1y ago
Memory leaks are by far the least interesting class of defect that Rust helps with - leaking memory is safe.
genter•1y ago
Until the kernel kills you for being OOM.
YZF•1y ago
That's still safe.

EDIT: Safe in the sense you're not writing into memory you don't own, e.g. write after release, buffer overflows etc.

scotty79•1y ago
Program that no longer runs is the safest.
aquariusDue•1y ago
For true safety we must prevent it from being written in the first place /s
dmit•1y ago
That's the true meaning of backward compatibility. The [backward] refers to the time scale.
drivingmenuts•1y ago
stomps butterfly

I've just saved untold generations from certain calamity.

** 6,000,000 years later **

Butterfly King: This chimpanzee-descended motherfucker ….

airstrike•1y ago
I'll add that even safety itself is not the sole reason why some people prefer Rust. There's a lot to Rust besides that and sometimes it's not about memory safety as much as it is about steering you into patterns Rust devs perceive as better overall.
jayd16•1y ago
Possible attack vector, though.
andrewflnr•1y ago
The least interesting attack vector. You can fix it by rebooting.
Arnavion•1y ago
And in fact is not even something that Rust does differently from C++. Memory releases in Rust are handled by dtors just like they are in C++. What a weird article.

(The only difference is that Rust defaults to moving while C++ defaults to copying, and Rust moves don't leave a moved-out object behind while C++ does, so the dtors in Rust are simpler and called fewer times than the equivalent C++ code.)

dmit•1y ago
Yes, the only difference.
api•1y ago
The problem with unsafe languages is not that you can’t write safe code in them with skill and discipline.

The problem is that programmers don’t always do that, either because they are not that experienced or they are in a hurry.

The real danger is when code is long lived and worked on by multiple people. One bad commit after a late night hacking session and now there is a zero day just waiting to be discovered.

Safe languages don’t rule that out but they make it profoundly less likely.

bluGill•1y ago
I write C++ all the time and I still cannot convince many developers to use unique_ptr over new. It isn't that hard to write code that doesn't leak but if you bypass the language features it cannot help you.

for that matter though I've seen rust programmers put everything in unsafe.

on_the_train•1y ago
There's static analysis which can effectively force these things. C++ problems are self-inflicted
bluGill•1y ago
There is but we have code predating c++11 that isn't worth rewriting. So the static analisys is off. We do use lots of static analisys but that one is too hard to fix all the old code that we have decades of proff works and isn't leaking (much?)
andrewflnr•1y ago
I mean, a sufficiently safe language would rule it out. Either one not expressive enough to express memory unsafety (i.e. GC or fully linear types with no escape hatches) or one that requires a machine checked proof of safety to compile. These options just happen to be too big of a pain in the assembly for today's appetite.
shmerl•1y ago
No, C++ is hopeless. No need to bend over backwards to try to disprove it. It's not only about memory safety, some of it is about legacy stuff and backwards compatibility it's forever stuck with.
tom_•1y ago
This only works with the VC++ CRT, which is potentially a bit limiting!

Also, the DEBUG_NEW thing is useless in practice since, from memory, it stops you using placement new, and dependencies typically don't participate, so a zillion unlabeled leaks is the usual result from the common case of you failing to call some dependency's free function.

And the allocation IDs (and therefore _CrtSetBreakAlloc) are pretty worthless in practice for multithreaded programs, because the allocation order isn't deterministic.

I use the LEAK_CHECK_DF flag in the programs I write (and the CHECK_ALWAYS_DF is worth investigating too), but the only point is to indicate whether there are leaks on exit, yes/no. If no, great; if yes, well that's useful information, but the actual output is almost never helpful. (Though occasionally I do somehow introduce a leak from something that happens before the first thread is created.)

yusina•1y ago
It's 2025 and we are still discussing memory leaks. The very existence of this article is an indication that C++ (used like that) has an issue. Non-kernel programmers should not even be able to create memory leaks by mistake.

Well, unless they are doing something incredibly stupid including stepping over several explicit warnings of "don't do this unless you are very sure about what you are doing".

teleforce•1y ago
It's really a shame isn't it? It's 2025 and we still have no programming languages that have impeccable GC for automatic memory management rather than forcing programmer to wrestling and fighting for manually managing the memory [1].

Auto industry kind of solved this automation mechanism for example with the new high performance Toyota GR Corolla has a new automatic gear transmission that's proven as fast if not faster than the manual version [2]. The same goes to F1, the epitome of car racing performance.

[1] Understanding Memory Management, Part 5: Fighting with Rust (101 comments):

https://news.ycombinator.com/item?id=43882291

[2] 2025 Toyota GR Corolla's New Automatic Gearbox Democratizes Fun:

https://www.caranddriver.com/reviews/a62672128/2025-toyota-g...

linotype•1y ago
I’ve seen way more comments from C++ developers complaining about Rust developers insulting them than I’ve seen Rust developers actually insulting C++. It’s weird to see how attached people are to programming languages, though it’s weird to me too how attached people are to ICE/drivetrains.
sunrunner•1y ago
I think that's because the Rust developers are having too much fun sitting on their high horse shouting about how great the horse is to need to spend time yelling about the people _not_ on the horse, while the C++ developers don't have a horse to yell about so need one to yell _at_ instead.
squirrellous•1y ago
It’s about jobs and livelihoods, even if not everyone will admit it. It’s easy to emotional when the argument boils down to “your skills are now outdated, go learn a better one”.
fithisux•1y ago
c++ is a huge language, with lots of backwards compatibility.

I think c++ should keep the good modern things and fork (restart) from there by breaking backwards compatibility, c++23 will be frozen with some fixes.

api•1y ago
There are lots of languages where true memory bugs are impossible. As you say they are higher level and usually GC.
andrewflnr•1y ago
Right, the interesting case would be the formal proof. Though, I suspect there are fewer high-level languages where memory bugs are actually impossible than you would naively think. I've segfaulted Python by accident, only using the standard library (concurrency shenanigans if I recall). You can probably do worse if you try. To make a truly memory-safe language, you would need to carefully design and implement the standard library, disallow all native code extensions, and probably more I'm not smart enough to figure out. So, not Java, not Python. Maybe some Schemes?