frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Derek Lowe: Detonating a Pile of Lead Azide

https://www.science.org/content/blog-post/detonating-huge-pile-lead-azide-really
280•beginning_end•3h ago•162 comments

Lean Verification of the Riemann Hypothesis - Joint statement by...

https://leanprover-community.github.io/blog/posts/riemann-hypothesis/
309•g-b-r•2h ago•229 comments

Brazil's tax authority open-sources its tax calculator on GitHub under MIT

https://www.gov.br/receitafederal/pt-br/assuntos/noticias/2026/novembro/receita-federal-publica-p...
417•dvaplima•4d ago•142 comments

My Monitor Was Cutting My Download Speed by 75%

https://blog.tymscar.com/posts/studiodisplayethernet/
242•soheilpro•6h ago•106 comments

Hurried Announcement: Alessandro Masullo GRH

https://math216.wordpress.com/2026/11/20/hurried-announcement-alessandro-masullo-grh/
2298•jasondavies•22h ago•1093 comments

Show HN: Zero C#, Power of C# without any GC

https://onurgumus.github.io/zero-csharp/index.html
33•reverseblade2•1h ago•21 comments

Levent Alpöge claims proof of the Generalized Riemann Hypothesis [pdf]

https://alpo.ge/remark.pdf
2807•iamronaldo•1d ago•1970 comments

I'm quite pleased by the tech architecture of my art website

https://klauria.tech/klauria-art/
44•evakhoury•1d ago•7 comments

Inkling 2 Mini

https://thinkingmachines.ai/news/inkling-2-mini/
1217•jasondavies•21h ago•236 comments

RCE in Gnupg

https://lists.gnupg.org/pipermail/gnupg-announce/2026q4/000517.html
153•gdgghhhhh•8h ago•50 comments

Deterministic Simulation Testing Is for Everyone

https://outdata.net/blog/261120
28•pgraug•1d ago•2 comments

Show HN: An ASCII cell aquarium for your terminal

https://github.com/kborer/cells/
16•kborer•3d ago•8 comments

Ask HN: I have been unemployed for 2y. 15 years of experience, US. What to do?

416•LetThingsBeDiff•17h ago•448 comments

We promoted developers into architects without informing them

https://manidoraisamy.com/developer-to-architect.html
529•QueensGambit•22h ago•289 comments

Astra 6.2 and Sol 6.2 flop at Simple Bench

https://simple-bench.com/
104•algoth1•3h ago•91 comments

Unforced Navier-Stokes Singularity and the Generalized Riemann Hypothesis

https://terrytao.wordpress.com/2026/11/20/unforced-euler-singularity-unforced-navier-stokes-singu...
508•archon1410•23h ago•213 comments

ClawDOS – An AI coding agent for DOS

http://ricapar.net/ClawDOS/
131•Ricapar•11h ago•42 comments

LLMs can read and write executables byte by byte from a hex dump

https://sgiannopoulos.github.io/blog/machine-code-programming/
86•fortran77•3d ago•65 comments

NINLIVE: The Nine Inch Nails live archive

https://ninlive.com/
323•CharlesW•18h ago•83 comments

The Soviet Elektronika BK-0010 home computer built on a clone of the PDP-11 CPU

https://8bitarchitect.net/machines/elektronika-bk-0010/
8•andrewstuart•3d ago•0 comments

Clojure will affect the way you think about programming (2017)

https://eli.thegreenplace.net/2017/clojure-the-perfect-language-to-expand-your-brain/
162•sammatilda•14h ago•75 comments

Language Models Can Rewrite Their Own Weights

https://arxiv.org/abs/2611.21885
458•lwhsiao•1d ago•138 comments

Slopstrap – Make your site look hastily vibecoded

https://slopstrap.mikelacher.com/
496•mlacher•1d ago•85 comments

Surprisingly Adorable Insect Portraits

https://amateurphotographer.com/latest/these-astonishing-insect-portraits-reveal-a-hidden-world-y...
113•NordStreamYacht•10h ago•25 comments

Nasdaq erases all 2026 gains as AI sell-off dampens Anthropic’s second day

https://www.theguardian.com/business/2026/nov/20/global-stock-markets-slump-anthropic-ipo-ai-sell...
433•cdrnsf•1d ago•762 comments

Sir Brian May adds new dimension to Hera asteroid

https://www.esa.int/articles/about-us/directorates/operations/space-safety/hera/sir-brian-may-add...
144•mooreds•17h ago•33 comments

FBI reportedly investigating apparent hack of its criminal database

