frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

Plasma Bigscreen – 10-foot interface for KDE plasma

https://plasma-bigscreen.org
225•PaulHoule•4h ago•73 comments

UUID package coming to Go standard library

https://github.com/golang/go/issues/62026
51•soypat•2h ago•9 comments

Can a wealthy family change the course of a deadly brain disease?

https://www.science.org/content/article/can-wealthy-family-change-course-deadly-brain-disease
15•Snoozus•1h ago•1 comments

this css proves me human

https://will-keleher.com/posts/this-css-makes-me-human/
187•todsacerdoti•6h ago•66 comments

LLMs work best when the user defines their acceptance criteria first

https://blog.katanaquant.com/p/your-llm-doesnt-write-correct-code
97•dnw•2h ago•78 comments

Maybe There's a Pattern Here?

https://dynomight.net/pattern/
36•surprisetalk•2d ago•11 comments

C# strings silently kill your SQL Server indexes in Dapper

https://consultwithgriff.com/dapper-nvarchar-implicit-conversion-performance-trap
73•PretzelFisch•5h ago•44 comments

Galileo's handwritten notes found in ancient astronomy text

https://www.science.org/content/article/galileo-s-handwritten-notes-found-ancient-astronomy-text
63•tzury•1d ago•8 comments

Hardening Firefox with Anthropic's Red Team

https://www.anthropic.com/news/mozilla-firefox-security
520•todsacerdoti•16h ago•148 comments

Tell HN: I'm 60 years old. Claude Code has ignited a passion again

213•shannoncc•4h ago•122 comments

Show HN: Moongate – Ultima Online server emulator in .NET 10 with Lua scripting

https://github.com/moongate-community/moongatev2
236•squidleon•13h ago•134 comments

The Shady World of IP Leasing

https://acid.vegas/blog/the-shady-world-of-ip-leasing/
76•alibarber•6h ago•47 comments

Tech employment now significantly worse than the 2008 or 2020 recessions

https://twitter.com/JosephPolitano/status/2029916364664611242
791•enraged_camel•10h ago•534 comments

Show HN: 1v1 coding game that LLMs struggle with

https://yare.io
11•levmiseri•21h ago•5 comments

Launch HN: Palus Finance (YC W26): Better yields on idle cash for startups, SMBs

41•sam_palus•9h ago•68 comments

Show HN: Kula – Lightweight, self-contained Linux server monitoring tool

https://github.com/c0m4r/kula
18•c0m4r•4h ago•18 comments

CT Scans of Health Wearables

https://www.lumafield.com/scan-of-the-month/health-wearables
192•radeeyate•13h ago•41 comments

What canceled my Go context?

https://rednafi.com/go/context-cancellation-cause/
22•mweibel•2d ago•13 comments

A Modular Robot Dashboard

https://github.com/transitiverobotics/transact
6•chfritz•1d ago•0 comments

Entomologists use a particle accelerator to image ants at scale

https://spectrum.ieee.org/3d-scanning-particle-accelerator-antscan
105•gmays•12h ago•20 comments

Ada 2022

https://www.adaic.org/ada-resources/standards/ada22/
116•tosh•8h ago•23 comments

A tool that removes censorship from open-weight LLMs

https://github.com/elder-plinius/OBLITERATUS
137•mvdwoord•13h ago•62 comments

Game about Data of America

https://americaindata.com/
5•fidicen•3h ago•0 comments

Workers who love ‘synergizing paradigms’ might be bad at their jobs

https://news.cornell.edu/stories/2026/03/workers-who-love-synergizing-paradigms-might-be-bad-thei...
525•Anon84•14h ago•300 comments

Good Bad ISPs

https://community.torproject.org/relay/community-resources/good-bad-isps/
112•rzk•13h ago•38 comments

Analytic Fog Rendering with Volumetric Primitives (2025)

https://matejlou.blog/2025/02/11/analytic-fog-rendering-with-volumetric-primitives/
87•surprisetalk•1d ago•8 comments

Multifactor (YC F25) Is Hiring an Engineering Lead

https://www.ycombinator.com/companies/multifactor/jobs/lcpd60A-engineering-lead
1•multifactor•11h ago

