One operator for all math & Symbolic regression with EML trees - Hacker News (Apr 13, 2026)

First up, a new arXiv paper that tries to make “elementary math” feel almost embarrassingly uniform. The claim is bold: with a single operator, eml(x,y)=exp(x) minus ln(y), plus the constant 1, you can construct the usual scientific-calculator toolkit—exp, ln, arithmetic, exponentiation—and even build constants like e, π, and i. The practical takeaway isn’t that you should write math this way tomorrow, but that it offers a surprisingly simple grammar for representing formulas: everything becomes the same binary-tree shape. If that holds up broadly, it could simplify how symbolic systems store, transform, and search over expressions, because you’re no longer juggling dozens of primitive node types—just one.

What makes it more than a curiosity is the machine-learning angle: the paper treats these EML expression trees as differentiable circuits, then trains them with standard optimizers to fit numerical data and recover exact closed-form functions at relatively shallow depths. That’s interesting because symbolic regression usually fights two enemies at once: a gigantic search space and results that are hard to interpret. A constrained, uniform representation can act like a funnel—still expressive, but more structured—potentially making it easier to land on formulas humans can read, especially when the “true law” is genuinely elementary.

Shifting from math to management, there’s a piece arguing many engineering orgs build day to day without a clear view of the economics behind those choices. The author puts real numbers on the intuition: an eight-person team in Western Europe can cost on the order of tens of thousands of euros per month, and that implies an internal platform team needs to reliably save multiple hours per week per supported engineer just to break even—and more than that once you price in maintenance and the fact that not every initiative works. The point isn’t that platform teams are bad; it’s that “we shipped it” isn’t the same as “it paid off.” In a world where AI tools keep compressing development time, the essay argues headcount and sprawling codebases stop looking like moats and start looking like liabilities unless you can prove they’re buying you measurable outcomes—churn, conversion, activation, or hard cost savings.

In AI infrastructure news, AMD is making the case that ROCm—its CUDA alternative—is graduating from a loosely connected toolkit into something closer to a cohesive product. In an interview, AMD’s AI software leadership talked about tightening release cadence, smoothing developer experience, and unifying acceleration across AMD hardware under a “OneROCm” umbrella. Why this matters is pretty simple: in data centers, software friction often decides hardware deals. If a stack “just works,” it reduces lock-in and makes price-performance shopping easier. AMD is also leaning on more open development practices and investing in higher-level tooling that can make portability less painful, with the big strategic goal being to turn GPU choice into a competitive market again, not a foregone conclusion.

Now to compilers: an arXiv paper proposes a new way to optimize 32-bit unsigned integer division by constants on 64-bit CPUs. This is one of those unglamorous optimizations that quietly affects a lot of real software, because compilers constantly lower divisions like “x divided by 7” into faster sequences. The authors argue the classic approach commonly used in compilers doesn’t fully exploit 64-bit hardware, and they report meaningful microbenchmark speedups on both a high-end Intel Xeon and Apple’s M-series silicon. The most immediate reason to care: patches exist for both LLVM and GCC, and the LLVM change has already landed in mainline—so developers may simply get faster code out of future compiler releases without touching their source.

On the programming-languages front, there’s an essay making the case that Lean stands out because it’s “perfectable”: you can write a program, state a property about it, and prove that property—inside the same environment, with machine checking. That matters less as a party trick and more as a vision for how software changes safely. If you can prove two pieces of code are equivalent, refactoring becomes less of a leap of faith, and optimization can be more aggressive without turning into a bug farm. The essay also highlights Lean’s metaprogramming and syntax extension as unusually practical, pointing toward a future where proving and programming blur together—especially as more developers look for stronger guarantees than tests alone can provide.

There’s also a thoughtful critique of modern web UI: the argument is that we’ve lost the “idiomatic” consistency people took for granted in desktop software—predictable controls, standard menus, reliable shortcuts, and interfaces that don’t reinvent basic interactions. On the web, you see a different date picker, form pattern, and keyboard model everywhere, which forces constant relearning and breaks flow. The author pins the drift on mixed touch-and-desktop priorities, heavy component reuse that can spread bad patterns, and framework-driven front ends that bypass browser conventions. The practical message is refreshing: lean on standard HTML elements, keep labels clear, respect expected browser behavior, and build trust through predictability—because novelty in UI is often just friction with better marketing.

From the community corner, Hacker News’ April 2026 “What Are You Working On?” thread is a snapshot of what builders are actually doing when no one’s writing a press release. Two themes stood out: AI-assisted development, especially agent workflows with guardrails like sandboxing and verification, and a strong tilt toward privacy and local-first tools—offline translation, on-device transcription, self-hosting, and systems that avoid constant cloud dependence. You also see a practical security streak: people exploring new ways to do remote access and networking under restrictive corporate environments. The broader signal is that AI is pushing productivity up, but it’s also raising the premium on reliability, safety, and keeping humans in control of their data and tools.

Finally, a fun bit of open experimentation: a multi-year blog project documenting homemade soft drinks, including a sugar-free, caffeine-free cola, with iterative tweaks and recipes tracked in a public GitHub repo. It’s essentially “reverse engineering,” but in food chemistry—balancing flavor oils, keeping them mixed, dialing acidity, and comparing against commercial benchmarks. Why it fits in this feed is the ethos: reproducibility, versioning, and community improvement, applied outside software. It’s also a reminder that a lot of what we call engineering—measurement, iteration, and careful documentation—transfers cleanly to the physical world.