I, unfortunately, cannot find an online copy currently.
Knuth's TAOCP's latest published part, Volume 4 Fascicle 6, on Satisfiability contains a number of visualizations that really are amazing and worth just buying a copy of the book for, just to ponder over these images.
The satisfiability problem of whether there exists an assignment of boolean values that makes a given boolean formula evaluate to TRUE is, IMO, truly a fundamental problem in computer science.
Any piece of code with some inputs and outputs can be transformed into a boolean formula (albeit a huge one). This process feels akin to expressing molecules, from simple ones like H2O, to the highly complex proteins that make up much of our Cells, in their constituent atoms and more importantly the atom interactions.
Knuth (EDIT: Actually, Carsten Sinz) takes this concept one step further and produces visualizations of non-trivial boolean formulas that clearly show the regular, both symmetrical and asymmetrical, sometimes fractal-like nature of these formulas.
In my mind, these visualizations are quite powerful and strikingly show the fundamental building blocks of (digital) computation.
> Knuth takes this concept one step further and produces visualizations of non-trivial boolean formulas that clearly show the regular, both symmetrical and asymmetrical, sometimes fractal-like nature of these formulas.
The visualizations were done by Carsten Sinz.
This is his paper describing the technique:
Carsten Sinz. Visualizing SAT Instances and Runs of the DPLL Algorithm. J. Automated Reasoning, 39(2):219-243, 2007.
I am lucky to be paid to work on SAT. I wouldn't yet say I am an expert, yet, but it is really a pleasure to do so. Trying to improve on algorithms to solve these problems is truly humbling.
What I found particularly striking about them was how much they reminded me of both neurons and larger brain structures, as well as some of those newer, ML-assisted FMRI imagery.
Probably just coincidence and wishful thinking, but it instills a sense of daydream-like wonder all the same.
I remember installing Mandrake Linux on my PC (via CD ordered online as magazines still hadn't started to include the CDs). I had the dial-up line and the modem but didn't know how to set it up as I was new to both Linux and dial-up. So I used to print the steps from websites/mail groups at office to try them at home. Initially I couldn't make it work and had no choice but to wait to get to office the next day to start again.
Finally I read a bunch of docs about how to talk to the modem and eventually I managed to do the correct steps and the modem produced its sweet handshake tone and the indicator lights started to blink - it was such a pure joy to finally be online from Linux!
I grew up after that sound, but I can mentally play back a dialup sound purely because it is used in every second show, podcast, documentary on computers.
It kept the speaker on at first so you could hear if a human answered the phone, or got some network message like "all circuits are busy". It muted once it had a confirmed modem on the other end.
It used to be useful to me back when my ISP had 28800 bps and 33600 bps capable modems in their pool, and I had a 33600 -- I learned to hear from the handshake when I hit one of the slower modems and would then immediately hang up and try again until I got one of the fast ones ;)
It was pretty useful in my experience because sometimes the line you called was busy, sometimes a human answered instead of a computer, and sometimes a computer modem just didn’t pick up for whatever reason. Hearing the dial & handshake was a way to know what exactly went wrong when you weren’t able to connect. BBSs didn’t have this problem so much, but it happened often enough when modeming with friends or with small businesses that didn’t have a large modem bank and a lot of lines. Typing the wrong number was common. I also remember experimenting with robo-dialing with my childhood friends, calling through a list of numbers, like in War Games, looking for unknown computers to connect to.
You could turn it on by sending the correct Hayes command before connecting. It's really annoying! And it can't be turned back off again until you disconnect.
Is it just me or... does the modem audibly say "Hi" when the connection is successful? Probably just me projecting from my imagination, but listen to the part after the handshaking and before the white-noise dataflow. There's a very clear 'boing-boing' sound and then a bunch of static that sort-of sounds like someone whispering the word "Hi". It's not just on the linked recording above, I remember being conscious of this back in the day when dial-up was "normal". Just curious to know if anyone else encountered this trick of perception...
Anyway, hearing those tones again did bring back all the feels, the joy of hearing that "boing-boing-Hi" greeting as I stepped once again onto the "Information Superhighway".
This makes me wonder: 1) Does Wikipedia / Wiki* not have a JS pan & zoom tool for graphics like these and 2) Has no one else made something like that just for this graphic?
Asking because the graphical linux genealogy concept / this illustration have been around for a while, as have JS pan & zoom plugins, and it's totally worth having something like this in that format.[1]
Edit: OK, there is Gadget-ZoomViewer (below), but maybe it doesn't work for SVGs? I don't see the option to open ZoomViewer from the Commons image page for this image.
> Instead of learning how Raskin’s color scheme worked, Jobs hired an artist, San Francisco’s Tom Kamifuji, who was a hot, up-and-coming artist in the late 70’s / early 80’s. Jobs gave him free reign to make it more artistic, though Jobs failed to explain that the original color scheme was important for using the chart easily.
I would like to see a lot more of them in the world, as interactive tools as well as simply diagrams. I think they would make a great basis for a UI to design multi-step async processes where things can fail at any point and you want to handle different failures differently.
Not sure if it fits in scope, but I find this classic to be an ingenious intro to where to start from in terms of visualisation:
https://bost.ocks.org/mike/algorithms/
I often cite this diagram: https://upload.wikimedia.org/wikipedia/commons/3/37/Netfilte... as my favorite picture. It shows the logical flow of packets through Linux. I'm pretty sure my career would be on a very different trajectory had I not discovered an earlier version of it back in ~2006.
Sadly I have not. I've been on the lookout though. I've also considered adding annotations for ebpf hooks to this one, but that turns out to be rather difficult to keep up with too.
Not as academic as some of the other replies, and certainly not all of them are CS-related, but Bartosz Ciechanowski's interactive web illustrations are fantastic examples of modern visuals.
It's the sort of interactive educational content that I always imagined computers and the internet would be amazing for, it just never panned out at a large scale.
Maybe not easy enough to create, maybe not profitable enough, who knows.
So unplanned interruptions affect programmers less than planned ones ? Next time I need to talk to a dev, I'll be sure to pop to their desk unannounced rather than trying to find a suitable time beforehand then ! /s
Recently he had done a video about convolution. And his videos about neural networks are pretty good. He has recommendation video for other good channels too.
While on the topic of FFT, the "butterfly diagram" sure is profound, although it takes me effort to wrap my head around it to make it a personal favorite in the same way that other illustrations make things click to me.
My favorite artistic illustration is probably Jorge Stolfi's drawing inspired by the self-adjusting splay tree data structure of Sleator and Tarjan:
https://www.link.cs.cmu.edu/splay/tree5.jpg
I don't remember the original source of this image but it's a comical take on the SDLC, showing how different roles / teams understand what the customer wanted versus needed when building a tree swing:
The Microsoft one was VERY true, at least until the mid 2K's. Small groups with lots of middle managers, bad communication, and hatred towards the other small groups.
For MS, it was definitely true when there was the policy of firing the bottom 10% every year or something like that.
It created extremely perverse incentives where nobody wanted to help each other or would even go as far as to sabotage other people's work in order to make sure they're not on the bottom. Some managers would hire people with the intent to fire them later.
Apple these days is very traditional with the SLT comprising the various VPs and everyone reporting to them via middle management layers.
In the period where Steve Jobs was not CEO it was a lot more like Microsoft with the various geographical divisions e.g. EMEA, AMR in particular having their own fiefdoms and starting wars with each other. And then of course the ridiculous number of skunkworks projects that would compete with other teams.
Honest question for those who have worked at several software companies: What works best? The chart displayed with Google with lots of connections but also a lot of complexity, or the "traditional" Amazon chart?
Interesting that what operations supposedly installed was closest to what was actually needed, and only an additional binding away from a complete solution.
This is exactly what I thought of coming into this post! I think I actually saw this first nearly 20 years ago and boy oh boy things don't change much (or should I say, people don't change much)
"The 1981 book School, Work and Play (World of Tomorrow) features this beautiful two-page spread. Apparently, thanks to computers, there's no crime in the future outside of the computerized variety. The "computer criminal" pictured really doesn't appear to be running very fast. Maybe they're playing a game of freeze-tag. Or maybe that policeman's gun has special settings the author didn't tell us about. I like to believe the former, but that's just me."
The book is full of really cool images like that one of "The Future" as seen from '81
> Computers will make the world of tomorrow a much safe place. They will do away with cash, so that you need no longer fear being attacked for your money.
The growing use of Debit and Credit Cards eliminating the need to carry a hundred or so with you at all times for spending/errand purposes without requiring the merchant to take the risk of taking personal cheques was a huge revolution made possible by mass computerisation in the finance industry. This includes the current discussions many governments are currently having about simply not issuing cash money any longer.
Cash money still has its uses. I always carry some for tips and for when a business's payment card reader goes down and nobody knows how to process a card without it.
Since the pandemic especially, a number of businesses don't take cash, only cards, particularly some small breweries and independent fast food places in our area (Silicon Valley). I guess if the card readers all go down they are out of business until they fix it.
I was paying for services rendered at the optician, and luckily had a wad of cash, but what's the user story there other than wait while they call support? I guess they could have invoiced me.
Yeah it's an interesting thought. Credit card scams, phishing, etc. have made new ways of stealing possible.
It's 'safer' as in I think you can claim muggings or burglaries (or losses to these) have reduced because people just don't carry as much cash anymore.
Not the GP, but I have a composite / s-video to hdmi converter from ebay. You can get DIN to RCA or S-video (the C64 exposes seperate luma and chroma signals) cables for the C64 fairly easily as well. Picture quality is... fine.
There's an important distinction that your explanation glosses over, which is that MergeSort is an out-of-place sort while QuickSort is in-place. As a practical matter, this distinction is important and it makes the two algorithms not quite duals. Your explanation of why we can assume that QuickSort pivots are medians makes sense, but it also glosses over one of the deep insights about why QuickSort works at all, which is that with unsorted data, the choice of pivot will rarely be bad (it will be "near the middle on average.")
Yes, this efficiency-aspect is not captured in the illustration -- while splitting perfectly _by index_ comes for free, splitting perfectly _by value_ needs nontrivial work (median-finding).
Yes and with naïve median-finding comes pathological inputs that hit the worst case O(n^2). Something to watch out for if you’re sorting user-provided input as that could open you up to some silly denial of service attacks!
Concerning the public key cryptography for the exchange of private encrypted messages, I would have rather represented the shared public keys by padlocks, and the private key by the key allowing to open the padlocks. This way, it is easier to understand that there is a relationship between the two keys. In his drawing, 2 different keys can open the safe door, which is not possible in the physical world...
In Networking, two illustrations of congestion control are just fantastic IMO.
First one is [1], by Chiu and Jain (page 7, figure 5), showing that Additive Increase / Multiplicative decrease is the only simple policy that converges among 2 senders (with rates x and y) to a rate that is fair (along the y=x diagonal) and efficient (along the x+y=Bandwidth). This is the basis of the algorithm that made TCP (and the Internet as we know it today) possible.
The other one is this diagram from BBR [2] (from the paper in [3]), that shows how BBR sets the window ("amount in flight") to the bandwidth-delay product (BDP) of the bottleneck link (the "volume" of the pipe in a water analogy). The cool thing is that you can only measure the delay of the link if you window is <= the BDP, and you can only measure the bandwidth if your window is >= the BDP, so the algorithm has to hover around this point to make sure it can determine both.
Chiu-Jain plots are great for getting a grasp of AIMD. Another related one I like is the figure illustrating ack-clocking in Van Jacobson's original congestion control paper - Figure 1 here: https://ee.lbl.gov/papers/congavoid.pdf
There's a standardized UML version of this, but I think it's easier to read when the arrows are sloped a little, like in this random example: https://www.graffletopia.com/stencils/1560
I really like the diagrams from Refactoring.Guru.
They provide clear representation of what the design patterns are solving, along with real world analogies.
I can't really come up with any good illustrations for something complex off the top of my head, so I'll go for a really simple one. In fact, that's part of its beauty.
When I had to deal with the signals from a rotary encoder the first time (being a programmer with two left hands and zero hardware affinity), I had a look at a couple of C libraries but didn't have the patience to slog through their implementations in order to understand what signals they were decoding.
I'm not sure if it was this exact library, but that's the comment I saw. Nice and obvious, in contrast to all the obscure attempts to convey what was happening all the other libs made through prose comments.
Wow. Didn't ever think that there is something like this. I've heard about UML, but I've always thought that it is something related only to programming.
Not from the CS world, but I've always enjoyed the Smith Chart. It's a tool to figure out impedance (eg resistance but a complex number) matching on a boundary to reduce reflected power.
I absolutely adore this Dilbert comic, not really strictly Computer Science nor illustrating a concept, but I think it is pretty funny.
https://dilbert.com/strip/1995-06-24
Anything from Setosa [0] is really good. It contains interactive, animated illustrations of several Machine Learning ideas.
I _loved_ reading papers from Distill Pub [1] as they contained interactive diagrams.
My most favorite one so far is the thread on Differentiable Self-organizing Systems [2]. I liked the lizard example very much as it is interactive, and lizards grow lost organs back. I think this is funny.
Shameless plug: I drew 36 illustrations of various data structures from simple ones like stack and binary trees to advanced ones like skip list and Merkle tree, and sell them as collectible card decks [0].
Nice effort, and the format of the diagrams looks good. I do find the description close to impossible to read due to the use of all caps, monospace and most of all, lack of line spacing. I haven’t thought more on this, but within the constraints of the card sizes if this part could be improved, that’d be great.
Can you email me at hello@cs.cards along with a screenshot? This is something determined by Shopify and I did not set anything that specifically leaves out India as a shipping destination.
It shows the "Universal Processor" which looks like a cross between a computer and a liquidizer and has a big knob on the front with "Data", "Word", "Food" on it! It is a humorous illustration of "An overgeneralized solution".
In fact Thinking Forth has lots of great humorous cartoons and super insights into making real software that it is still a good read today. You'll learn a bit of Forth too!
I read this book at a formative age, and despite not writing a great deal of Forth code, the philosophy of this book has stuck with me.
Here is a link where you can get an electronic copy as it is out of print now and Leo Brodie has graciously allowed it to be distributed under the Creative Commons license.
Youtube user Musicombo has plenty of videos showing different sorting algorithms in action and their runtime behavior under different (pathological) cases:
Watching SORTDEMO.BAS at the formative age of ~11 baited me into programming. I recall messing around trying to make even faster versions. https://www.youtube.com/watch?v=leNaS9eJWqo
Not only related to CS, but to most management areas and life as a whole. Going from state(A) to state(B) should never be that complicated, right? Oversimplification at its prime.
De gustibus non est disputandum, but I find these ugly. The icons draw too much attention, and (IMO) are incomprehensible.
They have zillions of products, so I understand that not all their icons can be immediately recognizable, but is there meaning to the colors of icons? I can’t think of, for example, a reason why “Batch”, “CloudFront” and “Glacier” have the same color.
Similarly, is there a language for recognizing icons? I don’t understand why EFS and CloudFront both are stacks of cubes, for example.
I think I would choose the same colour and/or similar shapes for all icons that denote data stores (examples: S3, Glacier, RDS), for example, a different one for compute (examples: Lambda, EC2, Batch), and a third one for connections (load balancer, Route 53, CloudFront)
Also, why are there such subtle differences in some of the colors? Do they mean something?
Finally, if one of your 100+ products is called “S3” and you have to design a recognizable icon for it, how on earth can you not put a big “S” and a big “3” in that icon? It can’t be that they want to avoid text at all cost, as they wrote “Aurora” in an other icon.
The Tanenbaum books on operating systems [1] and networks [2]. Here are just two samples, the various editions each have their slightly different illustrations.
I've always found it really awesome how the cover of a book can clarify concepts in such a funny and concise way :)
Figure 7.64 "Circuit diagram for a PLA", which demonstrates how the logical duality between AND and OR is reflected, at the physical gate level, by a π/4 rotation between encode and decode planes.
I worked at several companies that had this poster hanging on the wall back in the day and spent a lot of time staring at it while on the phone. It comes immediately to mind.
Thanks I had a hard time finding the original at all. I do remember it was specifically the one with the blue background in my case, though. Probably not “better” or even as accurate but it’s the one that really stuck out in my mind.
Borges was a direct influence on William Gibson most notably (to me at least) seen with the short story "The Aleph" by Borges [1]. Gibson had an "aleph" device simulating reality in "Mona Lisa Overdrive" (which many of the characters mispronounced as "LF" device).
It was my first introduction into actually thinking about and working with distributed systems at University, a field I've been in love with since, so it seems quite formative. Plus I always thought aesthetically it looks lovely, like it'd make a good tattoo.
Oh man a friend of mine used to have a shirt with a delightful illustration of the madness that is ATM, or maybe it was just illustrating IP-over-ATM. It had packets being like thrown into woodchippers and reassembled if I’m remembering right. Wish I could find it again.
It's the standard diagram of how Transformer language model works (https://www.researchgate.net/figure/Transformer-Language-Mod...). When I tried to figure out transformers, I saw it in every single paper, and it didn't help almost at all. I think I finally got a good understanding only when I looked at a few implementations.
From Transaction Processing: Concepts and Techniques:
Figure 2.3 (also inside the front hardcover) "The Price/Performance Tradeoff"
A diptych of size vs. cost, and latency vs. cost, for various storage technologies (in 1990. that said, the shape of the curves has not changed much in 3 decades; only the absolute numbers are out of date)
(FWIW, the "tape robot" streamed architecture they predicted has indeed come to pass; it's just that we use network flows instead of tape robots as our stream endpoints)
Figure 40. (a collage of scripts, demonstrating how meaning can be carried in strings of [many different choices of sets of] symbols: compare Turing or Shannon)
Figures 135 & 136. (Escher's Drawing Hands, followed by a structural sketch showing how the paradox of mutual recursion can be solved by something implicit and prior to both: compare McCarthy or Curry's Y combinator)
I drew a 9 page DTM that implemented binary multiplication for an assignment in a CS class at USC (southern cal) in the mid-90's. It is my favorite CS illustration. However, I am certain that no one else would be interested in it, as it is very specific, archaic, and personal.
What came to my mind is "An Introduction to Microcomputers" by Adam Osborne. I don't think I can find my copy anymore. If I remember correctly, there were block diagrams showing the main functional components of a microcomputer, E.G. the ALU, Arithmetic Logic Unit.
Likely the diagram of the multiphase multi-tape sort diagram that was a foldout in the first edition of TAoCP. As tape fades from memory and usage, the diagram has been removed. It is a sentimental favorite of mine as tape was important in the early part of my career.
Ah, my sweetest memories are of getting the whole family on the couch, grabbing some popcorn, pouring some soft drinks and watching Windows 95 defragment my disk for three hours as soothing chirps and hums emanate from the grey box beneath the monitor.
The “I wan to run an agile project” animation https://youtu.be/4u5N00ApR_k Nothing comes close to this, sums up the whole idea from bottom to the top perfectly
Time space diagrams in distributed systems. Very obvious once you see but never before saw some critical problems in distributed systems like fifo ordering, causal ordering and other things explained with such diagrams.
did not have formal education on distributed systems in my country but learned many things in this topic on job.
So then me took course by lindsey kuper on youtube. it is amazing course, super clear instructor even for me with not good english.
i think professor in this class say these diagrams came from leslie lamport who did lot essential thinking in distributed system space
maybe not CS concepts, but wanted to re-share Perpendicular disc storage from Hitachi. https://www.youtube.com/watch?v=xb_PyKuI7II It's a simple concept to explain, but animation sure makes it fun and lasting.
Knuth's TAOCP's latest published part, Volume 4 Fascicle 6, on Satisfiability contains a number of visualizations that really are amazing and worth just buying a copy of the book for, just to ponder over these images.
The satisfiability problem of whether there exists an assignment of boolean values that makes a given boolean formula evaluate to TRUE is, IMO, truly a fundamental problem in computer science.
Any piece of code with some inputs and outputs can be transformed into a boolean formula (albeit a huge one). This process feels akin to expressing molecules, from simple ones like H2O, to the highly complex proteins that make up much of our Cells, in their constituent atoms and more importantly the atom interactions.
Knuth (EDIT: Actually, Carsten Sinz) takes this concept one step further and produces visualizations of non-trivial boolean formulas that clearly show the regular, both symmetrical and asymmetrical, sometimes fractal-like nature of these formulas.
In my mind, these visualizations are quite powerful and strikingly show the fundamental building blocks of (digital) computation.