https://www.bbc.com/news/articles/cvze7de86pk3o
128•theanonymousone•6h ago•63 comments

Valkey kills the skiplist, cuts sorted set overhead by up to 43%

https://valkey.io/blog/from-skiplist-to-b+tree/
179•reconditerose•4d ago•63 comments

Defcon 5's California Caravan Program/Zine

https://netninja.com/2026/06/08/defcon-5s-california-caravan-program-zine/
22•speckx•3d ago•0 comments

DreamCoder: Coding harness and IDE from the author of Mastering Emacs

https://www.masteringemacs.org/article/announcing-dreamcoder
260•facundo_olano•21h ago•107 comments
Open in hackernews

The Beam

https://www.erlang-solutions.com/blog/the-beam-erlangs-virtual-machine/
105•Alupis•1y ago

Comments

schultzer•1y ago
One thing that is great about Erlang’s pattern matching is that it makes it extremely approachable for writing, lexer, parser and compilers in it: https://github.com/elixir-dbvisor/sql and with Elixir macros and sigils then you can embed other languages like sql and zig to name a few!
wk_end•1y ago
Does Erlang/Elixer have any edge over Ocaml or Haskell in that niche? They also have pattern matching, of course, and strong static types tend to work nicely for compilers too.

Of course, the big superpower they have is the BEAM and the robust multiprocessing support there, but that’s not especially helpful for compilers…or is it?

schultzer•1y ago
Elixir compiler is written in Erlang, Erlang can produce very efficient code, the new json library can beat c libraries at decoding / encoding. And you get this with a strongly typed dynamic language, which is a distributed language. It’s really hard to beat the BEAM, if only we had better number crunching, but in so cases you can always write a nif.
dcsommer•1y ago
"Strongly typed" is stretching it. Type checking is bolted on and not part of `erlc`. Typing is quite unergonomic in Erlang/Elixir (similar to Typescript bolted onto JS).

The type system is one of the weakest parts of the beam ecosystem.

troupo•1y ago
Elixir team is slowly bringing in type checking into the language: https://elixir-lang.org/blog/2022/10/05/my-future-with-elixi... and https://hexdocs.pm/elixir/gradual-set-theoretic-types.html
Munksgaard•1y ago
Erlang/Elixir are certainly strongly typed[0] but they are not statically typed[1].

0: https://en.wikipedia.org/wiki/Strong_and_weak_typing

1: https://en.wikipedia.org/wiki/Type_system#Static_type_checki...

lolinder•1y ago
You can't really use the word "certainly" when speaking about "strongly typed" because the entire concept is fuzzy and subjective. From the article you linked:

> > However, there is no precise technical definition of what the terms mean and different authors disagree about the implied meaning of the terms and the relative rankings of the "strength" of the type systems of mainstream programming languages. For this reason, writers who wish to write unambiguously about type systems often eschew the terms "strong typing" and "weak typing" in favor of specific expressions such as "type safety".

I personally think the whole concept of "strongly typed", which is usually used as a prop to make dynamic languages count as part of the cool kids typed-languages club, should be ditched as a point of argument. The supposed "weakly typed" languages people are usually comparing to (like C) aren't actually framed as viable alternative for problems dynamic languages are suited for, so they're something of a straw man. I'd like to see advocates for dynamically typed languages ditch the obsession with having types like the cool kids and instead focus on showing why dynamism is valuable.

There are plenty of great cases to make for dynamism without having to argue on rhetorical ground that the static languages defined and dominate.

Munksgaard•1y ago
As someone who has used both SML, Haskell, Rust and Elixir professionally: No, not really.

Access to the BEAM is nice, but unless you're targeting the BEAM in your compiler I don't see any benefit. Even if you're targeting the BEAM, you might decide to use another language, cf. Gleam: https://github.com/gleam-lang/gleam/

Edit: Actually, one thing I will mention is the superior support in Elixir/Erlang for pattern matching bitstrings[0]. Not usually helpful in compilers, but an evolution of pattern matching that other languages should take up, in my opinion.

0: https://hexdocs.pm/elixir/Kernel.SpecialForms.html#%3C%3C%3E...

tikhonj•1y ago
OCaml also has a binary string pattern matching feature which sounds pretty similar: https://practicalocaml.com/parsing-with-binary-string-patter...
Rendello•1y ago
Erlang's bitstring/binary handling is one of those things that once you use, you'll wonder why it's not in every language (alongside, for me, Rust's enum/sum types and Python's badly-named but wonderfully useful while-else).
xelxebar•1y ago
Studying the BEAM is definitely on my ToDo list. It's task parallelism sounds exemplar, and I really want to understand the architectural ramifications of choosing fine-grained task parallelism vs. a data parallel-friendly approach.
troupo•1y ago
I wish articles like this had more meat on why BEAM is good.

