frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

Al Lowe on model trains, funny deaths and working with Disney

https://spillhistorie.no/2026/02/06/interview-with-sierra-veteran-al-lowe/
39•thelok•2h ago•3 comments

Hoot: Scheme on WebAssembly

https://www.spritely.institute/hoot/
101•AlexeyBrin•6h ago•18 comments

First Proof

https://arxiv.org/abs/2602.05192
52•samasblack•3h ago•39 comments

OpenCiv3: Open-source, cross-platform reimagining of Civilization III

https://openciv3.org/
789•klaussilveira•20h ago•243 comments

Stories from 25 Years of Software Development

https://susam.net/twenty-five-years-of-computing.html
39•vinhnx•3h ago•5 comments

Reinforcement Learning from Human Feedback

https://rlhfbook.com/
63•onurkanbkrc•5h ago•5 comments

The Waymo World Model

https://waymo.com/blog/2026/02/the-waymo-world-model-a-new-frontier-for-autonomous-driving-simula...
1040•xnx•1d ago•587 comments

Start all of your commands with a comma (2009)

https://rhodesmill.org/brandon/2009/commands-with-comma/
464•theblazehen•2d ago•165 comments

France's homegrown open source online office suite

https://github.com/suitenumerique
510•nar001•5h ago•235 comments

Vocal Guide – belt sing without killing yourself

https://jesperordrup.github.io/vocal-guide/
184•jesperordrup•10h ago•65 comments

Software factories and the agentic moment

https://factory.strongdm.ai/
51•mellosouls•3h ago•52 comments

The AI boom is causing shortages everywhere else

https://www.washingtonpost.com/technology/2026/02/07/ai-spending-economy-shortages/
63•1vuio0pswjnm7•7h ago•60 comments

Coding agents have replaced every framework I used

https://blog.alaindichiappari.dev/p/software-engineering-is-back
189•alainrk•5h ago•282 comments

A Fresh Look at IBM 3270 Information Display System

https://www.rs-online.com/designspark/a-fresh-look-at-ibm-3270-information-display-system
27•rbanffy•4d ago•5 comments

72M Points of Interest

https://tech.marksblogg.com/overture-places-pois.html
19•marklit•5d ago•0 comments

Unseen Footage of Atari Battlezone Arcade Cabinet Production

https://arcadeblogger.com/2026/02/02/unseen-footage-of-atari-battlezone-cabinet-production/
108•videotopia•4d ago•27 comments

Where did all the starships go?

https://www.datawrapper.de/blog/science-fiction-decline
59•speckx•4d ago•62 comments

Show HN: Look Ma, No Linux: Shell, App Installer, Vi, Cc on ESP32-S3 / BreezyBox

https://github.com/valdanylchuk/breezydemo
268•isitcontent•21h ago•34 comments

Learning from context is harder than we thought

https://hy.tencent.com/research/100025?langVersion=en
198•limoce•4d ago•107 comments

Monty: A minimal, secure Python interpreter written in Rust for use by AI

https://github.com/pydantic/monty
281•dmpetrov•21h ago•150 comments

Making geo joins faster with H3 indexes

https://floedb.ai/blog/how-we-made-geo-joins-400-faster-with-h3-indexes
152•matheusalmeida•2d ago•47 comments

British drivers over 70 to face eye tests every three years

https://www.bbc.com/news/articles/c205nxy0p31o
169•bookofjoe•2h ago•153 comments

Hackers (1995) Animated Experience

https://hackers-1995.vercel.app/
549•todsacerdoti•1d ago•266 comments

Sheldon Brown's Bicycle Technical Info

https://www.sheldonbrown.com/
422•ostacke•1d ago•110 comments

Ga68, a GNU Algol 68 Compiler

https://fosdem.org/2026/schedule/event/PEXRTN-ga68-intro/
39•matt_d•4d ago•14 comments

Show HN: I spent 4 years building a UI design tool with only the features I use

