karlding

Keep in mind that overlay file systems are designed to treat the lower layer as read only. Changes made in the merged view are written to the upper layer while the original lower files are untouched.

So if you need to persist changes into the lower layers, I think you may need to do tricks like taking snapshots and then swapping the bind mount (maybe with some diffing logic) or some other offline methods.

I am not a lawyer, but from my understanding the legal precedent is NEC v. Intel which established that clean-room software development is not infringing, even if it performs the same functionality as the original.

As an aside, this clean room engineering is one of the plot points of Season 1 of the TV show Halt and Catch Fire where the fictional characters do this with the BIOS image they dumped.

You can write automated refactoring with clang tools if you need AST-level knowledge across your project (or monorepo).

I’m not sure if there’s other public examples leveraging this, but Chromium has this document [0] which has a few examples. And there’s also the clang-tidy docs [1].

[0] https://chromium.googlesource.com/chromium/src/+/80a6fc33dee...

[1] https://releases.llvm.org/21.1.0/tools/clang/tools/extra/doc...

Do you handle books with no ISBN?

I’ve recently acquired some photo books that don’t appear to have any ISBN but are listed on WorldCat and have OCLC Numbers and are catalogued in the Japanese National Diet Library. Not sure if they actually don't have ISBNs or if I just haven't been able to find them, but from what I got from some research it's quite common for self-published books.

Said online multiplayer [0].

The devs also wrote a write-up here about how they handle the desyncs in netcode [1].

[0] https://slippi.gg/

[1] https://medium.com/project-slippi/fighting-desyncs-in-melee-...

I'm not sure if you're aware, but there's the Wheel Variants proposal [0] that the WheelNext initiative is working through that was presented at PyCon 2025 [1][2], which hopes to solve some of those problems.

uv has implemented experimental support, which they announced here [3].

[0] https://wheelnext.dev/proposals/pepxxx_wheel_variant_support...

[1] https://us.pycon.org/2025/schedule/presentation/100/

[2] https://www.youtube.com/watch?v=1Oki8vAWb1Q

[3] https://astral.sh/blog/wheel-variants

If you watch the video, (one of) the reasons why the AI was winning was because it was using “meta” information from the Street View camera images, and not necessarily because it’s successfully identifying locations purely based on the landmarks in the image.

I realized that the AI was using the smudges on the camera to help make an educated guess here.

[0] https://youtu.be/ts5lPDV--cU?t=1412

Things like cargo-crev [0] or cargo vet [1] aim to tackle a subset of that problem.

There’s also alternate implementations of crev [2] for other languages, but I’m not sure about the maturity of those integrations and their ecosystems.

[0] https://github.com/crev-dev/cargo-crev

[1] https://mozilla.github.io/cargo-vet/

[2] https://github.com/crev-dev/crev/

The University of Waterloo has a similar course, CS452: Real-time Programming.

It’s not quite the same as having physical access to the train set, but a student eventually wrote a simulator for the Märklin train set [0]. Another student wrote an emulator for the TS-7200 used for the class [1] if you don’t want to test your kernel in QEMU.

[0] https://github.com/Martin1994/MarklinSim

[1] https://github.com/daniel5151/ts7200

I don't own AirPods, but one of the things that I've struggled with after the proliferation of headphone jack removal is that on all the Bluetooth headphones/earbuds I've tried the lowest volume setting is still too loud. I normally use Shure SE215s wired, but I've tried the Sennheiser PXC550, Sony WH-1000XM3, Jabra Elite 7 Sport with similar impressions, and tried using my work 2021 MacBook Pro as the audio source instead of my phone. Surely I'm not the only one who feels this way?

On my Samsung phone, I've had to manually set individual app volumes to 80% via Sound Assistant, have additional volume steps enabled, and have the system sound set to the lowest setting when using Bluetooth.

Rob ter Horst's (The Quantified Scientist) test results compared against a fingertip pulse oximeter—which include at ground level and on flights—seem to indicate that they're okay for detecting whether your SpO2 readings are normal/abnormal. Basically it seems that if you get a one-off abnormal reading then it's possible for it to be a false positive, while you're unlikely to consistently get false positive results.

See the video for the Apple Watch Series 6 [0], and Series 7 [1].

There's also tests for the Series 8 [2], although it doesn't include data collected in a low oxygen environment.

[0] https://youtube.com/watch?v=8HIcwMhEny0

[1] https://youtube.com/watch?v=EI-Bsvo7sHs

[2] https://youtube.com/watch?v=u8XbiWIUW4s

To me, it sounds more like the old system that WaterlooWorks replaced (JobMine). JobMine was just Oracle/PeopleSoft's PeopleTools under the hood.

Some of my friends who graduated earlier told stories about how JobMine at one point accepted resumes in HTML. Of course, this also meant that it was vulnerable to XSS attacks. The eventual fix was just to only allow PDF resumes.

There's a "Typo-tolerance" option [0] HN exposes in the search settings [1]. If you disable that, then those results no longer show up.

[0] https://www.algolia.com/doc/guides/managing-results/optimize...

[1] https://hn.algolia.com/settings

I think the break even point for the upgrade is actually $3k/year, not $2k/year?

