22 ms·
Ask HN: What is the most beautiful piece of code you've ever read?
Preferably an elegant snippet rather than an entire (well engineered) codebase.
- starmole 7y agoThat's a way to loaded and bait like question. Why not ask for "the most elegant snippet" instead? There are beautiful code bases like DOOM source or SAT solvers that are like super models beautiful. Complete and hard to improve. Marvel at from a distance. There is beautiful code in the libraries everybody uses all the time. All the lib* code. Somebody to marry. Discover the good beauty over time. And then there is the beautiful snippet of clever code at the bar, quick to love, but one you get to know him it's much more trouble than he's worth.
- canada_dry 7y agohttps://github.com/achael/eht-imaging https://github.com/achael/eht-imaging 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.
- seisvelas 7y agoWhat about the code did you find so striking? Any part in particular you recommend checking out?
- canada_dry 7y agoOverall I refer to it as a good example of relatively complex - yet highly readable - python code. It's utterly digestable due to its use of meaningful variable names, logical breakdown of functions and absence of 'clever' nontrivial one-liners.
- RodgerTheGreat 7y agoAt first, incomprehensible. Given time, the internal consistency shines through. Worth spending a few hours reading and contemplating: https://code.jsoftware.com/wiki/Essays/Incunabulum https://code.jsoftware.com/wiki/Essays/Incunabulum
- williamsmj 7y agoAny of Norvig's notebooks, http://www.norvig.com/ipython/README.html http://www.norvig.com/ipython/README.html, especially his Concrete Introduction to Probability https://nbviewer.jupyter.org/url/norvig.com/ipython/Probability.ipynb https://nbviewer.jupyter.org/url/norvig.com/ipython/Probabil....
- seisvelas 7y agoOh my God, his Lisp interpreter in Python: amazing. At the time I was just getting a grip with Python and starting in Lisp, it came at just the right moment in my autodidaction. Really really good, although for a lot of people here it might be a little elementary (but then, the best code always feels elementary even when doing something advanced!)
- segmondy 7y agoIMHO, the most beautiful lisp interpreter in a language that is not lisp is this one in prolog. https://www.metalevel.at/lisprolog/ https://www.metalevel.at/lisprolog/ https://www.metalevel.at/lisprolog/lisprolog.pl https://www.metalevel.at/lisprolog/lisprolog.pl
- gield 7y agohttps://norvig.com/lispy.html https://norvig.com/lispy.html
- deleted 7y ago[deleted]
- tiffanyh 7y agoFor me, the answer is - The code that never existed. Not to sound cheeky but eliminating code, is a beautiful thing. Less code is easier to maintain, understand, and faster to run. So the less code you can achieve, the better overall the software will be.
- seisvelas 7y agoDeleting code is a beautiful feeling. Python's new walrus operator has gotten a lot of hate recently, but a few days ago I was writing a script and realized I could get rid of a few lines (AND have my meaning be clearer) using the walrus operator. So satisfying.
- macintux 7y agoAs a fan of Erlang’s pattern matching, the walrus operator feels like an obvious win. I do, however, resent Python 3 for removing pattern matching on tuples in function heads.
- tuesdayrain 7y ago> For me, the answer is - The code that never existed. > Not to sound cheeky but eliminating code, is a beautiful thing. Less code is easier to maintain, understand, and faster to run. So the less code you can achieve, the better overall the software will be. Unless you think compressed/ minified code is beautiful, there must be additional factors involved other than minimizing LoC.
- seisvelas 7y agoTo me it's removing lines of code without affecting readability (or even improving it). Like when you don't know about a language feature so you implement a hacky version, then find out there's already a very elegant standard way to do it so you get to lance that hideous monstrosity you made off your code
- abaga129 7y agohttps://github.com/kelseyhightower/nocode/blob/master/README.md https://github.com/kelseyhightower/nocode/blob/master/README... you're welcome
- cepp 7y agoJohn Carmack's Fast Inverse Square Root: https://en.wikipedia.org/wiki/Fast_inverse_square_root#Overview_of_the_code https://en.wikipedia.org/wiki/Fast_inverse_square_root#Overv.... The first time I really and truly felt that people approach problems differently from how I, by default, go about them.
- vatys 7y agoThis is still one of my favorites. In a list of magic numbers, sorted by magic-ness, 0x5F3759DF would sit pretty high.
- jmcgough 7y agoIIRC Carmack didn't write that code, as brilliant as he is.
- dkersten 7y agoIt even says that he didn’t write it in that wikipedia page.
- deleted 7y ago[deleted]
- Const-me 7y agoCPUs have much faster (2-5 cycles latency) and much more precise (<0.04% relative error) version in hardware, since 1999: https://www.felixcloutier.com/x86/rsqrtps https://www.felixcloutier.com/x86/rsqrtps
- hwillis 7y agoI wonder which one used less energy in 1999?
- chii 7y agoit's the antithesis of maintainable code. But given that one is unlikely to want to change from calculating the inverse square root to inverse cube root or any other variation....
- bjconlan 7y agoAs a student in 2001, Tim Sweeney's template recursive inheritance was next level for me:https://www.flipcode.com/archives/Vector_Math_Quaternions.shtml https://www.flipcode.com/archives/Vector_Math_Quaternions.sh... About 10 years later you would find this stuff everywhere in boost but for the time this was spectacularly elegant for C++
- deleted 7y ago[deleted]
- keyle 7y agoIt's a bit of a tricky question because you can have a beautiful snippet entangled in a mess of a codebase. 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.
- seisvelas 7y ago> I think a much better question would be most beautifully structured codebase. That would be an interesting thread too! I think gorgeous snippets have a different kind of beauty that just generally well done projects. To me, it's kind of like comparing the beauty of a gem to the beauty of a bridge.
- wolco 7y ago10 print "Hello World"; 20 goto 10; run
- seisvelas 7y agoMy first language was QBASIC and much of the first code I read (other than modifying PHP scripts I didn't really understand) was from Pete's QB Site. I'd hardly call it beautiful, but definitely nostalgic and cool.
- sepent 7y agoThis is from QBASIC help file. Composing from PC speaker was very fun: PLAY "MBT180o2P2P8L8GGGL2E-P24P8L8FFFL2D"
- annoyingnoob 7y agoI'd guess the most beautiful code is in the part that I didn't read, because it just worked and I didn't think about it.
- zer01 7y agoThis PNG parser in Elixir uses pattern matching in an elegant way. https://gist.github.com/zabirauf/29c89a084901cab8bc6b https://gist.github.com/zabirauf/29c89a084901cab8bc6b Parsing binary data can be...nontrivial. The beauty is in the code that doesn't exist.
- symisc_devel 7y agoThe SQLite source tree and DRH code in general are truly piece of art. Almost every line of code is carefully commented. Despite the complexity of the project, you'll learn a lot of practical concepts including expression tree generation, bytecode execution, how to test your code and so forth.
- fdsdsa_7777 7y agoNot to mention humor -- there's a reference in SQLite to Golding's Lord of the Flies -- and I'm guessing more.
- kizer 7y agoI love the SQLite guy. His own version control, his own DB engine; you can tell from the site that he’s an individualist!
- segf4ult 7y agoHe mentioned on a podcast that he even uses his own text editor.
- pnako 7y agoThis reminds me of Chuck Moore (inventor of Forth). He designs his own CPUs, using his own CAD package, written in the programming language he invented!
- exikyut 7y agoOh? What podcast?
- textread 7y agohttps://changelog.com/podcast/201 https://changelog.com/podcast/201
- in9 7y agoWow! Do you remember which podcast? Now I am interested in this interview!
- mahmoudimus 7y agoDuff's Device: https://en.wikipedia.org/wiki/Duff%27s_device https://en.wikipedia.org/wiki/Duff%27s_device Very elegant use of the fall-through behavior of the swtich statement.
- Inityx 7y agoFor those unaware, * do not use this on modern systems. * Normal for-loops are much faster than they were when Duff's Device was invented, since they take advantage of modern branch prediction.
- notacoward 7y agoThat depends on how large the misprediction penalty is and how many times the branch executes. Branch prediction isn't magic. It never makes branches beneficial. The best it can do, with perfect accuracy, is bring the amortized misprediction penalty down to zero. The key is that Duff's Device also relies on branching, and it's a less predictable branch that's more likely to be mispredicted. On the other hand, one BP miss is still cheaper than several hits plus one miss at the end. On the other other hand, there are issues to consider like code size and cache turnover (favors a loop), handling of special cases where larger loads/stores can be used (favors DD), processor extensions, etc. If you're really trying to write an optimal memcpy-like function, you'll probably end up using a hybrid of several approaches - including Duff's Device.
- gnode 7y agoAnother thing to note, is that loop unrolling can be harmful to performance, as it requires more instruction cache. Beyond branch prediction, modern compilers can also convert loops into vector / SIMD instructions, and other magic. The Duff's device is still useful for creating co-routines though; a handy way of yielding, then returning to the yield point.
- wiineeth 7y agoC++ STL algorithms written by Alexander Stepanov.
- ddtaylor 7y agoAny specific ones that standout?
- vatys 7y agoFor me it's a BASIC one-liner which generates mazes 10 PRINT CHR$ (205.5 + RND (1)); : GOTO 10 I found this specific one via slashdot[1], but something similar, which I've never managed to find/replicate, was used to generate mazes on the Atari 800 XL at my school when I was a kid. [1] https://developers.slashdot.org/story/12/12/01/1847244/how-does-a-single-line-of-basic-make-an-intricate-maze https://developers.slashdot.org/story/12/12/01/1847244/how-d...
- th0ma5 7y agoIn action: https://youtube.com/watch?v=m9joBLOZVEo https://youtube.com/watch?v=m9joBLOZVEo
- flohofwoe 7y ago...or in a live emulator :) https://floooh.github.io/tiny8bit/c64.html?input=${wait:200}10%20PRINT%20CHR%24%20(205.5%20%2B%20RND%20(1))%3B%20%3A%20GOTO%2010%0ARUN%0A https://floooh.github.io/tiny8bit/c64.html?input=${wait:200}...
- Waterluvian 7y agoOh wow this is a cool loop closure. I wrote a CHIP 8 emulator to learn stuff and my main test rom was this program. I walked through the bytecode very slowly as I learned and debugged and repeatedly wondered how the heck the program was so tiny.
- jointpdf 7y agoThere’s actually an entire book on this at: https://10print.org/ https://10print.org/
- switz 7y agoThe one that blew my mind when I was in college was a simplified version of quicksort in Haskell. It's just so elegant and clean. quicksort :: Ord a => [a] -> [a] quicksort [] = [] quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater) where lesser = filter (< p) xs greater = filter (>= p) xs Now surely someone may come along and point out how this isn't a true quicksort[0] because it doesn't partition the elements in place, but it's more of the simplicity of the logic and its readability that showed me how beautiful functional code can be. [0] https://stackoverflow.com/questions/7717691/why-is-the-minimalist-example-haskell-quicksort-not-a-true-quicksort https://stackoverflow.com/questions/7717691/why-is-the-minim...
- ridiculous_fish 7y agoUnfortunately it's also incorrect! It discards NaNs, as they are neither < nor >=.
- hyperpallium 7y agoI saw a similar version in erlang (in Joe Armstrong's Programming Erlang) and agree it beautifully illustrates the concept of quicksort. Apparently, Tony Hoare came up with it when he took a class teaching him recursion (i.e. he was a student). But the flaw you note unfortunately undermines performance... the "quick" in "quicksort". Thus, IMHO it's a compelling illustration of the profound strengths and weaknesses of fp.
- 0b01 7y agoThis may be an elegant piece of code at first glance except the niceties of quicksort such as cache locality and stability come entirely from the in-placeness of the partition procedure.
- mattnewport 7y agoQuicksort in Haskell is very elegant, though not truly quicksort (not sort in place): https://wiki.haskell.org/Introduction#Quicksort_in_Haskell https://wiki.haskell.org/Introduction#Quicksort_in_Haskell
- seisvelas 7y agoYou are the second person to reference quicksort in Haskell in this thread. The other person even mentioned it not being true quicksort. Who knew quicksort in Haskell was such a beloved piece of code!
- abecedarius 7y agoBack when HotOrNot was hot, there was a site like it for rating code snippets. The top-rated one, I think I remember, was a broken version of this sort function: it had left out the recursions or something (I don't remember exactly), which made it even more 'elegant'. This wasn't the only case I noticed of highly-rated broken code there. It took me a long time to take this lesson to heart about especially slick-looking code of my own.
- jtms 7y agoCurious why the comment about STL algorithms written by Alexander Stepanov was downvoted so hard it died? I’m not a C++ dev... is he hated or is the implementation that bad?
- mattnewport 7y agoI was wondering too. His series of videos on YouTube from A9 on algorithms is excellent and has some very beautiful code but you have to work through the series to fully appreciate it.
- saagarjha 7y agoIt's from a user which seems to have had their comments killed immediately. I vouched for it so it should be fine now.
- wglb 7y agoIf you look at the comment history, it appears that there is a ban on almost all of the comments, which suggests an action by moderators: https://news.ycombinator.com/threads?id=wiineeth https://news.ycombinator.com/threads?id=wiineeth
- neuroscihacker 7y agohttps://github.com/seung-lab/dijkstra3d/blob/master/dijkstra3d.hpp#L240-L244 https://github.com/seung-lab/dijkstra3d/blob/master/dijkstra... // 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; }
- segmondy 7y agoExploit codes are often the most beautiful code I read, they are usually small and take some dazzling brilliance to push the computer and make it do what it wasn't. I can remember the first code that showed how to exploit IFS, race conditions via symlink, the classic "smashing the stack", RTM's worm. Beauty of a code to me has nothing to do with the formatting, comments, documentations, but everything to do with the mind that bent it into place. Most of the beautiful code I have ever seen would be classified as ugly, spaghetti, not production worthy.
- alasdair_ 7y ago>RTM's worm I had absolutely no idea until now that RTM co-founded y-combinator. I remember him from mentioned in Bruce Sterling's The Hacker Crackdown and Clifford Stoll's The Cookoo's Egg as well as an occasional Phrack article. https://en.wikipedia.org/wiki/Robert_Tappan_Morris https://en.wikipedia.org/wiki/Robert_Tappan_Morris
- the_watcher 7y agoHe was one of PG's Viaweb cofounders as well. He also introduced PG to the third cofounder, Trevor Blackwell.
- exikyut 7y agoI have similar admiration of hardware hacks. My current favorite is the one that dumped the SecureROM out of the iPhone 6 via PCI-e: http://ramtin-amin.fr/#nvmedma http://ramtin-amin.fr/#nvmedma, http://ramtin-amin.fr/#nvmepcie http://ramtin-amin.fr/#nvmepcie I'm partly impressed by the tooling used; most of the coolness (to me) is the author's self-confidence in his hunch that the SoC _didn't_ have its MMU set up properly, and the way he followed his nose in determining that he was probably right. I still wonder exactly how much was sunk into the project, before it was possible to determine that the MMU was indeed broken. Heh.
- blotter_paper 7y agoBash fork bomb (do not run, this will crash your system if it's not configured properly): :(){ :|:& };:
- balp 7y agoThat got my unix account suspended at university....
- danesparza 7y ago:-) DOS'ing the system is frowned upon.
- mongol 7y agoWhat is a proper configuration to avoid that?
- moviuro 7y agoulimits: https://wiki.archlinux.org/index.php/Limits.conf#nproc https://wiki.archlinux.org/index.php/Limits.conf#nproc
- numlock86 7y agoI like the Windows one, too. It looks a lot simpler as well. %0|%0
- dfox 7y agoThe conceptually same thing will also work on bourne shell. But as in the Windows case only as a script stored in file, the original with inline function definition is self-contained oneliner.
- jolmg 7y agoI don't know Windows scripting, but that looks like something you'd have to put in a file and call for it to work, instead of just running that on the command line. You can do the same thing on Unix systems. Writing $0|$0 on a file and running it should also work as a fork bomb.
- gorgoiler 7y agoLexical Scanning In Go is a charming piece of programming: https://m.youtube.com/watch?v=HxaD_trXwRE 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(&:+)
- Shoop 7y agoCool one liner! Here's some other languages: Python: 2 * sum([x for x in range(1, 13)]) Haskell: 2 * sum [1..12]
- why_only_15 7y agoYou don't need the list comprehension for python - just 2 * sum(range(1, 13))
- cool-RR 7y agoAnd drop the 1, too
- Godel_unicode 7y agoI prefer the explicit example for being explicit, I find it more pythonic. GPs example is perfect Python; every character has meaning, and it's extremely readable even for non-programmers.
- gorgoiler 7y agoWhat’s quite elegant about Ruby (in and of itself, not in comparison to your examples) is how consistently it is implemented using its own simple set of core features, with very little magic or syntactic sugar. reduce, Enumerable, what the & operator is doing etc. What’s so challenging about Ruby is how the language can be abused by library vendors to make all kinds of surprising magic and homegrown syntactic sugar.
- fortran77 7y agoTeX
- cormacrelf 7y agoFYI, there's an effort at the moment to translate XeTeX and dvipdfmx into Rust. Started with c2rust, now we have a test suite checking regressions against the entire arXiv archive. Contributors welcome. https://github.com/crlf0710/tectonic https://github.com/crlf0710/tectonic
- fortran77 7y agoWhy? It works fine. Does _everything_ need to be in Rust, or whatever the new language-of-the-day is?
- saagarjha 7y agoI'd have to think long and hard for the most beautiful code I've ever read, but I think the classic K&R "strcpy" comes pretty close: void strcpy(char *s, char *t) { while (*s++ = *t++); } It's short, elegant, and quite readable to the trained eye–a bit sharp too, but if you use it right it's quite functional.
- jancsika 7y agoI've got a better code snippet: your exact same code snippet but for a language which will short circuit based on the lvalue of the assignment expression. Then t would never be able to overflow s (nor even eat its null terminator)
- jjnoakes 7y agoThe size of the buffer pointed to by s may be larger than the current string it holds. It may also be uninitialized.
- saagarjha 7y agoOr point to the wrong thing, or point to unmapped memory, or be const, or…there's a lot of things that can go wrong with this function.
- jjnoakes 7y agoThe things I listed are things the function does right as written but could not do if it worked the way suggested above. The things you listed are general concerns in C which are unrelated to both the correct implementation and the suggested changes.
- dhsysusbsjsi 7y agoThat’s what strncpy() is for
- saagarjha 7y ago
- panic 7y agoThis 256-byte demo: https://www.linusakesson.net/scene/a-mind-is-born/ https://www.linusakesson.net/scene/a-mind-is-born/
- TheUndead96 7y agoI remember seeing Maxwell's equations written in Lisp (I believe it was in the Structure and Interpretation of Programs). This made me feel something very profound, although I am still unable to put this feeling into words.
- gitgud 7y agoFor me it's the unix example in [1] "AT&T Archives: The UNIX Operating System". $ makewords sentences | lowercase | sort | unique | mismatch - It reads a file called sentences then prints the words that are not spelled correctly. To me it's; concise, expressive, flexible, modular... Which makes it beautiful... [1] https://youtu.be/tc4ROCJYbm0 https://youtu.be/tc4ROCJYbm0
- jariel 7y agoLoathe to be contrarian but code that is very boring, readable , coherent and comprehensive at scale is 'great code' and I'm completely unimpressed by these 10-liner 'wow' bits of algorithmic anachronism often mentioned in response to such questions. Last time I checked into the TypeScript source, it was really nice to look at - this is very rare and admirable.
- deleted 7y ago[deleted]
- _bxg1 7y agoI like this bit of JavaScript for uniquifying an array: array.filter((item, index, arr) => arr.indexOf(item) === index) It works because indexOf returns the index of the first occurrence of the item, so you're asking whether this occurrence is the first occurrence.
- throwaway_n 7y agoThis is O(n^2) though
- _bxg1 7y agoAll of JS's list processing functions are pretty inefficient, since at the bare minimum each one creates and copies to a new array (as opposed to, say, Rust iterators). You use them when elegance is more important than performance; N^2 is fine when N is eight.
- deleted 7y ago[deleted]
- deleted 7y ago[deleted]
- kadoban 7y agoThat's always such a dangerous proposition though. Sure _you_ remember it's only fine when N is 8, but then the next guy comes along, or the input constraints change, or future you forgets because it _is_ fairly elegant looking. I try not to leave grenades laying around too often, myself.
- superfrank 7y agoPersonally I like this one, although it only works for an array of primitive types. const unique = [...new Set(arr)];
- _bxg1 7y agoThe other advantage of the filter one is it can be stuck in the middle of a bunch of other list operations - map(), sort(), slice(), other filters(). Also, you can use findIndex() instead of indexOf() to match any arbitrary predicate, instead of exact equivalence.
- susam 7y agoI began coding in IBM/LCSI PC Logo. The first line of code I ever wrote was: FD 100 That's the "hello, world" of turtle graphics in Logo. While probably not as beautiful as the several splendid examples posted in this thread, that simple line of code changed my world. I could make stuff happen in an otherwise mostly blank monochrome CRT display. Until then I had seen CRTs in televisions where I had very little control on what I see on the screen. But now, I had control. The turtle became my toy and I could make it draw anything on a 320 x 250 canvas. The next beautiful piece of code I came across in the same language was: REPEAT 360 [FD 1 RT 1] The code above draws an approximation of a circle by combining 360 short line segments. It showed me how control flow can be used elegantly to express complex ideas in a simple expression. And then I came across this: REPEAT 20 [REPEAT 180 [FD 1 RT 2] RT 18] The above code draws 20 overlapping circles. The output looks like this: https://susam.in/files/blog/dosbox-logo-1.png https://susam.in/files/blog/dosbox-logo-1.png . At an impressionable age of 9, reading and writing code like this, and using simple arithmetic, geometry, logic, and code to manipulate a two-dimensional world had a lasting effect on me. I like to believe that my passion for software engineering as well as my love for writing code, sharing code, and open source development are a result of coming across these beautiful code examples early in my life.
- mtrimpe 7y agoLogo was the best! I still remember my father ‘explaining’ me Pythagoras theorem when I was around 5 to show me how to draw the roof of a house on our hand-soldered Philips Apple II clone. I’ve been hooked ever since. The best thing was that 25 years later I opened a Logo emulator again and when faced with having to clean the screen somewhere deep, deep from my muscle memory the right command sprang forward: CLEAR
- plibither8 7y agoOh man, PC Logo takes me back down the memory lane. We were introduced to PC Logo in 4th grade, that's about 9 years ago. I instantly fell in love with it. The amount of power I had over the computer - ordering it to draw what I want, how I want was really exciting. My father had installed Kubuntu on our home computer which had an amazing suite of educational applications, including KTurtle which was (almost) the same as PC Logo. I got so addicted to it, my father suggested me to create a blog and regularly update it with the drawings and the code for it. And so I did [1]! I used Google Blogpost (that was the thing back then). Good times :). 1: http://kturtlecommands.blogspot.com/ http://kturtlecommands.blogspot.com/ Edit: Just checked the blog after almost 6 years, it still gets 100+ weekly impression, haha :D
- QuinnWilton 7y agoIt's impossible to choose a favourite, but here's a beautiful snippet, courtesy of Joe Armstrong [0] universal_server() -> receive {become, F} -> F() end. [0] https://joearms.github.io/published/2013-11-21-My-favorite-erlang-program.html https://joearms.github.io/published/2013-11-21-My-favorite-e...
- verall 7y agoSomeone once posted a C program here on HN, where each line, even the comments, seemed to "line up" in 6- or 8- character blocks with a space in between. It made the whole program look sort of like a table. 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.
- Galanwe 7y agoMost likely an IOCCC entry, but there are a lot that correspond to this description. Maybe you can find it back looking at previous winners of the contest: http://www.formation.jussieu.fr/ars/2000-2001/C/cours/COMPLEMENTS/DOC/www.ioccc.org/years-spoiler.html http://www.formation.jussieu.fr/ars/2000-2001/C/cours/COMPLE...
- verall 7y agoI appreciate your help, but I feel like its unlikely to be in there since it wasn't really obfuscated - it was meant to be clear in some sense of the word and had a bunch of comments explaining it. The comments sounded natural, but lined up so each Nth column was a space (or punctuation) all of the way down the code. None of the things I am seeing in that list seem to have quite the same layout. There was some comment about it like "some people feel code should be beautiful to enjoy debugging" or something along those lines but I don't really remember. I have been looking for a long time though and really wish I had saved it properly when I first saw it.
- whateveracct 7y agofibs = 0 : 1 : zipWith (+) fibs (tail fibs)
- Hnrobert42 7y agoAlong these lines, does anyone else have the experience of reading some code and thinking “Damn this is good. So clear, so well formatted,” only to realize moments later with a bit of embarrassment that it is your own code?
- mceachen 7y agoOr, worse, "who was the idiot that wrote this?" ... git blame ... oh. me.
- rectangletangle 7y agoTransposing a matrix in Python is pretty neat. >>>list(zip(*[(1, 2, 3), (4, 5, 6), (7, 8, 9)])) [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
- deleted 7y ago[deleted]
- 11235813213455 7y ago# Permutations of a list: - haskell: perms [] = [[]] perms xs = [ x:ps | x <- xs , ps <- perms ( xs\\[x] ) ] - js: (using https://github.com/tc39/proposal-slice-notation https://github.com/tc39/proposal-slice-notation for conciseness) const perms = xs => xs.length === 0 ? [[]] : xs.flatMap((xi, i) => perms([...xs[0:i], ...xs[i+1:]).map(xsi => [xi, ...xsi]) # Cartesian product of 2 or n lists - 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 - js: 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]))
- numlock86 7y agoUntil now I didn't know about flatMap() and flat(). Thanks for this!
- formalsystem 7y agoAutomatic differentiation in Haskell http://conal.net/blog/posts/beautiful-differentiation http://conal.net/blog/posts/beautiful-differentiation
- balp 7y agoFor me: smr from 1995 ioccc, http://www.ioccc.org/1994/smr.hint http://www.ioccc.org/1994/smr.hint
- yzh 7y agoLots of ioccc code are beautifully done. Especially the best self documenting ones.
- pjungwir 7y agoI have a T-shirt with this Perl code on the back: https://www.perlmonks.org/?node_id=45213 https://www.perlmonks.org/?node_id=45213
- mceachen 7y agoI really appreciated and missed Scala's `Some`/`None`/`Option` [1] and `lazy` constructs, so much so that I brought them with me to TypeScript. 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/75598510275865b8cf88bb2ef804cd07 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/master/src/Lazy.ts 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/scala/Option.scala#L618 https://github.com/scala/scala/blob/v2.13.1/src/library/scal...
- mixedCase 7y agoYou might want to look into fp-ts. Has plenty of constructs like those, although it now favors piping calling conventions over a fluent API.
- rswail 7y agoNEW 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.
- zentiggr 7y agoHad a KSR-33 wired up to a Synertek single-board 6502 kit... never did get the paper tape working, but man was it weirdly cool to be typing on a 50 pound behemoth to put numbers in the 2kB memory of a 6 ounce PC board.
- drallison 7y agoThis 4 instruction 8080/Z80 code sequence converts a 4-bit quantity in the A-register into the equivalent ASCII code: adc 40h
- anhldbk 7y agoWell, it's a C macro in Apache Thrift code base [1] #ifdef __GNUC__ #define TDB_LIKELY(val) (__builtin_expect((val), 1)) #define TDB_UNLIKELY(val) (__builtin_expect((val), 0)) #else #define TDB_LIKELY(val) (val) #define TDB_UNLIKELY(val) (val) #endif This code is beautiful when it deal with CPU cache-line effects to speed up your program. [1] https://github.com/apache/thrift/blob/647501693bd14256df8839c13cb03659bdee4202/lib/cpp/src/thrift/transport/TBufferTransports.h#L32-L33 https://github.com/apache/thrift/blob/647501693bd14256df8839...
- tomtomtom777 7y agoYou seem to be referring to the arguably beautiful effect of code. Are you seriously praising this monstrosity of preprocessor macros, integers used as magic booleans and compiler specific builtins as beautiful code??
- enriquto 7y agothe recursive "find" function on a disjoint set forest with path compression, by R.E.Tarjan. It brings tears to my eyes every time I read it. int dsf_find(int *t, int a) { if (a != t[a]) t[a] = dsf_find(t, t[a]); return t[a]; }
- labria 7y ago(define eval-expr (lambda (expr env) (pmatch expr [`,x (guard (symbol? x)) (env x)] [`(lambda (,x) ,body) (lambda (arg) (eval-expr body (lambda (y) (if (eq? x y) arg (env y)))))] [`(,rator ,rand) ((eval-expr rator env) (eval-expr rand env))]))) There's an amazing talk about it: https://www.youtube.com/watch?v=OyfBQmvr2Hc https://www.youtube.com/watch?v=OyfBQmvr2Hc
- estomagordo 7y agoGreat. In 90 minutes I may be able to know what you're talking about.
- estomagordo 7y agoIs it a complete lisp interpreter, written in lisp?
- deleted 7y ago[deleted]
- Globz 7y agoYes, it uses pmatch behind the scene to match your expr against the evaluator. https://github.com/webyrd/quines/blob/master/pmatch.scm https://github.com/webyrd/quines/blob/master/pmatch.scm I have to agree, this like rank #1 in my book!
- chombier 7y agoOnce you've seen this one, it's difficult not to rank it first :)
- lioeters 7y agoThis is exactly what came to mind when seeing the question. I was just recently (re-)reading an article that goes in depth: Lisp as the Maxwell’s equations of software http://www.michaelnielsen.org/ddi/lisp-as-the-maxwells-equations-of-software/ http://www.michaelnielsen.org/ddi/lisp-as-the-maxwells-equat...
- numlock86 7y agoI think c4 (a C compiler in four functions, hence the name) is pretty neat. https://github.com/rswier/c4/blob/master/c4.c https://github.com/rswier/c4/blob/master/c4.c
- userbinator 7y agoThat's my choice too. It's a C-subset, but more than a compiler; it includes a bytecode VM interpreter too. The best part about it is that it's tiny, yet very readable for its size and functionality.
- gingerlime 7y agoI personally really like ruby’s Array because it lets you pass anything and you can iterate over it: Array(nil).map ... Array(“string”).each ... Array([“a”, “b”]].select ... Array([]).reject ... ...
- known 7y agoawk '!seen[$0]++' awk 'NR==FNR{A[$0]; next} $0 in A' file1.txt file2.txt
- flukus 7y agoThanks, was trying to remember that first trick just last week. For log files I had to make a slight adjustment to filter the time at the front: !seen[gensub($1, "", "g", $0)]++ For anyone wondering, it filters out duplicates by storing the first occurrence of the line and skipping subsequent ones.
- wiz21c 7y agoThis : http://www.literateprogramming.com/knuthweb.pdf http://www.literateprogramming.com/knuthweb.pdf (actual "code" starts on section C)
- endymi0n 7y agoConsidering the magnitude of its impact on science, engineering and culture (as well as the tremendous force released), this line from the IGNITION subroutine in the BURN_BABY_BURN module of the Apollo AGG source code does it for me: https://github.com/chrislgarry/Apollo-11/blob/master/Luminary099/BURN_BABY_BURN--MASTER_IGNITION_ROUTINE.agc#L417 https://github.com/chrislgarry/Apollo-11/blob/master/Luminar...
- babuskov 7y agoI love the comments in that file. Especially these two: # HONI SOIT QUI MAL Y PENSE and # NOLI SE TANGERE
- p4bl0 7y agoGregory Chaitin discusses elegance of programs in his book The limits of mathematics, which is a very good read. I wrote a review almost ten years ago here: https://p4bl0.net/shebang/the-limits-of-mathematics.html https://p4bl0.net/shebang/the-limits-of-mathematics.html
- zengargoyle 7y agoPick a random line from a file / stream without knowing how many lines there are to choose from in one pass without storing the lines that have been seen. perl -e 'while(<>){$x=$_ if rand()<=(1/$.)}print $x' For each line, pick that line as your random line if a random number (0<=n<1) is less than the reciprocal of the number of lines read so far ($.). It hits my elegant bone. Only one line... rand < 1/1, pick it. Two lines, same as one, but the second line has a 1/2 change of replacing line one. Third line same as before but gets a 1/3 chance of taking the place of whichever line has survived the first two picks. At the end... you have your random line.
- visarga 7y agoDoes this algorithm guarantee uniform probability for all lines? Seems like the original ordering of the lines is a factor.
- smilekzs 7y agoIt does. It's a special case of reservoir sampling. https://en.wikipedia.org/wiki/Reservoir_sampling https://en.wikipedia.org/wiki/Reservoir_sampling
- chubot 7y agoThe OP should have mentioned that it's this algorithm: https://en.wikipedia.org/wiki/Reservoir_sampling https://en.wikipedia.org/wiki/Reservoir_sampling IMO it's a lot clearer if it's not in Perl ... The pseudocode in Wikipedia also avoids division.
- ChristianGeek 7y agoIMO it’s a lot clearer if it’s not in Perl What isn’t?
- IngoBlechschmid 7y agoPerhaps surprisingly, yes, it does! This is called "reservoir sampling", and a blog post with some more details is available at https://blog.plover.com/prog/weighted-reservoir-sampling.html https://blog.plover.com/prog/weighted-reservoir-sampling.htm....
- Papirola 7y agod3js
- vbezhenar 7y agoBit tricks. Like 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; } It was like magic for me when I encountered it first time.
- soylentgraham 7y agoCame here to say this, I first saw this in the book Hackers Delight which is full of 200X-me's mind blowing stuff. It really opened a door to writing (arb)GPU shaders where at the time if's weren't allowed and trying to cut branches from PS2/GameCube/Xbox code
- Tepix 7y agoCheck out the Othello implementation by Hans Wennborg with a bitboard at https://www.hanshq.net/othello.html https://www.hanshq.net/othello.html
- yitchelle 7y agoPersonally, it is "hello world". It is beautiful because it was my introduction to C that led to the world that I am in now.
- kqr 7y agoImplementing FizzBuzz with explicit monoidal operations has been one of those things that I go back to and marvel at the simplicity and elegance of: http://dave.fayr.am/posts/2012-10-4-finding-fizzbuzz.html http://dave.fayr.am/posts/2012-10-4-finding-fizzbuzz.html It really inspired me to get better at seeking out the fundamental operations of whatever I was implementing.
- emmelaich 7y agoThat is great.
- Jarqwiz 7y agoFor me it's a function that calculates factorial using iterators in Rust: fn factorial(i: u64) -> u64 { (1..=i).product() } In almost every other language this code would look messy or use some terrible recursion. For example in C it would look something like this: long factorial(int n) { int c; long result = 1; for (c = 1; c <= n; c++) result = result * c; return result; } Or with recursion: long factorial(int n) { if (n == 0) return 1; else return(n * factorial(n-1)); } In any case, I thin Rust looks better in every way with its cleaner syntax.
- cakoose 7y ago> In almost every other language this code would look messy or use some terrible recursion. Nah, lots of other languages can do this. Python: def factorial(i): return reduce(operator.mul, range(2, i+1), 1) Ruby: def factorial(i) (2..i).reduce(1, :*) end Haskell: factorial n = foldl (*) 1 [2..n]
- rnhmjoj 7y agoIn haskell you can also use the `product` function: factorial n = product [1..n]
- estomagordo 7y agoFor Python, we don't need to supply the optional initializer 1. And reduce resides in the functools namespace (much like mul is in operator). I assume we're not talking about that peculiar dialect of Python that is no longer supported a few months from now.
- messe 7y agoNot only that but in python 3.8, it can be written: def factorial(n): return math.prod(range(1,n+1))
- estomagordo 7y ago
- tgvaughan 7y agoI think this was the first line of the forth in the library of an older version of jonesforth (https://rwmj.wordpress.com/2010/08/07/jonesforth-git-repository/ https://rwmj.wordpress.com/2010/08/07/jonesforth-git-reposit...), but now I can only find it in my port: : \ IMMEDIATE #IB @ >IN ! ; \ We can now comment! Implementing a forth system is unbelievably fun because of gems like this.
- Xelbair 7y agoI once had to find all lines which did not contain a specific word. As back then i was absolutely new to regex stackoverflow came to the rescue - and i still have that link saved to this day - https://stackoverflow.com/a/406408 https://stackoverflow.com/a/406408 Regex for that is just great ^((?!word).)*$
- grrrrrrreat 7y agoprint "Hello, World !" Intro to pretty much any language. It opens up so many possibilities ..
- wumms 7y agoWaiting for a keypress in ZX81 BASIC (maybe it's the opposite of elegant, but I remember it as the first time seeing a kind of easter egg in code): 10 PAUSE 4E4 "PAUSE n stops computing & displays the picture for n frames of the television (at 50 frames per second, or 60 in America). n can be up to 32767, which gives you just under 11 minutes; if n is any bigger then it means 'PAUSE for ever'. A pause can always be cut short by pressing a key"[0] (4E4 = 4*10^4 = 40000) [0] http://www.worldofspectrum.org/ZX81BasicProgramming/chap19.html http://www.worldofspectrum.org/ZX81BasicProgramming/chap19.h...
- eb0la 7y agoI always enjoyed reading Charles Petzold code on Microsoft Systems Journal. 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!
- tu7001 7y agoFor me it's gradient descent with back propagation and fast Fourier and fast multiplication Schönhage–Strassen algorithm.
- alex-ant 7y agoHad a case where I needed to update MySQL column's value if an incoming argument is less/greater than it without using functions or procedures. This returns the greatest value (passed ? or max_value column): ?^((?^max_value)&-(?<max_value)) And for minimum: min_value^((?^min_value)&-(?<min_value))
- ashton314 7y agoLazily-generated infinite list of Fibonacci numbers in Haskell: fibs = 0:1:zipWith (+) fibs (tail fibs) Recursive definitions and lazy programming blew my mind.
- donaldihunter 7y agoAnd in Perl6 / Raku my @fibs = 1, 1, * + * ... ∞
- urxvtcd 7y agoCreated an account to post this: :v/./,/./-j in vim will go through the whole file, joining multiple consecutive empty lines into one. Not only it is fork-bomb-level cryptic, but also showcases how you can use addresses to do advanced stuff. Somewhat more readable version: :vglobal /./ .,/./- join which is: go to every line that doesn't match (vglobal) /./ (is empty) and join lines from that line (.) to the line before (-) the next line that is not empty (/./ again).
- 8lall0 7y agoThe simple regexp matcher by Rob Pike: https://www.cs.princeton.edu/courses/archive/spr09/cos333/beautiful.html https://www.cs.princeton.edu/courses/archive/spr09/cos333/be...
- practical_lem 7y agoPike's code should be studied in schools.
- nils-m-holm 7y agoUnification of the terms X and Y in the environment E in LISP (part of a PROLOG interpreter): (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))))))) LOOK-UP looks up X or Y in E, VARIABLE-P returns truth, if X or Y is a variable.
- Insanity 7y agoSomething super simple but that really entertained me when learning lisp: (loop(print(eval(read))) to have a REPL. (Just reverse the letters, easy enough to remember). That to me is elegance. It's simple yet powerful, and just 4 words really.
- mg 7y agoNice. I immediately had to try the same in PHP. To make a working repl with newlines in the output etc, this is what I a came up with: while(1) {eval(fgets(STDIN));echo "\n";}; I then tried it on the command line like this: php -r 'while(1) {eval(fgets(STDIN));echo "\n";};'; Hurray, it prompted me for input! So I typed: for ($i=0;$i<10;$i++) echo $i; Which got me: 0123456789 So far so good. I wondered: Can we now run the repl in the repl? So I typed: while(1) {eval(fgets(STDIN));echo "\n";}; It kept prompting me for input. Am I in a REPL in a REPL now? I typed: echo "Hello from a REPL in a REPL!"; And the reply was: Hello from a REPL in a REPL! I'm not totally sure if I believe it though.
- sillysaurusx 7y agoIt is that simple! It has practical benefits. For example, if you can call that code from somewhere specific in your program, which is handy for debugging. If your `eval` function takes a lexical environment, you can also implement a debugger easily. To test whether your logic is working properly, make your repl print out a different character when it prompts for input. For example, the toplevel repl can print out "> " whereas the inner repl prints out "repl> " For bonus points, your repl should exit if you type Ctrl-D. That way you can go from the inner repl to the outer repl, and from there it should exit your program.
- bitwize 7y agoSounds like a Nine Inch Nails song. "I am in a REPL in a REPL in a REPL, Running all my code in nested loops..." https://youtu.be/pVB_DI4ajKA https://youtu.be/pVB_DI4ajKA
- 74ls00 7y agoDon’t you have the cart before horse; isn’t the acronym derived from this defintion?
- hazeii 7y agoRecursive gem in PDP-11 assembler: convert binary value in R0 into ASCII:- 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
- rurounijones 7y agoMaybe not elegant but as a child, the first time I saw repeat 360 [fd 1 rt 1] used to draw a circle in Logo on the BBC micro. So obvious to an adult but blew my mind.
- neillyons 7y agoThis is very common in Elm but it blew my mind after years of programming in Python. In Python it is very easy to raise an IndexError by getting an element from a list by index that doesn't exist. eg. # python names = [] names[0] # <- raises IndexError In Elm you are forced to always consider this possibility. # Elm names = [] case List.head names of Just name -> name Nothing -> "empty"
- MawKKe 7y agoIdiomatic python: v = names[0] if names else "empty"
- lgas 7y agoYes, but the point is you can forget the check in python but not in Elm.
- dorfsmay 7y agoThis always felt weird to me given that Python does a good job with dict: d = {} assert(d.get("blah"), None) I was impressed by Rust the first time I run into: let mut last; for i in &[1, 2, 3] { last = i; } println!("{}", last); >> borrow of possibly uninitialized variable: `last`
- stillworks 7y agoThis is a very open ended question. For me, lazy as I am, most recursive algorithms operating on binary trees are a thing of beauty. Post-order ones even more so.
- Daave87 7y agoselect languageId, translate(language, languageId) language from language it was a stored procedure to populate a dropdown list of languages each translated into their own language on an old asp.net app. i always liked it
- nicolapede 7y agoCuriously Recurring Template Pattern (CRTP) [0] in C++. class Derived : public Base<Derived> [0] https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern https://en.wikipedia.org/wiki/Curiously_recurring_template_p...
- snak 7y agoThat's awesome. I ran into this situation in C#, and looks like it is useful in some cases. https://zpbappi.com/curiously-recurring-template-pattern-in-csharp/ https://zpbappi.com/curiously-recurring-template-pattern-in-...
- kmote00 7y agotl;dr: "Generally, whenever you need the derived class information in the base class, you are probably looking for CRTP."
- monista 7y agoDidn't see anyone mentioned these two pearls: C (K&R) program that calculates PI number by measuring circle that is its code: https://en.wikipedia.org/wiki/International_Obfuscated_C_Code_Contest#Pi 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"'
- zaarn 7y agoThe code for the "A Mind is born" 256 byte Demo. It produces quite a neat music sequence and visuals. The code doesn't have a code equivalent but the binary version is understandable. This post is 256 bytes. https://linusakesson.net/scene/a-mind-is-born/ https://linusakesson.net/scene/a-mind-is-born/
- mhd 7y agomv ax, 0013h int 10h
- majewsky 7y agoHaskell allows you to define the full list of prime numbers in just two lines: module Primes where primes = 2 : filter isPrime [3..] isPrime x = all (\y -> mod x y /= 0) $ takeWhile (\y -> y * y < x) primes The beauty of this is that it's self-referential. The list `primes` is built by filtering all the natural numbers for prime numbers, using the predicate `isPrime` which itself uses the list `primes`. The only caveat is that we need to encode that 0 and 1 are not prime numbers, but 2 is a prime number, to provide the base cases for the recursion. Furthermore, `isPrime` uses that each non-prime number has at least one prime factor less than or equal to its square root, to ensure that it only needs to look at a finite number of possible prime factors. If you have GHC in your repo, you can test this by putting it in a file and running `ghci` with the file as the only argument. It will give you a REPL where `primes` and `isPrime` are in scope: *Primes> isPrime 200 False *Primes> take 10 primes [2,3,5,7,11,13,17,19,23,29]
- bjoli 7y agoIt is also dirt slow. This is just trial division, done in a lazy fashion. At least it is better than the one some haskellers call the sieve of erathostenes (it isn't the sieve of erathostenes), which is so god-awful that I almost vomit every time I see it. The real lazy sieve of erathostenes is a thing of wonder! There is a paper describing it called "the genuine sieve of erathostenes" and it can be found by googling.
- ahakki 7y agothis? sieve :: Integral a => a -> [a] sieve l = sieve' [2..l] [] where sieve' (p:ns) ps = sieve' (filter (\x -> rem x p /= 0) ns) (p : ps) sieve' [] ps = reverse ps
- bjoli 7y agoThe lazy sieve i have seen, taken from the paper mentioned in my post: primes = sieve [2..] sieve (p : xs) = p : sieve [x | x <− xs, x ‘mod‘ p > 0]
- known 7y agoto count the unique lines from a file: cat animals.txt | awk '{ cnts[$0] += 1 } END { for (v in cnts) print cnts[v], v }' https://blog.jpalardy.com/posts/alternative-to-sort-uniq-c/ https://blog.jpalardy.com/posts/alternative-to-sort-uniq-c/
- thequux 7y agoFrom HAKMEM, Item 172: CONS: EXCH A,[EXCH A,[...[PUSHJ P,GC]]] EXCH A,CONS This allocates a cons cell for Lisp on PDP-10, by using the first instruction in the routine as the head pointer of the free list. The first instruction puts the first word of the free list into A (and then clobbers that word with the original contents of A, initializing the cons cell). The second then swaps the first instruction with the first item in the free list. 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.
- tcgv 7y agoOne of the first recursive algorithms I learned was the solver for the Tower of Hanoi problem. I was stunned about its simplicity, solving a problem most people couldn't with just a few lines of code: - https://en.wikipedia.org/wiki/Tower_of_Hanoi#Recursive_solution https://en.wikipedia.org/wiki/Tower_of_Hanoi#Recursive_solut...
- tomerbd 7y agocomment bait
- andrewstuart 7y agoDas Inbox - an SMTP handler server written by Kenneth Reitz https://github.com/billzhong/inbox.py/blob/master/inbox.py https://github.com/billzhong/inbox.py/blob/master/inbox.py It's about 42 lines of actual code excluding newlines.
- ptrkrlsrd 7y agoMy favorite is this one-liner for generating the Fibonacci sequence in Haskell: fibonacci = 1 : 1 : [x + y | (x, y) <- zip fibonacci (tail fibonacci)]
- 7thaccount 7y agoA fully graphical calculator app in Rebol is just a few lines of code. The formatting looks pretty legible at the below link if you scroll down a bit. 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_language.html https://easiestprogramminglanguage.com/easiest_programming_l...
- kome 7y agoREBOL and Red are so so cool. I wonder why hackers are not embracing them.
- 7thaccount 7y agoRebol was closed source back when open source was really starting to take off with Perl and Linux. It is seriously cool (I agree), but the interpreter is a little slow. Red still has a little ways to go, but could be a game changer some day. The project is insanely ambitious, but I'm optimistic.
- exikyut 7y agoThe main (IMO sad) reason REBOL sits in a weird half-life position of "not quite dead, but..." is that, while REBOL Core is open, the GUI parts (which are crossplatform, and run on Linux) are still closed source. It's a bit like .NET Core. Great to base a business on... not so great to tinker around with. Arguably the second (tinkering, learning) comes before the first (using what you've learned to build a business). Mildly infuriating...
- draegtun 7y agoJust to clarify it's Rebol 2 (Core/etc) that is closed source. Rebol 3 is open-sourced along with the GUI (R3-GUI).... * https://github.com/rebol/rebol https://github.com/rebol/rebol * https://github.com/metaeducation/ren-c https://github.com/metaeducation/ren-c (community fork) * https://github.com/zsx/r3-gui https://github.com/zsx/r3-gui (Atronix fork)
- swah 7y agohttps://www.cs.princeton.edu/courses/archive/spr09/cos333/beautiful.html https://www.cs.princeton.edu/courses/archive/spr09/cos333/be... Something completely different: the Factor language, in the beginning.
- lioeters 7y agoThe link goes to an article about Rob Pike's regular expression matcher (which is great BTW). Looking for the "beginning" of the Factor language led me to this wonderful site about concatenative languages: https://concatenative.org/wiki/view/Concatenative%20language https://concatenative.org/wiki/view/Concatenative%20language
- yakshaving_jgt 7y agoIf you create an executable file with the following contents, and run it, it will delete itself. #!/bin/rm
- Iwan-Zotow 7y agoThere is a better example - original /bin/true source. Presented to you below.
- nidificate 7y agoCompare that with the version in GNU Coreutils[1] that is 50+ lines long so that false[2] can be written as: #define EXIT_STATUS EXIT_FAILURE #include "true.c" [1] https://github.com/coreutils/coreutils/blob/master/src/true.c https://github.com/coreutils/coreutils/blob/master/src/true.... [2] https://github.com/coreutils/coreutils/blob/master/src/false.c https://github.com/coreutils/coreutils/blob/master/src/false...
- social_quotient 7y agoKinda seems like the perfect question to be used with this show hn from a couple days ago https://carbon.now.sh/ https://carbon.now.sh/
- xamuel 7y agoI'll nominate this pseudocode from a paper of mine currently under review. Treat it like a koan to be meditated upon to gain enlightenment about AGI. The paper introduces an ordinal notation system in which ordinals are notated by computer programs. This pseudocode notates the ordinal omega^2. `, ⌜, and « are progressively higher-level opening quotation marks. ', ⌝, and » are the corresponding closing quotation marks. LEFT = «X=⌜»; RIGHT = «⌝; While(True) {Print(X); X=⌜Print(`⌝+X+⌜')⌝}»; X = «Exit()»; While(True) { X = LEFT + X + RIGHT; Print(X); }
- globuous 7y agoHere’s one i’m really proud of, i crafted it when learning js a while back. Its a one liner that flattens arbitrarily nested array. Its recursive though, so i guess it has its limits. I remember commenting something along the lines of “dark magic functional prog” (thats how i found it a second ago in GH actually): 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
- peterwwillis 7y agoThis number: 4856507896573978293098418946942861377074420873513579240196520736 6869851340104723744696879743992611751097377770102744752804905883 1384037549709987909653955227011712157025974666993240226834596619 6060348517424977358468518855674570257125474999648219418465571008 4119086259716947970799152004866709975923596061320725973797993618 8606316914473588300245336972781813914797955513399949394882899846 9178361001825978901031601961835034344895687053845208538045842415 6548248893338047475871128339598968522325446084089711197712769412 0795862440547161321005006459820176961771809478113622002723448272 2493232595472346880029277764979061481298404283457201463489685471 6908235473783566197218622496943162271666393905543024156473292485 5248991225739466548627140482117138124388217717602984125524464744 5055834628144883356319027253195904392838737640739168912579240550 1562088978716337599910788708490815909754801928576845198859630532 3823490558092032999603234471140776019847163531161713078576084862 2363702835701049612595681846785965333100770179916146744725492728 3348691600064758591746278121269007351830924153010630289329566584 3662000800476778967984382090797619859493646309380586336721469695 9750279687712057249966669805614533820741203159337703099491527469 1835659376210222006812679827344576093802030447912277498091795593 8387121000588766689258448700470772552497060444652127130404321182 610103591186476662963858495087448497373476861420880529443 This is a 1811-digit illegal prime number, which when unpacked into binary, becomes a compressed ELF executable which will decrypt DVDs. This was one of many ways used to enable people who had legally purchased a DVD with copy protection to play it on Linux. Here's the story behind finding the prime: https://web.archive.org/web/20070223075434/http://asdf.org/~fatphil/maths/illegal.html https://web.archive.org/web/20070223075434/http://asdf.org/~... Aside from that, the qrpff perl scripts that became t-shirts (https://web.archive.org/web/20011221024307/http://www.copyleft.net/item.phtml?page=product_1174_front.phtml 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 ;)
- rpmisms 7y agoDoom Source. I don't do C, but this stuff just... made sense.
- oftenwrong 7y agocamel code: https://www.perlmonks.org/?node_id=45213 https://www.perlmonks.org/?node_id=45213 This was the first artistic use of code I had ever stumbled upon (not including LOGO programs).
- lgas 7y agoI always liked the elegance of this definition of the power set function in Haskell: powerSet = filterM (const [True, False])
- totalperspectiv 7y agoKind of cheating because Kernighan literally labels it as beautiful. It's Rob Pike's implementation of Ken Thomson's regex matcher. https://www.cs.princeton.edu/courses/archive/spr09/cos333/beautiful.html https://www.cs.princeton.edu/courses/archive/spr09/cos333/be...
- svendahlstrand 7y ago,[.,] When it comes to the weird and wonderful world of esoteric programming languages, the above Brainfuck program is pretty elegant. It's a basic implementation of the echo program: printing back what the user inputs. 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 [
- DanielBMarkham 7y agoI've written several pieces of code that I am quite fond of. I guess the most recent was last year. A client asked what was necessary for a totally secure yet extensible blogging system. I ended up putting something together in Vue.js and AirTable that was tight, static, and extensible. That had a sweet feel to it. It was extremely small for having so many features. Fun times.
- jpochtar 7y agohttps://norvig.com/spell-correct.html https://norvig.com/spell-correct.html Changed the way I think about code
- igammarays 7y agoAnd to think that I once got a job interview question that asked me to invent a spell-checker in 45 minutes.
- yboris 7y agoThank you for the share! This was excellent. Could you leave a sentence or two about how it made you "change the way [you] think about code"?
- jpochtar 7y agoBecause of Norvig's spelling corrector, my measure for good code is whether or not I can understand what it's supposed to be doing, and how it's supposed to work, from reading it in one pass. This code passes that test. Before reading it I would have never thought that could be a goal— I couldn't imagine it was possible to know what a program does without comments and documentation. When I heard the word "readable" from others, I understood it as "parsable". From an OO context, I thought readable meant neatly formatted lines that let you say "ah, yes, this is an if statement", "this is a constructor", and so on, but with no idea what the code actually does or means to do. Norvig's spelling corrector is better read without comments. The names of the functions tell you what you need to know— their purpose, and their implementations tell you exactly what the author thinks they mean. It's "declarative": "def correction(word):..." means exactly "the correction of a word is ___", "def candidates(word):..." means exactly "the candidate corrections of a word are ___". There's a strong functional/LISP influence here, which I only learned later. Because this code demonstrated it was possible, my standard for all code is that it should tell you what it does from one reading. Most code (including my own!) doesn't come close, but aiming for that goal has tons of good effects on difficult code.
- yboris 7y ago
- tolodolo 7y agolife←{ ⍝ John Conway's "Game of Life". ↑1 ⍵∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂⍵ ⍝ Expression for next generation. } via here: https://dfns.dyalog.com/c_life.htm https://dfns.dyalog.com/c_life.htm I figure that when we finally figure out the answer to the universe it will be something akin to this parsimoniousness.
- jlv2 7y ago/bin/true on a v7 UNIX system. A zero byte file with the execute bit set.
- jlv2 7y agoFound a copy: https://github.com/v7unix/v7unix/blob/master/v7/bin/true https://github.com/v7unix/v7unix/blob/master/v7/bin/true
- JimBrimble35 7y agoconsole.log('cellar door')
- gigatexal 7y agoWhen I first saw something solved in a recursive way my mind was blown. Does that count?
- freqshow 7y agoclass Universe(void): def __init__(): eval("Fiat Lux")
- mitchtbaum 7y agohttps://rosettacode.org/wiki/99_Bottles_of_Beer#World_model_solution https://rosettacode.org/wiki/99_Bottles_of_Beer#World_model_... https://en.wikipedia.org/wiki/The_Complexity_of_Songs https://en.wikipedia.org/wiki/The_Complexity_of_Songs https://en.wikipedia.org/wiki/Generative_music https://en.wikipedia.org/wiki/Generative_music https://en.wikipedia.org/wiki/Repetitive_song https://en.wikipedia.org/wiki/Repetitive_song |>~~~<<< https://en.wikipedia.org/wiki/E%3DMC2_(song) https://en.wikipedia.org/wiki/E%3DMC2_(song) https://genius.com/Big-audio-dynamite-e-mc2-lyrics https://genius.com/Big-audio-dynamite-e-mc2-lyrics https://www.youtube.com/watch?v=cHTDkJ-bQqM https://www.youtube.com/watch?v=cHTDkJ-bQqM
- Iwan-Zotow 7y agoSource of the original "true" command, presented to you below
- manifestsilence 7y agoThis one is kind of contrived, but a work of mad genius. Mandelbrot code that resembles Mandelbrot, in Python 2: _ = ( 255, lambda V ,B,c :c and Y(V*V+B,B, c -1)if(abs(V)<6)else ( 2+c-4*abs(V)**-0.4)/i ) ;v, x=1500,1000;C=range(v*x );import struct;P=struct.pack;M,\ j ='<QIIHHHH',open('M.bmp','wb').write for X in j('BM'+P(M,v*x*3+26,26,12,v,x,1,24))or C: i ,Y=_;j(P('BBB',*(lambda T:(T*80+T**9 *i-950*T **99,T*70-880*T**18+701* T **9 ,T*i**(1-T**45*2)))(sum( [ Y(0,(A%3/3.+X%v+(X/v+ A/3/3.-x/2)/1j)*2.5 /x -2.7,i)**2 for \ A in C [:9]]) /9) ) ) https://codegolf.stackexchange.com/questions/23423/mandelbrot-image-in-every-language https://codegolf.stackexchange.com/questions/23423/mandelbro...
- vmchale 7y agoEasy: http://hackage.haskell.org/package/recursion-2.2.4.0/docs/Control-Recursion.html#v:zygo http://hackage.haskell.org/package/recursion-2.2.4.0/docs/Co... Also: subsets = filterM (pure [True, False])
- YeGoblynQueenne 7y agoThis grammar of the aⁿbⁿ language in Prolog's Definite Clause Grammar syntactic sugar: s --> a,b. s --> a,s,b. a --> [a]. b --> [b]. s is a non-terminal, a and b are preterminals, [a] and [b] are terminals and "-->" can be read as "expands to". The syntax is the same as BNF and the grammar is a Prolog program that is directly executable as both a recogniser or a generator, depending on instantiation pattern at call time. 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
- thedudeabides5 7y agofor(int i=1;i<=10;i++){ doStuff(); } Sounds trivial compared to the rest listed here, but for me it was just the first time I got a for loop to work in java. Like, conceptually I knew programming was about getting machines to doStuff, but this was probably the first time I actually had a machine do something I asked of it directly. Well, that and Logo writer. https://twitter.com/dosnostalgic/status/726236764759842817 https://twitter.com/dosnostalgic/status/726236764759842817
- vagab0nd 7y agoI did not write this, but: main(){char*s="main(){char*s=%c%s%c;printf(s,34,s,34);}";printf(s,34,s,34);}
- candu 7y agoFrom [1], a terse one-liner that outperformed many longer and more complicated entries in The Second International RoShamBo Programming Competition: int henny() { return((*opp_history?opp_history[random()%*opp_history+1]+1:random())%3); } [1] https://webdocs.cs.ualberta.ca/~darse/rsbpc.html https://webdocs.cs.ualberta.ca/~darse/rsbpc.html
- mbrodersen 7y agoThe Lambda Calculus (https://en.wikipedia.org/wiki/Lambda_calculus https://en.wikipedia.org/wiki/Lambda_calculus).
- kcarter787 7y agoprint(“hello world”) This Python snippet is the most beautiful code I’ve read. It only went downhill from there.