https://vecti.com
365•vecti•23h ago•167 comments

An Update on Heroku

https://www.heroku.com/blog/an-update-on-heroku/
465•lstoll•1d ago•305 comments

Show HN: If you lose your memory, how to regain access to your computer?

https://eljojo.github.io/rememory/
342•eljojo•23h ago•210 comments

What Is Ruliology?

https://writings.stephenwolfram.com/2026/01/what-is-ruliology/
66•helloplanets•4d ago•70 comments

Show HN: Kappal – CLI to Run Docker Compose YML on Kubernetes for Local Dev

https://github.com/sandys/kappal
18•sandGorgon•2d ago•8 comments
Open in hackernews

The history of the Schwartzian Transform (2016)

https://www.perl.com/article/the-history-of-the-schwartzian-transform/
54•mooreds•6mo ago

Comments

RodgerTheGreat•6mo ago
I wrote a blog post some time ago which contrasts the "Schwartzian transform" with the slightly clearer alternative used by most APL-family languages and (in my opinion) an even cleaner approach which is possible in languages with a first-class table type: https://beyondloom.com/blog/rankingoffruits.html
inopinatus•6mo ago
That was a lovely vignette, thanks. Much earlier in my career I had exactly the sense suggested that “something’s off” about the Schwartzian, even though it became a useful and idiomatic tool at the time. I only really understood the disquiet much later, when working with columnar data, and realising the positive qualities of declaring structs-of-arrays rather than arrays-of-structs, with subsequently excellent mechanical sympathy, and so on from there.
throwanem•6mo ago
Unfortunately, the only such language to which most workaday devs have access is some dialect of SQL. Fortunately, at least there's that.
mont_tag•6mo ago
Python's key-functions nicely encapsulate the whole process.
oofabz•6mo ago
I find it interesting that the transform was controversial in the '90s.

Today, it seems like a normal solution to the problem to me, and the controversy seems silly. I have much experience with the map function from Javascript. It is too simple to be objectionable.

But in the '90s, I would also have had trouble understanding the transform. Lambdas/closures were unheard of to everyone except Lisp dweebs. Once I figured out what the code was doing, I would be suspicious of its performance and memory consumption. This was 1994! Kilobytes mattered and optimal algorithmic complexity was necessary for anything to be usable. Much safer to use a well understood for loop. I have plenty of experience making those fast, and that's what map() must be doing under the hood anyway.

But I would have been wrong! map() isn't doing anything superfluous and I can't do it faster myself. The memory consumption of the temporary decorated array is worth it to parse the last word N times instead of N log N times. Lisp is certainly a slow language compared to C, but that's not because of its lambdas!

zippyman55•6mo ago
Thank you for posting! I always felt like such a badass in the late 1990s when I used this.
ygritte•6mo ago
I'm so grateful for the Lisp translation. Perl is such a write-only language, my hair curls up just from looking at it.
spauldo•6mo ago
To be fair, this isn't what normal Perl usually looks like. Perl allows you to write like this but most people don't. This is more like Duff's Device in that it works and it's clever and you'd can anyone who put it in production code.

That's not to say that idiomatic Perl doesn't have its quirks and oddities - Perl idioms do throw off people who aren't used to them. But this is a bit far even for Perl.

dale_glass•6mo ago
I've definitely seen it in production code, but it was a good deal after 1994.

By then it was a commonly known technique, so it was a pattern a Perl dev would be expected to recognize.

kilna•6mo ago
If the production code has to be maximally performant, you'd want the transform. It doesn't copy data around with a bunch of needless assignments. Pipelining the extract/sort/reconstitute in this manner is absolutely the right thing to do in production if production requirements are to keep it fast and with a small footprint. There's no excuse for not commenting it, but strictly-code-speaking there's no reason not to use this for production if the requisite needs are there.
throwanem•6mo ago
Eh. It's not worse than Ruby, and vice versa.
heresie-dabord•6mo ago
> X is such a write-only language, my hair curls up just from looking at it.

