What piece of code/codebase blew your mind when you saw it?

https://en.wikipedia.org/wiki/Duff%27s_device

  send(to, from, count)
  register short *to, *from;
  register count;
  {
      register n = (count + 7) / 8;
      switch (count % 8) {
      case 0: do { *to = *from++;
      case 7:      *to = *from++;
      case 6:      *to = *from++;
      case 5:      *to = *from++;
      case 4:      *to = *from++;
      case 3:      *to = *from++;
      case 2:      *to = *from++;
      case 1:      *to = *from++;
              } while (--n > 0);
      }
  }

The Legendary Fast Inverse Square Root with "Voodoo Black Magic"

https://medium.com/hard-mode/the-legendary-fast-inverse-squa...

Quine Relay, "a Ruby program that generates Rust program that generates Scala program that generates ...(through 128 languages in total)... REXX program that generates the original Ruby code again."

https://github.com/mame/quine-relay

(HN thread: https://news.ycombinator.com/item?id=6048761)

I've read and re-implemented a lot of stuff by Inigo Quilez. Much of it is ingenious but eventually straightforward once you get the hang of it. I still find this particular snippet magical:

https://www.shadertoy.com/view/MdB3Dw

Well, the code itself is simple GLSL. The math is (and I have not verified this) not that complex either, as I believe it's all about integrating the raytracing equation for a moving sphere over the time variable. I guess what I find most impressive is just the fact that it works and that someone even thought of doing that. I also think this is currently the only example of this method being used anywhere, and it might mostly stay that way because the method might not be super generalisable.

https://github.com/chrislgarry/Apollo-11/blob/a13539c7c5c482...

My mind was blown that I could read Apollo 11 source code. It was additionally blown that it included comments like, "# TEMPORARY, I HOPE HOPE HOPE"

Years ago, fresh out of training, I got a job that involved image recognition, and I spent a couple of weeks reading the code dealing with image processing. I was confused, until I realized that all the operations were basically the same, the only difference was the matrix of weights applied to the pixels.

That same week, I had a chat with a friend who at the time was dabbling in audio processing, and we tried to understand how lowpass and hipass filters worked. When we did understand it, I realized they worked basically the same as the image processing operations, just with a temporal aspect to it.

I really don’t like that example. I get that it’s just demonstrating mutual recursion and not intended to be practical, but I feel like there could be other ways to demonstrate that concept that aren’t so inefficient.

My answer would be the jQuery code base, back in the day when that was popular. At the time I didn’t know a whole lot about Javascript or the DOM. I remember it feeling like the kind of code you could just read top to bottom and it was almost like reading a novel. Really well-organized, well-commented, and effective. I don’t know if it’s still like that, but at the time it was transformative for me.

I was mind blown in college when learning recursive programming and being introduced to the recursive solution to the Tower of Hanoi problem:

- https://en.wikipedia.org/wiki/Tower_of_Hanoi#Recursive_imple...

I remeber thinking "where's the rest of the code? It surely can't be just those lines!"

Not code or a codebase - but reading Eloquent Ruby every morning on the DC Metro made the commute to work fly by in an instant and kinda blew my mind. I will try to illustrate the stuff that blew my mind below:

Quick backstory: a feature of Ruby (that you tend to either love or hate) is that you do not need to use parentheses to call a function.

if you have a function like so

    def prefix_hello(name)
      "hello, #{name}!"
    end

you can call it like this

    prefix_hello "fred"
    => "hello, fred!"

After learning about some of the spiritual ancestors of Ruby (like Smalltalk), message passing, learning everything is just an object and function calls are just messages being sent to objects, a lot of things clicked immediately for me. It was kind of a mind blown moment.

Take the `+` (add) symbol in `5 + 3` - in essence, it's just a regular method that is literally caled `def +(number)`, which belongs to the int/number object.

In laymans terms this code is saying, hey object (number) '5', call your + method with '3' as the argument.

You can simulate this in an `irb` shell:

    irb(main):001:0> x = 10
    => 10
    irb(main):002:0> x.send(:+, 10)
    => 20

It's all right there! `objectA.send(methodName, arg, arg, arg)`

Then you realize that this is true of many languages, Python included (__add__)... but I do think Ruby does this in a particularly, ahem, eloquent way that really impressed me.

This moment in my career/learning was almost like a springboard/catalyst and unlocked a lot of additional learning down the road, like getting involved with Erlang and Lisp/Clojure.

Handmade Hero.

Before warching Casey program, it had not occurred to me you could sit down with a compiler and write an entire video game from scratch.

Then, I found out Jonathan Blow sat down and wrote his own compiler, followed by an engine, and now has a game in flight.

It's a truly incredible what these guys (and their teams) get done.

Actually Portable Executables / Cosmopolitan

https://justine.lol/ape.html https://github.com/jart/cosmopolitan

qmail was the first codebase I read that blew a lot of assumptions I had about "good code" and "clean design" out of the water.

It went its own way on a lot of things compared to GNU projects and achieved an enormous level of success for 10-15 years despite some really weird decisions. And even the "wrong" decisions, with hindsight, stemmed from a clear desire to keep creative control and a small codebase. I'd rather read well-documented "bad" code any day of the week.

Since then I've felt a bit of rebellion against standard practice is often a valuable if it's 100% aligned with the goal of your project - reinventing a wheel, ignoring portability, picking a weird language, a new storage format, that kind of thing.

For an engineer it's so easy to get sucked into assuming you should make standard, well-supported, well-understood choices that you suppress your more creative & judgmental instincts.

Ken Thompson's self-perpetuating hack on the c compiler and login.c to create a back door that is invisible in the compiler source code and the source code of login.c. Described in his Turing Award acceptance speech, "Reflections on Trusting Trust".

In python the inverse of the zip function is zip. You call it with with * to make list elements into function arguments. So a, b = zip(*c) is the inverse of c = zip(a, b).

A binary rate-monotonic scheduler. It was in the Ada realtime executive for an avionics box (there was no OS). It executed tasks at 5 rates, each half as fast as the previous one. It was dead simple, something like (pseudocode)

    counter = 1

    do highest priority stuff
    case counter
        when 1, 3, 5, 7, 9, 11, 13, 15
            do high priority stuff
        when 2, 6, 10, 14
            do medium priority stuff
        when 4, 12
            do low priority stuff
        when 8
            do lowest priority stuff (1st half)
        when 16
            do lowest priority stuff (2nd half)
    end

    counter++
    if counter > 16
        counter = 1
    end

This was called on a timer interrupt.

I was like "what the heck does this do?" followed by "that sure reminds me of binary trees" and finally "whoa! cool!"

For me it was the "Make a Lisp" project. Reading the architectural diagram of a Lisp interpreter, and browsing its implementation in many (~87) programming languages.

https://github.com/kanaka/mal

Especially where the guide explains how tail-call optimization works, my mind was blown.

https://github.com/kanaka/mal/blob/master/process/guide.md#s...

Studying the project changed the way I understand code. Since then I've created my own little Lisps in about three or four versions/languages. Next I'd like to write one in WebAssembly Text format, which is already in a Lisp-shaped syntax.

I went through and commented the Perl tokeniser (toke.c) back in the late 90s/early 2000s, and my mind was blown by the "is this regular expression syntax involving $ or is it a variable interpolation involving $"? logic which was basically "here are some things we might have seen, make a weighted sum of which were actually seen and then if it's greater than x, let's assume it is variable interpolation".

You'll note that we were busting that clean separation between tokeniser and parser. Yup, sometimes it's hard to DWIM and still stay in your lane.

Just checked and, thanks to the hard work of far smarter people than myself, the whole thing has been refactored and now the better code has better comments. Progress is wonderful! (I couldn't find the weighted guess, so maybe they found a way to work around it)

Here's the first that blew my mind, from the early 1980s: It was a BASIC "AI" program that would guess what animal you were thinking of just by asking a few questions. "That's crazy," I thought.

And, it learned more each time you ran it - even more crazy! It was only when I looked at the source code and realized that it was using self-modifying code that I went, "Wait a minute - THAT'S A THING?"

I had so many of those moments. The very first was realizing you could use an iterator variable to do other things within the loop. That's the exact moment when programming clicked for me. My perception of it changed from being a glorified way to write out steps (like a hair-washing algorithm on a shampoo bottle) to realizing it could be very expressive and flexible.

Well, .NET's garbage collector certainly springs to mind. Not exactly in a good way. You know you have something special on your hands when GitHub refuses to show you a highlighted version of a hand written C++ file (https://github.com/dotnet/runtime/blob/98984ccad55362a66b7fd...).

Other than that, I remember my mind was blown a few times while watching Jim Weirich's presentation on functional programming all those years ago (https://www.youtube.com/watch?v=FITJMJjASUs).

The OPs example blows my mind but not in the way originally intended. Wow, it managed to make a trivial constant-time operation into an exponential-time operation. This is a mind-blowingly bad example of recursion.

It's like trying to enter a house by demolishing it and rebuilding it around you instead of opening the door and walking in.

Thanks to Haskell's laziness, the following implementation of `minimum` is O(n):

  import Data.List (sortBy)

  minimum :: Ord a => [a] -> a
  minimum = head . sortBy compare

`sortBy` is O(n log n). But `head` only needs the first element which can be found in linear time. So `sortBy` does not compute the rest and `minimum` is O(n).

Arthur Whitney's compiler for a language "isomorphic to c": https://kparc.com/b/.

Amazing that someone can write correct, fast code like that.

The Peter Norvig spellchecker: https://norvig.com/spell-correct.html

I like it because it's so clearly coded - there are no crazy syntax tricks or hacks - it's just obviously the right way to write it. And yet it is compact, elegant and non-obvious if you are writing it yourself.

The original ADVENT game in FORTRAN. It was way, way beyond my pedestrian programming. It even had OOP in it: "a troll is a modified dwarf". And it did the marvelous thing of once it had gone through the world-building initialization, which took some time, it would patch its own executable with the results!

I used that trick for years until the virus scanners shut down that sort of activity. Sigh. This is why we can't have nice things.

LFSR's are mind blowing; the fact that you can generate a randomish sequence that covers an entire ^2 range visiting each number once, and only once, seems like a lucky piece of magic.

And in just a couple of lines, excuse my quickie untested code:

  #include 
  #include 

  // 5-bit maximal LSFR taps to get pseudo-random sequence of 31 unique numbers in range 1-31
  // 0x12, 0x14, 0x17, 0x1B, 0x1D, 0x1E, 0x18, 0x17
  int main(int c, char **v) {

    uint8_t taps = 0x17; // could be any of the taps above
    uint8_t seed = 0x7;  // start, could be 1-31
    uint8_t lfsr = seed;

    do {
      printf("%d\n", lfsr);
   
      lfsr = (lfsr & 1)
             ? (lfsr >> 1) ^ taps
             : (lfsr >> 1);
    } while ( lfsr != seed );

    return 0;
  }

Swap two variables using XOR:

    x ^= y;
    y ^= x;
    x ^= y;

Check if the number is even:

    x & 1 == 0

For me it was as simple as when I could start doing functional programming with javascript.

I was so surprised, since I had learned the other way first that it is actually easier to teach functional approaches with teenagers.

arr.map(x => x2) was abundantly clearer than

const newArr = [] for(let i, i < arr.length, i++) { newArr.push(arr[i]2) }

And to be perfectly honest, I might have goofed the for loop.

It has long since been cleaned up, but the history of Lucene's Levenshtein automatons are a fascinating mix of pragmatism, hackery, grit, and engineering. Using a Python library to generate crazy-looking Java code, which you can't (yet) understand, but whose tests pass and benchmarks look amazing.

- https://blog.mikemccandless.com/2011/03/lucenes-fuzzyquery-i... - https://www.youtube.com/watch?v=4AbcvHKX8Ow

(Levenshtein distances are used as a measure between fuzzy/misspelled matches, and was ironically misspelled initially - https://lucene.apache.org/core/7_4_0/suggest/org/apache/luce...)

Lots of good responses here, so I’ll give an example that blew my mind in a negative way:

Fortran IV code, thousands of lines, no functions, only GOTOs jumping everywhere randomly. Mostly one or two letter variables, lots of GOTOs that turned out to be loops, with lots more jumping into the middle of them and jumping out of them into other loops. No documentation, I was supposed to modularize it. Failed.

But it successfully calculated thermodynamic properties for engineering designs, so go figure.

Hashlife.

I'm pretty sure that if something of the sort had occurred to me before I came across it, I would have thought "that'll never work" and moved on without taking it seriously.

I'm partial to this snippet from SICP (4.2.3 Streams as Lazy Lists):

    (define (cons x y) (lambda (m) (m x y)))
    (define (car z) (z (lambda (p q) p)))
    (define (cdr z) (z (lambda (p q) q)))

This implements cons-style linked lists in terms of only functions. In other words lists need not be the fundamental construct of a Lisp/Scheme—you can use functions instead.

I love learning programming, and also math, because I feel like my mind is blown every time I come across a new concept.

However, it's rare for that feeling to obtain just by programming in a language. One language that (so far) has consistently had that feeling even when simply programming in it is Dyalog APL.

To think that it's so expressive that naming things is often unnecessary, the name being the function itself.... It feels like I'm playing with raw essence.

+/÷≢ is the classic example, of course. That's four characters -- the "tally" character at the end tends to render wrong in browsers, but I assure you it really is only one character. Four characters! What is the name of the function? Either "Mean", or "Average", one of which is four characters itself, and the other longer. Of course, you could just say, "Avg", but why bother?

And this contains in itself another example. +/ being "Sum", which is longer. And "Product" is an even higher contrast: ×/

This language also has the added mind-blowing feature where the glyphs are often visually related when they are functionally related.

So "Scan" is \. Therefore, "Running Sum" aka "Plus Scan" is +\. Likewise "Running Product" aka "Multiply Scan" is -- you guessed it! -- ×\.

And there is so much more. I've been doing APL for a while now (IDR if it's a full year yet or not, but it's getting close I think), and it keeps blowing my mind over and over again. It's gotten to the point where when writing APL I feel like I'm just spelling out my thoughts for the most part. I've never gotten that feeling in any other language, and it's a mind-blowing feeling.

A snippet of pandas code in a notebook I saw when learning pandas, it looked like this:

  def to_minutes(df, col):
    df[col] = df[col].dt.minutes
    return df

  (
    pd
    .read_csv('data.csv')
    .assign(dur=df.finish-df.start)
    .pipe(to_minutes, col='dur')
    .query('dur < 30')
    .sort_values(by='dur')
    .pipe(
      seaborn.relplot,
      x='dur',
      y='distance',
      hue='city'
    )
  )

It's a simple snippet but the code structure is clever in many ways. The enclosure of the whole expression, starting with pd, into () makes it possible to split method chaining into multiple lines without backslashes and start each line with ".". Now we can treat DataFrame methods similarly to verbs from dplyr data grammar and "." similarly to %>% operator. Its now easy to rearrange, add and delete whole lines without thinking if we forgot to add "." to the line above or below. Everything is immutable, no side effects, it's safe to copy the code in a new notebook cell and tweak it a little without worrying about tens of temporary df2_copy1 variables. The .pipe method allows to avoid "df = df[...]" junk, to reuse code fragments and even to use plotting libraries in ggplot fashion. If the chain becomes huge, just put it in a function and apply in to df using pipe method, etc... I wonder if it's possible to add memorization to pipe method to avoid recalculating the whole construction every time when rerunning the cell during debugging.

How about, that C program which produces random dot (well, character) stereograms, whose source code is such a stereogram?

Winner of 2001 IOCCC:

https://www.ioccc.org/2001/herrmann2.c

Function pointers

I was a self-taught programmer as a teenager so there was a lot of theory and mental models I was missing. I viewed code as something static I wrote into an editor and later interpreted (QBasic) or compiled and ran (C).

Learning about function pointers in C was transformational. I started thinking about code as data that can be called and passed around and even changed at runtime and suddenly things like cooperative multi tasking made sense to me.

PPR - Pattern-based Perl Recognizer. It's basically a giant regex that matches Perl code.

The regex itself: https://metacpan.org/dist/PPR/source/lib/PPR.pm#L65

Documentation: https://metacpan.org/pod/PPR

Rob Pike’s lexer was very nicely done and struck a chord with me. It’s not nearly as magical as some of the other things here. It’s just great engineering:

https://m.youtube.com/watch?v=HxaD_trXwRE

> The IOCCC Flight Simulator was the winning entry in the 1998 International Obfuscated C Code Contest. It is a flight simulator in under 2 kilobytes of code, complete with relatively accurate 6-degree-of-freedom dynamics, loadable wireframe scenery, and a small instrument panel.

> IOCCC Flight Simulator runs on Unix-like systems with X Windows. As per contest rules, it is in the public domain.

https://blog.aerojockey.com/post/iocccsim

Oh, and the code is shaped as a plane. Pretty awesome.

This .NET Dictionary that allow very cheap lookup when your key is a type. https://github.com/asynkron/protoactor-dotnet/blob/dev/src/P...

ICantBelieveItCanSort: https://arxiv.org/pdf/2110.01111.pdf

For codenbases... Objectweb ASM blew my mind.

It's a library to read/write java class files. The core at that time would fit into 2 java files.

It was a reader and a writer built around a visitor pattern. At that time apache bcel was also big, a library to build in-memory class file representations which you would then manipulate. ASM allowed you to do many transformation without ever holding the whole file in memory.

ASM also had an in-memory representation as an add-on. It was all nicely layered and the core was just a marvelous small piece of code, with incredible low memory consumption.

Arthur Whitney’s J Incunabulum: https://code.jsoftware.com/wiki/Essays/Incunabulum

CPS comes to mind (Continuation passing style). Apparently continuations really do it for me. One of the many gains from picking up functional programming is stumbling upon little "pearls" like these that I wouldn't have otherwise.

https://en.wikibooks.org/wiki/Haskell/Continuation_passing_s...

The Idris codebase is quite beautiful. Given some understanding of how it works underneath, I find that there’s a succinct clarity in everything.

https://github.com/idris-lang/Idris2

Mine was super basic, one of many, that a 0 DAY can push an excel date a day behind, so DATE(2022, 10, 0) means Last Day of October. No need to keep an array of which month has 30, 31 or 28/29 days. Simple DATE(2022,3,0) gives the last day of February.

Lenses, and going from lenses to optics more generally. You start with what looks like a bad reinvention of "dot notation" to deal with updates on nested records, but then as you generalise, it turns into a deep well to draw from. You get an incredibly powerful toolkit to query/summarise/transform/rewrite data structures, and it's the only library I know where compositionality is _enhanced_ by _exposing_ its inner workings:

Here is SPJ giving a talk on them: https://www.youtube.com/watch?v=k-QwBL9Dia0

A book called "Astronomical Algorithms" was written back in the 80's or 90's. It was very exciting and inspirational for me that the sun and moon and the position of planets - nature itself - could be predicted by code. It still is an inspiration for me today.

My first job in 1987 was porting all of Oracle's source code (entirely in C for 32 bit architectures) to a 64 bit Control Data mainframe.

So, that.

More of a shell snippet, but removing duplicate lines with awk is one that comes to my mind:

awk '!seen[$0]++'

The python code for a NN to learn addition.

I know it seems trivial, but back then, it seemed everybody talked about it, there was that coursera course about driving car, the self promotion of towarddatascience.com, video on youtube... but not a single line of code which made sense.

I mean : "Shut the fuck up and show me the actual code !".

I finally found it on github.

I was like : https://www.youtube.com/watch?v=xYHJRhRym1U

IOCCC taught me that form is just as important as function, and often a lot more fun:

https://www.ioccc.org/

Stolen from 4chan. Not malicious, just prints out a string, but in terms of code density is simultaneously some of the smartest and dumbest code I've ever seen. Bonus points if you can actually figure out exactly how it works.

  #include 
  #include 
  int main()
  {
     //the following code should be self-explanatory
     int format = 684837;
     uint64_t freqs[16] = {4557704611105873944,6293041952211349568,7232032755832676440,9836271091686599272,11342418091143829394,7666925796986299039,8289648};
     uint64_t phases[16] = {2745812699376323861,4477710776532278558,4107622644641439798,4062343665106426382,4257685111635071841,2598073413584315427,1713226};
     uint64_t composite[32] = {0};
     int i = 0;
     unsigned char frequency = i[(char*)(freqs)];
     unsigned char phase = i[(char*)(phases)];
     while (frequency > 0){
       for (int j=phase;j<2048;j+=frequency){
         (j/64)[composite] |= ((uint64_t)1 << j%64);
       }
       frequency = (i%64)[(char*)(freqs+i/64)];
       phase = (i%64)[(char*)(phases+i/64)];
       i++;
     }
     printf((char*)&format, composite);
     return 0;
  }

Not programming per se, but: mathematical induction. It feels like cheating to get an infinite number of true statements by cleverly setting up a deductive argument.

The actual y combinator (for recursive anonymous functions) took me a while to understand, and I'm pretty sure that by now I've forgot how it works and would need to take a second look at it.

On the less functional side, Linux linked lists are super smart.

A flight simulator called fly8 had an interesting C structure made of pointers to functions. It was a way to declare a device driver in C.

Years later I could tell my colleagues how a device driver/plugin actually worked (before COM/etc) just with this.

The doom square root trick. Reducing an expensive function to almost nothing with low error. Many writeups on the web far better than I could give.

In Ruby, all of the following statements are true:

    Class.ancestors.include?(Object)
    Object.ancestors.include?(Class)
    Class.is_a?(Object)
    Object.is_a?(Class)

It's beautiful.

Haskell:

    primes = filterPrime [2..]
      where filterPrime (p:xs) = p : filterPrime [x | x <- xs, x `mod` p /= 0]

The codebase that has most blown my mind is the one I currently work on. It is the biggest steaming pile of garbage I've ever seen. It's a Rails app developed by two guys who had never worked as developers before. They built an MVP that found immediate traction in their market and so they hired some slightly more experienced contractors to add features. It is shockingly poorly designed. We've hired an army of talented people to try to fix things so we can actually get to the point where we can add new features but I'm not sure we'll ever get there.

Until this job I hadn't realized how blessed I had been in my career to work at companies that took software development seriously. I can safely say that every instance of "bad code" I had run into previous to this one was really nothing.

I'm not sure how much longer I'll stay here tbh. The place is toxic for a variety of reasons not just the software.

Data from functions:

(define (cons x y) (lambda (m) (m x y)))

(define (car z) (z (lambda (p q) p)))

(define (cdr z) (z (lambda (p q) q)))

Swapping two variables without a temporary using xor.

APL. I didn't care for the particular symbols, but the concept blew my mind, and got me interested in "table oriented programming" (TOP) and later the SMEQL query language (what SQL should have been). I'd often make table-driven logic using dBASE/xBASE back in its day because it was so nimble to edit meta-attributes AND put code in tables with it.

I still believe in data-dictionaries to drive CRUD instead of crap like C#/Java "annotations" on model classes, but our current tools and languages are not TOP-friendly. I'm convinced TOP is the future, I just don't know when. Some say "you lose type checking", but relational integrity can do much the same thing if set up right. I do personal TOP R&D, but the job is too big for 1 hobbyist.

The O(1) sleep sort algorithm: https://www.cs.princeton.edu/courses/archive/fall13/cos226/l...

A more advanced example of mutual recursion: it's possible to perform an exhaustive search over the "Cantor space" of all infinite sequences of bits that either finds a sequence satisfying a (total, computable) predicate or determines that such a sequence doesn't exist. That is to say, there's a function `search`,

    type Cantor = Natural -> Bit
    search :: (Cantor -> Bool) -> Maybe Cantor

that returns in finite time if its argument does.

Source: https://math.andrej.com/2007/09/28/seemingly-impossible-func...

Euclidean algorithm as a one-line function:

    function gcd(a,b){ return b ? gcd(b, a%b) : a; }

...none. Not because I've never seen mindblowing code, but because I've never understood it for what it was when first seeing it.

I'm a slow learner.

The Unreal Engine 4 code, when it first went open-ish source. I was blown away by how huge it was, but yet, how clean and modular everything was.

Ray Casting Algorithm is neat because it's immediately understandable efficiency https://en.wikipedia.org/wiki/Point_in_polygon

The `@inlineCallbacks` decorator from Twisted. Not the implementation, even, just what it does. Understanding it was what finally made async click in my head.

Richard Bird's Haskell program to solve Sudoku, both the final product and the process of deriving it from a series of less efficient versions, as described in his functional pearl paper [1]

[1] https://www.cs.tufts.edu/~nr/cs257/archive/richard-bird/sudo...

I learned programming informally via scientific project work. When I learned about hashing and O(1) lookup the power of it truly blew my mind.

C++'s "Curiously Recurring Template Pattern"

     template 
     class Foo {};

     class Bar : public Foo { ... };

https://en.cppreference.com/w/cpp/language/crtp

A year or so ago I stumbled across the A-normalization code discussed here:

https://matt.might.net/articles/a-normalization/

I've got a fairly good grasp on recursion, but it took some effort to get a mental model of what was going on (k is what to do with the inside thing), because it's doing both recursion and continuation passing at the same time. It feels like a technique that could come in handy someday.

Not code/codebase, but I also want to mention the transform behind bzip:

https://www.hpl.hp.com/techreports/Compaq-DEC/SRC-RR-124.pdf

I understand how it works, but it seems magical that you can sort all of the rotations, take the last column, and still be able to recover the original text.

Fast inverse square root. Commonly attributed to john carmack, it actually predates his application of it by several years

I interned at a web agency a long time ago and none of their technical people were more than integrators for WordPress and Drupal but sometimes they had to dable in custom modules and stuff like that, which was clearly not their strong suit.

Anyway, one of the modules had a piece of code that was checking what was in a mailbox, and the name of that function was literally "butWhatIsItThatThereIsInThatMailbox()".

For another project I used Laravel to make a website, and they needed to add a feature after it went to production but I was not working there anymore. I later learned that they just did a "mysql_connect" and ran their query directly in the view's template because they didn't know how to use the framework to make a DB query and pass the data to the view.

And they had HUGE clients that everyone has heard of.

So yeah, mind blowing.

Although I have not seen the source code, I was mind blown when first heard of and saw the demo of the Sketchpad, a program created by Ivan Sutherland in 1963.

http://scihi.org/ivan-sutherland-computer-graphics/

Ph.D. thesis: - https://dspace.mit.edu/handle/1721.1/14979 (1963 original), - https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-574.{html,pd... (2003 electronic edition)

My first real software engineering job.

I was put in charge of the company's email program. This was in 1987-8.

It was a single file, with over 100 KLoC of 1970s-vintage FORTRAN IV code.

Not one single comment.

Variables written like INTEGER A1, for a buffer index.

No subroutines.

GOTOs galore.

That was some trauma that convinced me to write good, structured, well-documented code, from then on.

Almost forgot - Lisp In Life. Pretty sure I first saw it here at HN. IMO the most amazing part is the Life-based processor - once you have that, the rest is "merely" a matter of adding layers. But it's one thing to know someone could do it, quite another to see it in action.

https://github.com/woodrush/lisp-in-life

Run it in your browser here. Definitely worth zooming all the way in to get a sense of scale.

https://woodrush.github.io/lisp-in-life/

When I was a student, I went to a programming lab one very hangover morning, new teacher. He was a bit ambitious and he had us program a visitor pattern in smalltalk, it really openend my mind on using the vtable as a flow control system.

The Elixir |> (pipeline / nose) operator. Makes functional programming much cleaner without brackets or intermediate variables. I wish more programming language has this. JavaScript comes close with chained calls of map.

the rotating donut written in C shaped like a donut, also a lot of early demoscene written by hand in assembly

The Lambda Calculus. So simple. So powerful. Still studied today.

Learning that I could pass a -function- as a value blew my mind for sure.

I'd been programming for quite a while at that point, though mostly it was self-taught or procedural/OOP things I had learned in school.

That made a lot of impacts on how I thought about programming; basically until tha point I had never encountered functional programming, and boop it pushed me off a big ol' cliff.

Reverse Polish Lisp (on the HP 49G) for starters.

The basic Haskell function definition,

    factorial 0 = 1
    factorial n = n * factorial (n - 1)

A lot of VGA/SVGA paging blew my mind 20-25 years ago when I saw it.

Frankly, it still does. Low-mid level graphics code is incredible wizardry.

A lot of code from The Art of Prolog that used some form of accumulator data structure as a third argument to predicates.

Not code but I always marvel at the relational databases of creaky Enterprise behemoths - SharePoint, SAP, etc...

Clojure transducers (https://clojure.org/reference/transducers). It's clearly a functional construct, but somehow I haven't seen it being used in other functional languages.

It would have to be an HID interface for some controller I ran into. It was essentially a large switch that used bitwise operations against some magic byte as the cases to determine which button was pressed. Avoided using variables or an enum which I thought was interesting

I do not have access to a C compiler at the moment so cannot verify this with latest compiler but one thing I remember seeing long time ago was that you can interchange an array name and it's index, something like this: a[i] can also be written as i[a]

YOLO v3's paper is hilarious. The model was state of the art at the time, yet it's written in a tongue-in-cheek way:

https://arxiv.org/pdf/1804.02767.pdf

I think groupcache and singleflight are surprisingly simple for what they do: https://go.dev/talks/2013/oscon-dl.slide

notcurses: https://github.com/dankamongmen/notcurses

The guy is a literal genius, I hope to forget half the stuff he knows.

Also Fabrice Bellard (ffmpeg/qemu) and Inigo Quilez.

messagepack implementations.

made me realize how much knobs are there in writing a data to bytes encoding function.. you get to pick a trade off between readability, ease of implementation (in other language), encoding speed, encoding output size, and more.

I saw the title, came to post the exact code that OP posted. It's from Dybvig's Scheme programming language book. I remember going through that book and just being blown away by the elegance of Scheme.

Its been a while since I worked with this lib but I always thought Pygments was pretty.

https://github.com/pygments/pygments

A recursive version of depth first search that I coded in python while practicing for interviews with leetcode. Recusion and DFS is so elegant.

I feel the SCP foundation has something about a Cthulhu codebase that literally explodes the brains of all who read it.

And I feel I’ve worked on that codebase …

it isn't rocket science, but https://github.com/fkling/astexplorer significantly raised my standard of what a readable, modifiable, nontrivial react/redux codebase could look like. bonus that astexplorer is basically used by everyone in the js tooling ecosystem

SQLite’s codebase - the test to code ratio is something like 1 to 20000. It’s the most tested codebase in existence.

Sadly I cannot share the code. But some COBOL code used for validation of financial transactions. It was crazy!

I once saw a 20k line Java source file, being used in production... no it wasn't generated. that blew my mind.

Most legacy ML models I’ve had to move to production aka not on a laptop. Oh you meant in a good way…

Hash tables are something I learned in college and was just mind-blown, so simple and so useful

There was a youtube video a few years back that showed a guy livecoding...I think an ECMA interpreter, or maybe a WASM interpreter from scratch using some very easy to follow code. I can't remember what it was or the video, but it was gobsmacking. So instead here's another story.

I once worked with an old Perl greybeard, he had written some kind of code that could parse an almost impossible large set of string formats that a large collection of automated systems produced except they all had some sort of non-standard/non-guaranteed formatting or semantics. Little bits and pieces (some semi-atomic bits) of them were semi-reliable, but the aggregate strings were just a huge mess, things came in all kinds of orders, had unreliable separators (if any) some things came in backwards, some forwards, and so on.

You might imagine them to be things like IP addresses that sometimes had system names attached, sometimes locations, sometimes, no address, sometimes the address was separated by dots or commas, sometimes, pieces of equipment were listed. All legacy of decades of people slowly accruing bits and pieces of the larger system and naming things for local convenience rather for global understanding. As the systems rolled up these strings would sometimes get concatenated in different ways and in different orders.

His code looked like total gibberish, a library of a bunch of code that sort of looked like Perl but also sort of looked like a custom rule language, it had something like 1200 rules in it based on the kinds of "atomics" he'd observed. The rules were sort of pieces of regexes, and then a string with embedded functions in it.

And then some bizarre code elsewhere I also didn't get at first.

It turned out the code was clever way of writing a meta program that would assemble new code on the fly that was capable of processing every possible string format -- potentially billions of them. At the core of the code was simple lexer that atomized the strings based on a few heuristics (nonstandard of course), and then would apply the rules to each lexical piece.

It turns out the rules were regexes that emitted code snippets on match. The snippets were often templated to take pieces of the atomic bits and the regex would parse the atom and put the pieces into the snippet.

There was some simple logic to assemble all of the emitted code into a "program" that when eval()'d would generate an output object that had all of the components of the original string, but also decoded, enriched, normalized, and ready for downstream work.

In the rare case an "atom" was encountered the system didn't have a "rule" for, it would throw an error and dump the string out to a file where he'd take a look at it, and in about 30 seconds slap in a new "rule" to handle the case forever more.

The entire codebase was maybe the rules and a couple hundred more lines of code -- maybe 1400-1500 lines. Written in a few weeks, processing tens of millions of strings per day, silent and forgotten in the bowels of some giant enterprise automation system.

It, running on a Pentium II or III of some kind, had replaced a rack of Sun Pizza boxes, and an old codebase setup by a consulting company that went down or garbled the processing of the strings at least once a week and required two full-time people to keep running. When the company had a downturn they laid off that team and in a fit of desperation the greybeard had come up with this little monster -- the beauty of which was under 5 minutes of maintenance per week to check logged errors and write a new rule if needed.

edit ahh here's the video https://youtu.be/r-A78RgMhZU

Iterating through the set bits in an integer in O(# of set bits) time.

This is bit dated but when in my university days I reas code of xterm

10 PRINT "HELLO HELLO" 20 GOTO 10

Is this code supposed to work?

Comonadic User Interface design.

Scalaz.

Discrete cosine transform.

profunctor optics.

In the Elixir kernel, defmacro is defined by calling the defmacro macro about itself

https://github.com/elixir-lang/elixir/blob/main/lib/elixir/l...