frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Outages reported at Bank of America, Chase, U.S. Bank, Wells Fargo and Zelle

https://apnews.com/article/bank-outage-chase-wells-fargo-truist-50fee2693c22f597fa6ca51a97ef2cda
351•samk3nny•1h ago•241 comments

Software is breaking down at a systemic level

https://www.breck-mckye.com/blog/2026/11/software-is-breaking-down-at-a-systemic-level/
181•zero_shift•2h ago•109 comments

Grazing sheep in fields with solar arrays

https://news.cornell.edu/stories/2026/10/sheep-grazing-solar-fields-offers-farmers-economic-ecolo...
127•PaulHoule•2h ago•107 comments

Jiff 1.0: A datetime library for Rust

https://burntsushi.net/jiff/
199•burntsushi•3h ago•46 comments

Frame – 31.5" color ePaper display

https://trmnl.com/blog/introducing-frame
144•geerlingguy•3h ago•74 comments

Squircles

https://linebender.org/wiki/curves/squircle/
19•raphlinus•12h ago•8 comments

The Secret ThinkPad Powerbutton Code to Bring Dead Laptops Back to Life (2007)

https://masnick.com/posts/the-secret-thinkpad-powerbutton-code-to-bring-dead-laptops-back-to-life/
262•sammatilda•8h ago•105 comments

Aristotle Expands into Rust

https://www.harmonic.fun/news/aristotle-rust-verification/
53•maufl•2h ago•31 comments

Michael Mann's 'Heat' Copyright Fight Turns on a Deal with Himself

https://copyrightlately.com/michael-mann-heat-copyright-termination/
42•speckx•2h ago•10 comments

How to Intercept HTTP/3 Traffic: QUIC and Qpack

https://interceptsuite.com/blog/intercept-http3-traffic-quic-qpack-explained/
11•anof-cyber•51m ago•0 comments

OpenAI: Strengthening the fight against online child sexual abuse

https://openai.com/index/strengthening-online-child-safety/
38•rossant•2h ago•62 comments

Many of Amazon’s Black Friday and Cyber Monday “deals” offered no savings

http://groundworkcollaborative.org/news/amazons-decoy-deals-groundwork-investigation-reveals-near...
681•DeepLogin•6h ago•414 comments

How to make almost anything

https://pub.cba.mit.edu/863.26/site/
784•o4c•14h ago•130 comments

Giant Roadside Attractions Face Mounting Costs and an Uncertain Future

https://www.nytimes.com/2026/11/08/world/canada/roadside-attractions-giant-dinosaur.html
14•bookofjoe•6d ago•11 comments

Jolt – Clojure that speaks C

https://jolt-lang.net/
50•michaelsbradley•3h ago•12 comments

Microsoft blames monster email outage on software defect introduced in July fix

https://www.theregister.com/saas/2026/11/16/microsoft-blames-monster-email-outage-on-software-def...
77•Bender•7h ago•64 comments

Nvidia was in trouble before the Jensen Huang mess

https://www.wired.com/story/nvidia-was-already-in-trouble-before-the-jensen-huang-mess/
175•Brajeshwar•4h ago•164 comments

Smallest possible nopert polyhedra: the Septopert

https://github.com/tom7/noperts/blob/main/septopert.md
38•RebelPotato•2d ago•3 comments

Interpreting claims that a theorem is correct because it was checked in Lean

https://xenaproject.wordpress.com/2026/11/12/and-the-proof-is-checked-in-lean/
257•matt_d•12h ago•111 comments

OOS – an open operating system for the Rigol Scopes

https://www.eevblog.com/forum/testgear/oos-an-open-operating-system-for-the-rigol-scopes/
110•qwezxcrty•2d ago•35 comments

A 512 KiB binary message teaching chess without a shared language

https://artemlegotin.com/golden-board/
37•legotin•5h ago•6 comments

The Origins of the Placenta

