Programming languages that blew my mind (2023)

Original Article ↗ Hacker News Discussion ↗

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.