frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

Show HN: I'm an airline pilot – I built interactive graphs/globes of my flights

https://jameshard.ing/pilot
251•jamesharding•1h ago•55 comments

Qwen VLo: From "Understanding" the World to "Depicting" It

https://qwenlm.github.io/blog/qwen-vlo/
5•lnyan•6m ago•0 comments

The Power and Beauty of Incrementalism

https://supernuclear.substack.com/p/the-power-and-beauty-of-incrementalism
27•surprisetalk•2h ago•7 comments

I Switched from Flutter and Rust to Rust and Egui

https://jdiaz97.github.io/greenblog/posts/flutter_to_egui/
140•jdiaz97•3d ago•66 comments

Parameterized types in C using the new tag compatibility rule

https://nullprogram.com/blog/2025/06/26/
79•ingve•9h ago•24 comments

Show HN: Zenta – Mindfulness for Terminal Users

https://github.com/e6a5/zenta
84•ihiep•6h ago•16 comments

PJ5 TTL CPU

https://pj5cpu.wordpress.com/
38•doener•7h ago•1 comments

Moonbase Alpha: That time NASA made a meme video game

https://www.spacebar.news/moonbase-alpha-nasa-video-game/
51•todsacerdoti•3d ago•12 comments

AlphaGenome: AI for better understanding the genome

https://deepmind.google/discover/blog/alphagenome-ai-for-better-understanding-the-genome/
476•i_love_limes•1d ago•155 comments

XSLT – Native, zero-config build system for the Web

https://github.com/pacocoursey/xslt
312•_kush•9h ago•227 comments

Launch HN: Issen (YC F24) – Personal AI language tutor

290•mariano54•1d ago•251 comments

Sailing the fjords like the Vikings yields unexpected insights

https://arstechnica.com/science/2025/06/this-archaeologist-built-a-replica-boat-to-sail-like-the-vikings/
91•pseudolus•3d ago•23 comments

Show HN: Sink – Sync any directory with any device on your local network

https://github.com/sirbread/sink
44•sirbread•8h ago•46 comments

Whitesmiths C compiler: One of the earliest commercial C compilers available

https://github.com/hansake/Whitesmiths-C-compiler
16•todsacerdoti•4d ago•5 comments

Calculating the Fibonacci numbers on GPU

https://veitner.bearblog.dev/calculating-the-fibonacci-numbers-on-gpu/
26•rbanffy•3d ago•13 comments

A Lisp adventure on the calm waters of the dead C (2021)

https://mihaiolteanu.me/language-abstractions
42•caned•3d ago•7 comments

Alternative Layout System

https://alternativelayoutsystem.com/scripts/#same-sizer
301•smartmic•19h ago•39 comments

The Effect of Noise on Sleep

https://www.empirical.health/blog/effect-of-noise-on-sleep/
38•brandonb•1h ago•18 comments

The time is right for a DOM templating API

https://justinfagnani.com/2025/06/26/the-time-is-right-for-a-dom-templating-api/
171•mdhb•19h ago•154 comments

Blazing Matrix Products

https://panadestein.github.io/blog/posts/mp.html
33•Bogdanp•8h ago•5 comments

Why is the Rust compiler so slow?

https://sharnoff.io/blog/why-rust-compiler-slow
233•Bogdanp•19h ago•276 comments

Starcloud can’t put a data centre in space at $8.2M in one Starship

https://angadh.com/space-data-centers-1
132•angadh•18h ago•209 comments

A lumberjack created more than 200 sculptures in Wisconsin's Northwoods

https://www.smithsonianmag.com/travel/when-a-lumberjacks-imagination-ran-wild-he-created-more-than-200-sculptures-in-wisconsins-northwoods-180986840/
72•noleary•12h ago•31 comments

VA Tech scientists are building a better fog harp

https://arstechnica.com/science/2025/06/these-va-tech-scientists-are-building-a-better-fog-harp/
28•PaulHoule•3d ago•12 comments

How much slower is random access, really?

https://samestep.com/blog/random-access/
96•sestep•3d ago•47 comments

Kea 3.0, our first LTS version

https://www.isc.org/blogs/kea-3-0/
105•conductor•18h ago•39 comments

Show HN: PILF, The ultimate solution to catastrophic oblivion on AI models

https://github.com/dmf-archive/PILF
4•NetRunnerSu•3h ago•0 comments