https://www.caltech.edu/about/news/uncovering-the-hidden-origins-of-the-placenta
4•gmays•3d ago•0 comments

Coffeehouses and the Rise of Science [pdf]

https://www.monirbounadi.com/Bounadi_JMP.pdf
160•Michelangelo11•9h ago•98 comments

Just 400 US Data Centers Use More Electricity Than Michigan

https://www.wired.com/story/data-centers-use-more-electricity-than-michigan/
62•Betelbuddy•2h ago•49 comments

First phase of embedded assessments at OpenAI

https://openai.com/index/our-first-phase-of-embedded-assessments/
18•dvaplima•4h ago•4 comments

Researchers track whole body movement with just a smartwatch

https://news.cornell.edu/stories/2026/11/researchers-track-whole-body-movement-just-smartwatch
187•PaulHoule•3d ago•63 comments

Psychic: Like fzf but learns from your actions

https://klauria.tech/psychic/
23•articulatepang•4h ago•7 comments

The Active Directory Era Is Finally Over

https://infisical.com/blog/active-directory-machine-identity
91•FinnLobsien•6h ago•61 comments

How Billions in Safe Insurance Money Is Being Bet on A.I. Debt

https://www.nytimes.com/2026/11/16/business/insurance-ai-debt.html
36•syllablehq•2h ago•5 comments

Winudf – DVD / BluRay driver for DOS, Windows 1.x – 3x / 95 / 98 / ME

https://github.com/ages2001/WINUDF
80•Oxodao•12h ago•12 comments
Open in hackernews

Understanding the Go Scheduler

https://nghiant3223.github.io/2025/04/15/go-scheduler.html
180•gnabgib•1y ago

Comments

90s_dev•1y ago
I heard that the scheduler is a huge obstacle to many potential optimizations, is that true?
NAHWheatCracker•1y ago
In some ways, yes. If you want to optimize at that level you ought to use another language.

I'm not a low level optimization guy, but I've had occasions where I wanted control over which threads my goroutines are running on or prioritizing important goroutines. It's a trade off for making things less complex, which is standard for Go.

I suppose there's always hope that the Go developers can change things.

silisili•1y ago
You can kinda work around this though. runtime package has a LockOSThread that pins a goroutine to its current thread and prevents others from using it.

If you model it in a way where you have one goroutine per os thread that receives and does work, it gets you close. But in many cases that means rearching the entire code base, as it's not a style I typically reach for.

naikrovek•1y ago
That sounds a lot like just using another language.
silisili•1y ago
It's really not that bad. If you have a codebase in Go you can speed up, it's fine.

That said, if you're greenfielding and see this as a limitation to begin with, picking another language is probably the right way.

jerf•1y ago
If you need it here or there, no. I've got a use case where I need a single locked thread for a particular syscall's functionality. It's not like it leaks out into the rest of the program and everything else has to change to accomodate it.

If you need it pervasively, Go may not be the correct choice. Then again, the list of languages that is not a correct choice in that case is quite long. That's a minority case. An important one, but a minority one.

jasonthorsness•1y ago
It's always a sign of good design when something as complex as the scheduler described "just works" with the simple abstraction of the goroutine. What a great article.

"1/61 of the time, check the global run queue." Stuff like this is a little odd; I would have thought this would be a variable dependent on the number of physical cores.

01HNNWZ0MV43FF•1y ago
That's so funny. I just saw `61` in the Tokio code with a comment "copied this from Go"
__turbobrew__•1y ago
Make sure you set GOMAXPROCS when the runtime is cgroup limited.

I once profiled a slow go program running on a node with 168 cores, but cpu.max was 2 cores for the cgroup. The runtime defaults to set GOMAXPROCS to the number of visible cores which was 168 in this case. Over half the runtime was the scheduler bouncing goroutines between 168 processes despite cpu.max being 2 CPU.

The JRE is smart enough to figure out if it is running in a resource limited cgroup and make sane decisions based upon that, but golang has no such thing.

