00:00:19.480
Hello everyone. I think we’re about ready to start. I want to welcome you to "That Works?! Quines and Other Delightfully Useless Programs." By the end of this talk, I hope all of you will look at the background of this slide and say, "Of course, I know what that does!"
00:00:24.770
It’s incredibly obvious to me. Look, it’s Ruby—that is valid Ruby! So obviously, it all seems very simple.
00:00:30.800
Ruby is such a readable language that you can write code like that. It's great. My name is Colin Fulton, and I'm a front-end developer for a security company called Arbor Networks.
00:00:43.129
If you want to get in touch with me, I’d recommend emailing me because I just joined Twitter and haven't actually tweeted anything yet. However, if you want to see stuff related to this talk, I recommend following me on Twitter, as I'll be posting more there later.
00:00:59.269
All of the code you see in this talk that I personally wrote is available on GitHub. Some of it I have just uploaded, and it’s all under open-source licenses, so if you want to use it in your production code, feel free—though I wouldn't recommend doing that!
00:01:16.610
I want to start this talk with two stories about playing with computers. The first story is from the 1830s, when Charles Babbage was working on a problem and enlisted Ada Lovelace—whose full name is quite lengthy, which is why we call her Ada—for assistance.
00:01:29.450
At that time, if you wanted to do math, you didn't have computers or calculators. To perform lots of calculations, you would use log books filled with tables of logarithms—a huge amount of entries.
00:01:45.950
The question was, how do you calculate a giant book full of logarithms without computers? The answer was simple: you calculate them by hand, resulting in hundreds and thousands of calculations. As you can imagine, a few errors crept in over time.
00:02:05.240
In the realm of astronomical calculations, errors might not affect anyone significantly, but if you’re performing naval or military computations, such errors could be critical. Hence, the errors in log books were a major issue.
00:02:11.360
Charles Babbage worked on an engineering solution to this problem. Though he never built the device he conceptualized, we do have this beautiful fragment—a segment of the machine he was trying to design. This was a mechanical device made out of steel and brass.
00:02:30.769
You would input some initial numbers into it, and by turning a crank on the machine, the full-sized device would mechanically perform all calculations. Unlike a slide rule, it would do exact calculations; if a wheel was off by just half a turn, the entire machine would stop.
00:02:42.650
However, calculating numbers was not enough, because these numbers needed to be copied by printers and arranged for printing.
00:02:48.650
The full version of the machine was designed to include an actual printer that would mechanically lay out all the numbers, and in future versions, it could adjust kerning, spacing, and layout of the table.
00:03:06.049
Babbage never completed this device, as it was incredibly difficult to design in the 1800s, and Babbage himself was notoriously difficult to work with, often disrespecting those who collaborated with him. In his search for solutions, Babbage conceived the idea of the analytical engine.
00:03:36.410
He realized that instead of building a machine solely for calculating log tables—a task that, while useful, had a narrow scope—there should be a general-purpose machine to handle various calculations.
00:03:48.290
This analytical engine was the first real general-purpose computer proposed. It included serial buses, registers for storing data, op codes, and even had microcode to optimize certain operations. However, it was overly complex to implement.
00:04:12.859
Babbage didn't fully grasp several aspects of computer science; for instance, the largest registers that he envisioned could store 100-digit numbers—not binary digits, but decimal digits. No one needed that level of precision in programs. He thought it might be interesting to have more digits available.
00:04:29.870
Where Ada Lovelace comes in is she helped Babbage work on this project and was writing some papers for him. She realized that the analytical engine might not only compute numbers but could also represent other objects and their relations expressed by the abstract science of operations—computer programs.
00:04:53.890
For instance, she wondered if the fundamental relations of pitch sounds in harmony and musical composition could be expressed through this machine, which might enable it to compose elaborate and scientific pieces of music of any complexity.
00:05:39.730
What Ada Lovelace was observing was that a general-purpose machine could operate on numbers that could represent anything you might programmatically deal with—music, text, poetry, and more. She predicted the information revolution before computers and even the electric light were invented.
00:06:08.650
At the time, however, no one thought much of it. After all, this machine was never built, and the idea of computing music or images seemed absurd. Yet, as we know today, it is incredibly useful.
00:06:15.160
Sometimes, just toying around with computers can change the world. Ada Lovelace wasn’t the only one to play with computers, which led to world-altering concepts.
00:06:31.950
The Linux kernel, for instance, was created by Linus Torvalds as a hobby project. He didn't anticipate it would become immensely popular. In his original post, he even mentioned that it could only support one kind of hard drive—because that was all he had access to.
00:06:49.300
Now, as we know, the Linux kernel is a little more popular and relied on by many people. But it started out as just playing around with code.
00:07:02.410
Ruby was created when Matsumoto—also known as Mats—was toying with code, even though the world didn't need another scripting language or another object-oriented language. But Mats wanted to have some fun, and obviously, we're all here today because of that.
00:07:30.186
This talk isn't just about that.
00:07:35.559
It's about having fun in a different way. In the 1970s, a man named Steve Dompier was part of MIT's Homebrew Computer Club—a group dedicated to just playing around with computers.
00:07:56.040
At that time, computers were quite limited. He had just gotten an Altair 8800—a kit you could build yourself. As you can see, it had a bunch of switches and lights, and that was it.
00:08:14.470
If you wanted to program this machine, you had to use these switches to turn on signals for each line of the address bus and use another switch to individually pipe that data into the machine, line by line. This was time-consuming; it wasn't just writing assembly code—it was writing machine code in binary using dip switches.
00:08:41.100
It wasn't the most efficient way to program, but everything has to start somewhere.
00:08:53.430
One day, while playing with this machine, he had a radio turned on next to him, and he noticed that running certain programs produced a few beeps and bloops from the radio.
00:09:07.430
If you've ever had a Bluetooth speaker with an iPhone, you might have noticed, while your iPhone is on, it generates some noise. This phenomenon is due to radio interference. The FCC regulates electronic devices to ensure they don't emit excessive electromagnetic radiation, preventing interference with other devices, such as pacemakers.
00:09:29.910
Back in the 1970s, this wasn't as significant a concern; computers weren't ubiquitous, clock speeds were slower, and these devices weren't well-shielded. So, Steve was picking up the sounds from the computer computations.
00:09:49.110
He found it interesting and decided to experiment with it. He discovered that accessing specific memory addresses produced specific tones. He even pulled out his guitar to check the notes.
00:10:04.000
He would try different addresses and operations, came up with different tones, and eventually wrote a program that played music through the radio interference coming from his computer.
00:10:24.240
By today’s standards, this was a whimsical exercise with no practical application, but he and his friends had a lot of fun experimenting with it.
00:10:36.890
Of course, nowadays, we connect speakers to computers with audio ports, which is a better way to produce music.
00:10:46.890
Today, I want to delve into this idea of programming for the fun of it.
00:10:51.179
This talk is not about striving to create something useful or contributing to an open-source project. Instead, it's about the joy of writing code simply because we enjoy doing it.
00:11:07.640
So, while we often discuss writing good code, efficient code that’s easy to read, and the various aspects of bad code, I want to focus on fun code today. Fun code may be slow, inefficient, or hard to read—yet it is undeniably enjoyable to explore, especially if you love to tinker and solve problems.
00:11:45.319
A word of warning, though.
00:11:49.279
This talk will include really ugly-looking code—extremely ugly code. If you are sensitive to poorly written code or have had bad experiences with it recently, you may want to leave.
00:12:01.580
I hope none of you have encountered code like this, as this is my reaction if anyone ever does something like this in production. But let’s take a moment to relax and understand how all this terrible code works.
00:12:19.589
To begin, I want to discuss esoteric programming languages. These are languages that aren't suited for practical purposes yet can compute anything any other language can, though they are often difficult to write in or just meant for interesting ways to form programs.
00:12:44.350
One such language is called Brainfuck. In jest, I'll refer to it as 'brain fun' since children sometimes attend these talks, but those familiar with Ruby will understand what I mean. Brainfuck operates with just eight commands—each a single character—resulting in very concise code.
00:13:06.770
Brainfuck assumes your environment is an infinitely long tape of integers with a pointer pointing to one of those integers. The commands are designed to manipulate this tape, allowing computation through a unique syntax.
00:13:36.790
However, these operations alone do not yield a Turing-complete language—you need additional commands for loops. Despite its simplicity, the language can still express complex ideas using its minimal commands.
00:14:05.580
Another esoteric programming language is JSFUN, created as a parody of JavaScript. A group of programmers on a forum wondered how few characters they needed to write any JavaScript program using a limited subset of characters. This exploration aimed to evaluate strings as code.
00:14:25.720
In essence, you can represent any JavaScript program in a vastly reduced format while still utilizing the necessary components within JavaScript to evaluate and execute code.
00:14:51.180
We can parse down the characters used, removing any unnecessary numbers. We can rely on the basic operators and structures provided in JavaScript to build complex programs using these limited characters.
00:15:11.210
These esoteric programming languages are not new. In 1972, two Princeton students developed their own programming language to mock the languages of their time, calling it Intercal, which humorously stands for Compiler Language With No Pronounceable Acronym.
00:15:39.020
This language included several new operators and had some features that were left undocumented, making it quite remarkable—especially the requirement to use a 'please' keyword multiple times for politeness, or you would get errors.
00:15:55.960
But you don't need to create an esoteric programming language to display this kind of absurdity. I came up with an idea inspired by Sass, a CSS preprocessor.
00:16:05.540
For those unfamiliar, Sass allows you to use variables and functions in CSS, which helps reduce code redundancy. Its capabilities include creating Turing-complete languages through constructs such as methods and functions.
00:16:23.480
Here's an implementation of Fibonacci using Sass. It's amusing to consider adding a Fibonacci function to your CSS, which, while not common, reflects the potential to challenge ourselves with unusual problems.
00:16:58.620
Now, there’s Lisp—a family of programming languages that symbolizes code as nested lists. These lists are encapsulated using parentheses, and the first item in each is interpreted as a function, with the remaining items as the function's arguments.
00:17:20.740
I created Sassy Lisp—a combination of Sass and Lisp rules. It's a playful interpretation of these two languages and allows nested functions, closures, and variable scoping.
00:17:38.830
The implementation includes numerous helper functions while maintaining the structure necessary for classic Lisp operations, all crafted inside Sass.
00:18:06.300
However, this is not practical for production code—as your colleagues might think you're a little crazy—and is quite inefficient. Yet, it serves as a playful exploration that emphasizes programming's fun side.
00:18:20.360
Now, let us shift to code golf—a game where you attempt to write a given programming prompt in as few characters as possible. For instance, fizzbuzz is a classic exercise.
00:18:38.200
You print numbers from 0 to 100 but replace those divisible by 3 with 'fizz,' numbers divisible by 5 with 'buzz,' and those divisible by both with 'fizzbuzz.' Here’s a typical implementation in Ruby.
00:19:12.150
As with code golf, the goal in this case is to refine code reuse, finding efficiencies and reducing repeated patterns while attempting to condense the code into as few characters as possible.
00:19:36.560
In the case of fizzbuzz, we can utilize logic to dry up our implementation significantly without losing clarity. This process continues until we reach the desired character limit.
00:19:49.820
Obfuscation is another avenue of fun. The International Obfuscated C Code Contest elevates the absurdity of writing unreadable code to an art form.
00:20:08.480
You’d be surprised at how intricate and confusing these programs can be! He Yusuke Endo is a Ruby core maintainer known for his obfuscated code as well.
00:20:20.450
Just for fun, I'll demonstrate one of Endo’s obfuscated C codes—a print statement that outputs 'Hello, World.' But be wary! It may look simple, but the behind-the-scenes mechanics are quite complex.
00:20:37.860
As you can imagine, the final output will differ from the initial code itself. This highlights the concept of code that behaves differently from how it is presented.
00:20:51.360
Now let's transition to a different esoteric exercise known as a Quine. The rules here are quite simple: your program, when executed, must print out its own source code. This adds a layer of complexity to coding.
00:21:04.340
The challenge arises from the requirement that the program cannot read from its own file, which kind of messes with our ability to craft a solution. But with creativity, we can build a working Quine!
00:21:20.180
In Ruby, we can use various interpolation techniques to execute this challenge, allowing the output of the original program's source code, even with variations.
00:21:34.090
Moreover, with some clever coding, we can even extend our Quine to allow for slight modifications and manipulations without losing its self-identity.
00:21:40.820
As a side project, I proposed creating a chess program designed as a Quine, where the chessboard itself is represented in ASCII art, and the code to create it is also embedded.
00:21:56.970
This concept allows adding playful elements while maintaining the essence of a Quine, enriching the overall experience and creativity in programming.
00:22:10.510
I was motivated to explore this realm after reflecting on the flexibility of Ruby's syntax, where we can distribute codes widely without compromising architectural integrity.
00:22:24.990
The thrilling aspect of programming is that creativity can lead to unexpected results, as demonstrated by the chess program I crafted.
00:22:38.890
Finally, although the implementation of this chess program involved reams of code, the final result is still a bit humorous as it outputs an entirely valid chess board.
00:22:52.890
And yes, we remained open to the possibility of receiving user inputs during the gameplay!
00:23:07.890
My exploration of lambda chess concluded successful, following a lengthy execution process to execute complex calculations.
00:23:21.890
All this quirkiness and experimentation in programming leads one to reflect: why do we commit our time to absurdities? For some, it's a joyful distraction from convention.
00:23:36.980
Ultimately, these exercises present a platform not only for creativity but also a venue for collaboration among programmers who share an appreciation for playful exploration.
00:23:49.670
Thank you all for entertaining this notion. Please consider exploring these ideas further—whether that be through implementing your own interpretations or simply having fun with the process.
00:24:05.820
I encourage you to reach out if you’re curious to see more code of this type or discuss further insights. Let's educate one another in our programming journey!
00:24:13.460
I will be putting the code and resources from today's talk on GitHub, and I invite you to engage with it. If you’re interested, feel free to follow me on Twitter where I will be sharing more and fostering connections.
00:24:31.420
Lastly, if you prefer not hearing from me again, that’s perfectly fine too! Thank you for your time today.
