imurray

Here is a pytorch optimizer that can maintain a matrix as orthogonal throughout optimization:

https://github.com/adrianjav/pogo — POGO: A Proximal One-step Geometric Orthoptimizer

https://arxiv.org/abs/2602.14656 — An Embarrassingly Simple Way to Optimize Orthogonal Matrices at Scale; Adrián Javaloy, Antonio Vergari

I think you're thinking of "You Suck at Excel" by Joel Spolsky. https://www.youtube.com/watch?v=JxBg4sMusIg

Lots of past HN discussion... https://hn.algolia.com/?q=you+suck+at+excel

That video was before the introduction of xlookup, which I believe is now worth considering over index and match.

The Ubuntu backport did include regressions that an Ubuntu update a couple of days later addresses: https://ubuntu.com/security/notices/USN-8349-2

That version has security fixes from the same day as the latest rsync release: https://ubuntu.com/security/notices/USN-8283-1

As usual, Ubuntu backported fixes and didn't upgrade to a new version. Whether or not they also backported regressions in edge cases that afflict the latest rsync, I don't know. Pinning the Ubuntu package may prevent getting further regressions, but is preventing you getting any future such backported security fixes.

For those wanting alternatives to KL-divergence, the KL and Jensen–Shannon divergences are both F-divergences: https://en.wikipedia.org/wiki/F-divergence

Reminds me of https://cr.yp.to/djbdns/ipv6mess.html

Which has been discussed previously: https://hn.algolia.com/?q=The+IPv6+mess

I think that's meant to be covered by the "IPv4x when we can. NAT when we must" part, in particular "ISPs used carrier‑grade NAT as a compatibility shim rather than a lifeline: if you needed to reach an IPv4‑only service, CGNAT stepped in while IPv4x traffic flowed natively and without ceremony."

It seemed strange that the need for CGNAT wasn't mentioned until after the MIT story. The "Nothing broke" claim in that story seems unlikely; I was on a public IP at University at the end of the 90s and if I'd suddenly been put behind NAT, some things I did would have broken until the workarounds were worked out.

Ooof, I'd never seen that. Thanks! From the wikipedia link:

The May 1799 test at Oakengates carried a party of investors aboard the vessel, who nearly suffocated before they could be freed.

(!) ...and eventually they built a flight of nineteen locks instead, with a steam-powered pump to return water. The lift locks (and Falkirk Wheel) are a really impressive and elegant solution in comparison.

The Falkirk Wheel is cool and a fun trip, along with the nearby Kelpies, which were much more striking in person than I'd anticipated.

The wheel is a one-of-a-kind, but there are other ways of avoiding having a ladder of flood locks, see: https://en.wikipedia.org/wiki/Boat_lift

I really liked this one in Peterborough, Ontario, Canada: https://en.wikipedia.org/wiki/Peterborough_Lift_Lock Built as a real working lift lock (originally 1904), rather than as a tourist attraction. Powered by a little bit of extra water in one of the buckets to tip the balance and drive the pistons.

The site didn't load for me in Firefox, but I found these fantastic for preventing climbing shoe stink: https://bootbananas.com/product/original-shoe-deodorisers/ They absorb sweat, not just mask the smell.

It's clearly hard, but there are tools for doing exploratory visualization of high-dim data. GGobi http://ggobi.org/ and all the ones that arrange points but try to get local neighborhoods correct (t-sne, umap, et al.).

Some things that may be of interest. First relevant to the posted article:

A site that has used neural nets to classify go moves that good players would probably make that weaker players (of varying ranks) would probably not: https://neuralnetgoproblems.com/ (code available on github)

https://ai-sensei.com/challenge (behind login wall, and in future possibly a pay wall) is a similar idea, but the difficulty of evaluating the position is determined by how users of the site perform in practice.

And more generally, but relevant to your comment:

Players can play humans at an appropriate rank on OGS https://online-go.com/ (not as popular as the Eastern servers, but probably popular enough) -- or against calibrated rank "human-like" AI players by painfully setting up the right katago models themselves, or by paying for a subscription on ai-sensei.com

A go education site that's currently largely by and pitched at Westerners: https://gomagic.org/ for leveling up from the basics.

And a lot of books are now available easily and electronically in English (and some in German): https://gobooks.com/ --- I'd recommend "graded go problems for beginners", "tesuji", and "attack and defense".

Some good sites aren't (fully) available in English, like https://www.101weiqi.com/ -- but there are chrome and firefox extensions to translate just enough of it to make it usable.

[To help search engines: go is also known as weiqi and baduk]

This post is for those interested high-performance matrix multiplication in BQN (an APL-like array language).

The main thing I got out of it was the footnotes, in particular: https://en.algorithmica.org/hpc/algorithms/matmul/ is a really nice post on fast matrix multiplication, and is a chapter of what looks like a nice online book.