The standard Gold Star Membership costs $60/year, and the Gold Star Executive Membership costs $120/year [0]. This is an additional $60/year (ignoring sales tax, etc.).

In order to break even, you need to earn at least $60 using the 2% cash back from the Executive Membership in order to cover the upgrade. This works out to ($60/year) / 0.02 = $3k/year.

[0] https://customerservice.costco.com/app/answers/detail/a_id/8...

This is called the "inverted pyramid" structure [0]. It's definitely less common in the era of online media.

[0] https://en.wikipedia.org/wiki/Inverted_pyramid_(journalism)

Sounds like CVE-2015-3860 [0].

[0] https://nvd.nist.gov/vuln/detail/CVE-2015-3860

At a previous job the DB admin mandated that everyone had to write queries that would create a temporary table containing a copy of all the rows that needed to be deleted. This data would be inspected to make sure that it was truly the correct data. Then the data would be deleted from the actual table by doing a delete that joined against the copied table. If for some reason it needed to be restored, the data could be restored from the copy.

The big Facebook outage from last fall [0]?

[0] https://blog.cloudflare.com/october-2021-facebook-outage/

There's the commercial SemanticMerge [0] which might work if it has a parser for the language that you use. According to their docs they currently only support C#, Java, C, C++ and PHP [1].

[0] https://www.semanticmerge.com/

[1] https://www.semanticmerge.com/features

Yeah, see Kenji's comment on /r/seriouseats [0]:

I am not an owner any longer! I gave my shares to my former Sous chef Erik who still lives in the area. My involvement at Wursthall is only a friendly one, not a business one at this point.

However, in the same thread Kenji also says the following [1]:

it’s still my recipes (and one of Stella’s!) there, as well as quite a few Serious Eats-inspired techniques.

[0] https://reddit.com/r/seriouseats/comments/oszuh0/made_it_to_...

[1] https://reddit.com/r/seriouseats/comments/oszuh0/made_it_to_...

Trash compactors work by compressing the trash to reduce its volume. Due to this pressure, trash compactor bags are designed to handle these forces. This makes them much more durable than normal trash bags.

It's a classic ultralight hiker move [0] and is commonly the first suggestion in gear shakedowns on /r/ultralight.

[0] https://sectionhiker.com/how-to-keep-your-backpacking-gear-d...

Do you consider the ClangBuiltLinux project [0] a Google fork?

[0] https://clangbuiltlinux.github.io/

You can also write your own standalone LibTooling [0] app, which accomplishes something similar [1].

[0] https://clang.llvm.org/docs/LibTooling.html

[1] https://clang.llvm.org/docs/LibASTMatchersTutorial.html

I've submitted a few minor PRs (doc changes, typing changes, test fixes, some small features) over the last few years as a non-core developer. To be fair, some changes were reviewed promptly so the problem of reviews taking a long time doesn't necessarily reflect on Python as a whole.

In my experience, typeshed changes were always reviewed promptly and Mariatta reviewed a bunch of simple doc fixes within a couple of days.

Contributing to libraries that didn't have an established owner definitely took longer to get reviewed (even more so for features that only a subset of developers would use). I sent an email on the mailing list to follow up after a while and Guido ended up merging one of the changes. For another PR (to fix a broken test that had been broken for years) a core developer assigned various reviewers, who all unassigned themselves. After a year of no activity, I then followed up directly with a core developer during their office hours and we walked through the review together.

Being a volunteer-run project means that they work on things during their free time, and during my discussion with one of the core developers they highlighted that since Python is volunteer-run, they can't really force anyone to do reviews—people just work on whatever they want, whenever they want. I think that's fair, but it certainly biases away from people who submit a few contributions outside of the core developer group. We also talked about the recommendations in the dev guide about reviewing code as a non-core developer, since it seemed like a sort of chicken and egg problem where people who aren't core developers won't/aren't able to review code. And even if they do, their review isn't necessarily conclusive to getting a change reviewed and approved by a core developer, who likely will just ignore their review (since there's no credibility).

It looks like there's some discussion on the patch series which suggest various diffs that need to be applied in order to compile with LLVM=1 [0].

[0] https://lwn.net/ml/linux-kernel/YdM4Z5a+SWV53yol@archlinux-a...

In general, you can partition the loop to delegate to "workers" and have each instance pipe the output to different files, each corresponding to an output stream. This avoids the need for mutual exclusion around your output streams. If you need to aggregate logs then run some log aggregator.

There's also the pass-tomb extension [0] which stores the directory in a tomb [1].

[0] https://github.com/roddhjav/pass-tomb

[1] https://www.dyne.org/software/tomb/

The 20 Newsgroups dataset is a collection of ~20k newsgroup documents and is super popular for experimentation in text applications of various machine learning techniques. Without Usenet (and archives of Usenet) that probably wouldn't exist.

Enterprise-level Chromium removes view-source to prevent students from cheating [0].

[0] https://news.ycombinator.com/item?id=29211611

Chromium has "Paint Preview" (aka "Freeze-Dried Tabs") [0] which does something similar. Basically it consists of a capture (Skia Picture and links in a proto), compositing the capture into bitmap tiles, and then playback to play the page using the native UI.

I think it's only supported on Chrome for Android right now.

[0] https://chromium.googlesource.com/chromium/src/+/refs/heads/...