What is the most beautiful piece of code you've ever read?

    # python
    names = []

    names[0]  # <- raises IndexError

    # Elm
    names = []

    case List.head names of
        Just name ->
            name
        Nothing ->
            "empty"

I felt it was sort of like poetry. I unfortunately no longer have a link to it, and once looked very hard but couldn't find it.

I would be extremely appreciative of someone else saw it and had a link. If I recall correctly it was a type of interpreter, I remember it having code for parsing.

    public static int bitCount(int i) {
        i = i - ((i >>> 1) & 0x55555555);
        i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
        i = (i + (i >>> 4)) & 0x0f0f0f0f;
        i = i + (i >>> 8);
        i = i + (i >>> 16);
        return i & 0x3f;
    }

- haskell:

  perms [] = [[]]
  perms xs = [ x:ps | x <- xs , ps <- perms ( xs\\[x] ) ]

  const perms = xs => xs.length === 0
    ? [[]]
    : xs.flatMap((xi, i) => perms([...xs[0:i], ...xs[i+1:]).map(xsi => [xi, ...xsi])

- haskell:

  cart2 xs ys = [(x,y) | x <- xs, y <- ys]

  cartn :: [[a]] -> [[a]];
  cartn [] = [[]]
  cartn(xs:xss) = [x:ys | x <- xs, ys <- yss]
                        where yss = cartn xss

  const cart2 = (xs, ys) => xs.flatMap(x => ys.map(y => [x,y]));

  const cartn = (...args) => args.reduce((yss, xs) => yss.flatMap(ys => xs.map(x => [...ys, x])), [[]]);
  // or recursive
  const cartn = (xs, ...xss) => xss.length === 0
    ? xs
    : xs.flatMap(x => cartn(...xss).map(y => [x,y]))

10 PRINT "HELLO"

20 GOTO 10

30 END

RUN

I remember typing this on an ASR-33 and being amazed. I made a computer do that. Then I hit Ctrl-C and learned how to make a paper tape with a "here is" leader, turning the paper punch off, then typing "LIST" and turning it back on before hitting RETURN.

A PDP-11/10 with 16K and 3 20mA TTYs connected, no disks, no storage except paper tape.

I've still got that paper tape somewhere, it's 42 years old now.

REBOL [title: "Calculator"] view layout [ origin 0 space 0x0 across style btn btn 50x50 [append f/text face/text show f] f: field 200x40 font-size 20 return btn "1" btn "2" btn "3" btn " + " return btn "4" btn "5" btn "6" btn " - " return btn "7" btn "8" btn "9" btn " * " return btn "0" btn "." btn " / " btn "=" [ attempt [f/text: form do f/text show f] ] ]

https://easiestprogramminglanguage.com/easiest_programming_l...

https://code.jsoftware.com/wiki/Essays/Incunabulum

  >>>list(zip(*[(1, 2, 3), (4, 5, 6), (7, 8, 9)]))
  [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

I think a much better question would be most beautifully structured codebase.

Code, as a snippet, or line, is constantly struggling between poetic conciseness and verbose clarity... To which I will always pick clarity (for "the next guy"), hence not necessarily elegant.

  CONS: EXCH A,[EXCH A,[...[PUSHJ P,GC]]]
        EXCH A,CONS

The free list is simply a linked list of first instructions, which could be done because the PDP-10 was a 36-bit machine with an 18-bit address space, and the address field of an instruction was the entire right half: the same part of a word that was used as a pointer. So, when interpreted as a pointer, each of these instructions was just the pointer to the next cell.

The beautiful part to me is that, once you ran out of free list, the last word was a call to the garbage collector, which would build a free list of unreferenced cells and return a pointer to the second cell (with the correct opcode field) in A; the second instruction would then finish the cons operation, leaving the address of newly allocated cons cell in A.

Option provides an elegant way to handle parameters or results that may or may not be defined.

Here's a simple Option implementation:

https://gist.github.com/mceachen/75598510275865b8cf88bb2ef80...

With this you can write something like

Opt(possiblyNullResult).flatMap(ea => functionThatRequiresANonNullResultAndReturnsUndefinedOrDefined(ea)).getOrElse(() => someDefaultValue)

And here's a (very) simple implementation of lazy:

https://github.com/photostructure/exiftool-vendored.js/blob/...

The idea of lazy is to allow deferment of expensive operations until they are actually needed.

The above implementation allows for something like:

const service = lazy(makeService)

Which will ensure makeService is only called once, and the first caller will have to wait for the result of makeService(). All subsequent callers re-use the first result.

It's a simple construct, but extremely handy.

[1] https://github.com/scala/scala/blob/v2.13.1/src/library/scal...

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

A good debuggable piece of code explains what it is trying to do by being clearly written and conforming to a consistent and logical model. I don’t think I would ever have invented this type of lexer pattern in Go by myself, but would be very grateful to come across it in a code base I had to fix. Like Duff’s Device mentioned in this thread, it has just the right amount of cleverness without becoming inscrutable.

Also, if you’ll excuse some avuncular pride, my niece and I wrote some code yesterday. She asked me how many times grandma’s clock chimes every day and we ended up with the following Ruby:

  2 * (1..12).reduce(&:+)

  fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

  ,[.,]

The complete language consists of eight single-character commands. The four used in the echo program is:

, – accept one byte of input and store it at the current memory cell

. – output the byte at the current memory cell

[ – if the value of the current memory cell is zero, jump forward to the command after the matching ]

] – if the value of the current memory is nonzero, jump back to the command after the matching [

  :v/./,/./-j

Somewhat more readable version:

  :vglobal /./ .,/./- join

  : \ IMMEDIATE
        #IB @ >IN !
  ; \ We can now comment!

C (K&R) program that calculates PI number by measuring circle that is its code: https://en.wikipedia.org/wiki/International_Obfuscated_C_Cod...

Perl one-liner that checks if a number is prime: perl -lne '(1x$_) =~ /^1?$|^(11+?)\1+$/ || print "$_ is prime"'

  4856507896573978293098418946942861377074420873513579240196520736 6869851340104723744696879743992611751097377770102744752804905883 
  1384037549709987909653955227011712157025974666993240226834596619 6060348517424977358468518855674570257125474999648219418465571008 
  4119086259716947970799152004866709975923596061320725973797993618 8606316914473588300245336972781813914797955513399949394882899846 
  9178361001825978901031601961835034344895687053845208538045842415 6548248893338047475871128339598968522325446084089711197712769412 
  0795862440547161321005006459820176961771809478113622002723448272 2493232595472346880029277764979061481298404283457201463489685471 
  6908235473783566197218622496943162271666393905543024156473292485 5248991225739466548627140482117138124388217717602984125524464744 
  5055834628144883356319027253195904392838737640739168912579240550 1562088978716337599910788708490815909754801928576845198859630532 
  3823490558092032999603234471140776019847163531161713078576084862 2363702835701049612595681846785965333100770179916146744725492728 
  3348691600064758591746278121269007351830924153010630289329566584 3662000800476778967984382090797619859493646309380586336721469695 
  9750279687712057249966669805614533820741203159337703099491527469 1835659376210222006812679827344576093802030447912277498091795593 
  8387121000588766689258448700470772552497060444652127130404321182 610103591186476662963858495087448497373476861420880529443

Aside from that, the qrpff perl scripts that became t-shirts (https://web.archive.org/web/20011221024307/http://www.copyle...) were another fun and illegal way to point out the stupidity of the DMCA. But they aren't so pretty ;)

  s --> a,b.
  s --> a,s,b.
  a --> [a].
  b --> [b].

How does the grammar work? It must accept, or generate, a string of equal numbers of a's and b's, but the grammar is not keeping track of the length. There is nothing to count how many a's have been consumed or produced so far. How does it know?

s is the start symbol of the grammar. The first production of s, which is also the terminating condition for the recursion, accepts or produces one a followed by one b. The second production of s accepts an a, followed by an s-string, followed by a b.

Suppose we executed the grammar as a generator. In the first step, the output would be the string S₁ = ab. In the second step, the output would be the string S₂ = aS₁b. In the n'th step the output would be aSₙb.

So the grammar would always add exactly one a at the start, and one be at the end of its output, recursively.

And it would always generate the same number of a's as b's.

Similar for when it runs as an acceptor.

You can visualise the first couple of steps as follows:

           S
   ,-------|-------.
   |       S       |
   A      / \      B
   |     A   B     |
   a     |   |     b
         a   b

https://en.wikipedia.org/wiki/The_Complexity_of_Songs

https://en.wikipedia.org/wiki/Generative_music

https://en.wikipedia.org/wiki/Repetitive_song

|>~~~<<<

https://en.wikipedia.org/wiki/E%3DMC2_(song)

https://genius.com/Big-audio-dynamite-e-mc2-lyrics

https://www.youtube.com/watch?v=cHTDkJ-bQqM

About 10 years later you would find this stuff everywhere in boost but for the time this was spectacularly elegant for C++

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

Regex for that is just great

  ^((?!word).)*$

https://github.com/billzhong/inbox.py/blob/master/inbox.py

It's about 42 lines of actual code excluding newlines.

  10 print "Hello World";
  20 goto 10;
  run

This python code was part of the imaging, analysis, and simulation software for radio interferometry that led to the historical first 'image' of a black hole.

  array.filter((item, index, arr) => arr.indexOf(item) === index)

Also:

  subsets = filterM (pure [True, False])

    int dsf_find(int *t, int a)
    {
     if (a != t[a])
      t[a] = dsf_find(t, t[a]);
     return t[a];
    }

    (defun unify (x y e)
      (let ((x (look-up x e))
            (y (look-up y e)))
        (cond ((eq x y) e)  
              ((variable-p x) (cons (list x y) e))  
              ((variable-p y) (cons (list y x) e))  
              ((or (atom x) (atom y)) nil)  
              (#t (let ((ne (unify (car x) (car y) e)))
                    (and ne (unify (cdr x) (cdr y) ne)))))))

https://carbon.now.sh/

    fibs = 0:1:zipWith (+) fibs (tail fibs)

  // Dijkstra, Edgar. "Go To Statement Considered Harmful".
  // Communications of the ACM. Vol. 11. No. 3 March 1968. pp. 147-148
  if (neighboridx == target) {
    goto OUTSIDE;
  }

const flatten = arr => ((flat = [].concat(...arr)) => flat.some(Array.isArray) ? flatten(flat) : flat)()

Its simple, but i was - and still am - way to proud of it ;p

    int henny() {
      return((*opp_history?opp_history[random()%*opp_history+1]+1:random())%3);
    }

When I discovered the Magazine (back un the 90's) I wasn't ready to code for windows nor win32 because I was a broke student with a 1MB 80286; but I am pretty sure reading and rereading that code and articles made me learn more C/C++ than most books or courses I took later.

Mr. Petzold: If we meet someday, the beers are on me!

  CNV10: MOV R0,-(SP)    ;Converts binary value 
         CLR R0          ;in R0 to ASCII in buffer
  1$:    INC R0          ;pointed to R1
         SUB #10.,@SP
         BGE 1$
         ADD #72,@SP
         DEC R0
         BEQ 2$
         CALL CNV10
  2$:    MOVB (SP)+,(R1)+
         RETURN

https://www.cs.princeton.edu/courses/archive/spr09/cos333/be...

This returns the greatest value (passed ? or max_value column):

  ?^((?^max_value)&-(?

  min_value^((?^min_value)&-(?