You have to say why it's good. E.g. https://news.ycombinator.com/item?id=28015852

brandonpollack2•1y ago
If only there was a typed language that didn't hand wave serialization
mrkeen•1y ago
I don't think we'll ever do better than 'IO is made out of bytes'.
kimi•1y ago
Like Java?
monkfish328•1y ago
Love beam

I just wish elixir had static typing built in :)

arrowsmith•1y ago
Give Elixir a try anyway, you might be surprised:

https://arrowsmithlabs.com/blog/you-might-not-need-gradual-t...

Taikonerd•1y ago
Then you'll love Gleam -- it's a BEAM language with static typing!

https://gleam.run/

idahoduncan•1y ago
The Strand programming book states that an early version of the Erlang runtime was implemented in Strand (see "13.1: History" http://www.call-with-current-continuation.org/files/strand-b...), which is an interesting tidbit that I haven't seen come up when the history of Erlang is discussed, like in the featured article.
kristel100•1y ago
It’s fascinating how long the BEAM has lasted. And even more fascinating how relevant its concurrency model still is in today’s async-heavy world. Built different.
Munksgaard•1y ago
I agree that the terminology is not ideal, but think there's a huge difference between JS' "weak types", i.e. abundant implicit conversions, and e.g. Elixirs "strong types", where `1 + "foo"` is a runtime error. I don't care if we call the latter something else though. Any good suggestions?

That said, I prefer having both strong and static typing, but that's another argument.

zbentley•1y ago
I'd suggest "high-cast" and "low-cast". They draw attention to the thing that people usually mean when they talk about strong (not static) typing: whether operations in a language bias towards automatically coercing types so that a non-type-error result can be produced or not. High-cast languages tend towards requiring explicit type conversion; low-cast languages tend towards both implicit conversion and more complex behaviors when more than one type is supplied to a given operation. Also, the terms pun nicely with "high-cost" and "low-cost".

That said, it's still a spectrum and there's a lot of subjectiveness here. Everyone agrees that '1 + "foo"' is meaningless, but what about string multiplication? If a language documents that an integer multiplied by a string repeats the string, is that weakly typed/low-cast, or is it just documented multiplication operator behavior? If string multiplication is a whole separate operator, is that more strongly typed (and if so, are we all gonna be able to sleep at night since that means Perl 5 is more strongly typed than Python)?

That subjectiveness extends into the domain of hidden runtime costs, as well. Theoretically, any iterable of hashable items can be passed to a language's implementation of "HashSet::union(items)". But the implementation/performance of "union()" might differ based on the type of the iterable: should we be allowed to pass a lazy iterator which produces values after arbitrary custom computations? Many languages say "yes" here, but some consider collecting/each-ing the iterator something that must be explicit so the cost/exhaustion/side-effectfulness of the iteration is made clear. How about unioning a set with a vector, versus another set? Very different algorithmic behavior happens inside the union if another hash set is supplied instead of, say, a static array or linked list; while the complexity for nonlazy unions is always O(N), the average complexity/wallclock performance may be very different. Rust's stdlib, for example, discourages this kind of heterogenous union (not, I suspect, out of a desire for high-cast-explicitness, but because it wants to encourage use of its lazy O(1) union system instead). Are the answers to that question part of the high-cast/low-cast (or strong/weak type system) spectrum, or are they just specific choices made by each language's collections library? Ask 10 programmers, and I suspect you'll get a lot of different answers.

cess11•1y ago
Dialyzer might be considered "bolted on", but the BEAM itself is strongly and dynamically typed. In Elixir the compiler is getting static typing as well.

https://learnyousomeerlang.com/types-or-lack-thereof

These languages have other properties that can play the role that types are sometimes relied upon to do. It's uncommon that I think in types at all when building things in Elixir, thinking about shapes usually gets me all the way.

In my experience string processing libraries are the weakest part, due to some of them having abysmal performance for whatever reason. Last I had this problem I wanted to do ETL on mbox files but gave up and did it with someone's PHP one-class weekend project instead.

cess11•1y ago
You probably don't, Numerical Elixir/Nx has been out for years and did the NIF:ing for you.

It's one part of why it's quite convenient to juggle ML and LLM tasks on the BEAM, and easy enough that I can manage it.

https://github.com/elixir-nx