Programming Languages That Blew My Mind (2023)

I would second Prolog as mind-blowing. I've found you're typically confronted with fully engaging with the core of whatever problem you're solving, and only that core. This is probably what can make it so frustrating sometimes as you have no option but to work out the hard stuff nearly immediately; not to mention that unconsidered edge cases, mistakes can cause some pretty opaquely wrong results, or the query not terminating, which can make conventional debugging pretty difficult. The guarantees you get with using the 'pure' core of Prolog do open up some really interesting avenues though, for example Scryer's debugging library is quite neat in affording _semantic_ debugging: https://www.scryer.pl/debug

Just some additional commentary too - I think this post quite misrepresents it with some of the comparisons.

Prolog at its core is SLD Resolution [1] (a form of search) over Horn Clauses [2] (first order logic). Queries posted to the runtime are attempts to find a set of values which will satisfy (cause to be true) the query – whilst SQL is founded on relational algebra which more closely aligned with set theory.

Whilst there's probably some isomorphism between satisfying/refuting a logical predicate, and performing various set operations, I'd say it's a bit of a confusion of ideas to say that SQL is based on 'a subset of Prolog'. The author might be thinking about Datalog [3], which is indeed a syntactic subset of Prolog.

[1]: https://en.wikipedia.org/wiki/SLD_resolution [2]: https://en.wikipedia.org/wiki/Horn_clause [3]: https://en.wikipedia.org/wiki/Datalog

My mind blown experience was listening to a Rich Hickey talk (maybe not [1]) that flipped upside down my accepted method of thinking about types and type system paradigms. I still love writing Haskell and Rust, but I see the warts that he is so concisely pointing out. The either type really sticks out to me now, and I see the problems with overtyping what are essentially maps, and how rigid that makes every aspect of your programs. Currently I deal with a fairly large go monolith that had some clean code practices in it, and changing a single field that is going to make it into the public API ends up being hundreds or thousands of lines of changes. Such a waste of time to CRUD what is a map of strings.

1. https://youtu.be/YR5WdGrpoug?si=jRsXcYlwRuz0C1IN