Snow - Classic Macintosh emulator

https://snowemu.com/
260•ColinWright•1d ago•86 comments

Show HN: Magnitude – Open-source AI browser automation framework

https://github.com/magnitudedev/magnitude
113•anerli•20h ago•38 comments

E.A. Spitzka's Studies of Exceptional and Deviant Brains (2024)

https://www.huntington.org/verso/ea-spitzkas-studies-exceptional-and-deviant-brains
13•Hooke•20h ago•1 comments
Open in hackernews

A Lisp adventure on the calm waters of the dead C (2021)

https://mihaiolteanu.me/language-abstractions
42•caned•3d ago

Comments

lproven•2h ago
Previously:

https://news.ycombinator.com/item?id=28851992

https://news.ycombinator.com/item?id=44359454

No comments on any of them.

It sounded of interest to me, but I read it and closed the tab within a page or so as it wandered off into tech arcana. Shame. There may be an interesting idea in here but it's phrased in terms I think few will be able to follow and understand.

I did not finish it but I saw no mention of the lambda calculus or of currying, both of which -- from my very meagre understanding -- seem directly relevant to what I understood to be the core point, which seems to be about anonymous functions.

tmtvl•1h ago
The core point, to me, seemed to be about limiting factors in language extension. To allow something like:

  my_if (points <= 100, printf ("%D", points), error ("Invalid point total"));
Where the various parameters are lazily evaluated. Or like:

  frobnicate (frazzle: foo, frozzle: bar, frizzle: baz);
Where frazzle, frozzle, and frizzle are position-independent keyword variables.

Allowing those in C would require a modicum of effort, while other languages make these kinds of syntax extension fairly easy.

PaulHoule•31m ago
In languages like Java (or C) you can build S-expression like structures like so

   Variable<Integer> x = newVariable();
   Expression<Integer> = add(x,literal(5));
   x.set(15);
   System.out.println(eval(x))  // prints "20"
and it is not that hard to either serialize these to code or run them in a tree-walking interpreter where quote() and eval() imply an extended language where you can write functions that work on Expression<Expression<X>>. Type erasure causes some problems in Java that make you sometimes write a type you shouldn't have to and you do have to unerase types in method names which is a little ugly but it works.

I did some experiments towards this to convince myself it would work

https://github.com/paulhoule/ferocity/blob/main/ferocity0/sr...

had I really kept at it I would have bootstrapped by developing a ferocity0 which was sufficient to write a code generator that could generate stubs for the Java stdlib + a persistent collections library and then write a ferocity1 in ferocity0, and if necessary ferocity(N+1) in ferocityN until it supported "all" of Java, though "all" might have omitted some features like "var" that are both sugar and use type inference that ferocity would struggle with -- if you need sugar in this system you implement it with metaprogramming.

The idea is that certain projects would benefit from balls-to-the-walls metaprogramming and the code compression you get would compensate for the code getting puffed up. My guess is a lot of people would see it as an unholy mating of the worst of Java and Common Lisp. However, I'm certain it would be good for writing code generators.

molteanu•18m ago
The solution, which I often seen in practice, is to eventually write code generators, which is what Lisp macros are, after all. I've seen it in C and wrote a big piece about it that was posted here some time ago[1], about the extra tools, code generators, special formats and standards employed and needed to make up for C's deficiencies (in respect to meta-programming, at least).

Everywhere I see code generators, that's a feature lacking in the main language used for the project. Then you bring in other tools to make up for that deficiency. Only, usually, we don't call that deficiency, since we are used to things being that way. It is called day-to-day business. I think that's what I've tried to convey in the article.

[1] https://news.ycombinator.com/item?id=41066544

qsort•43s ago
I have done something exactly like this in production for a system that turned natural language into SQL. This was pre-LLM, so we had models that produced intent and keywords as structured output and we had to turn it into queries for several backends. The project didn't work out for a variety of reasons, but technically it was beautiful: it produced query plans that in many cases were identical to those from the queries analysts wrote by hand. So yeah, I accidentally wrote a compiler. Does it still count?
dreamcompiler•21m ago
Currying is done automatically in Haskell but not in Lisp. If you wanted currying in Lisp you could write it, but Lisp programmers don't depend on or talk about currying as much as Haskell programmers do.
mrbluecoat•16m ago
At least "the dead C" was a nice pun :D