Art Bits from HyperCard

https://archives.somnolescent.net/web/mari_v2/junk/hypercard/
69•TigerUniversity•6h ago•15 comments

Astra: An open-source observatory control software

https://github.com/ppp-one/astra
86•pppone•12h ago•21 comments

Show HN: Claude-replay – A video-like player for Claude Code sessions

https://github.com/es617/claude-replay
75•es617•12h ago•28 comments
Open in hackernews

What canceled my Go context?

https://rednafi.com/go/context-cancellation-cause/
22•mweibel•2d ago

Comments

ashishb•2h ago
Context cancellation (and it's propagation) is one of the best features in Go.

Is there any equivalent in major popular languages like Python, Java, or JS of this?

gzread•2h ago
Not really, since they don't have `select`

There's a stop_token in some Microsoft C++ library but it's not nearly as convenient to interrupt a blocking operation with it.

ndriscoll•2h ago
ZIO in Scala tracks this sort of thing except you don't have to remember to pass around or select on the ctx (it's just part of the fibre/"goroutine"); if it's cancelled, the fibre and its children just stops the next time it yields (so e.g. if it "selects" on anything or does any kind of IO).
nnx•2h ago
in JS, signals and AbortController can replicate some of the functionality but it's far less ergonomic than Go.

https://github.com/ggoodman/context provides nice helpers that brings the DX a bit closer to Go.

drdaeman•2h ago
C# has CancellationToken, but it’s just for canceling operations, not a general purpose context.
perfmode•2h ago
one of the reasons why i love writing control planes in Go.
deathanatos•1h ago
Python async tasks can be cancelled. But, I don't think you can attach must context to the cancel (I think you can pass a text message), so it would seem the argument of what go suffered from would apply.

(I also think there's some wonkiness with and barriers to understanding Python's implementation that I don't think plagues Go to quite the same extent.)

lifis•1h ago
All mainstream languages have it in one or more forms (either direct task I/O cancellation, or cancellation tokens or I/O polling that can include synthetic events) since otherwise several I/O patterns are impossible
richbell•1h ago
Kotlin Coroutine's structured concurrency. Cancelling a parent automatically cancels child jobs, unless explicitly handled not to. https://kotlinlang.org/docs/coroutines-basics.html
tadfisher•23m ago
Stupidly, child cancellation cancels the parent scope as well, unless the scope opts out by including SupervisorJob.
Quekid5•1h ago
Java's Virtual Threads (JVM 21) + the Structured Concurrency primitives (not sure exactly what's available in Java 21+) do this natively.

Also, a sibling poster mentioned ZIO/Scala which does the Structured Concurrency thing out of the box.

lemoncucumber•37m ago
It’s great that they identified this (incredibly common) pain point and introduced a way to solve it, but I can’t help being disappointed.

Reading the examples I found myself thinking, “that looks like a really useful pattern, I should bookmark this so I can adopt it whenever I write code like that.”

The fact that I’m considering bookmarking a blog post about complex boilerplate that I would want to use 100% of the times when it’s applicable is a huge red flag and is exactly why people complain about Go.

It feels like you’re constantly fighting the language: having to add error handling boilerplate everywhere and having to pass contexts everywhere (more boilerplate). This is the intersection of those two annoyances so it feels especially annoying (particularly given the nuances/footguns the author describes).

They say the point is that Go forces you to handle errors but 99% of the time that means just returning the error after possibly wrapping it. After a decade of writing Go I still don’t have a good rule of thumb for when I should wrap an error with more info or return it as-is.

I hope someday they make another attempt at a Go 2.0.

XorNot•28m ago
There are two things I think you could have as implict in Go - error values, and contexts.

Just pass along two hidden variables for both in parameters and returns, and would anything really change that the compiler wouldn't be able to follow?

i.e. most functions return errors, so there should always be an implicit error return possible even if I don't use it. Let the compiler figure out if it needs to generate code for it.

And same story for contexts: why shouldn't a Go program be a giant context tree? If a branch genuinely doesn't ever use it, the compiler should be able to just knock the code out.