Ruby
Tales of the Ruby Grimoire
Summarized using AI
Tales of the Ruby Grimoire
by Brandon WeaverIn the talk "Tales of the Ruby Grimoire" presented by Brandon Weaver at RubyConf 2019, the speaker uses a whimsical story featuring a curious lemur named Red to explore advanced programming concepts in Ruby. The narrative unfolds as Red discovers the mythical Ruby Grimoire, a book containing powerful and intricate knowledge about Ruby that is not typically accessible to novice programmers.
Key Points Discussed:
- Introduction of the Main Character: Red, a young lemur, begins his journey of discovery under the guidance of his master, Scarlet.
- Exploration of Knowledge: Intrigued by legends surrounding a secret door leading to forbidden knowledge, Red opens the door to find the Grimoire and the Dark Lord Crimson, who offers lessons that delve into advanced programming paradigms and tricks in Ruby.
- Lessons from Scala: The session highlights placeholder arguments and closures as features drawn from Scala's programming model, enriching Ruby's flexibility and power. Red learns about closures and how they can be used in Ruby through a playful and educational dialogue with Crimson.
- JavaScript Insights: The story transitions to the realm of JavaScript, where Red learns about destructuring, a feature that simplifies variable extraction from objects, and the concept of punning, which offers new syntax possibilities.
- Haskell Lenses: The final segment presents concepts from Haskell such as lenses, which enable deep manipulation of data structures without mutation. Brandon emphasizes how lenses can be leveraged in Ruby, akin to existing methods like dig.
- Metaprogramming Dangers: Throughout the talk, the speaker raises awareness of the potential pitfalls in metaprogramming, addressing common concerns around its complexity and misuse, while acknowledging its power.
- Concluding Thoughts: The narrative leverages humor and imaginative storytelling to engage the audience while reinforcing the idea that with great power comes responsibility. Weaver concludes the talk encouraging experimentation and exploration of the Ruby language, as the knowledge learned today might become standard practice tomorrow, underscoring the importance of understanding the implications and costs associated with advanced programming techniques.
00:00:12.080
So, I brought a special little story this time. I love stories! But before we get into that, let's start a little bit with who exactly this madman is up in front of you speaking.
00:00:18.570
My name is Brandon Weaver, and you see, I started as an artist. I like to illustrate things—like that avatar up there in this entire talk.
00:00:27.270
It started when someone said, "You know, web design is a little bit more profitable; it'll get you a bit more reception." So I tried it. I enjoyed it; it was a good time. Maybe not the CSS part.
00:00:35.969
But then they said, "How about some JavaScript? That'll make you more effective!" Okay, so I added some JavaScript.
00:00:41.999
Then someone suggested, "How about a back end?" And it went very far downhill from there.
00:00:54.690
So far downhill, in fact, that I ended up becoming a frameworks engineer over at Square, where I'm currently working as a Ruby architect. But that's not why you're here; you're here for a story. I have a story today for everyone, so shall we get started?
00:01:12.810
Our story begins with young Red and his master Scarlet. You see, Red was studying diligently when his master came in and informed him that she was going to be leaving. "Now, Red, I’m going to be leaving. The Council 3.0 has called and I'll be gone for a bit, so be sure to study your hardest for the test because I'm going to have it as soon as I get back."
00:01:31.710
With that, Scarlet left, and Red made sure she had actually gone. He was a mischievous little lemur, and he had some very, very bad ideas. You see, my esteemed audience, in the castle of Master Scarlet lies secrets.
00:01:43.440
Forbidden corridors, libraries filled with knowledge unseen and untold for generations. Red was determined to find a few of those secrets.
00:01:56.970
So down he went, down into the depths of the castle where the candlelight faded into blackness and where all light seemed to vanish. There, at the very end, he found it—a massive door made of steel, locked tightly. The door he had often dreamt of opening.
00:02:10.560
A secret only whispered in the halls of the castle. Great and terrible knowledge lay beyond that door, perhaps even the secret to mastery.
00:02:24.069
With that power, Red could become a master, and studying would become a thing of the past. Tests would be a thing of the past. After all, masters don't need to study, do they? But the door did not open at his touch. This must have been a sign—divine providence.
00:02:49.569
So, Red entered, and in that hall, he found a vast library, the likes of which were unmatched in the land of lemurs, surpassing even the grandest city libraries. At the center, he saw it—the Book of Legends, a grimoire of infinite power and possibilities, a dark manuscript whispered in the histories of lemurs, rumored to contain wisdom beyond the capacity of a normal lemur.
00:03:13.750
But Red was no ordinary lemur, so this was absolutely fine. With the book in hand, knowledge would soon be his. He took a moment to savor his triumph and opened the book. Upon its pages, he found words he didn't quite understand, but then things started getting stranger.
00:03:40.180
The words seemed to blend together on the page, and everything faded. Something changed in the air; the room grew suffocating. The words on the page faded, disappearing into swirling fog, and an angry, red, hot fog crept in.
00:04:07.030
Then a new phrase appeared: "Welcome to the Ruby Grimoire!" And thank you for freeing me, young one." "Free? What does it mean, free?" Then another phrase appeared: "Behold the Dark Lord Crimson!" Red looked up, and standing there was a specter—a malignant being swirling in red fog. The Dark Lord Crimson was free!
00:04:43.550
The specter let out a scream—well, for a moment, at least. You see, I like fun stories, even if they are a bit horrific. So let's get back to the fun part. "Keep it down, keep it down! No need to be rude! I can't see a thing with that lamp. It's been a while since I had visitors down here.
00:05:09.440
Step back and stupefied horror a scrim—how long has it been since there was a lemur that actually bothered to open it? Welcome! Welcome, welcome! It's been so long, dear chronologist! At last, how exciting!
00:05:16.010
What lesson should we learn first? What stories should we attempt? So many possibilities! Indeed, tales and lands beyond, delving into deep, shelled languages, old and new.
00:05:24.140
Power beyond your wildest imagination is all written upon these pages. But I must ask, young one, are you willing to pay that cost?
00:05:30.200
Poor, poor Red. He was transfixed and started nodding vigorously. You see, there was knowledge here, beyond him—and knowledge, as he would learn, no matter the cost.
00:05:55.060
The true nature of the grimoire is that it is a journal of my journeys into lands beyond Ruby, where I met several wise ones, beyond anything I had ever seen before.
00:06:01.689
And if all the tales be good told, we shall start with three, and some of my personal favorites: the tales of the lemurs of Scala, of JavaScript, and of Haskell. Each fairy tale holds knowledge beyond what I'd imagined, so we will take a glance at each today.
00:06:20.090
From the lemurs of Scala, we shall first learn. Lemurs of Scala wear conical hats, spires to the heavens, cloaked in robes that change colors and styles.
00:06:37.150
Their programming is unique. Where Ruby has flexibility, Scala has even more. The lessons they bring us give insight into those flexibilities.
00:06:43.450
They teach us parts of closures, spell known as placeholder arguments, where an underscore can act as shorthand for arguments to a function.
00:06:57.190
Now, you might know this from Ruby, but what if we could do the same in Ruby? Before we can perform such tricks, we need to know a few little tricks.
00:07:05.000
Consider with me a function—a lambda—which takes an argument, a. It returns a function which takes an argument, b.
00:07:12.650
Why would someone do something like this? The outer function takes in a value, a. The nifty part about these functions is that when that function is returned taking an argument b, it remembers the value of a.
00:07:27.250
This is what we call a closure; it remembers the context where it was created. Now, why is this useful? Whenever we call add with one, it remembers that we've added one, and we can call add one right afterwards with the value of two to get back three, remembering the one from above.
00:08:05.180
So, why again is this useful? Let's say that we put that in a map expression using an ampersand, which is two proc. We can add one to every element of a list by this, or we could just inline this code directly.
00:08:23.100
But if we wanted to, we could even make it more succinct with square brackets being equivalent to call. But that's short and confusing; we'll prefer a longhand from now on.
00:08:35.899
How does a plus operator work in Ruby? Well, as it turns out, there's a secret there—it's no more than a method call. And we can define methods, and it looks something like this if you squint hard enough and pretend C code is Ruby, leaving out a few more details.
00:09:10.750
Red stared with a doubtful expression. "What is the lesson? Not an exact science?" Anyway, moving on.
00:09:20.270
Now, with these two tricks, we have enough to make our placeholders. We just need a little bit more Ruby magic to dance the fine dance. Remember our entity class? What if we made our own class that had a plus defined on it? We can call it P, our placeholder arguments.
00:09:46.910
Now, here's another fun trick: there's nothing that says you can't define plus on the singleton of a class. You might wonder why you'd want to do this because it allows you to do something that looks like this, and that works—that's very valid Ruby!
00:10:11.710
We can call plus directly on the class. If we do that, we can use a lesson on closures to perhaps return a function instead because there’s also no rule on what that needs to return.
00:10:38.990
You know, people who are studying get bad ideas. Yes, yes, great! Magnificent! I love bad ideas! This brings us to a very interesting feature of Ruby: I discovered that two proc applies after infix operators.
00:11:00.520
So we can do something like this, which applies to proc on the function that we just returned, allowing us to get something which looks very much like Scala, doesn't it?
00:11:26.400
If we're particularly naughty lemurs, we can always redefine underscore. Now, this can undoubtedly do bad things, but we wanted to prove a point, so we're going to do it anyway.
00:11:43.849
Now imagine we rewrite the rest of the possible operators—maybe we use method missing to allow it to use any other function, or perhaps respond to find out if it can even do that.
00:12:01.290
If we really wanted to, we could even make this into a stack builder and do something like underscore plus one double equals two, and we could add these operations and have them reduced onto a stack.
00:12:21.990
Imagine the possibilities! But that's a tale for another day or a later chapter in the grimoire.
00:12:27.360
As they walked, Red stopped and had to ask, "Aren't these dark magics? It feels like we're just doing bad things to language. Why would we want to do that?" Crimson replied, "Now come now, you're not one of them, are you? Some call these dark magics, while I would simply say we're exploring the possibilities of language.
00:12:55.740
Imagine the use of such things and how much more powerful Ruby might be with it. They might even merge it into Ruby core, word in these days."
00:13:10.290
Red nodded, suitably convinced, and they moved on to the glimmers of JavaScript.
00:13:30.380
In my journeys, and lands not far from this one, I found the lemurs of JavaScript fascinating masters, with lessons more fascinating indeed. The lemurs of JavaScript were fashionable, with all forms of accessories, colors, designs, and decorations.
00:13:50.360
They could even change the very language which they communicated with by using different jewelry, accessories, and a wonderful system called Babel. They brought with them an art of destruction beyond that which we know in Ruby.
00:14:09.440
It allows them to pull values out of objects by name. So, say we had a move north function, which can extract the x and the y values from the object passed into it. This is known as the art of destructuring.
00:14:20.440
But what exactly is that doing? You see, inside this function, the value of x is 1 and the value of y is 2, because it extracts those values from the object passed in. We can use those values to add 1 to y, and make it move north, as it were.
00:14:45.850
But there's another magic in JavaScript, one I have not found a way to emulate no matter how much I might try, known as punning. And of course, we love punning in Ruby! Yes, yes, several famous Rubists love punning, but this type of punning is different.
00:15:08.110
We have to ask what cost would it be to add this to Ruby? This allows us to make a new object with x unchanged and y with one added. But I need to figure out how to make this thing work.
00:15:28.420
Anyways, we can do destructuring in Ruby, but first we must learn the art of extracting arguments from a proc. Yes, you can do just that!
00:15:49.400
Say we had a function f, and the body doesn't matter. We just have arguments x and y, empty for now. Only arguments. Now, there exists a method called parameters on a proc; it returns back an array of pairs, the first being the type and the second being the name.
00:16:11.200
If we were to map the last item of those, we have the names of the function arguments. There are fun things we can do with this.
00:16:36.500
Now we need to make our own idea of destructuring. If we know the names of the arguments, we can use them. Let's say that we have a point—a simple struct. Now, for those not familiar with a struct, it’s vaguely like this, but it's a lot of code to write, and I don't like that.
00:17:01.890
So, for simplicity's sake, we'll start with the point at an origin of x of 0 and y of 0. Then we're going to make our own destruction function that takes in an object and a block function.
00:17:22.470
We can assume for now that the object is our origin point and our function will have arguments x and y.
00:17:43.620
So the first step is to get the names of arguments that we passed in. In our case of this x and this y, it means these arguments are effectively x and y.
00:18:05.130
Now that we have those names, we can do something very bad in Ruby. We can map over those names and use the object to send to extract those values from the function arguments. So the cases of our origin point of zero-zero and our function that takes the arguments x and y.
00:18:28.990
This means that the arguments become x and y. Our values are effectively going to be object.x and object.y, or in the case of origin, 0 and 0. Both are extracted using those argument names.
00:18:48.450
Now, what do we do with those values? You see, there's no rule in Ruby for when you need to call a function that is passed to a method. So we can call it at the end with those values we extracted, meaning we're effectively doing this with our origin points.
00:19:04.350
So, let’s step back to our point in origin. We can use a destruction method on this point, passing it a block function which takes arguments x and y. Because it's (0,0), this means that x inside that function is 0 and y inside that function is 0.
00:19:24.150
Inside this function, we can create a new point using that x and that y to add one to the value of y, which moves it north. Now, look how much fun that is!
00:19:45.940
Now, a clever lemur might be able to redefine methods with some of those same tricks to add a destructured decorator that can tell the difference between the object passed and its expected arguments.
00:20:03.370
But now the chapter I'm afraid is beyond us for the moment.
00:20:16.900
By this point, Red was very worried and had to say something about this. But surely, that's evil! Isn't metaprogramming the root of all evil?
00:20:34.160
Dreaded metaprogramming has its uses and is a fast, albeit seldom well-understood territory. Of course, there are dangers, but must one discard such power simply because it's dangerous?
00:20:52.420
No, it depends on the context and the wisdom of the wielder. Fast is too strong a word for what is merely misunderstood and abused by those not ready for it.
00:21:10.080
You're ready for it, aren't you, young Red? Yes, I believe so. Red nodded, convincing himself he was obviously ready for such an art.
00:21:28.720
Now, I have one last lesson for you from the wise sages of the realms of Haskell. Descending from their ivory towers, they bring knowledge far beyond even me.
00:21:45.740
But this knowledge is fascinating—the implications that may shake the very foundations of how we think about programming. They bring with them an art of lenses—an ability to focus on something and see or change its value.
00:22:03.360
I cannot say I fully comprehend them, but I find them fascinating nonetheless. And of course, I've tried to write them in Ruby.
00:22:30.430
Now, lenses allow the lemurs of Haskell to look deeply into a nested data structure, performing magic on that data without mutating them.
00:22:56.680
The examples they shared with me from the book of Hackage were very confusing at first, so I took some liberties in trying to make things more understandable.
00:23:20.540
I cannot say I understand how to make lenses work beyond that they fill in a lot of the code that makes lists. But I may be able to explain the rest.
00:23:39.930
We have a data atom with an atom containing a point, and we make lenses for both of those. At least, I assume that's what's happening.
00:23:57.709
Can we create a function that moves an atom to the north and returns a new atom, presumably moved north? Now, the point has x and y coordinates.
00:24:14.677
But what is that function doing down there? Let's simplify again because this is still confusing.
00:24:29.410
Now we have a move north function which uses the function over lenses and allows us to execute it over something which looks or behaves like a lens.
00:24:49.400
And now we're specifying that we want to do something over the y of a point and want to add one to that to move it.
00:25:03.500
Lenses allow us to specify a path to something and run a function over them to retrieve or change values without mutating the underlying object.
00:25:24.590
All this seems abstract, but you'd be surprised to know that you already know something in Ruby which does something similar.
00:25:40.930
The method dig references something like half the idea of a lens. It allows us to find a value that’s deeply nested in a hash, an array, or even a mix of both.
00:25:59.090
Oh yes, that's very fun! I’ve had so much fun with that! The key thing to pay attention to here though is the path.
00:26:14.050
With the path, we know how to get a value. Would it be that far of a leap of faith to say we could also set that value down there?
00:26:35.120
The path is the basis of a lens and lets you know what path you need to focus on. Lenses are much like glasses—scopes, or something like that.
00:26:50.670
If we wanted to apply something like this to Ruby, it may be difficult, but I believe we can get close. For this neat exercise, we can assume we have a nested set of hashes.
00:27:09.710
We'll use this to demonstrate. We start with the idea of capturing paths in class. We can call scope.c; it even sounds like a lens. We're making progress!
00:27:26.300
Now, we want to capture the path of what we're looking at within the scope and then define our own get function.
00:27:43.300
You might ask why we would wrap this in a function. Well, using the art of closures from before allows us to go over a collection and do something that looks a lot like this.
00:27:56.190
We can have a scope focus on a, b, and c, and we can map using the get to extract the values of one through five from those hashes we defined before.
00:28:13.430
But to set a value is a little bit more difficult. I had to do a few unique tricks to make this work.
00:28:26.600
The first thing we need to do is clone the object, to ensure we're not mutating something we don't want. This is a quick way to make a deep clone of a hash.
00:28:40.030
I can't say I understand how it works, but it does—and that's good enough for now.
00:28:57.790
Then we start by getting the path we need to get to our value. You'll notice that I left one of those paths off as a talking key—the last key that we need to focus on.
00:29:10.120
Let's get into that with a generational example: we use a, b, and c, meaning the lead-in to get to that value would be a and b. The target key would be c.
00:29:30.620
Now amusingly, to bury a value in Ruby, you would need to dig down to it first. This gives us a target location right above where we need to put the value.
00:29:44.260
This means that we have an array of a and b and a collection of a, b, c, with values "1" that means we're going to dig into that collection to get back the hash c:1.
00:30:06.600
Now, the next thing we need to do is decide what value it is that we're going to set there. If we happen to be given a block function, we're going to yield or call that function with the value at the target location.
00:30:25.670
In this case, it would be c:1, and the target key of c means we've added one to c. The new value will be 2.
00:30:43.350
Or let’s say that we didn't get a block; we could set it to a static value, which isn't quite as fun, but it's still useful.
00:31:05.370
Now we're relying on a value being set, so leading into our shenanigans—why did we want to do the entire lead-in thing? Well, if we want to overwrite that value at that location, we have to be just above it.
00:31:25.890
Because otherwise, we cannot overwrite the value of c in Ruby. We could use merge, but that's slow and I don't like slow code.
00:31:37.900
The Haskell lemurs were very put off by my interpretation of mutation-free code, but it works, and it technically doesn't mutate. We’ll call that good enough for now.
00:31:55.060
After all that, we started by getting the values at the path we need to gather the data at.
00:32:03.490
It could be used to deeply set a value according to paths. Imagine the possibilities—if we were to use this on JSON or large hashes.
00:32:19.700
We could even use triple equals to decide if we’re dealing with schemas or not, or if we allowed this to traverse any indiscriminate depth across any hash looking for a matching path.
00:32:34.630
I can't say much more on Haskell, considering I believe they don’t like me for some reason.
00:32:52.400
Going beyond magic, Red was fascinated by all the implications of Crimson’s tales—the possibilities! What else might lie in the grimoire?
00:33:03.620
So Red had to ask, "How many more tales are there in this grimoire of yours? How many more stories? What new tricks do you have in there? How many more from tribes and societies far and wide?"
00:33:21.360
There are tribes beyond all things—the conventionally Java lemurs, the mystical disbelievers, all the way to the orderly and well-dressed Python lemurs.
00:33:31.980
But there's one, or many, many tales—and there’s an entire universe out there, powers beyond imagination!
00:33:51.660
And so many more chances within the grimoire. Let it remind the potential of the fold lemurs out there, who taught us all their tricks.
00:34:10.000
We would be absolutely unstoppable! So the books left and right turned, and what he found behind him scared him far more than Crimson ever had.
00:34:33.660
Because Master Scarlet was back—and she was not amused. So Red turned quickly, trying to get help from his new friend Crimson, just to find a sign saying, "Good luck!" and a puff of dust from where Crimson had been standing moments before.
00:34:55.360
It seemed Crimson was also afraid of Master Scarlet for some reason. "We have much to talk about now, don't we, Red?" Red broke into a nervous sweat.
00:35:13.020
"Proper magic! This is a dangerous book!" Red was full of all forms of knowledge that he might not be ready for or know how to use appropriately.
00:35:35.150
He made a particularly intense study of the possible fears that awaited him. He must remember, for all languages out there, to always use Ruby.
00:35:54.800
For Ruby magic can indeed be confusing, unwieldy, and difficult to control. It's even harder to understand for those not ready.
00:36:09.690
But even given that, there are many lessons to be learned, wisdoms we may apply to the highest levels of Ruby.
00:36:23.210
And language is always evolving. We need people who are willing to experiment to drive its future.
00:36:36.180
Consider the lesson of the placeholder arguments: such a thing now exists in Ruby 2.7 with numbered arguments. And many more may well soon follow.
00:36:54.360
What is considered magic today may very well be canon law in Ruby tomorrow.
00:37:06.200
Now, there are many more tales in this grimoire and more lessons I’m sure Crimson could teach you.
00:37:29.200
But be cautious and wise in pursuing such knowledge; the cost is high for using such magics.
00:37:44.880
The great weaves of production you do not entirely understand yet, but the cost is higher to pretend they do not exist at all.
00:38:03.680
In the meantime, I do believe I have a test ready for you upstairs! I do hope you studied while I was gone because I'll be giving it as soon as I get up there! And with that, Red made a dead heat run towards the stairs.
00:38:23.150
Epilogue! So there, behind Master Scarlet, Red hurried up the stairs in a bit of a panic.
00:38:40.150
Once she was sure he left, she grinned and called out into the darkness, "So the Dark Lord Crimson, eh? Quite a title you've taken for yourself now, haven't you, dear brother? I thought you'd enjoy that one!"
00:39:01.520
Oh, just having a bit of fun, that's all! It's so rare to have visitors. You keep on knocking them out; I had to prepare a special surprise for such a momentous occasion.
00:39:19.030
Can you believe it? Someone actually wanted to learn from me today!"
00:39:34.600
"Surprise! You nearly scared the poor child out of his wits!" "That's not so surprising! That's horrific!"
00:39:52.910
"Yes, well, perhaps a bit too surprising. It's been a while! I really did enjoy getting to speak to Red. I suppose he has grown quite a bit since you've taken him in, hasn't he?"
00:40:06.240
He has, and I believe he’s finally ready for some of the lessons you and the other lemurs down here can teach him.
00:40:24.420
Interesting you should say that! It was quite strange to see him down here, especially with that giant door you had put up in front of my library to make sure he didn’t get into something beyond him.
00:40:40.890
It’s almost as if someone left the door unlocked on purpose! Now, whoever could do a thing like that?
00:40:57.010
Who indeed! And so it was in the tales of the Ruby Grimoire that Red the lemur would come to know of its magics.
00:41:07.300
That his master Scarlet would give him permission to study under Master Crimson, and he would move one step closer to his own mastery. For you see, magic is integral to Ruby.
00:41:25.470
To explore, to express oneself in code beyond what’s possible in many languages. The beauty of programming and Ruby is to have the freedom to do just that.
00:41:45.160
And that very experimentation can, and sometimes does, become a core part of the language, and sometimes it drives discussion around what Ruby should be in the future.
00:42:02.150
What we should be doing in programming, how we should be programming.
00:42:17.660
But there was a cost mentioned here; the cost can indeed be very high.
00:42:35.650
It takes a lot of discretion and great wisdom to handle such magic in production.
00:42:51.160
And often, the simplest of code is best. There’s a special type of magic in very simple, readable, and understandable code.
00:43:07.330
But that's a lesson for another day. To wrap up: it's been fun! This talk involved custom illustrations, 62 illustrations, 85 hours of work, and about 156 slides.
00:43:23.000
And your steel wouldn't see for good measure! Now, the scary part of this talk... you thought all those magics were just me doing presentations?
00:43:41.090
Oh no! Those who know me know very well that’s not true; it’s real, oh it is very, definitely real!
00:43:58.090
And there are gems currently. I might get a chance to do exactly that!
00:44:07.040
Placeholder arguments, the first Scala part we saw! SF happens to be the stack builder!
00:44:18.379
There are two little experimental things I would not touch—easier said than done, I might add! They break a lot of things!
00:44:34.869
Not surprisingly, destructuring was maxed into Qo, which was also an implementation of pattern matching that I’ve done.
00:44:48.610
And some of that ended up becoming pattern matching, and lenses are currently in something called XF.
00:45:01.640
And I'm still trying to convince Matz that we need a berry function—so we’re working on it! I’d still be quite fond of that function.
00:45:17.050
But we’ll endeavor nonetheless!
00:45:29.680
So, if you wish to find out more about the lemurs and our next adventures—because I fully intend to make more—follow me on any of these social networks.
00:45:43.640
I’ll be posting slides, examples, more. And honestly, we have to give credit where credit is due!
00:46:02.800
A talk like this doesn’t exist without a lot of help from the community—from those willing to entertain my mad scientist experiments.
00:46:18.440
What I can only call a very odd form of the hallway test—"Hey, you want to see something cool with Ruby?"
00:46:31.390
And those who did have time, I think them very much! Because those mad science experiments really built up a community of people who enjoyed hacking around and having fun!
00:46:49.000
You may also notice a few foxes—I hid them around earlier slides. This is because my first Ruby book happened to be written by a certain lucky stiff.
00:47:02.310
As you can see, it still influences the way I write and teach code today. Ruby needs more fun and whimsy.
00:47:16.650
So don’t be afraid to submit your own wild illustrated talks because I look very much forward to seeing them one day!
00:47:34.020
And, as with years past, we’re playing a little bit of a fun sticker game again!
00:47:48.110
You’ll find five Square engineers, myself included (yes, I have stickers!) up here, as well as several other presenters!
00:48:02.180
They’ll be off around the conference. I posted pictures of them tagged with #lemursofrubyconf.
00:48:15.870
So, if you can find them all, send me a picture, tag it, and we’ll have a special raffle with an indeterminate prize, which I’m still working on.
00:48:29.879
That’s how raffles work, right? But that’s about all I have for today.
00:48:39.670
So it’s been fun! Thank you for allowing me to tell you this magical little story.
Explore all talks recorded at RubyConf 2019
+84