xyzzy_plugh•1y ago
Relevant proposal to make GOMAXPROCS cgroup-aware: https://github.com/golang/go/issues/73193
robinhoodexe•1y ago
Looks like it was just merged btw.
yencabulator•1y ago
This should be automatic these days (for the basic scenarios).

https://github.com/golang/go/blob/a1a151496503cafa5e4c672e0e...

jasonthorsness•1y ago
uh isn't that change 3 hours old?
kortex•1y ago
Fantastic writeup! Visualizations are great, the writeup is thorough but readable.
weiwenhao•1y ago
Your write-up is so detailed that I even feel like I could implement a complete golang scheduler myself
davidw•1y ago
I'd be interested in seeing a comparison of this and the BEAM/Erlang/Elixir scheduler by someone paying attention to the details.
yencabulator
•
1y ago
Oh heh yes it is. I just remembered the original discussion from 2019 (https://github.com/golang/go/issues/33803) and grepped the source tree for cgroup to see if that got done or not, but didn't check when it got done.

As said in 2019, import https://github.com/uber-go/automaxprocs to get the functionality ASAP.

jasonthorsness•1y ago
super-weird coincidence but welcome, I have been waiting for this for a long time!
williamdclt•1y ago
I honestly can’t count on my fingers and toes how many times something very precisely relevant to me was brought up or sorted out hours-to-days before I looked it up. And more often than once, by people I personally knew!

Always a weird feeling, it’s a small world

formerly_proven•1y ago
This is probably going to save quadrillions of CPU cycles by making an untold number of deployed Go applications a bit more CPU efficient. Since Go is the "lingua franca" of containers, many ops people assume the Go runtime is container-aware - it's not (well not in any released version, yet).

If they'd now also make the GC respect memory cgroup limits (i.e. automatic GOMEMLIMIT), we'd probably be freeing up a couple petabytes of memory across the globe.

Java has been doing these things for a while, even OpenJDK 8 has had those patches since probably before covid.

mappu•1y ago
GOMEMLIMIT is not as easy, you may have other processes in the same container/cgroup also using memory.
kunley•1y ago
As long as I admit respecting cgroup's setting is a good thing, I am not sure it's really quadrillions.

Or is it? Need calculations

formerly_proven•1y ago
I would've expected it to be either way too much or way too little, but after doing the math it could be sorta in the right ballpark, at least cosmically speaking.

Let's go with three quadrillion (which is apparently 10^15), let's assume a server CPU does 3 GHz (10^9), that's 10^6, a day is about 100k seconds, so ~ten days. But of course we're only saving cycles. I've seen throughput increase by about 50% when setting GOMAXPROCS on bigger machines, but in most of those cases we're looking at containers with fractional cores. On the other hand, there are many containers. So...

kunley•1y ago
Nice reasoning, thanks.

Hey, but what did you have in mind with regard to bigger machines? I think we're talking here about lowering GOMAXPROCS to have in effect less context switching of the OS threads. While it can bring some good result, a gut feeling is that it'd be hardly 50% faster overall, is your scenario the same then?

01HNNWZ0MV43FF•1y ago
Trying to see if Rust and Tokio have the same problem. I don't know enough about cgroups to be sure. Tokio at this line [1] ends up delegating to `std::thread::available_parallelism` [2] which says

> It may overcount the amount of parallelism available when limited by a process-wide affinity mask or cgroup quotas and sched_getaffinity() or cgroup fs can’t be queried, e.g. due to sandboxing.

[1] https://docs.rs/tokio/1.45.0/src/tokio/loom/std/mod.rs.html#...

[2] https://doc.rust-lang.org/stable/std/thread/fn.available_par...

nvarsj•1y ago
Probably not?

The fundamental issue comes down to background GC and CPU quotas in cgroups.

If your number of worker threads is too high, GC will eat up all the quota.