Send Heterogenous Default with airSlate SignNow

Send heterogenous default

(jaunty music) - Hello. So Rich Kilmer there was also one of the co-founders of Ruby Central, along with David Allen Black and Dave Thomas who aren't here. I just wanted to include that for completeness. I wanted to show you this site real quick. This is lifeistooshortformeetings.com (members of the audience laugh) Just one second, I made that site just as a reminder. We're getting old. I haven't been here in like six years, I think. And by here I mean RubyConf, because RubyConf is just a location that floats around through space. And it's true I haven't ever keynoted. In fact, the only talk I ever gave at RubyConf was in 2005 and in San Diego. Was anybody there? Matz, Rich, Jeremy, yeah. Eric and it was... Takahashi. It was a continuations tutorial with Jim Wyrick who has since left us. Because I haven't been here for a while, it's the first time I'm coming here and Jim's not here. So I have this lazy way of doing talks. (members of the audience laugh) Matz even retweeted this for me, thank you. Coming back to the Ruby community after a while, I just wanted to see what did people think, even outside the Ruby community that we need to be aware of. I'm not gonna put the answers up because it's not really worth it. There were a lot of answers to this. It's useful, I'm not saying the answers weren't good, but what I saw was a lot of stuff that sort of verified that Ruby is getting old. It was stuff like some of the libraries are getting old and decrepit and don't work very well, or the documentation is out of sync with the code. Things are slow. It's not all about Rails. That was a pretty constant theme. And then there were a whole bunch of feature requests for the language that we've been hearing since 1999, I think. I mean a lot of them. It used to be a thing when we started with Ruby as English speakers on the Ruby-lang mailing list, pretty much every new person that joined would request the same set of features, to make it be more like Java. (members of the audience laugh) Now I think they all want it to be like TypeScript but there we are. I wrote this blog series back in 2006, after what I thought was a pretty full career already of being what I like to call a systems euthanizer. So I just go from euthanasia, for those who are speaking English as a second language means killing something for mercy because the thing needs to die, and so system after system I have been part of projects to painfully kill those systems. They're sick, they're slow, they're legacy systems, they're dying, they're unhealthy, and so we painfully put them out of their misery, and in the process of doing it we usually create new systems of course. You don't just kill it and leave a dead carcass of a system behind. I realized though, because I work too hard when I work. I put so much of myself into this work, as I'm killing these systems I realized I'm also crushing the last remnants of the hopes and dreams of the developers that created the systems that I've killed. So it's a pretty miserable job really, either both the job of a euthanizer and the job of someone who creates systems, because they tend to die so frequently. If you don't know this, this is sort of a non-sequitur but you'll see that it kind of matters. I came to the software world originally as a musician. This is me doing a recent jazz show in Little Rock. And it changed the way I thought about how software development should be done, and really how just how I assumed it would be done. And there was one major thing that stuck out. It is this word. I said it a minute ago. When I said legacy systems, how many of you thought, "Oh yes, legacy systems. "I love legacy systems." Thank you one person. We've created this negative feeling around this word, but I'm a musician. I still think of myself as a musician who just happens to be programming 'cause it pays better, and as a musician I came in with a different assumption of what legacy meant, so people would say legacy and I would think, "Okay, "something that someone leaves behind, "like an inheritance, a bequest, "a gift from a past generation." Legacy is a really nice thing when you think about it from that perspective, but in our world here, we think of it as a negative thing. It's a nasty old messy pile of junk that is left behind by someone else, whose name we usually curse in our everyday work, and that's kind of strange you know as a musician, like right now we're listening to the second movement of Beethoven's Seventh Symphony. This is a picture of Beethoven. Beethoven left behind such a legacy of his music than even we Americans can pronounce his name properly. Oh, Beethoven by the way, this piece, Seventh Symphony. Everyone knows the ninth, everyone knows the fifth. This is the best one. Here, listen to it. I'm a saxophone player. This is John Coltrane. How many of you have heard of John Coltrane? (audience member whoops) Most people have heard of John Coltrane. Every saxophone player obsessively tries to imitate John Coltrane, even today. Even like fifteen-year-old kids in New York City are playing, and you can hear Coltrane in their sound, and jazz is irrelevant at this point, and still they're doing it because he left behind this legacy. The same is true in the world of literature. One of my heroes, Kurt Vonnegut for example, left behind words that I have read even after he died that have shaped the way I think, and probably the way that I'm speaking to you now are heavily influenced by having read Kurt Vonnegut's work. Architecture, same thing. This is Gaudi. Walk through Barcelona and you see his legacy and his imprint on the city. Even the world of fashion. This is a piece by the Japanese group Comme des Garcons, which is my favorite fashion house. I'm not sure what your favorite is, but mine is Comme des Garcons. Not just because I want to impress Matz, I promise, but they are Japanese. But they create these pieces that not only will live, theoretically forever if they could be preserved, but changed the course of fashion. They have rippling effects. Same thing with art. This is Joan Miro. I like Joan Miro so much that I have basically matching tattoos on my arm for this painting. But Joan Miro left behind a massive body of work that we can all still enjoy, still be influenced by, and also pioneered the idea of visual poetry, so he actually created... Most people don't realize this, but he created a visual language of symbols, and his paintings at certain periods in his career were poems, so this is a poem. But we have a problem in the software world. Like I said, we use this word legacy negatively. We also have a really hard time shipping software, so you're not going to be able to read this but you'll get the gist of it. This is some data that is kind of questionable, by a group called the Standish Chaos Group, and I say it's kind of questionable meaning you might challenge the scientific merits of it. However, you will probably agree with the directionality of the data. So what they do is they go around and they inventory projects, they survey projects across the world, and they categorize them into successes and failures. And what we have here is the green row at the bottom most part is successful projects. The top, the red, are failed projects that just got completely scrapped. And then in the middle are challenge, and for challenge they call that significantly over time or over budget, which to me is also a failure. So look at how bad we are at making software. And this is just for creating software in the first place. Once we create it, I made up this statistic but I think it's kind of right, you know. I travel around the world and I kill these things, and it seems like they only live about five years, in business systems especially. So unfortunately software, when it is initially birthed, like most things that are created, is not immediately perfect, so if you create something, it may live for five years on average. Well it may take longer than that to even have it be good. So this is a bad situation. Software might only live five years, and it takes ten years for it to even get good. It takes that long to iterate it and actually meet the users' needs and perfect the UX and make it perform. So we have a problem. (Beethoven's Seventh Symphony) (members of audience laugh) So how do you create a legacy software? How do we turn this around? Well this has become my quest. Some of you, very few I would guess, have seen me do a talk like this before. This has different slides and different content, but I've been talking about this for the last seven years or so. And much of my work has been really influenced by the quest, figure out how to create software that doesn't have to be killed by people like me. So I initially went to what I thought was a perfect source of information, which is Mike Feathers. Mike Feathers wrote this book, and if you work in legacy code, which you all do, in the bad definition of it, you all work in code that already exists that needs to be modified, you should read this book. You'll have to hold your nose and read through the C++ and Java stuff, but it's worth it. So I asked Mike. I actually got on a video chat with him a few years ago, and I said, "How do we create legacy code?" And I was incredibly disappointed by his answer. He said, "Well let's see. "People need to be afraid of it. "It needs to be not dynamic, basically in stasis, "and very difficult to change." So I don't think he understood the question when I asked him this, but I'm pretty sure we could all do this. So I turned to Twitter as I like to do, and I did this again recently. I got very similar answers, but what are the characteristics that make software that we still use that's old still used? And I also got the same negative bias, because people think of old software as being bad. Fear of Awesome. Sunk cost fallacy. Old still-in-use managers. That was one of my favorites. But I got some good ones too. It works, it's stable, its valuable, it provides value to the users et cetera. So I was sort of encouraged by that, and I got a lot of things that got me thinking. But back to around the time that I wrote that big rewrite article series, which is sort of relevant timing-wise, there was this post by DHH on the Basecamp blog, or the signal versus noise blog on 37signals, and it was joking that enterprise is going to be the new legacy, and he really ran this propaganda campaign against the word enterprise. If any of you were doing Rails or watching back then, we went from enterprise being a good word that was often used for negative purposes to being something that you would chuckle about and make fun of. But the sad thing about this is David's way of panning the word enterprise and making us all hate it was comparing it to legacy and saying it's gonna be like legacy, which is obviously bad. So I found this comment to be really well-written. I'll read it to you. "Careful. Legacy isn't a bad word. "Legacy usually means tried, true and of enough value "that it lasted long enough to be old and outdated." True, right? "To mock legacy is to look at the successes of the past "and to declare that they aren't to be revered or respected. "Most of what runs our economies is legacy. "In the future I hope the software I'm creating now "was highly regarded enough "that it's still around and being referred to as legacy." I thought that was really inspiring as I typed those words into the comment box. (audience laugh and applaud) Unfortunately though, the software I was creating at that time was not highly regarded regarded enough. In fact it was one of those red boxes on the Standish Chaos report, and it was a year of my life, and of a colleague's life, that I swear we still have PTSD over, and I mean that literally. It's one of the only periods that I regret in my career, and it was dismal. I still look at it as like I died a year early in 2005, and I can't get it back. Miserable. Before that, on a more positive note, toward the beginning of my career, I worked for General Electric, which at GE Appliances, we had this system that was running on a Honeywell Bull mainframe. Who has a Honeywell Bull mainframe? Nobody has one any more. Amazing. The funny thing about this is I think it was 25 years old at the time. It had a custom TCP/IP stack. It had a custom RDBMS. We had created this RPC mechanism that we could use to talk to it. It was terrifying. The hardware was so old that you could not get replacement parts from the manufacturer because it wasn't being manufactured any more, so we had a team of people who knew how to manufacture hardware replacement parts that were not available. But we could not get rid of it, because what it did was both so valuable and performed so well that every attempt to replace it failed, because the users would reject it. There was also just too much information in this thing. But I left that unexpectedly I think, 'cause when I came in I thought, "Well this is gonna be terrible," but I left that job feeling a great deal of respect for what the Honeywell team have created at GE. There was even a team called the Bull exit team that had been in existence at that point longer than my software career had been, and when I left still existed, and then eventually was disbanded, and I've heard recently that this thing's still running. It's amazing and terrifying but amazing. So I had that influence. At that time I think the system was my age actually. I was 25 or so when I started it. Speaking of which, I'm 43 now and I don't deserve to be alive, because I take really bad care of this system. You know, refactoring and maintenance, and you may have seen me before, I've looked a lot better in the past and I've also looked worse. But how do we create systems that survive? Well the first step, like the Standish thing, the system has to be born. When Twitter first got launched, did you know that it was a database back web app written in Rails? Everyone knew it at the time in our community, but a lot of people don't realize that now, and if you tell them that you think, "Well that's ridiculous, "a database back web app for Twitter?" Because Twitter is a messaging system. It's this massive asynchronous parallel thing, it has all these crazy optimizations, because you've got like Justin Bieber with millions of fans, you've got Trump, you've got all these different things that require high volume. To do this in a database, they really type like Rails' new Twitter or whatever. It was probably script slash generate Rails Twitter. But it's not actually stupid, like we used to see these failures all the time and for a while we would make fun of it. There was the fail whale you would see. But you know if they hadn't created it like this, we wouldn't have Twitter today, because it never would have amounted to anything, because they'd still, they would have run out of money while trying to build the distributed message queuing system that Twitter needed to be, and thank God they didn't realize that's what it was going to need to be, they just made this micro blogging system in Rails. So they got it to be born. Had they not, we wouldn't care about the legacy of the software behind Twitter, and it's harder to get software born then we might believe. I'm going backward. Maybe you need to go backward, because when you get older you can't you can't feel the keys like you used to, so you press the wrong ones. So the conversation with Mike Feathers wasn't all doom and gloom. He gave me a link to this thing at the top. I put a tiny URL link. I don't know why but it's tiny URL code alive. An article he wrote in I think also 2006, where he says your software is alive, and he starts thinking in terms of this biological metaphor for software, which is really interesting for someone who's thinking heavily about how to create systems that can live a long time and live healthier lives, and what he says here in the article is it all comes down to one thing. Code survives by providing value and being difficult to replace. So the value has to be greater than the difficulty. This is an interesting point. The biological metaphor is really what got me interested when I talked to him about this. Your code is alive, and he sent me looking at this paper by Dick Gabriel, Richard P Gabriel. If you're not aware of Dick's work, he is I believe the first person to have written about software in terms of patterns, so taken the Christopher Alexander patterns ideas and applied them to software. He wrote the Common Lisp Object System, he did a bunch of really influential, important stuff, and not enough people know his work. He wrote this paper that you can find. I have the URL there, ULS Gabriel is what that says on the tiny URL link. Design Beyond Human Abilities, which is a pretty enticing title anyway, and basically what he's doing is he's looking at make-believe systems to see what would you do if some crazy parameters were present? So for example, trillions of lines of code, how would you maintain a system that looked like that? Which is not even likely to ever happen, unless it were generated. But what really got me interested is he ends up turning to this biological metaphor for systems, and he says biological systems are very much larger than anything coherent people have built, not just in software but in general. There are a bunch of interesting things that come out of this, but as we talk about complexity and systems, if you look at biology, the human body for example, you can get some really interesting examples of stuff that would work. So we're biological, and like I said, I have no business even being alive at 43, given how I've treated my body, but yet your software systems can't compete with me, Generally. That's pretty sad. We should both be embarrassed. How do we create systems that outlast us, or at least me? So this sent me down this path. First I started thinking, "Okay, how did this system "stay alive like me, where I'm not giving a lot of input "to make them be better?" There is a concept in biology called homeostasis, which I honestly don't understand that well because I'm so not a scientist it's insane, but homeostasis is a balancing process in biological systems, where different subsystems in the organism play different roles that might be at odds to each other to balance each other out, using an effect called negative feedback. So something happens that's not bad, something else happens that's not good in a certain amount, something else happens to counteract it. So you have like the brain which manages the whole thing, the liver metabolizes toxic substances, kidney deals with blood, water level et cetera, and it's a system that just balances each other, and all the right components are there to make it work. In the same way that we talk about really good agile development systems, our systems where all the components need to be present to balance each other out, or management systems with executives that play different functions that balance each other out. Simplified kind of dumbed down version, but that's what homeostasis is, and when you are a biological organism, if you're unable to maintain homeostasis then you reach a state called homeostatic imbalance, where these checks and balances aren't happening, and it can lead to death. Good news though in that case is you're already dying. We're all dying at an alarming rate. 50 trillion cells in your body, 3 million die per second. So just look around at the death that's happening around you. It is truly disgusting. It's like a zombie movie in here. But that's interesting, because here I am, I'm still me, and we all grow up hearing about this, and you know skin cells are falling off and regenerating and all that. We say we're not even the same organism we were, but somehow I'm still me, and you can recognize me barely when I come at RubyConf. Six years later you still know it's probably me, or it might be this guy named Chaz that goes to RailsConf that looks exactly like me. It's weird. Have you seen him? He's there. It's me. I'm just called Chaz. Turns out there... It's not really true that all of the cells in your body regenerate, but a lot of them do, and maybe that's a key. Glenn Vanderburgh, in response to one of my many tweets about this subject, said, "We've learned that software should start small and grow, challenging to replace an existing system that way." So what he's saying is we already know that dealing with small pieces and growing them from there is a good idea, but it's very hard to take a whole system and replace it by starting small and growing it, and that's why we run into problems. I also asked the question of a bunch of people many times, what are the oldest surviving systems that you use regularly? So I'm trying to get a sense of old systems that people are actually still using, probably not because they're forced to, and you can see most of these things are from the UNIX world. That's probably partially because that's the best software, and partially because the people who follow me on Twitter are UNIX people. Until now, because now I work at Microsoft, but that's a whole other story. You can categorize these things into two categories. They are either really small components, you know, the UNIX philosophy of tools that do one thing and do them well, or they are systems and they are systems of probably made up of a bunch of small components, so stuff like the X-Windows System, or Apache, or probably a better version of Apache would be something that can connect. You get the idea. So we've been using systems like this for a long time. Here's a row of them that are still driving down the street and are much older than software and even older than me. They are systems, each one is a system that is a vehicle, and it's made of all these little components that can be replaced. I'm not sure what I'm doing with my hand here. The cell... The slides are so irrelevant, they're only a distraction to me. So then I started asking myself, well what if we built software this way? What if we think in terms of the biological metaphor? The idea of regeneration, what is a cell in this context? What is a cell in the context of a software system, and what is a system? What are the lines between those, and how do you know what to build and when? Well the cell thing to me is pretty easy to get. A cell is just a small thing. It's a tiny component, and if you've ever had to work on something where you go to a piece of code and you have a task to complete, and you look at it and it's tiny. You think, "Oh good, this is gonna be easy." Right? If you go look at something and it's big, you think, "Shit, now I have to read it "and try to understand it, "and who knows, it might not go well." You could you could watch this talk from RailsConf 2014 by Sandy, and it's really right at the beginning, she says something, you pretty much could just not have done the rest of the talk. Not that it wasn't great, but this is so good, this is worth sitting through the whole conference. All of the problems we cause have the same simple solution. Make smaller classes, make smaller methods, and let them know as little about each other as possible. Turns out this is a summary of my talk too, but probably we could all just get up on the mic and say that and be done with almost every talk of the conference. When I was working on Wunderlist, which was the last job I had before we were acquired by Microsoft, I made a rule. I was CTO, and I would say you can do code in any language you want, any technology you want, and you don't have to ask me. It doesn't matter who you are. You could be an intern. As long as the code is this big or smaller, then I would just hold up my fingers like this, and then there are a few other rules, like it had to work with our deployment system, and you had to get someone else who thought it would be a good idea to use that technology. You know, some simple obvious ones, but you literally didn't even have to ask me about it, though I would prefer to know about it later. Because I realized that even if you wrote like a whole critical service in the Idris programming language, which probably only 70 or 80% of us are expert in in this room, if someone came along and was on call and there was a problem, and the code was this big and they couldn't figure it out or they couldn't get him to compile, they could probably just read it well enough to understand what it did and rewrite it and deploy it. That was the idea. And if they did that, I would like that, and actually as it happens, I wrote with one of my co-workers, who was one of the most junior people on the team. I wrote our one and only set of Haskell services, and some of the people on the team were angry that we wrote Haskell services, 'cause they thought that was academic elitist crazy stuff they couldn't understand, and then one of the angry people came and rewrote it in Go, and then another person rewrote it in Clojure, and another person rewrote it in JavaScript, and another person rewrote it in Ruby, and as CTO I did not think that was a waste of time, because it was this much code, and they just didn't want to deal with the Haskell. I was fine with that. Turned out the Haskell performed so much better than all the other things that we stayed with the Haskell. What we didn't do though is we didn't destroy the code regularly enough. So to have small things, that's good, but if you want to really use this biological metaphor you should be destroying those things. And like I said I'm okay with it if you destroy something that's big and you recreate it, you replace it. They did that but then we ended up sticking with the Haskell, and I'm gonna talk about that in a sec, but if you replace the cells regularly it enforces some things. One is it shows that the interfaces to whatever it is are clean enough that the rest of the system doesn't have to be bothered with the fact that you've replaced that component. The other is it proves to you that you can replace it, which i think is an important meta system around software development. If you don't have a meta system for knowing that you can replace code, then you probably cannot replace code. And at Wunderlist we built up this crazily, seemingly over-engineered, in fact when they did due diligence on us for the acquisition, I got a glowing review, this 40-page report, that used the words over-engineered in a positive light to describe what we had done. But this crazy over-engineered system of cells regenerating, and you'll hear more about it, but because the system ran so well, especially the Haskell one, we didn't have to change it, because you know when you write Haskell code, if it compiles it works. That's how Haskell works. So there were never any bugs in the Haskell code because it compiled, but because of that a problem occurred where the dependencies changed and the Cabal system changed out from under it, which is the package management system for Haskell, and now by the time we did the acquisition, we could no longer actually compile and deploy the code, so we had a critical problem with the system that never had an issue, because the ecosystem around it changed, and we learned that we should be destroying and replacing things, even when they're not broken and when they don't need to be replaced. It's a healthy meta system development. And along with this whole thing as I started thinking about throwing away code and being in a big organization now that has a whole lot of old code, for example Excel, I realized that developers have a fetish for code. They're obsessed with code. They think code matters. Code doesn't matter at all. The system is the thing that matters. That is the asset you create. The code is a liability, and that sounds weird, but the more code you have, the worse your system is in a sense, and if you could take a system that does exactly the same thing exactly as well, two different systems and one has 200% more code than the other one, the one with more code is worse, right? Because you don't want that code. So think about it this way, think about that system. You need to be creating a system. The code is just a part of it. Just plays a part. Back to Dick Gabriel's Design Beyond Human Abilities, they also sort of reached this conclusion that cells need to be destroyed sometimes, so he's talking about an external cell can command the cell to destroy itself without releasing toxins, so without destroying anything around it. And that that influenced how we deployed as well, so I've been talking about code, but runtime is the same way. In the '90s at GE we had a server that we had set up, and I remember looking at the uptime, and it was like 600 days up time on this UNIX server. And we kind of high-fived and, you know, "Great job," it didn't reboot for crash or whatever, but then we realized this is terrifying, because we don't know what's on this and there's no way we could reproduce this. So we started this thing; I coined this term immutable infrastructure to describe it, where we would do the same sort of thing at runtime in our back-end systems, and whenever you want to change a piece of software on a server, you would have to throw away the server and replace it with a new one. Now in the 90s that would have been hundreds of thousand dollars every time you did it, so it wouldn't have worked, and six years ago it started to make more sense, with AWS and EC2. Now this is how everyone does it, and by everyone I mean you know leading edge nerds that are using Docker, which doesn't seem like leading edge probably to a lot of you but it actually still is, amazingly. So never upgrade software on an existing node. Always just throw it away, create a new one and replace it. And then always deploy. So we had we had a rule. We were still using EC2 container at the time or, what are they called, instances, and if I had a graph of uptime on all the instances, so I used to be proud of my 600 days of uptime, and now if I saw something that was more than a couple of hours I would get worried, like why is that server not being recycled and destroyed? Because the system is not healthy in that case. We don't have a meta system for proving that we can replace things. So my goal, and we got acquired so everything got ruined, in terms of my my nerdy plans, but everything wasn't ruined otherwise, but in terms of my nerdy desires, my goal was to have uptime be less than an hour. Just always be cycling through servers constantly in an automated fashion. But speaking of this immutability, it brings me to the idea of immutability and code, which is also I think one of the most important things that we can learn from biological systems. Immutability and impermanence code, if we can think in terms of pure functions, think about it. An immutable, a pure function, actually gives you an immutable disposable scope, and you can't create huge long pure functions. It ends up being harder than just creating small ones, because you don't have scope, you don't have state mutable state that you can do. So pure functions, meaning functions that don't have side effects, kind of force you into a mindset, and you can do this in Ruby. You have to enforce your own rules, but thinking in terms of your functions is a valuable way to force yourself to think in small pieces and create immutable stuff. And there's this whole new wave of functions as a service. Some of you have probably played with AWS Lambda or Azure Functions. Standard Live is a company that my VC firm has invested in, and we did it because they were trying to sort of reinvent how you build things based on pure functions with no side effects. With no stake anyway. So an area to explore. How about this for a rule? Never edit a method. Always rewrite it instead. So what if you had Coke code folding on an error and you had to enhance your code, and the only way to do it, that's your rule on your team, is you can't unfold the code, you just have to make a new method with the same name and replace the functionality every time. This is a crazy idea, which is in fact probably not a good idea, but I like the mindset, because if this were the rule, imagine how it would change what you would write when you created a method. It would be like Sandy was sitting there looking at me. Small. So kind of a summary of these ideas, the mutability of a system is enhanced by the immutability of its components. I just sat there silently so you could think about that for a second. Once you have all these little components they need to communicate with each other. The best way to do this is through stupid inefficient simple interfaces. So don't worry about binary protocols, unless that's fun for you of course Rich, but I'm thinking I've got to do it once. Do the stupidest thing you can. An example of that is the UNIX standard in and out kind of idea. UNIX utilities, they just read from standard in, they print the standard out, and most apps or most tools in UNIX, that's what they do. In our Bull mainframe we had built this Bull RPC, which was a really dumb input-output thing using TCP, which we then created generators and all sorts of languages to talk to its COBOL programs with, and it allowed us to create this extensible ecosystem around the Bull and our custom TCP/IP stack. This was my first Ruby experience at work. By the way, I was generating Java classes to talk to the Bull mainframe by getting the COBOL copy books off the Bull mainframe, and that's sort of like the schema of these things, of the data structures in COBOL. I would parse them with Ruby, I would generate Java code and I would commit that to CBS or whatever we were using at the time. And I did that so that no one would know I was using Ruby, but I didn't have to write in Java. In a sense these interfaces, if you sort of zoom out, are the system. So this is just one stupid simple concept, but if you think about the fact code doesn't matter that much because it's so small and so simple, then it's the interfaces and the way the components communicate to become the system. So that's how much attention you should pay to this. Even though I'm telling you make it dumb, I mean that in a good way. Make it as simple as possible, simple and easy as Richard E. likes to say. Maybe a rule to keep in mind in cursive that you can't make out is Postel's law, which says to be conservative in what you accept... I'm sorry, conservative what you produce and what you do, and liberal in what you accept. It's a good way to deal with something that can evolve over time. Now something I did that's maybe... Yeah, I think it's okay at a Ruby conference. Do I have a Ruby... Yeah I've got a Ruby logo on here. A way that we did this at Wunderlist, in the Wunderlist organization, is we said okay, we're going to be heterogeneous by default. When I started there I started talking about Scala a little bit, because I've been watching this stuff that Twitter and LinkedIn had been doing, and people would really snicker, in the same way that in the '90s, people were snickering at me when I talked about Ruby to GE. But what I wanted to do was get everyone into a mindset where they weren't dealing with these monolithic processes, monolithic memory spaces, monolithic sets of languages and libraries that all bleed together. All of these boundaries of creating small things that have to communicate through clean interfaces, well it's a lot harder to produce tight coupling between your Haskell code and your Ruby code than it is to not produce tight coupling. You have to go out of your way. You'd have to be Aaron Patterson with his BHP interpreter at Ruby for example. So we didn't use all these languages, or platforms or whatever they are, but by the time we were acquired and stopped working on our back-end platform we had something like 12 or 13 back-end languages, including Haskell as I said, Rust, Go, Ruby, Clojure, Scala, Node, et cetera, and I think that actually contributed creating the system that we wanted to create very heavily. So this is Joe Armstrong. If you were at RubyConf 2006 you probably learned about this video, but assume that things are going to fail. Failure in a system like this, where you want things destroyed is a virtue at runtime, but also in your code, which leads you to the concept of mean time between failure optimization versus mean time to resolution optimization. A lot of people spend a lot of time thinking about how can I never have a failure, which is probably impossible in most cases. Rather if we spend all of our time thinking about how to recover from failures and forcing them, we would be in a better state. One classic example of MTBF, probably MTTR too, is testing, so this slide probably speaks for itself. Tests are a design smell. I'm surprised that no-one booed. I guess we've gotten past that point now We're too old to worry about it any more, but there was a time at a Ruby conference people would have been upset about this thing. Tests are coupling. Tests reach into your code in a way that actually stops it from moving forward. I had at least one conversation yesterday, and every time I go to a conference I talk to people about their project, where they end up spending, they're trying to upgrade a Rails version for example, which was the most recent one I heard about, and they spend so much time screwing around with the test suite that it is a detriment to them. It doesn't help them. So we'd forgotten why we test things. What if your code... like I got to pair with Kent Beck once, and we sat down and I wrote something. I don't know what it was, it was in Java, and I said, "Should I write a test for this?" And he said, "You shouldn't write a test "for anything that could possibly break." And I said, "Well what about this?" And he said, "Could it possibly break?" It's like, "I don't know." I'll write a test for it because I thought he was trying to trick me. But I think that's a good way to think, and of course he didn't want to tell me, because the idea is not to tell me when to write a test, it's to give me intuition about when. Well what if your intuition... your code triggered the intuition that the answer is always no? Because your code's so simple it just can't break. That's what I mean by this. The other thing though is don't let your test be an anchor that you have to drag around, and maybe it's more important to monitor the runtime behavior of your code than it is to test it, 'cause you do all this shit to make your tests work and simulate reality, but they aren't reality. You can't catch the errors. How about catching the errors in production and getting to where you can fix them really really quickly? I'm sorry bad words. Experience the worst case scenario as soon as possible so you don't have to face it, or you don't have to fear it. When I joined Wunderlist, I think it was the second day I was there I got access to the backend systems, and I started just deleting servers from the clusters until it crashed, and at that point they had moved me from the United States to Berlin to be their CTO, and I'm sure they were thinking, "Well it's too late to send him back now." But I did that slowly, and you would see it getting worse and worse, you would watch the graphs, and then it would crash, and then the team that had currently had previously been paralyzed by fear had to jump into action with me to save me from my own idiocy, and to make it come back. And the users were really complaining. We had problems. People weren't able to log in. So I probably took it a little too far, but we were in a situation before I got there where everyone had finally gotten the system to where it would sort of work, and no one wanted to change anything. They were afraid of it. And there you have stasis, and you're screwed when you have stasis. You will not create a system that could survive. So I got us into this situation where we got used to dealing with it, and I think that's a pattern for the future. Back to this homeostasis idea, and the idea of regulation, really my grand experiment is paused right now having gotten to this point, but I wrote some papers about it, because I thought that's what a CTO is supposed to do, and I was imagining, here's a generic diagram of a system, but think about the different ways that if you work on back-end systems that have scalability problems for example, where you have components that crash because they're under too much load, the database can't handle load et cetera. If you've got measurements on everything, you could say okay, the database can't handle it, the system is going to regulate itself, and it's going to slow down the incoming traffic. It turns out that the way that you deal with a distributed system like this when you're trying to work on scaling issues is by doing these things manually, so this is the first sort of obvious step to simulating homeostatic regulation. You can imagine a lot of different things though, where the system watches itself and adjusts its own components, kills things, slows things down artificially, speeds things up, in order to take care of itself. Even to create problems that it can then react to, so some sort of older examples, there's the chaos monkey which is sort of famous from Netflix, which would just go around because back in the day when they started using EC2 it was controversial, and the AWS thing, because people would say the instances would die randomly et cetera, so they made the decision to use it, and they said well if the instances are going to die randomly, we need to make sure they're dying a lot, so that our system can deal with it. So they created this thing that would just cause problems, and make sure that the system could run smoothly all the time. Pinterest did something cool a few years ago. AWS has a concept called Spot Instances on EC2. So normally if you want to start a new server, there's a fixed price for a certain type of server. You boot it up and you pay that price, and then you shut it down and you stop paying the price. Spot Instances give you a chance to bid on a secondary market for computing common to these same types ofservers, and you set a minimum and maximum price, and when you get it it starts up the servers, and when the price changes and you can no longer afford it, it just kills them, which is weird if you think about running production code, 'cause it's going to die. Pinterest switched entirely to Spot Instances, and then they built their systems so they could deal with all these fluctuations, which I thought was a great way to both force the concepts that I'm talking about, and save a lot of money, because it's much much much cheaper. So we started doing experiments with that too, and we were saving hundreds of thousands of dollars a year on paper doing this. A lot of what I'm talking about with this cellular idea is encapsulation, so for this to work, the services have to encapsulate their own data, they have to own the data, and I think encapsulation is decoupling. It's sort of an obvious thing to say. It leads to stuff like lots of small databases, instead of one big one. Maybe some of this stuff is obvious now. A lot of people then say, "Well don't you have "referential integrity? "What do you do about that?" No we don't have that. I would rather have this. I would rather have decoupling, and the ability to revolve things separately. The whole point of this is that I don't want any of us to be doing these rewrites anymore, 'cause it's just sad, like I said. It's sad. I mean if you want to just be a capitalist, it's a waste of money, but I think it's much worse than that. Here we are, hundreds of people in this room, who are probably working on things that will not survive more than a few more years if we're lucky, and we spend so much time on it. It's just not worth it. Life is too short for that. Few years ago I went to Nordic Ruby in Stockholm, and Reginald Braithwaite did a talk, and I don't remember anything except for this line. That's how bad the old aging memory is. Ruby has beautiful coupling. That was sort of the main point I think of his talk. And it's true. Part of what I loved about Ruby when I got into it was I could do crazy stuff. No-one would stop me. It's like Java... Dave Thomas used to say that Java is the blunt scissors of programming 'cause it tries to protect the programmer from everything, and Ruby doesn't do that, and Ruby you can redefine everything in the system at runtime and cause all sorts of crazy crashes and make it impossible for another programmer to come behind you and work. You can put something in a path somewhere that gets loaded and they can't find that redefined tel string work. That's it. They'll spend a long time trying to figure it out. And it's true. That's part of what we love about Ruby. Flexibility. But as I think about Ruby's place in the world now, and the responses to my question, what does the Ruby community need to hear in 2017, some of it was stuff like, "Well why would I choose Ruby over Python at this point?" You know, really kind of snotty answers like that. A lot of them were about Python. Python won the data science thing, and therefore is gathering steam around that, and other people said Node won, and to both of these I say well what did it win? And that's sort of a relevant point too. It didn't win anything. We're still here. We still love Ruby and we still use it. But what if Ruby was the language that when people talked about it, they said, "If you build things in Ruby, "there are tools and practices in that community," and I would say tools first. Tools and parts the language. I don't know what they are but they're probably not the ones that have been requested since 1999. What if Ruby was the community where when someone builds a system in Ruby, it's probably never going to have to get rewritten? It's never going to be thrown away, at least not en masse, as the system will survive. So I hope that that's an inspirational idea. (Beethoven's Seventh Symphony)