Very much agree with Erlang/Elixir. After years battling and hating the JVM, I was initially very put off by the existence of a VM (BEAM) and by how it forced the concurrency model on me, and it did make getting into serious development with it harder, but once I "got" it, it really blew my mind. The "let it fail" philosophy was particularly mindblowing to me (especially once I understood that it doesn't mean "don't do error handling").

I started learning programming with modern dialect of BASIC and when I first tried Lua, I've had my mind blown when I discovered:

  - tables (hashmap)
  - regex
  - pass by reference (caused a lot of confusion and frustrating bugs)
  - metatables
  - goto and labels
  - multiple return values

After Lua I did want to try a language that's fast, something compiled to small native binary. My choice was Nim. And Nim got my mind blown to pieces:

  - static types
  - function declarations I can understand how to use without reading their code
  - functional paradigm
  - batteries included standard library
  - compile-time functions
  - generics
  - templates
  - macros
  - exploring and manipulating AST
  - const, let, var (immutability)
  - pointers and references
  - compiler optimizations
  - move semantics
  - memory management
  - I can compile code to both javascript and C?!
  - C, C++ and JS interop (ffi)
  - I can read and understand source code of standard library procedures?!
  - huh, my computer is fast, like crazy fast!!
  - and probably more, but that's what I can recall now..

Verilog

Having done all the functional, lisp-like, logic, stack-based, etc., "non-mainstream" languages, the one that most blew my mind so far is Verilog. Everything executing all the time, all at once, is just such a completely different way of thinking about things. Even though the syntax is C-like, the way you have to think about it is completely different from C. Like it looks imperative, but it's actually 100% declarative: you're describing a circuit.

Everything else maps pretty close to minor extensions over OOP after you've worked with it for a while. Except logic languages, which map like minor extensions over SQL. Verilog to me was in a class of its own.

Go really blew me away with its explicit error handling. As someone who has come from the OOP cult of clean code and other useless principles that haven’t led our industry to have less messes over the past 20-30 years. Who was slowly moving into the “simplicity”, “build things that can be easily deleted”, “YAGNI” mindset it simply clicked.

Then Rust took it a few levels beyond Go.

It’s a really good list, I suspect the languages you add is going to spend on your experience. So I wouldn’t feel too sad if your favorite language is on that list. The author lists Java as a language with an amazing standard library, but something tells me a lot of people will have C#, Go or similar as their Java, and that’s fine!

It's supertempting to remember my path:

1. Basic on ZX Spectrum around 5-6 years old. Draw circle and a box and a triangle and... Look ma, a rocket!

2. Pascal around 10-12. I can write a loop! and a function. But anything longer than 100 lines doesn't work for some reason. C is also cool but what are pointers?

3. PHP around 14-15. The Internet is easy!

4. Perl around the same time. I can add 5 to "six" and get "5six". Crazy stuff.

5. C around 16-17. Real stuff for real programmers. Still didn't understand pointers. Why can't it be more like Pascal?!

6. C++ around 18-19. I can do ANYTHING. Especially UIs in Qt. UI is easy! Now, let's make a Wolf3d clone...

7. Common Lisp + Emacs Lisp around 20. No compilation?! REPLs? What are atoms? Cons cells? Live redefinition of everything? A macro? A program image?

8. Python around 22. Ok, so languages can be readable.

9, 10, 11, ... StandardML for beautiful types and compiler writing, vanilla C and x86 assembly/architecture the deep way, back to Lisps for quick personal development...

Looking back, it's Lisps and vanilla C that sticked.

APL is the perfect mind blower: https://xpqz.github.io/learnapl/intro.html

My university had essentially a weird-languages course to blow our minds. Smalltalk (everything is a message to an object, back when C++ was the new hotness), Lisp (everything is a sexpr that you can redefine), Prolog (everything is a clause to search for known axioms).

Later: Lisp again, because of closures and CLOS let you program how method dispatch should work and CLCS let you resume from just before an error. Haskell, because you can lazily consume an infinite structure, and every type contains _|_ because you can't be sure that every function will always return a value. Java, back when the language was poor but the promise was "don't send a query, send code that the backend will run securely" (this was abandoned).

While I wouldn't say "mind blown", I really like F#'s built-in support for fluent interface style programming using the pipeline operator, e.g.

  X |> one |> two |> three

  versus the more conventional

  three(two(one(X)))

I’ll second Prolog as mind blowing. It is a fundamentally different way to think about problem solving using a computer. Well worth even a trivial playing with it.

I think that are a couple of programming langs out there that everyone needs to be in contact with at least one time. I will mention the three ones that actually changed my mind (I have taken these in a semester at uni): Haskell, Prolog and Smalltalk (even if you do not like nor use them, they will force you to think radically different). Then you should add a structured language (C or Pascal will suffice). If you like metal, try assembly. Yes there are others like APL and Forth but I can't say anything about those as I haven't tried them. Lastly a LISP or scheme flavour won't be bad to experience as well.

I remember my mind being blown when I first came across list comprehensions. It was one thing to be able to effectively generate one list from another:

  Squares = [X*X || X <- [1,2,3,4]].

(This can be read as, Squares equals a list of X*Xs such that each X is a member of [1,2,3,4])

Going from that to then realizing that you can use list comprehensions to implement quicksort in basically 2 lines of code:

  qsort([]) ->
     [];
  qsort([H | T]) ->
     qsort([ X || X <- T, X < H ]) ++ [H] ++ qsort([ X || X <- T, X >= H ]).

These examples are written in Erlang though list comprehensions are found in many other languages, Python and Haskell to name a couple.

Learned programming with Pascal, and Turbo Pascal (not the language itself) was what blew my mind back then. The Swag libraries weren't the language itself neither, but for pre-internet age they were a jump forward.

Then had to do things in OS/2, and then it was the REXX turn. Shell scripting didn't had to be as basic as I knew from DOS. Some years later moved to bash, and from complex script to long but very powerful oneliners, so it was another shock.

Still was working with OS/2 when learned Perl, and regexes, and its hashes, and all with some interesting semantic approach on that. And for many years it was my "complex" shell scripting language. Python was not as mindblowing or at least had the same kind of impact on me.

Nice article. Amazed they came across Prolog but not Forth!?

Prepare to have your mind blown: https://ratfactor.com/forth/the_programming_language_that_wr...

More no-code than programming language but Lotus Notes totally blew my mind.

Imagine going from pre World Wide Web - and for many companies pre-email - age of local area networks (for file sharing only) and 38.K modems directly to group and user oriented, email integrated, distributed, replicated, graphics and multimedia integrated, no-code, document oriented, user programmable, fully GUI, secure, distributed database applications.

Lotus Notes blew my mind completely. A truly amazing application at the time.

Round about the seventh language, he stops using exclamation marks. The list goes from "Mind blown: Programming my own games!" to "Mind blown: Some support for writing my own gradual type system."

Parallel track:

- MacBASIC: Mac GUI programming w/o Pascal or C https://www.folklore.org/MacBasic.html (which is something I'll never forgive Bill Gates for)

- HyperCARD (also on that list, and agree with almost all points made): It was magic to get into Developer mode and to create stacks --- it's unfortunate that Asymetrix Toolbook didn't get further, nor that the Heizer stack for converting HyperCard stacks to Toolbook wasn't more widely available, and a shame that Runtime Revolution which became Livecode reneged on their opensource effort --- hopefully someone will make good on that: https://openxtalk.org/

Unfortunately, I never got anywhere w/ Interfacebuilder.app or Objective-C....

- Lua: real variables in TeX! (and latex), and one gets METAPOST as well --- even recursion becomes simple: https://tex.stackexchange.com/questions/723897/breaking-out-...

- OpenSCAD: Make 3D things w/o having to use a full-fledged CAD program

- BlockSCAD: Make 3D things w/o typing: https://www.blockscad3d.com/editor/ (though to be fair, https://github.com/derkork/openscad-graph-editor also allows that)

- PythonSCAD: variables and file I/O for OpenSCAD (though to be fair, RapCAD had the latter, it was just hard to use it w/o traditional variables) https://pythonscad.org/

Still working through a re-write of my OpenSCAD library in Python: https://github.com/WillAdams/gcodepreview and am hopeful that a tool like to https://nodezator.com/ will make that graphically accessible (w/o going into OpenSCAD mode to use OSGE).

For me it would be (after BASIC, which came with my Apple II):

GraFORTH (build the program up rather than down, mindbogglingly fast 3D graphics on the II)

TransFORTH (same thing, with floats)

Pascal and C (build up or down, convenient syntax)

APL (because it's extremely concise, and taught me the value of understandable code - focus on why, the program already says what and how)

Actor (like Smalltalk, but with a less surprising syntax)

Smalltalk (because the syntax IS important)

Visual Basic (because an integrated interface designer is immensely helpful)

Python (because batteries included)

Haskell (everything is clear once you rotate the program 90 degrees on the time axis)

Rust (because the compiler saves me from myself)

There were a few times I had my mind blown. Once with Scheme when I was watching the old SICP video lectures. But also (and this may be a rather unpopular thing to say) once with C when I had coded something up and compiled it and ran it and it finished instantly. Rust didn't really blow my mind, but I have taken some of its lessons (using error values, lifetime and ownership management) to heart.

Common Lisp, which at the moment is the only language I can see myself using unless I decide to make one myself, never really blew my mind, although the little things it does make it hard for me to imagine switching away from it.

Regular expression is not listed in the article, but it blew my mind when I first used it in Perl. Any of sed/awk/perl/python/ruby/javascript could have expose the author to regular expressions, but maybe they didn't find it as transformative as I did.

Call-with-current-continuation in Scheme blew my mind.

Red/Rebol has a different, powerful approach to homoiconicity and DSLs.

And there is this XL language that has very interesting approach to extending the language, but sadly the compiler is not in a runnable state, I could only assess it by the docs.

Early on when I was learning, assembly language blew my mind. I went from Basic to Pascal but I wanted to make games so I tried my hand at C/ASM and it was just so wild to be that close to the metal after a couple years at such a high level.

In recent years, Go blew my mind with it's simplicity and how strong of a case it makes for writing boring code.

It's been decades since writing C/ASM and my guess is what little I remember isn't applicable anymore, but I plan on diving in again at some point if only to better understand Go.

I'd like to put a word in for AS3. As a kid who grew up on hypercard, BASIC, pascal, proce55ing and eventually PHP and javascript, AS3 was the language that bridged the gap for me to strongly typed code. It made me a much better programmer. The graphics APIs were fantastic but they also taught me for the first time how to avoid tightly coupling graphics with logic.

TS + PixiJS is a reasonable replacement for some of it now, but I still sometimes miss having compile-time warnings.

Mathematica. Usefully homoiconic with an underlying compute model of "get AST, pattern-match-and-replace within in, repeat until fixed point".

As a corollary to this question.

I happen to be learning functional programming and really struggling with a different way of thinking, at the same time I saw the movie Arrival, with the alien language as main plot point.

It struck me that what programming language we pick, fall in love with, dig into, does seem to change our thinking and ways of approaching problems. It can actually change our brain.

My list is similar: PDP-11 BASIC, followed quickly by UCSD Pascal, Turbo Pascal (which brought the most important parts of UCSD Pascal's IDE to CP/M-80/DOS), LISP.

And then Awk, and associative arrays. You can literally create any data structure you need using associative arrays. It won't be fast; but if I could have only one container type, this would be it.

And then TCL, which is where I really learned to appreciate meta-programming. (I wrote Tcl's "Snit" object system in pure Tcl; it got quite a lot of use once upon a time.)

I make it a point to check out new languages on a regular basis, just to keep myself fresh (most recently, Rust and Haskell).

Strand is one of the languages that particularly blew my mind, I think it was Armstrong that said that Strand was "too parallel"

Strand is a logic programming language for parallel computing, derived from Parlog[2] which itself is a dialect of Prolog[3]. While the language superficially resembles Prolog, depth-first search and backtracking are not provided. Instead execution of a goal spawns a number of processes that execute concurrently.

http://www.call-with-current-continuation.org/strand/strand....

I didn't get the part about the stack in assembly, in my experience the stack is very much a thing at that level.

Mainstream CPUs expose one or more explicit stack pointers, and in assembly you use that all the time, right?

Let me add something I found recently, though I haven't used it yet, but it looks impressive from the webpage: Uiua

https://www.uiua.org

My parallel track:

* C++: The feeling that I can make a-n-y-t-h-i-n-g. (not true but still mostly true) * Ruby: elegant, OO, who-needs-compile-time-if-you-have-unit-tests * Haskell: hard to learn but so worth it, by doing so I became a follow-the-types person * Elm: not hard at all, a well picked subset of Haskell for browser apps only * Kotlin: a well typed Ruby, with the ecosystem of the JVM at your disposal * Rust: when every bit of runtime performance counts (but now without sacrificing safety like with C/C++)

Smalltalk: the object/message model so powerful that the language itself doesn't even need any special syntax for ifs or loops.

Slight tangent: Domain-specific languages (DSLs) that blew my mind.

Here are three DSLs that left lasting and positive impressions:

1) Mathematical programming languages, first GNU MathProg, then later python pulp and pyomo. These launched a subcareer in applying LP and MIP to practical, large-scale problems. The whole field is fascinating, fun, and often highly profitable because the economic gains from optimization can be huge. Think of UPS.

2) Probabilistic programming languages, first BUGS (winbugs, openbugs, JAGS), later Stan, pymc, and various specialized tools. These helped me become a practicing Bayesian who doesn't much like p-value hypothesis testing.

3) The dplyr | ggplot universe. These are really two independent eDSLs but they're from the same folks and work great together. Writing awkward pandas|matplotlib code is just soul-wrecking tedium after using dplyr|ggplot.

No Perl? cgi.pm and http requests, plus regexes blew my mind after Basic, Z80 assembler and Turbo Pascal...

One that never seems to make the list, but is worth considering: Excel, the only popular functional programming language! Not the VBA stuff, but the formulaic language of the spreadsheet itself.

My list:

BASIC, but specifically on a TRS-80. I can just type something in and run it. I don't have to wait a week for the teacher to take the card deck over to wherever the mainframe is.

Pascal. That's it, all of it, in those ~4 pages of railroad diagrams expressing the BNF.

C. Like Pascal, but terser and with the training wheels removed. It just fits the way my mind works.

Java. The language itself is kind of "meh", but it has a library for everything.

Perl. Regular expressions and default variables.

> The entire idea of multi-tier programming seems to have been vanished into oblivion

Not entirely https://eyg.run/

The page has been hugged to death, but it isn't github that is the problem; it is cdn.bootcss.com, where some of the static assets for this site are hosted.

BBC BASIC. You mean I can POKE things here, and stuff shows up on the screen in a different color?!

Turbo Pascal. Woah this is fast. And Mum is impressed when code sells for money.

Visual Basic. I'm living in the future, Ma. Dentist has a side business sell flowers and needs a program that can handle root canal and roses? I got you.

Perl. Suddenly system administration is fun again.

Java. My mind is blown, in a bad way. This is what I have to write to keep a roof over my head? Ugh.

Go. Aaahhh. Feels like reading W. Richard Stevens again. Coming home to unix, but with the bad parts acknowledged instead of denied.

No mention of PicoLisp (application server, embedded Prolog, etc, etc...) or Dylan. No way Teller saw them and they didn't make the list.

I found Coq in the list to be very interesting. Is anyone using Coq here for serious math or programming? What kind of problems are you solving with Coq?

And I'd also like to know how different Coq and Lean are. I'm not a mathematician. I'm just a software developer. Is there a good reason for me to pick one over the other?

> Mind blown backwards: Understanding how finally was implemented in the JVM.

In old versions the JVM does jsr and ret. In new versions it just duplicates the code. I don't understand what's mind blowing about it?

Interesting perspective! I think HN would benefit if we shared our own mind-blowing insights here. A couple from the top of my head:

- Python: slicing, full reflection capabilities, and its use as an interface to almost anything [1], not to mention its role as an embedded interpreter (beyond the GIL debate).

- Z3: one of the closest I know for defining the ‘what’ rather than the ‘how.’ I got lost with Prolog when I tried to add more complex logic with ‘hows’, though I was a complete newbie with Prolog. Z3, however, really boosted my beginner capabilities.

- OMeta: allows me to write fast parsers without spending time resolving ambiguities, unlike ANTLR and other popular parsers using classical techniques.

- Smalltalk/Squeak: everything can be re-crafted in real-time, a blend of an OS and a programming language. The community vibe is unique, and I even have friends who implemented an operating system using Squeak. The best example? TCP/IP implemented in Smalltalk/Squeak! [3]. David Weil and I also created an early proof of concept [4] that used Linux behind the scenes, aiming to ‘compete’ with the QNX floppy disk.

- AutoLISP: a programming language embedded in AutoCAD, which I discovered in high school in the late ’80s—only to just find out that its first stable release is considered to be around 1995 [5].

- REXX on the Commodore Amiga: not only could applications be extended with this language, but they could also interact with each other. A decade later, when I used REXX on an IBM Mainframe, I still preferred the Amiga’s approach.

- Racket: I can draw in the REPL. For example with Racket Turtle.

- C++: object orientation "for C". I was not mesmerized by templates.

- Clipper: first database usage and relatively simple to create business apps.

- Objective-C: the first implementation of GCD [1], providing a C/C++ style language with fast performance, a clean event-loop solution, and reflective capabilities. However, I never liked the memory handling.

- Machine Code/Assembler on the Apple IIe: I could jump directly into the assembler monitor from BASIC.

- APL: a powerful yet complex way to program using concise expressions. Not ideal for casual use—best suited if you really understand the underlying concepts.

By the way, it’s time for Apple to embrace programming languages on iOS and iPadOS!

[1] http://www.garret.ru/dybase.html

[2] https://wiki.squeak.org/squeak/1762

[3] http://swain.webframe.org/squeak/floppy/

[4] http://toastytech.com/guis/qnxdemo.html

[5] https://en.wikipedia.org/wiki/AutoLISP

[6] https://en.wikipedia.org/wiki/Grand_Central_Dispatch

I am impressed by Haskell, Prolog, but also ... C.

(zx spectrum) BASIC: nothing like the first contact with AI

C++: pointers, OOP and so much more - good and bad - all in one package

Fortran90: vector programming for humans

Python: general programming for humans

Biggest disappointment: Scratch. Why isn't visual programming more mind blowing?

Anyway, always looking out for these well-regarded "mind-blowing" languages but somehow they never show up in really mind-blowing projects? Would be interesting in this respect to have a list of mind blowing projects that were only possible due to a mind-blowing language.

No Clojure or Lisp so another Mind Blown discovery awaits.

Good article.

No mention of Reflection? Try-catch/Exceptions?

I've been dreaming: can the era of learning foreign languages come to an end now?

Are there large models that fully learn all programming language design principles and all user codes?

Truly achieving natural language programming.

> Mind blown: The stack is an illusion!

Why?

opalang blew my mind when i first saw it too - it took a whole lot of web development ideas that i'd seen floating around various languages and frameworks, and actually managed to make them consistent, principled and wonderfully ergonomic. no offence to ur/web (probably its closest competitor) but i never managed to quite get to grips with it; somehow opa managed to make the ideas feel a lot friendlier and easier to use.

For me.

Practical Phase:

$Basic - look, I can print things to the screen $Assembly - I have no clue what's going on $Matlab - Ok, this mostly makes sense and I can chart graphs and make functions $Python - ok I can do all kinds of automation now. It would be great to create an executable to give someone, but this apparently requires traversing the inner circles of hell. $SQL - declarative languages are weird, but it's easy to get up to speed. I'm doing analysis now over multi-TB datasets. $GAMS - a declarative language for building linear programming and other kinds of mathematical optimization models (algebraic modeling). This language is weird. Ok. Very weird. I'll go back to the Python API. $Unix/Bash/Awk - ok, I'm doing everything through the command line and it is beautiful, but after a short while I have to switch to Python. $Powershell - kind of like the Linux command line, but way more powerful and a lot slower. Can write more complex code, but often the cmdlets are too slow for practical use. Have to move back to Python a lot.

Exploration:

$Lisp - this is supposedly the best language. Read several books on language. Everything seems less readable and more complicated than Python. Aesthetics are fine. A lot of power here. Limited libraries. $Haskell - this seems like it is trying too hard. Too much type theory. $APL - this is really cool. Typing with symbols. Scalars, vectors, and matrices...yeah! $Prolog - very cool, but ultimately not that useful. We have SQL for databases and other ways to filter data. Prob a good niche tool. $Forth - this is amazing, but I'm not a low level hardware coder, so it has limited value. Hardly any libraries for what I want. $Smalltalk - the environment and GUI is part of the application...what? $Rebol - way too far ahead of its time. Like lisp, but more easy to use and dozens of apps in a few lines of code. Amazing alien technology. $Java - OMG...why does everything require so much code? People actually use this ever day? Aghhh. $C - where is my dictionary/hash type? What is a pointer? A full page of code to do something i can do in 3 loc of Python. At least it's fast. $Perl5 - cool. It's like Python, but more weirdness and less numerical libraries and a shrinking community. $Perl6(raku) - They fixed the Perl5 warts and made a super cool and powerful language. Optimization seems like it will take forever though to get it performant. $OCaml - pretty and elegant. They use this at Jane Street. Why is it so hard to figure out how to loop through a text file (this was 10 years ago)? $8th - a forth for the desktop. Commercial, but cheap. Very cool ecosystem. Small and eccentric community. I wish this would be open sourced at some point. $Mathematica - by far the most powerful programming tool/environment I've used for practical engineering and science work. Like lisp, but no environment/library problems. Commercial and pricey. I can create a directed graph and put it on a map of my home town, train a neural network, do differential equations, and create a video out of my graphs all in a single notebook with built-in functions. Nice! $Swift - can I not get this on Windows? $F# - oh it's OCaml on .Net, but the documentation is a little hard to follow. Everyone assumes I know C# and .Net. $Clojure - Rich Hickey is a genius. A lisp IT won't fire me for installing. Oh wait...I don't know the JVM. Workflow kind of soft requires emacs.

Julia is a language that blew my mind. It convinced me that multiple dispatch is the way to do generic programming.

I like the article but I had to come here and say that these AI images in blogs are killing the reading experience:/

He had me until Rust.