A PhD thesis that explores some aspects of the limitation: https://era.ed.ac.uk/handle/1842/42931

Detecting and preventing unargmaxable outputs in bottlenecked neural networks, Andreas Grivas (2024)

generating DTMF tones yourself and injecting them into the audio stream?

When I was an undergrad I had an audio file for each digit and a winamp playlist for each of my frequently dialed numbers. I'd hold my (landline) phone against the computer speakers and double-click the playlist to dial. I'm sure I spent more time setting this up than it ever saved, but it was somehow pleasing that this ridiculously over-powered speed dialer worked.

I wrote firefox and chrome extensions that do exactly what you want:

Firefox: https://addons.mozilla.org/en-US/firefox/addon/redirectify/

Chrome: https://chrome.google.com/webstore/detail/redirectify/mhjmbf...

Source: https://github.com/imurray/redirectify

Sadly I never got around to making it configurable, so it's just a fixed table of rules for a handful of journal and pre-print sites.

Another machine learning paper ("ancient", 2015) where being able to exactly reverse a computation was useful: https://arxiv.org/abs/1502.03492

I'm sceptical about the energy motivation, but there are multiple reasons why making invertible deep learning architectures can be interesting or useful. Cf, a series of workshops from 2019-2021: https://invertibleworkshop.github.io/

Since then diffusion models have been popular. Generating from these can be seen as a special case of a continuous time normalizing flow, and so (in theory) is a reversible computation. Although the distilled/fast generation that's run in production is probably not that!

Simulating differential equations is not usually actually reversible in practice due to round-off errors. But when done carefully, simulations performed in a computer can actually be exactly bit-for-bit reversible: https://arxiv.org/abs/1704.07715

No, it will be about the same. The algorithm is wrong (calling write repeatedly) and -O3 isn't sufficient to rewrite that.

I was asked why there are two tides a day in an interview for my undergraduate University place. I blundered through to the classic answer. This stackexchange discussion made me realize I was even more of an imposter than I thought :-).

Heh. I submitted it in Oct 2012. I submitted a few things back then, none got traction and I stopped bothering :-).

A photo taken on my street (no exif) "only" gives the correct town in chatgpt and gemini, and then incorrectly guesses the precise neighbourhood/street when pushed. Gemini claimed to have done a reverse image search, but I'm not convinced it did. An actual Google reverse image search found similar photos, taken a bit further along the same street or in a different direction, labelled with the correct street (no LLM required).

Looks neat. It would be useful to compare to other implementations: https://ann-benchmarks.com/ -- potentially not just speed, but implementation details that might change recall.

That nice benchmark shows that multiple implementations of HNSW perform differently (my experience also). It would be helpful therefore if HANN benchmarked its implementation against the others, and tried to get the details the same as the best version.

Every product has its hate, but everyone is rarely true. Personally (no longer at Amazon) I was impressed by Chime. It was simple, but rock solid, handling large calls well. Teams is still worse for me (>9 people display is bad, even in MS Edge, when on Linux). Zoom has a finicky interface.

Early in the pandemic I had to use many different systems as an academic, when lots of different contacts pivoted online in different ways. Chime was the least of my problems; it just worked when many other systems struggled.

I liked the Chime meeting/calendar integration at Amazon that could ring everyone at the start of the meeting, meaning that most meetings started promptly.

Nelder–Mead has often not worked well for me in moderate to high dimensions. I'd recommend trying Powell's method if you want to quickly converge to a local optimum. If you're using scipy's wrappers, it's easy to swap between the two:

https://docs.scipy.org/doc/scipy/reference/optimize.html#loc...

For nastier optimization problems there are lots of other options, including evolutionary algorithms and Bayesian optimization:

https://facebookresearch.github.io/nevergrad/

https://github.com/facebook/Ax

See also:

https://www.scale2x.it/

https://johanneskopf.de/publications/pixelart/

And do you know a good speech to text model?

OpenAI's whisper, code+model are available, and multiple projects have built on it. You could try this wrapper: https://github.com/m-bain/whisperX -- or for short utterances on a smart-phone https://github.com/futo-org/whisper-acft

Machine learners might think of "Microtome publishing", who used to print JMLR (the Journal of Machine Learning Research -- community run and free for all authors and readers). It turns out they don't bother to publish on paper any more:

http://www.mtome.com/Publications/JMLR/jmlr.html

The paper says they tried that: https://arxiv.org/abs/2402.14905

Deep link to the relevant snippet in html version: https://ar5iv.labs.arxiv.org/html/2402.14905#S3.SS5

"So far, we trained compact models from scratch using next tokens as hard labels. We explored Knowledge Distillation (KD)... Unfortunately KD increases training time (slowdown of 2.6−3.2×) and exhibits comparable or inferior accuracy to label-based training (details in appendix)."