That would be a powerful language feature, but alas

X.isWriteOnly() for X in aLanguagesIdonotUse

is merely akin to

X.hasTooManyRules() for X in aHumanLanguagesIdonotSpeak

ubercore•6mo ago
I believe I first came across this in the early xslt days, when I had a manager that wanted to write all software with an XML requirements spec, then use xslt to simultaneously generate code AND documentations.

1. It did not work because of course it didn't work 2. This meant that all data output of the system would done in XML and transformed, so I got to know xslt quite well 3. It did give me a fun moment at a conference where a speaker asked "Who knows the Schwartzian transform or has used it?" and only me and my coworkers raised their hands

jiggawatts•6mo ago
I was curious to see what other languages do by default (or not), so I quickly tested a few:

C# evaluates the lambda only once per item, in input order: https://dotnetfiddle.net/oyG4Cv

Java uses "Comparators", which are called repeatedly: https://www.jdoodle.com/ia/1IO5

Rust has sort_by_key() which is encouraging... but also calls the key transformation many times: https://play.rust-lang.org/?version=stable&mode=debug&editio...

C++20 with std::range also calls the lambda repeatedly: https://godbolt.org/z/raa1766PG

Obviously, the Schwartzian Transform can be manually implemented in any modern language elegantly, but it's interesting that only C# uses it implicitly!

PS: The fancy solution would be a temporary "Hashset<T,K>" used to map values to the transformed sort keys, so that the mapping Foo(T t): K would only be called once for each unique input value 't'. That way the transformation could be invoked less than O(n) times!

ynzoqn•6mo ago
Inspired by your behavior, I looked up the Wikipedia article on Schwartzian transform[1]. The article mentioned that Rust not only provides sort_by_key, but also sort_by_cached_key. :D

[1]: https://en.wikipedia.org/wiki/Schwartzian_transform

jiggawatts•6mo ago
I keep saying to colleagues that simply knowing that something exists in a library somewhere is 90% of the skill of modern programming.

I suspect the profession of software archeology form the Vernor Vinge science fiction novels will soon become a reality, especially now that old languages can be uplifted mechanically with AI.

Sharlin•6mo ago
This one is particularly easy to chance upon, though, by either browsing the docs of slices’ `sort*` methods (because they’re all clumped together on the page), or even simpler, noticing it when you type `foo.sort` and your editor suggests autocompletions.
Sharlin•6mo ago
The reason Rust has a separate `sort_by_cached_key` is, of course, that it doesn’t make sense to cache cheap projections which are the 95% use case.

The implementation is somewhat more sophisticated than just the naive transform:

> The current implementation is based on instruction-parallel-network sort by Lukas Bergdoll, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on fully sorted and reversed inputs. And O(k * log(n)) where k is the number of distinct elements in the input. It leverages superscalar out-of-order execution capabilities commonly found in CPUs, to efficiently perform the operation.

> In the worst case, the algorithm allocates temporary storage in a Vec<(K, usize)> the length of the slice.

jiggawatts•6mo ago
Indeed, that works the same as the default C# sort: https://play.rust-lang.org/?version=stable&mode=debug&editio...
Sharlin•6mo ago
> Some people want Perl to be accessible at first glance to someone who doesn’t know the language.

…oh boy.

In retrospect it doesn’t seem like these people prevailed.

kilna•6mo ago
Perl was ahead of its time, and likely because of it's Borg-like capacity to absorb a little bit of everything... it was unfortunately nigh on impossible to refactor. This is why Perl6 (nee Raku) took nearly 2 decades to be "done". It's a crying shame that it lost momentum, because many of the techniques that the features of Raku enable are as clever/succinct/revolutionary as the Schwartzian Transform was back in its day... but because the developer community is so very small now, Raku will have a very hard time catching up to the performance of competing languages.