Programming languages that blew my mind (2023)

Original Article ↗ Hacker News Discussion ↗

Programmers trade stories about languages and tools that “blew their mind,” from classics like Smalltalk, Prolog, APL, Erlang/Elixir and Forth to newer entries such as Rust, Go, Julia, Nim, Uiua and Elixir. Many describe how features like explicit error handling, multiple dispatch, list comprehensions, pipelines, homoiconicity, logic and constraint programming, or live, image-based environments permanently changed how they think about code and problem‑solving. Alongside nostalgia for BASIC, Turbo Pascal, HyperCard and Lotus Notes, a recurring theme is that learning radically different paradigms—rather than just new syntaxes—shapes a developer’s mental model and can be more valuable than chasing the latest mainstream language.

Mind‑blowing languages and tools

  • Many comments list personal “mind blown” languages: BASIC variants, Turbo Pascal, C, C++, Java (for the standard library), Perl, Python, Ruby, Kotlin, Haskell, Elm, Rust, Julia, Nim, Lua, REXX/ARexx, AutoLISP, Smalltalk/Squeak, Objective‑C, Go, Erlang/Elixir, F#, OCaml, Common Lisp, Scheme, Prolog, APL, Forth, Verilog, Uiua, Rebol/Red, Mathematica, R, Excel.
  • Common themes: live environments (Smalltalk, Lisp REPLs), metaprogramming and macros (Lisp, Racket, Tcl), homoiconicity (Mathematica, Lisps, Rebol), powerful standard libraries (Java, Python), generic programming and multiple dispatch (Julia).
  • Several nostalgia tracks: HyperCard, MacBASIC, Lotus Notes, Visual Basic, Flash/AS3, ZX Spectrum/BBC BASIC, early assemblers.

Error handling philosophies

  • Strong debate around Go’s explicit if err != nil style:
    • Supporters praise its simplicity, locality, and forcing developers to confront errors.
    • Critics see it as noisy manual exception propagation that doesn’t truly “handle errors where they occur.”
  • Rust’s Result and the ? operator are widely admired as more ergonomic explicit error handling.
  • Mention of limitations: composing error types in Rust is awkward; crates like thiserror and anyhow help but add boilerplate.
  • Alternatives discussed: Zig’s explicit error types and try, checked exceptions (Java), union types / Either in FP languages, monads in Go (hypothetical).

Logic, constraint, and functional paradigms

  • Prolog repeatedly cited as truly mind‑bending: declarative problem solving, SLD resolution over Horn clauses, and “semantic debugging.”
  • Datalog, constraint programming, SAT/SMT, and answer set programming are suggested as adjacent or more powerful paradigms.
  • Erlang/Elixir’s BEAM VM and “let it fail” model impress many once understood; clarified as “focus happy path, handle failures in supervisors,” not “ignore errors.”

Typing, data modeling, and maps

  • Discussion of a talk arguing that over‑rigid types (records + Maybe/Option) can make systems brittle compared to map/dictionary‑centric designs with optional keys.
  • Some agree this better matches evolving business data and open‑world APIs; others prefer explicit algebraic data types and exhaustive enumeration of cases.

Pipelines and composition

  • Pipeline operators (|>, thread macros, shell pipes, R’s magrittr, fluent interfaces) are widely loved for readability and “data‑flow thinking.”
  • Concern that overuse (long chains with nested lambdas) can harm debuggability; some wish for tooling/linters to keep pipelines reasonable.

Hardware, DSLs, and nontraditional “languages”

  • Verilog described as uniquely mind‑bending: everything executing concurrently; code as circuit description rather than imperative steps.
  • Forth, PostScript, HP calculator RPN/RPL highlight stack‑based and minimalistic approaches.
  • Domain‑specific languages called out: linear/mixed‑integer programming (e.g., GAMS, Pyomo), probabilistic programming (BUGS, Stan, PyMC), and data‑manipulation/plotting DSLs (dplyr/ggplot) dramatically expanded what people could do.
  • Excel’s formula language is framed as a de facto functional language for many users.

Meta reflections

  • Several note how language choice reshapes thinking and career paths; some describe “progression tracks” from early playful BASIC to more abstract or “boring but reliable” tools.
  • There is criticism of AI‑generated blog imagery as visually off‑putting and distracting.