Kent Beck: Software Engineering in the Age of AI | Prodacity 2026 - https://www.youtube.com/watch?v=F8fBgDCf2Y4
I've spent my career in commercial software development. I've had occasional encounters with the military or government world. Remember working on a project at Lockheed way back in the day? Does Lockheed still exist? Yes. Okay, good. Glad I didn't sink them. So some of the things that I was hearing this morning were outside of my usual sphere of concerns. But much of what I heard was spot on and the constraints are very similar. And I also solved a long term puzzle. The way my brain works is I'll take a problem and I'll stick it in the back and I'll churn on that. And sometimes the answer comes within minutes, sometimes it's months, sometimes it's years or even decades. And so at the end I'm going to reveal a refinement of an idea that I've been working on for 10 or 15 years that I think I cracked this morning as a result of listening to General Whiting. But I'm just going to leave that out there to make sure that you pay attention to the whole thing. Is that okay? By the way, if anybody has questions as we go along, I'd rather have you raise your hand and ask right away than sit there and wonder about it. Asking questions is a form of leadership. I remember being a freshman in college and we had a, we had an experimental discrete math class and Professor Ken Ross, I still remember him at the whiteboard was not being terribly clear. And one day he was a little late coming in, this is probably three weeks in and the whole class was there and we're sitting there and just kind of the glazed eyes, everybody looking forward, trying not to make contact, eye contact with anybody else. And finally somebody said, does anybody know what's going on? And everybody said, no, no, we're completely, completely close about what's going on. And it was such a moment of. And then Ken Ross came in and we just blasted him just like nobody knows what's going on. Stop whatever you were going to lecture about, please don't explain what was going. And it was great for everybody. And he ended up writing a very popular discrete math textbook. And I would like to say that our class really had a lot of responsibility for that happening. So if you have a question, comment, please raise your hand. We have mic runners ready to go. Go around. So my name is Kent Beck. I've been coached by Gene Kim, who many of you will know that I ought to introduce myself in the following kind of way. I don't like it, but Gene says so. So I was instrumental in bringing patterns and that Pattern style of thinking to software development. Programmer testing. Programmer testing frameworks like Junit was my original invention. I refined it with Eric Gamma and it was then copied a million different ways. Test driven development, which is an age old idea. I recently found a book from 1957 called Something like digital programming where the distinction between binary computers and decimal computers had not been worked out yet. Which I thought was like, oh, I guess that must have been a question at some point. But late in that book it talks about how do you write programs? And it talks about you go to the users and you ask them for some check items, that is give me some input output pairs from your domain and we'll make sure that the computer program matches those input output items. And I thought that's test driven development right there. So I can't claim to have invented tdd, but I maybe rediscovered it or something like that and then refined it. Extreme programming is my baby. I was one of the signatories of the Agile Manifesto. I wasn't just one of. I was the first signatory of the Agile Manifesto alphabetically. And then since then I've spent a lot of time coaching high potential engineers. I'm deep in the augmented development world. I'm working with one of the frontier labs, which is its own set of interesting constraints. I mean it's one of the first. I work at the intersection of technology and sociology and this is one of the first times when it's not a press play kind of problem on how a team that's building a frontier model or building a sequence of frontier models, how they should actually work. I'm having to really think, I'm having to learn a lot, which I appreciate. So that's my background. I'm coming here to talk to you about craft and the role of craft in an augmented development world. I always say augmented development because to me this is still a human process, at least so far. I still have a lot to add to the decisions that the GENIE is making. I call it the GENIE because it grants your wishes, but it ends up not being what you really wanted. Just as a reminder that that's the essential relationship here, I'm going to make some requests, I'm going to get something back, it's going to seem really cool and then at the end of it I'm going to be a little bit disappointed. So that's how we work together. I wanted to say I'm not going to bury the lead. The one thing I would like you to take away from is there's a tendency now when people talk about augmented development, where they make a statement like, now that the genie, they don't usually call it the genie because they're not going to be that cynical now that the genie is better at coding than humans. And I'm calling balderdash on that statement, that attitude that just because GENIE can create syntactically correct programs doesn't mean that they're better than a programmer or even that they actually work. And one of the things I always loved as an autistic person, that I loved about programming is this binary red, green. Oh, that's so relaxing to be able to say, this program doesn't work. I fix a bug and now it's fixed. And that's the programs that we get out of augmented development oftentimes just don't work. They're plausible. Jeanne's really good at plausible. But actually working. No. And we've all read these breathless accounts of what? Well, we spent $10,000 in tokens and we got a working C compiler out of it. How amazing is that? And then you start digging and you realize that working C compiler, hello world, doesn't actually work. Or there were a few remaining bugs, and every time one of those bugs got fixed, three more bugs were introduced. If you dig a little bit deeper, it's close to a C compiler. It's C compiler ish, but it doesn't actually efficiently compile C programs that then run, which seems to my old fashioned way of thinking to be the criteria we ought to be using. So that idea that somehow it we've just replaced programmers because computers can do what programmers used to do is simply wrong. Now maybe someday it will be less wrong, but today it's simply not true. And that means your relationship as a programmer or as a manager of programmers or as a purchaser of software, if there's a heavy presence of the GENIE in the production of some software, you have to take a cynical view, you have to take an adversarial view and say, okay, you say this works, you made yourself happy. But did you make me happy? How real is that? How hard do I have to push? So the kinds of things that you do as a programmer to make sure that a program works by construction or that a certain class of bugs is simply not possible. Genie doesn't have those tricks. So things that you used to be able to infer, trustworthiness that you used to be able to infer, you simply just can't assume that that's true anymore. Which now I've been through a number of Cycles. One of the advantages of losing all this hair was I've been through enough cycles where people said, oh goody, we don't need programmers anymore. And as programmers, it behooves us to think about why they keep trying to get rid of us. Kind of at a strategic level. But also it's never been true, you know, because. Computer programmers are highly technical artifacts and we'd love for, say, business people to just be able to speak in a plain language to the computer so that we don't need programmers anymore. The business people can just state their requirements in plain language and the computer will just compute it. And that, of course, is the high level description of cobol. But that cycle has been going over and over again. And here we are at the next round of that cycle, which is why I'm not worried about having a job. That and because much of my job is coaching. It turns out that young engineers make exactly the same young engineer mistakes that young engineers have been making since the time of the Romans. And they can use someone who comes along and says, yeah, yes, you're kind of weird, but you're definitely not alone. And you know what? I've seen worse. And that's a very soothing thing for a young, nearly overwhelmed programmer to hear. So that word craft that's in the title of my talk is an interesting word. And I have a mixed relationship with that word craft. I've written at least three books which can all be described as craft oriented. Okay, you're a programmer. What is it that, like, how can you put your whole self into the act of programming? And all three of those books are completely obsolete and should be thrown away at this point, which is an odd thing to do. Feel it towards the end of a career. But there you have it. The kinds of activities that we used to use to express craft. Careful naming, careful decomposition of logic into little pieces that all compose together to create some larger effect. Indentation, use of white space, optimizing program structure for human understanding. Those aren't decisions. Those used to be decisions that had a lot of leverage. Now they tend to have a lot of leverage over time. So five years later, someone would come across some code and say, oh, thank goodness I can read and understand this, and they would feel good about it. Those decisions don't have the same leverage that they used to have. And that's just true. It doesn't mean that humans don't need to understand code. I think there's still a lot of leverage if I have to choose a system where the humans can read it and a system where the humans can't. I'd much rather have a system where the humans can read and understand about it. But I also have to recognize that that reading and understanding is going to happen in the context of I've got this genie, it can explain stuff to me if it's not lying to me, which is always an option. But if it's not lying to me, I'm going to be able to understand this more quickly. But that, that detail oriented which feels so good. Oh my good, you know, I'm like, how does this go together? And then I realize, oh, I inline these things and I extract those things and I rename these. Ah. Then it all becomes clear. That moment felt really good to me and there's just not payoff for that particular moment. Now, CRAFT was, let me say. From my perspective, that word craft was hijacked by a group of people who wanted, again this from my perspective, wanted to go in their little cave and they wanted to be programmers and it was just them and the computer and they would craft themselves until they were ready to be finished. This is the flip side of my relationship with that word craft. I really hated that. Oh no, it's not done yet because I haven't finished with my craft. Well, sometimes if the cost of delay is high, an ugly program that gives you feedback is exactly the right thing to do. Other times if the cost of delay is low, this software is going to live for the next 20 years, then absolutely. That Swiss watchmaker get everything exactly right is going to pay off over time. But the idea that as a programmer time doesn't matter compared to your experience of programming, I just disagree with that strongly. And I didn't like what that side of programming did with that word craft. But we have to recognize now that CRAFT is going to mean something different. It's still a valid concern, it's still a valid discipline, but it's going to show up very differently. And I'll talk as I go along more about how I see that change happening. So let me draw a little bit for you all. I've noticed that if you look at my GitHub, so I've been programming augmented development like back into programming hardcore every day for maybe the last 18 months. I saw Gene Kim and Steve Yeage give a demo and they were so excited. I thought I have to get back into this. And I gotta say, I absolutely love programming with the genie. I've always had bigger ambitions than my technical skill could achieve and now I can try ridiculously ambitious projects and make a lot of progress. I didn't say accomplish them because on my GitHub you'll see that there's a name of a project and then Project two, Project three, Project four. Because I kept hitting the wall, I kept getting to that place where I couldn't fix one bug without breaking something else. And then new project, new project two, new project three. Now it somehow never occurs to me to put a one by that new project. I just assume this time it'll be different. This time I'll be able to actually get this thing completed. But no, I have to release over and over and over again. So here's how I've come to think about this. If we look at progress. It took me a while to get to this visualization, by the way. This is. This is one of those ideas that went in the back of my head and I had to work on for a while. If we look at progress on features, what we see is it goes fast at first and then it goes slower and slower and slower and slower. And that's the like what goes into that dynamic, what goes on the other axis? And sometimes I call it optionality, sometimes I call it futures. So it's easy to see futures versus Features. And then I knocked out one of my front teeth and then I had to call it Futures versus Features and it was a really terrible choice. But then I got the tooth replaced, so now I'm good. The vicissitudes of age so here's what happens. We always start with a wide variety of things that we could do but we have no features. And then we implement something and we burn some of our futures in order to realize that feature. At the very least we're going to have to maintain backwards compatibility if we add the next feature, which will constrain what we can do a little bit. Or we'll decide we don't like that first feature and we'll have to take it out and then again constrains a little bit what we do next. But what happens next is we burn some more futures in order to get our next feature, and then we burn some more and then eventually we get down to the point where we have no options for change at all because everything is such a big mess. And then that's when I start Project two or Project three or Project four. So now we've made a lot of progress in software development. It used to take us 100 people 10 years to get to this absolute zero state where we can't make any changes without breaking something else. And now with AI, I can do this in the privacy of my own office. One person, one week, and I can make a complete mess. So that's a big productivity enhancer to get to a project that can't be changed with far less in the way of investment. But what's the alternative? What else can we do? So that's what I want to create that first feature. It's always going to burn some futures. Nothing you can do about that. But now we have a moment. When I was in music school, there was a story about Pablo Casals, who was one of the greatest cellists of the 20th century. And the cello is a very physical instrument. It's big, it moves a lot of air, takes a lot of feel, physical strength to play the cello. And Casals had a piece that was a long run of 16th notes, on and on and on and on. And someone asked Casals, don't you get tired playing all those 16th notes? And he said, no, I rest between the notes. And for me, as a young classical guitar major trying desperately to play fast enough, the idea that there was a between the notes was just mind boggling. Now it turns out Casal's never said this. The story's made up, but it's such a good story that I have to tell it. But here we have a moment. We've completed a feature. The genie said, okay, boss, you know, the finger guns, okay, boss, I finished that feature. Do you want me to implement the next thing? And we all have the opportunity to take a breath and say, huh, maybe I'm not ready. And that gives us a chance to add back some of the futures and maybe even a little bit more before we implement the next feature. And then again with the finger guns, and then again, we can say, no, I'm going to refactor what's there. I'm going to eliminate some duplication, I'm going to optimize some of this for readability. I'm going to throw away what I just did and implement it again in a different way, see if that turns out differently. There's a lot of things that you can do in that moment between features that are going to add value to the project. Because the economic value of a project is the sum of the features that it currently has and the futures, all the options that for what it could do next, I can add value by adding to the futures. And so this is the trajectory that I want to create, to go back and forth between adding features and improving the futures of the project. Now, the challenge with this Is adding features is visible, legible in that seeing like a state sense. Everybody can see the progress. They want the features, the users want the features. Now they have it. Woo. Thank you very much. Futures is harder to account for. You may have added to the theoretical value of the software, but the fact that you could make a change that you may or may not want to make seems like gilding the lily. Why didn't you just implement the next feature? Well, because if I just implement the next feature, I'm going to go down to zero and everybody hates that. So this is how I think about the challenge of augmented, not just augmented development. This is the challenge of software development is balancing the investment between the next set of features and the futures which determine what it is that you can implement next. With the GENIE involved, the whole thing ramps up. The timelines are shorter, the opportunity cost, you know, if you just say, yeah, implement the next feature, you're going to get it really fast. Something like it, maybe that works mostly. And if instead you go and future proof your software, you remove the sources of error, it's harder to account for that. It's not written in any spec that says, and this will be easier to change in the future. Nobody seems to ask for that. They're all looking for that project that gets finished. Whereas for me, finished, like I don't want to change, this software is a failure. I want to write software that inspires any number of new ideas to me, that's more valuable, but it's harder to write a spec for that. And I'll talk, I'll get cynical about spec driven development before this is over, I promise. So this is the trajectory I'm trying to create. If you step back from this as a trajectory far enough, you don't notice the back and forth. It just looks like the software is getting more features and more options at the same time. If you try to, as an implementer, try and actually implement more features and more options at the same time, it turns out that's a bigger problem than fits even into the combined brain of the GENIE and the human. The more effective strategy is to go back and forth between the two. We're going to make some progress, then we're going to consolidate, we're going to make some progress and we're going to consolidate. You can't wipe the knife while you're cutting. You have to cut and wipe the knife and cut and wipe the knife, but you have to wipe the knife. You know, if you went into a professional kitchen and you said, you know, you're wiping the knife and it's pretty much clean already. Why don't you just stop wiping the knife? Then the chef is going to offer to use the knife on you and then wipe it. So, you know, the commercial kitchen has developed these strategies that work out well. And in software development, I mean, one of the things about extreme programming that I thought was the biggest compliment I could have gotten was this is what really good teams look like in the wild. This isn't theoretical. This is an observation of what teams really look like. And that was my goal in extreme programming. If I said anything creative or I said anything innovative, it was definitely a mistake. And I wanted to take it out. I wanted proven techniques. But now we have this much more powerful tool that can go much faster, that can create opportunities for feedback faster than we're prepared to gather that feedback or analyze that feedback. And the temptation is there to just let it go full speed ahead. And for me, this is dangerous anytime I've tried fully agentic. The dark factory. The dark software factory. And the dark doesn't. It's not meant like dark, like evil. I was kind of hopeful. The dark software factory, like, oh, I get to finally write evil software. And no, it turns out that's not what they mean at all. It's just there's no human involved, there's no feedback. And that always goes off the rails. Always. And here's the problem. It's amazing. While it's going off the rails, the crash is so entertaining, right? You're like, wow, how did you get this much? How did you do this much? And it's still complete crap, but there it is. So the challenge for me and my personal practice for the people that I coach, for the teams that I coach, is how do you create this space between features to go back and enhance the futures of the work that you're doing and to do that in this environment where it's so tempting to just implement the next feature. The next feature. The next feature feature. So the comment is by pacing yourself, you're giving yourself the chance to form understanding. And that's exactly right. The best software that I've ever, that I've worked on is software where I tried to maximize learning, which threw off software is a side effect as opposed to I'm trying to produce software and sometimes accidentally I learn something because I messed up your habits. If you're trying to maximize learning, your habits look completely different, the pace looks completely different. You're not afraid to throw stuff away when it gets kind of messy. This is One of my early experiences working with Ward Cunningham, who was my mentor when I came straight out of school, the biggest piece of luck I ever had in my life. Ward invented the wiki and we had developed some code, did what we wanted to, but it was late in the day, we felt a little bit like, I don't know. And he just reached over and turned off the computer and I about jumped out of my skin. Like we implemented this stuff and it was kind of working and we only felt a little bit bad about it. How could you destroy that? So I kind of huffed my way home and came in the next morning and we re implemented everything that we had done the entire previous afternoon in about 15 minutes. And it was absolutely clear and we understood it. And that was the light bulb moment for me. This is a learning process that throws off software as a side effect. Whereas the temptation in the Dark Factory, you don't learn anything except at the end you learn how unreliable the genie really is. But we already knew that. So why is it that I need to keep learning that I don't know? So that's what I'm trying to create. This trajectory where futures and features go together in a little bit back and forth. Something I've heard echoes of earlier in the day is a distinction that I want to make that. It's coming back. This is again one of these advantages, disadvantages of experiences. You see stuff and you go like this again. Okay? And this is the distinction between one shot development and iterative. Demel, Sorry about that. Iterative development. Sometimes my mouth gets a little ahead of my brain, or maybe it's the other way around, but here we are. There is such a temptation in spec driven development to go down the path of I'm going to write a spec and the GENIE is going to produce the software and if the spec is good enough, the software is going to be good enough. And there's a word for that that's exactly waterfall development. Where it didn't work, it never worked. If you go back to the original Winston Royce paper about the waterfall, there's a diagram with the waterfall and it says right there on that page, of course this doesn't work because decisions you make later are going to inform decisions that you made earlier. So the next page has waterfall going down and feedback coming up. But it's the power of an image is everybody looked at that waterfall and thought, wouldn't that be awesome? If I could just write a spec that was good enough and then the software would be finished and that's what Stuck. That's how careful you have to be when you're explaining things. What about formal methods? Great question. I have enjoyed. So when I was in graduate school, I was in music school and computer science school every other year and I just ended on the wrong year. So I'm on stage here during the day instead of in the evening. Feels good to be in a music venue though. I was a TA for the Proof of Program Correctness class. So I have those patterns baked into my head and I use them informally all the time to do some data flow analysis or control flow analysis and define some invariance and so on. But I hadn't done formal proofs until maybe a year ago and a friend introduced me to Lean and Lean with the genie and I tried it out. The challenge I have with formal methods is twofold. One, it still feels like a one shot process. I have some formal specification and I want to prove some properties of it. And I do a whole bunch of work and I prove the properties. What happens if I change one element? Oh, I got to wind back. And even if it's faster because I have the GENIE helping, it's still a drag on my ability to change. And I want to encourage, I want to build systems that encourage change instead of discourage change. So that's my first one. And the second one is even with formal methods, there's still a gap between this mathematical model and implementation. Okay, I can have some formal specification, I can derive some properties, I can prove those properties. Properties hold for this formal specification. And now I want to turn that into a running program. There's still a gap in that derivation of the program from the formal specification. And I don't know how to bridge that. Okay, I want to turn that into C code, I want to turn that into C or ARM 64. You can program an assembly language now. It's so cool. It's so. I mean, that's where I started. My dad and I soldering together a 6800 machine. You can do that now. You can just say, well, okay, implement this data structure and do it in x86 assembly. Chung chunga chung ding. I will come some. It's amazing. Figuring out all the different ways I can torture the GENIE is just so entertaining. Okay, let me make this even harder and more awkward. So the second part of the to finish that thought about formal methods, the second part is that bridge that gap between here's a specification and here's an implementation that matches that specification. Specification, as far as I can tell, is something that hasn't been fully bridged. Now the good news is you can get to low defect densities with a combination of examples, automated tests, carefully chosen and foolproofing of the design. If you work at those two things pretty hard, you can get software that is trustworthy. Unfortunately, the GENIE wants to make shortcuts, it doesn't want to foolproof the design and it will do things that subvert the intentions of test cases. You have to watch for returning constants, you have to watch for just all of the nasty things that you can imagine that a 14 year old programmer would do just to say, yeah, it works boss. So it is possible to write though trustworthy program with the genie. Ah, so I got into that one shot versus iterative. So are you making some software that has value deployed in the world that you then change and now it has more value in the world that you then change and then how now it has more value in the world? That's one paradigm versus the I'm going to write a spec and the spec's going to be so good that the software is going to be good. Oh, it's not. I'm going to write more of a spec and a bigger spec and a until the spec is big enough and complicated enough that the software is correct. And there's times to do both. If I'm writing a little app, one shot is fine. If I'm writing as I am a virtual machine for a graph database with an embedded programming language, that's not good enough. It's going to have to be something. Where I have some software, it has some value, I see a way to improve it and so on. The people who are getting really excited about spec driven development just reminds me, it doesn't sound like they've ever had a billion users because the kinds of things that you have to do, if you have a really large installed base and a lot of traffic to change software like one shot and then, oh no, never mind, let me one shot it again. That's just never going to work because you've got, you have continuity problems, you have data migration problems. You're better off assuming that you're going to be iterative all along the way. Now I said that I was going to show you an update of a diagram and I'm excited because anytime I get one of these, I have a puzzle and I can finally solve it. Then I'm a very happy person. So. Us programmers, I'm a programmer mostly and so that's the way that I speak. If we want to look at what we do. There's this sequence where, as a programmer, you put in a certain amount of effort and then you have, say, a new feature that you can deliver to your customers, and that's output. And then the customers use that feature and their behavior changes. After all, if we produce software and nobody's behavior changes in any kind of way, we didn't need to produce the software. And that's outcome. And one of the big changes in my life was moving to the web and being able to observe what customers actually do with the software. Before then, you had software on a cd, you'd send it out. Are people using my new features? I don't know. There was no way of knowing. So just being able to observe outcomes was a big step forward. How much of what we did wasted effort because nobody used the feature at all? But here's what I learned today is outcome for the customers. The people using the software leads to, and I used to use the word impact, but I love this word mission leads to changes in our accomplishment of the mission. And the mission is shared between the people making the program and the people using the program. And here's where we get to the tyranny of metrics. People will be amazed. The genie produced 200,000 lines of code. That's a measure of effort. It has nothing to do with the mission. And whether the mission is making enough money for my next yacht or I don't have a yacht. Just using that as an illustrative example or making the country safer. The fact that we've generated 200,000 lines of code is irrelevant. And 200,000 lines is not 10 times as much as 20,000 lines from the mission perspective. It's just irrelevant. And yet it's the easiest thing to measure. And so we look for our keys under the lamppost, and the GENIE is able to produce so much output with so little effort, it's easy to see that as productivity, because after all, productivity, the very definition of productivity, is the ratio of output to input. And whether it's lines of code, which we've known was balderdash for a very, very long time, and somehow it's back PR count. Anything which is a measure of effort or a measure of output is, per definition, not a measure of mission. The problem with measuring mission is it's hard to do. Oftentimes value from the mission is bursty, like you don't see it until a crisis happens, and then you realize that you're ready for the crisis. So it's hard to measure from the level of the mission. But that's what actually matters. So the fact that the genie can give you a lot of effort, and now I can just spin up 10 genies, and now I have 10 times as much effort. Yeah, but it doesn't matter. Doesn't mean that we're making progress on what really matters to people. And the earlier in this cycle you measure, the more likely you are to see Goodhart's Law. You know, when a measure becomes a goal, it ceases to be a measure. I think Goodhart was an optimist. It's not just that the measure ceases to be a measure, it's that people will twist the entire system out of shape. They'll make it worse in order to get better measures. So it's not that you just, you lose visibility by turning measures into goals. It's, you know, you lose progress on the mission by doing that. The later in this cycle you go, the harder it is to attribute, hey, the mission is now 7% better, and I own 0.075% of that. You know, it's hard to say what you did versus what he did versus what she did, like, which of us deserves the credit. And this is the challenge we had from earlier today. How do you incentivize progress on the mission? And I'll close with just a few words about this. I've had the great good fortune of having a few of my ideas spread out in the world of software development. And what I know about that process is you have to find an expression of what you're trying to accomplish of the mission. You have to find an expression of the mission that speaks to people's heads and their hearts. And then you have to repeat it and repeat it and repeat it. And that repetition that not getting bored with telling the story of how software development can be over and over again is part of the skill of leadership to tell that same story for the thousandth time as if it's brand new. And then someday somebody will come to you and say to you, I have this great idea. And they'll tell you your idea without realizing it was you, without giving you any credit whatsoever. And that's the moment that you've succeeded as a leader. And I think we have these tools that have the capability of transforming the value we create in the world. And that's the challenges for finding those missions into which the tools fit for human purposes. And I'm looking forward to finding out what comes out next, to doing my little bit to shape what that is and to seeing what it is that you do that also shapes the future. Thank you so much for your time and attention, Ra.
Kent Beck: Software Engineering in the Age of AI | Prodacity 2026 - https://www.youtube.com/watch?v=F8fBgDCf2Y4
저는 평생 상업용 소프트웨어 개발 분야에서 일해 왔습니다. 군이나 정부 쪽 일은 가끔씩만 접해 봤습니다. 옛날에 록히드에서 프로젝트를 한 기억이 나네요. 아주 오래전 일인데, 록히드는 아직 있나요? 네. 아, 다행이네요. 제가 회사를 망하게 하지는 않았나 봅니다. 아무튼 오늘 아침에 들은 이야기 중 일부는 제가 평소 고민하던 영역 밖의 것이었습니다. 하지만 들은 내용 대부분은 정확히 맞았고, 제약 조건도 매우 비슷합니다. 그리고 저는 오랫동안 풀리지 않던 수수께끼도 하나 풀었습니다. 제 머리는 문제를 하나 잡으면 머릿속 한구석에 넣어 두고 계속 곱씹는 식으로 돌아갑니다. 어떤 때는 몇 분 만에 답이 나오고, 어떤 때는 몇 달이 걸리고, 몇 년, 심지어 수십 년이 걸리기도 하죠. 그래서 마지막에 제가 10년 혹은 15년 동안 다듬어 온 아이디어를 한 단계 발전시킨 내용을 공개하려고 합니다. 오늘 아침에 해법을 찾았다고 생각하는데, 휘팅 장군님의 말씀을 듣다가 떠올랐습니다. 하지만 일부러 지금은 말하지 않고 남겨 두겠습니다. 여러분이 끝까지 집중해서 들으시도록요. 괜찮으시죠? 그리고 진행하는 중에 질문이 있으시면 앉아서 혼자 궁금해하지 마시고 바로 손을 들고 물어봐 주세요. 질문하는 것은 일종의 리더십입니다. 대학교 1학년 때가 생각나는데, 저희에게 실험적인 이산수학 수업이 있었어요. 켄 로스 교수님이 화이트보드 앞에 서 계시던 모습이 아직도 기억나는데, 설명이 그다지 명확하지 않았습니다. 어느 날 교수님이 조금 늦게 오셨어요. 아마 수업 3주 차쯤이었을 텐데, 학생들은 모두 와 있었고 다들 멍한 눈으로 앉아서 앞만 바라보며 다른 사람과 눈이 마주치지 않으려고 애쓰고 있었죠. 그러다 마침내 누군가 말했습니다. "지금 무슨 얘기를 하는 건지 아는 사람 있어?" 그러자 모두가 "아니, 아니, 우린 완전히, 완전히 갈피를 못 잡겠어"라고 했습니다. 정말 대단한 순간이었어요. 그러고 나서 켄 로스 교수님이 들어오셨고, 저희는 교수님께 대놓고 "아무도 무슨 말인지 모르겠어요. 준비하신 강의는 그만하시고, 제발 지금까지 하던 설명도 하지 말아 주세요"라고 쏘아붙였죠. 그게 모두에게 잘된 일이었습니다. 교수님은 나중에 아주 인기 있는 이산수학 교재를 쓰셨어요. 그리고 저는 그 일이 일어나는 데 저희 반의 공이 컸다고 말하고 싶습니다. 그러니 질문이 있으시거나 의견이 있으시면 손을 들어 주세요. 마이크를 들고 다니는 분들이 준비되어 있습니다. 돌아다닐 겁니다. 제 이름은 켄트 벡입니다. 진 킴에게 코칭을 받았는데, 여러분 중 많은 분이 아실 겁니다. 그가 저더러 다음과 같은 식으로 제 소개를 해야 한다고 하더군요. 저는 마음에 들지 않지만 진이 그러라고 하니까요. 저는 패턴, 그리고 그 패턴식 사고방식을 소프트웨어 개발에 도입하는 데 기여했습니다. 프로그래머 테스팅도 그렇고요. JUnit 같은 프로그래머 테스트 프레임워크는 제가 처음 만든 것입니다. 에리히 감마와 함께 다듬었고, 이후 수많은 방식으로 복제되었죠. 테스트 주도 개발은 사실 아주 오래된 아이디어입니다. 최근에 1957년에 나온 책을 하나 발견했는데, 제목이 '디지털 프로그래밍' 비슷한 것이었어요. 그 책이 나올 때는 이진 컴퓨터와 십진 컴퓨터의 구분이 아직 정리되지 않았던 때였습니다. 그걸 보고 저는 '아, 한때는 그게 의문거리였나 보구나' 싶었죠. 그런데 책 후반부에 프로그램을 어떻게 작성하느냐는 이야기가 나옵니다. 거기서는 사용자에게 가서 확인용 항목을 달라고 하라고 해요. 즉 그 분야에서 쓰는 입력과 출력의 쌍을 몇 개 달라고 해서, 컴퓨터 프로그램이 그 입력과 출력 항목에 들어맞는지 확인하는 겁니다. 그래서 '이게 바로 테스트 주도 개발이잖아' 하고 생각했습니다. 그러니 제가 TDD를 발명했다고 주장할 수는 없고, 어쩌면 그것을 재발견하고 다듬었다고 하는 게 맞겠죠. 익스트림 프로그래밍은 제 자식 같은 존재입니다. 저는 애자일 선언문의 서명자 중 한 명이었습니다. 그냥 서명자 중 한 명이 아니라, 알파벳순으로 애자일 선언문의 첫 번째 서명자였습니다. 그 이후로는 잠재력이 높은 엔지니어들을 코칭하는 데 많은 시간을 썼습니다. 지금은 증강 개발 분야에 깊이 몸담고 있습니다. 프런티어 연구소 중 한 곳과 함께 일하고 있는데, 그곳만의 흥미로운 제약 조건이 있습니다. 제 말은, 이것이 최초의 사례 중 하나라는 겁니다. 저는 기술과 사회학이 만나는 지점에서 일하는데, 프런티어 모델, 혹은 일련의 프런티어 모델들을 만드는 팀이 실제로 어떻게 일해야 하는가가 재생 버튼만 누르면 되는 식의 문제가 아니게 된 것은 이번이 처음에 가깝습니다. 저도 정말 깊이 생각해야 하고, 많이 배워야 하는데 오히려 그 점이 고맙습니다. 이상이 제 배경입니다. 오늘은 여러분께 장인정신, 그리고 증강 개발 시대에서 장인정신의 역할에 대해 말씀드리러 왔습니다. 저는 늘 증강 개발이라고 부릅니다 제게 이건 여전히 사람이 하는 과정이니까요, 적어도 지금까지는요. 아직 보탤 게 많습니다, 지니가 내리는 결정에 말이죠. 저는 이걸 지니라고 부르는데, 소원은 들어주지만 결국 내가 진짜 원했던 건 아니게 되기 때문입니다. 이게 핵심적인 관계라는 걸 상기하기 위해서이기도 한데, 저는 몇 가지를 요청하고, 결과물을 받고, 그게 정말 멋져 보이지만 결국 끝에 가서는 조금 실망하게 됩니다. 우리는 그런 식으로 함께 일합니다. 본론을 미루지 않고 바로 말씀드리겠습니다. 여러분이 꼭 가져가셨으면 하는 한 가지는 요즘 증강 개발에 대해 이야기할 때 사람들이 이제 지니가, 보통은 지니라고 부르진 않죠, 그 정도로 냉소적이진 않으니까요, 이제 지니가 사람보다 코딩을 더 잘한다고 말하는 경향이 있다는 겁니다. 저는 그런 말과 태도가 헛소리라고 말하고 싶습니다. 지니가 문법적으로 올바른 프로그램을 만들 수 있다고 해서 프로그래머보다 낫다거나, 심지어 실제로 동작한다는 뜻은 아니니까요. 그리고 자폐인으로서 제가 늘 좋아했던 것 중 하나, 프로그래밍에서 좋아했던 건 빨강과 초록이라는 이분법입니다. 아, 그게 얼마나 마음이 편한지 모릅니다. 이 프로그램은 동작하지 않는다고 말할 수 있고, 버그를 고치면 이제 고쳐진 거니까요. 그런데 증강 개발에서 나오는 프로그램은 종종 그냥 동작하지 않습니다. 그럴듯하긴 하죠. 지니는 그럴듯하게 만드는 데는 아주 능합니다. 하지만 실제로 동작하느냐? 아니요. 그리고 우리 모두 숨 가쁘게 쓰인 이런 기사들을 읽어봤죠. 뭐라고 하냐면, 토큰에 1만 달러를 썼더니 동작하는 C 컴파일러가 나왔다는 겁니다. 정말 놀랍지 않나요? 그런데 파고들어 보면 그 동작한다는 C 컴파일러가 헬로 월드조차 제대로 동작하지 않습니다. 아니면 남은 버그가 몇 개 있었는데, 그 버그를 하나 고칠 때마다 새로운 버그가 세 개씩 생겨났다고 하죠. 조금 더 깊이 들여다보면, C 컴파일러에 가깝긴 합니다. C 컴파일러 비슷한 것이긴 한데, C 프로그램을 효율적으로 컴파일해서 실제로 실행되게 하지는 못합니다. 구식인 제 생각에는 그게 우리가 써야 할 기준인데 말이죠. 그러니 컴퓨터가 예전에 프로그래머가 하던 일을 할 수 있으니 우리가 프로그래머를 대체했다는 생각은 그냥 틀렸습니다. 언젠가는 덜 틀리게 될지도 모르지만, 오늘날에는 단순히 사실이 아닙니다. 그리고 그건 여러분이 프로그래머로서, 혹은 프로그래머를 관리하는 매니저로서, 혹은 소프트웨어를 구매하는 사람으로서 갖는 관계가 어떤 소프트웨어를 만드는 데 지니가 크게 관여했다면 냉소적인 시각을 가져야 하고, 적대적인 시각을 가져야 한다는 뜻입니다. 그래서 이렇게 말해야죠. 좋아, 이게 동작한다고 했지, 너 스스로는 만족했겠지. 그런데 나를 만족시켰나? 그게 얼마나 진짜인가? 내가 얼마나 세게 밀어붙여야 하지? 프로그래머로서 우리가 하는 일들, 즉 프로그램이 설계상 반드시 동작하도록 만들거나 특정 부류의 버그가 아예 불가능하도록 만드는 일들 말입니다. 지니에게는 그런 요령이 없습니다. 그래서 예전에는 추론할 수 있었던 것들, 예전에는 추론할 수 있었던 신뢰성을 이제는 더 이상 당연하게 가정할 수 없습니다. 그런데 이제 저는 여러 번의 사이클을 겪어봤습니다. 머리카락이 다 빠져서 좋은 점 하나는, 사람들이 이렇게 말하던 사이클을 충분히 겪어봤다는 겁니다. 아싸, 이제 프로그래머는 필요 없겠네. 그리고 프로그래머로서 우리는 왜 사람들이 계속 우리를 없애려 하는지 생각해볼 필요가 있습니다. 전략적인 차원에서요. 하지만 그건 한 번도 사실이었던 적이 없기도 합니다. 왜냐하면, 컴퓨터 프로그래머는 고도로 기술적인 산물이고, 우리는 이를테면 비즈니스 담당자들이 그냥 컴퓨터에게 평범한 말로 이야기할 수 있어서 프로그래머가 필요 없어지길 바라니까요. 비즈니스 담당자들이 요구사항을 평범한 말로 말하기만 하면 컴퓨터가 알아서 계산해주는 거죠. 그리고 그건 물론 코볼에 대한 고수준 설명이기도 합니다. 그런데 이 사이클은 계속해서 반복되어 왔고, 우리는 지금 그 사이클의 다음 라운드에 와 있습니다. 그래서 저는 일자리를 걱정하지 않습니다. 그리고 제 일의 상당 부분이 코칭이기 때문이기도 하죠. 알고 보니 젊은 엔지니어들은 로마 시대 이래로 젊은 엔지니어들이 해온 것과 똑같은 실수를 그대로 합니다. 그리고 그들에게는 다가와서 이렇게 말해줄 사람이 필요합니다. 그래, 맞아, 너 좀 이상하긴 한데, 분명히 혼자가 아니야. 그리고 있잖아, 나는 더 심한 것도 봤어. 그건 거의 압도당할 지경인 젊은 프로그래머가 듣기에 아주 마음이 놓이는 말입니다. 제 발표 제목에 들어 있는 'craft(장인정신)'라는 단어는 흥미로운 단어입니다. 저는 이 craft라는 단어에 대해 복합적인 감정을 갖고 있어요. 저는 책을 최소 세 권 썼는데, 모두 craft 지향적이라고 할 수 있습니다. 자, 여러분은 프로그래머입니다. 그렇다면 어떻게 하면 프로그래밍이라는 행위에 자기 전부를 쏟아부을 수 있을까요? 그런데 그 세 권은 모두 완전히 구식이 되어서 지금은 버려야 합니다. 참 이상한 일이죠. 커리어 막바지에 이런 걸 느끼다니요. 하지만 현실이 그렇습니다. 예전에 우리가 craft를 표현하던 활동들, 즉 신중한 네이밍, 로직을 작은 조각들로 신중하게 분해해서 그것들이 서로 어우러져 더 큰 효과를 만들어 내는 것, 들여쓰기, 공백의 활용, 사람이 이해하기 쉽도록 프로그램 구조를 최적화하는 것 말이죠. 이런 것들은 더 이상 중요한 결정이 아닙니다. 예전에는 영향력이 아주 큰 결정이었죠. 그런 결정은 시간이 지날수록 큰 영향력을 발휘했습니다. 5년 뒤에 누군가가 어떤 코드를 보고 "아, 다행이다, 읽고 이해할 수 있네"라고 말하며 뿌듯함을 느끼곤 했으니까요. 이런 결정들은 예전만큼의 영향력을 갖지 못합니다. 그건 그냥 사실입니다. 그렇다고 사람이 코드를 이해할 필요가 없다는 뜻은 아닙니다. 사람이 읽을 수 있는 시스템과 읽을 수 없는 시스템 중에서 하나를 골라야 한다면, 여전히 영향력이 크다고 생각합니다. 저는 사람이 읽고 이해할 수 있는 시스템을 훨씬 선호합니다. 하지만 그 읽고 이해하는 일이 이제는 이런 맥락에서 일어난다는 점도 인정해야 합니다. 저에겐 지니가 있어서 제게 이것저것 설명해 줄 수 있죠, 거짓말만 하지 않는다면요. 그럴 가능성은 항상 있지만요. 하지만 거짓말을 하지 않는다면, 저는 이걸 훨씬 빠르게 이해할 수 있을 겁니다. 하지만 그 디테일에 몰두하는 일은 정말 기분 좋았어요. "세상에, 이건 어떻게 맞물려 돌아가는 거지?" 하다가 "아, 이걸 인라인하고, 저걸 추출하고, 이건 이름을 바꾸면 되겠네. 아, 이제 다 분명해졌어." 그 순간이 15:50.580 --> 15:54.020 저에겐 정말 좋았는데, 그 특정한 순간에 대한 보상은 이제 없습니다. 자, craft라는 말은 말이죠, 제 관점에서 craft라는 단어는 어떤 사람들에게 가로채였습니다. 다시 말하지만 제 관점에서, 그들은 자기들만의 작은 동굴에 들어가고 싶어 했고, 프로그래머가 되어 오직 자신과 컴퓨터만 있기를 원했으며, 스스로 craft를 다듬고 또 다듬다가 준비가 되면 끝내려고 했죠. 이것이 craft라는 단어에 대한 제 감정의 반대편 면입니다. 저는 그게 정말 싫었어요. "아, 아직 안 끝났어요, 아직 제 craft를 다 마치지 못했거든요." 글쎄요, 지연 비용이 높다면 때로는 피드백을 주는 못생긴 프로그램이 정확히 올바른 선택입니다. 반대로 지연 비용이 낮고 이 소프트웨어가 앞으로 20년간 쓰일 것이라면, 물론 스위스 시계공처럼 모든 걸 완벽하게 맞추는 일이 시간이 지나면 보상을 줄 겁니다. 하지만 프로그래머에게는 시간이 프로그래밍 경험에 비하면 중요하지 않다는 생각에는 저는 강하게 반대합니다. 그리고 프로그래밍의 그런 면이 craft라는 단어를 가지고 한 일이 마음에 들지 않았습니다. 하지만 이제 우리는 craft가 다른 의미를 갖게 되리라는 걸 인정해야 합니다. 그것은 여전히 유효한 관심사이고 여전히 유효한 분야이지만 나타나는 방식은 매우 달라질 겁니다. 그 변화가 어떻게 일어난다고 보는지는 발표를 이어가면서 더 이야기하겠습니다. 그럼 여러분께 조금 그려 보여드리겠습니다. 제가 알게 된 건데요, 제 GitHub를 보시면, 저는 증강 개발, 그러니까 다시 본격적으로 프로그래밍에 뛰어든 지 아마 지난 18개월쯤 됩니다. 매일같이요. 진 킴과 스티브 예이지가 하는 데모를 봤는데 두 사람이 너무 신나 보여서, 저도 다시 이 세계로 돌아가야겠다고 생각했습니다. 그리고 솔직히 지니와 함께하는 프로그래밍이 정말 좋습니다. 저는 늘 제 기술 실력이 감당할 수 있는 것보다 더 큰 야망을 품어 왔는데, 이제는 터무니없이 야심 찬 프로젝트에 도전해서 많은 진전을 이룰 수 있습니다. '완수한다'고는 말하지 않았어요. 제 GitHub를 보시면 프로젝트 이름이 하나 있고, 그 뒤에 프로젝트 2, 프로젝트 3, 프로젝트 4가 있거든요. 계속 벽에 부딪혔기 때문입니다. 버그 하나를 고치면 다른 것이 망가지는 지점에 계속 도달했죠. 그러면 새 프로젝트, 새 프로젝트 2, 새 프로젝트 3으로 넘어갔습니다. 그런데 이상하게도 그 새 프로젝트에 1이라는 번호를 붙일 생각은 한 번도 안 들어요. 그냥 이번에는 다를 거라고 생각하죠. 이번에는 정말로 이걸 제대로 끝난 거죠. 하지만 아니, 저는 계속 반복해서 릴리스해야 해요 계속 또 계속요. 그래서 저는 이렇게 생각하게 됐습니다. 진행 상황을 살펴보면요. 이 시각화에 이르기까지 시간이 좀 걸렸어요, 참고로요. 이건 머릿속 한구석에 들어가 있던 아이디어 중 하나였고 한동안 붙들고 씨름해야 했습니다. 기능의 진행 상황을 보면, 처음에는 빠르게 진행되다가 점점 느려지고, 느려지고, 또 느려집니다. 그리고 그게 그 역학에 무엇이 들어가느냐인데, 다른 축에는 무엇이 들어갈까요? 저는 그걸 때로는 선택 가능성(optionality)이라고, 때로는 퓨처스(futures)라고 부릅니다. 그래서 퓨처스 대 피처스(Features)라고 하면 알아보기 쉽죠. 그러다 앞니 하나가 부러졌고, 그래서 '퓨처스 대 피처스'라고 부를 수밖에 없었는데 정말 끔찍한 선택이었어요. 하지만 이를 새로 해 넣었으니 이제 괜찮습니다. 나이 들면 겪는 풍파죠. 자, 그럼 어떤 일이 일어나는지 볼까요. 우리는 언제나 할 수 있는 일은 다양하게 많지만 기능은 하나도 없는 상태로 시작합니다. 그러다 무언가를 구현하면 그 기능을 실현하기 위해 퓨처스를 일부 소진합니다. 최소한 다음 기능을 추가하면 하위 호환성을 유지해야 할 테고, 그러면 우리가 할 수 있는 일이 조금 제약됩니다. 아니면 첫 번째 기능이 마음에 들지 않아서 빼야 할 수도 있는데, 이 역시 다음에 할 일을 조금 제약하죠. 하지만 그다음에 일어나는 일은, 우리가 다음 기능을 얻기 위해 퓨처스를 더 소진하고, 또 더 소진하다가 결국에는 변경할 수 있는 선택지가 전혀 없는 지점에 이르는 겁니다. 왜냐하면 모든 게 엉망진창이 되어 있으니까요. 그러면 저는 프로젝트 2를 시작합니다. 아니면 프로젝트 3, 프로젝트 4를요. 그런데 소프트웨어 개발은 상당히 발전했습니다. 예전에는 100명이 10년이 걸려서야 이 절대 영도 상태, 즉 다른 걸 망가뜨리지 않고는 아무것도 바꿀 수 없는 상태에 도달했어요. 그런데 이제는 AI 덕분에 제 사무실에서 혼자 조용히 그걸 해낼 수 있습니다. 한 사람이, 일주일 만에, 완벽한 엉망진창을 만들 수 있죠. 그러니 이건 엄청난 생산성 향상입니다. 훨씬 적은 투자로 변경할 수 없는 프로젝트에 도달하니까요. 그렇다면 대안은 뭘까요? 달리 무엇을 할 수 있을까요? 제가 만들고 싶은 건 바로 그 첫 번째 기능입니다. 그건 언제나 퓨처스를 어느 정도 소진합니다. 어쩔 수 없어요. 하지만 이제는 한 순간이 생깁니다. 제가 음대에 다닐 때 파블로 카잘스에 대한 이야기가 있었어요. 그는 20세기 최고의 첼리스트 중 한 명이었죠. 그리고 첼로는 매우 신체적인 악기입니다. 크고, 공기를 많이 움직이고, 연주하려면 감각과 체력이 많이 필요하죠. 그런데 카잘스에게 16분음표가 길게 이어지는 곡이 있었어요, 계속 또 계속 또 계속해서요. 누군가 카잘스에게 물었습니다. 그 16분음표를 전부 연주하면 지치지 않으세요? 그러자 그가 말했죠. 아니요, 저는 음과 음 사이에서 쉽니다. 그리고 클래식 기타 전공생으로서 충분히 빠르게 치려고 필사적이던 저에게, 음과 음 사이라는 게 존재한다는 생각은 정말 충격적이었습니다. 사실 카잘스는 이런 말을 한 적이 없대요. 지어낸 이야기죠. 하지만 워낙 멋진 이야기라 안 할 수가 없습니다. 아무튼 우리에게는 한 순간이 있습니다. 기능 하나를 완성했어요. 지니가 말하죠. 알겠습니다, 보스, 이렇게 손가락 총을 쏘면서요, 보스, 그 기능 끝냈어요. 다음 걸 구현할까요? 그리고 우리 모두에게는 숨을 한번 고르고 "흠, 아직 준비가 안 된 것 같은데"라고 말할 기회가 있습니다. 그러면 퓨처스를 일부 되돌려 놓을 수 있고, 어쩌면 조금 더 늘릴 수도 있습니다. 다음 기능을 구현하기 전에요. 그리고 또 손가락 총을 쏘면, 다시 한번 아니, 지금 있는 걸 리팩터링하겠다고 말할 수 있어요. 중복을 제거하고, 이 중 일부를 가독성 위주로 최적화하겠다고요. 방금 한 걸 버리고 다른 방식으로 다시 구현해서 결과가 다르게 나오는지 볼 수도 있고요. 기능과 기능 사이의 그 순간에는 프로젝트에 가치를 더해 줄 수 있는 일이 정말 많습니다. 왜냐하면 프로젝트의 경제적 가치는 현재 가지고 있는 기능들과 퓨처스, 즉 다음에 할 수 있는 일에 대한 모든 선택지의 합이기 때문입니다. 저는 퓨처스를 늘림으로써 가치를 더할 수 있어요. 그래서 이것이 제가 만들고 싶은 궤적입니다. 기능을 추가하는 일과 프로젝트의 퓨처스를 개선하는 일을 오가는 거죠. 그런데 여기에 있는 어려움은 기능 추가는 눈에 보인다는 점입니다. 《Seeing Like a State》에서 말하는 의미의 가시성, 즉 일목요연함이죠. 진행 상황은 누구나 볼 수 있습니다. 사용자들은 기능을 원하고 원하던 기능이 이제 생겼습니다. 와. 대단히 감사합니다. 퓨처(futures)는 따져서 반영하기가 더 어렵습니다. 소프트웨어의 이론적 가치는 높였을지 모르지만, 할지 말지도 모를 변경을 할 수 있게 만들었다는 건 괜한 사족, 사서 고생처럼 보입니다. 왜 그냥 다음 기능을 구현하지 않았느냐고요? 그냥 다음 기능만 구현하면 제 수치가 0으로 떨어질 텐데, 다들 그걸 싫어하니까요. 그래서 저는 증강, 단순히 증강 개발만의 문제가 아니라 소프트웨어 개발 전반의 과제를 이렇게 봅니다. 다음 기능들과, 다음에 무엇을 구현할 수 있는지를 결정하는 퓨처 사이에서 투자 균형을 맞추는 일이죠. 지니(GENIE)가 끼어들면 모든 것이 가속됩니다. 일정은 짧아지고, 기회비용은... 그러니까 "그래, 다음 기능 구현해" 하고 말하면 아주 빠르게 결과가 나옵니다. 비슷한 것이, 아마 대체로 동작하는 걸로요. 그런데 대신 소프트웨어를 미래에 대비하게 만들고 오류의 원인을 제거하면, 그건 따져서 반영하기가 더 어렵습니다. 어떤 명세에도 "그리고 이건 나중에 바꾸기 더 쉬워야 한다"라고 쓰여 있지 않아요. 아무도 그걸 요구하지 않는 것 같습니다. 다들 끝나는 프로젝트를 찾고 있죠. 반면 저에게 "끝났다"는 건, 더 이상 바꾸고 싶지 않다는 뜻이고, 그런 소프트웨어는 실패작입니다. 저는 저에게 수많은 새 아이디어를 불러일으키는 소프트웨어를 쓰고 싶습니다. 그게 더 가치 있지만, 그런 것은 명세로 쓰기가 더 어렵습니다. 그리고 말씀드리지만, 이야기가 끝나기 전에 명세 주도 개발에 대해 냉소적으로 말하게 될 겁니다, 약속하죠. 그러니까 이것이 제가 만들려는 궤적입니다. 이 궤적에서 충분히 멀리 물러서서 보면 왔다 갔다 하는 건 눈에 띄지 않습니다. 그저 소프트웨어가 기능도 더 많아지고 선택지도 동시에 더 많아지는 것처럼 보이죠. 구현하는 입장에서 실제로 기능과 선택지를 동시에 더 많이 구현하려 하면, 지니와 사람의 두뇌를 합친 것조차 감당하기 어려울 만큼 큰 문제라는 게 드러납니다. 더 효과적인 전략은 둘 사이를 오가는 것입니다. 좀 진행하고, 그다음 정리하고, 또 좀 진행하고 또 정리하는 식으로요. 자르면서 칼을 닦을 수는 없습니다. 자르고 칼을 닦고, 자르고 칼을 닦아야 하죠. 그래도 칼은 닦아야 합니다. 전문 주방에 가서 "칼을 닦고 계시네요, 이미 거의 깨끗한데 왜 그냥 닦기를 그만두지 않으세요?" 하고 말한다면, 셰프가 그 칼을 당신에게 써 보겠다고 할 겁니다. 그러고 나서 닦겠죠. 그러니까 상업 주방은 효과적인 방식들을 발전시켜 온 겁니다. 그리고 소프트웨어 개발에서도, 익스트림 프로그래밍에 대해 제가 들은 최고의 찬사는 이런 것이었어요. "이건 정말 훌륭한 팀들이 현장에서 실제로 일하는 모습이다. 이론이 아니라, 팀들이 실제로 어떤지에 대한 관찰이다." 그리고 그게 익스트림 프로그래밍에서 제 목표였습니다. 제가 뭔가 창의적이거나 혁신적인 말을 했다면 그건 분명 실수였고, 저는 그걸 빼고 싶었습니다. 저는 검증된 기법을 원했어요. 하지만 이제는 훨씬 더 강력한 도구가 있습니다. 훨씬 더 빠르게 움직일 수 있고, 우리가 피드백을 모으고 분석할 준비가 되기도 전에 피드백을 얻을 기회를 더 빨리 만들어 내는 도구요. 그러다 보니 그냥 전속력으로 달리게 두고 싶은 유혹이 생깁니다. 그리고 저에게 이건 위험합니다. 완전한 에이전트 방식을 시도할 때마다요. 다크 팩토리. 다크 소프트웨어 팩토리. 여기서 '다크'는 사악하다는 뜻이 아닙니다. 저는 좀 기대했었어요. 다크 소프트웨어 팩토리라니, 드디어 사악한 소프트웨어를 쓸 수 있나 싶었죠. 그런데 전혀 그런 뜻이 아니더군요. 그저 사람이 개입하지 않고 피드백도 없다는 뜻입니다. 그러면 항상 탈선합니다. 항상요. 그리고 문제는 이겁니다. 놀랍다는 거예요. 탈선하는 동안에는 그 추락이 너무 볼만하거든요, 그렇죠? 이런 생각이 듭니다. 31:27.750 --> 31:30.230 와, 어떻게 이만큼이나 만들었지? 어떻게 이렇게나 많이 했지? 그런데도 여전히 완전 쓰레기입니다. 그래도 결과물은 눈앞에 있죠. 그래서 저의 과제는, 그리고 제가 코칭하는 사람들과 팀의 실천 과제는 기능과 기능 사이에 이런 여백을 어떻게 만들 것인가입니다. 돌아가서 작업의 퓨처를 강화할 수 있는 여백이죠. 그리고 그걸 이런 환경에서 해내야 합니다. 그냥 다음 기능을 구현하고 싶은 유혹이 너무 큰 환경이죠. 다음 기능. 다음 기능 기능. 말씀하신 의견은, 스스로 속도를 조절하면 이해를 형성할 기회를 얻는다는 거죠. 정확히 맞습니다. 제가 지금까지 작업해 본 최고의 소프트웨어는 학습을 극대화하려고 했던 방식이었죠. 소프트웨어는 그 부산물로 나오는 거예요. 소프트웨어를 만들려고 하다가 가끔 우연히 뭔가를 배우게 되는 것과는 정반대죠. 실수를 하면서요. 학습을 극대화하려 하면 습관이 완전히 달라지고, 속도도 완전히 달라집니다. 코드가 좀 지저분해지면 버리는 것도 두려워하지 않죠. 이건 제 초기 경험 중 하나인데요, 워드 커닝햄과 함께 일할 때였습니다. 제가 학교를 갓 졸업했을 때 제 멘토였던 분이고, 제 인생 최고의 행운이었죠. 워드는 위키를 발명한 사람입니다. 우리는 코드를 좀 개발했고, 원하는 대로 동작은 했는데, 하루가 거의 끝나갈 무렵이라 뭔가 찜찜한 기분이었어요. 그런데 그가 손을 뻗어 컴퓨터를 꺼버렸고, 저는 깜짝 놀라 펄쩍 뛸 뻔했죠. 우리가 구현한 게 어느 정도 돌아가고 있었고, 찜찜함도 약간뿐이었는데 말이에요. 어떻게 그걸 날려버릴 수 있죠? 저는 씩씩거리며 집에 갔다가 다음 날 아침에 출근했고, 우리는 전날 오후 내내 했던 작업을 전부 다시 구현했는데 15분 정도밖에 안 걸렸습니다. 게다가 아주 명확했고 우리는 그걸 완전히 이해하고 있었죠. 그게 제게는 깨달음의 순간이었습니다. 이건 소프트웨어를 부산물로 내놓는 학습 과정이라는 거죠. 반면에 다크 팩토리의 유혹은 이렇습니다. 아무것도 배우지 못하다가 마지막에야 지니가 얼마나 믿을 수 없는 존재인지 배우게 되죠. 하지만 그건 이미 알고 있잖아요. 그런데 왜 그걸 계속 다시 배워야 하는 걸까요? 글쎄요. 아무튼 제가 만들고 싶은 건 바로 그겁니다. 퓨처와 피처가 함께 가는 궤적이죠. 서로 오가면서요. 오늘 낮에 앞서 나온 이야기에서 메아리처럼 들렸던 구분이 하나 있는데, 그걸 짚고 싶습니다. 그게 다시 돌아오네요. 이것도 경험이 주는 장점이자 단점 중 하나죠. 이런 걸 보면 "또 이거네" 하게 되거든요. 좋아요. 이건 원샷 개발과 반복적 개발의 차이입니다. 데멜, 죄송합니다. 반복적 개발이요. 가끔 입이 머리보다 앞서가요. 아니면 그 반대일 수도 있고요. 어쨌든 그렇습니다. 스펙 주도 개발에는 이런 유혹이 정말 큽니다. 스펙을 쓰면 지니가 소프트웨어를 만들어 주고, 스펙이 충분히 좋으면 소프트웨어도 충분히 좋을 거라는 생각이죠. 그걸 부르는 말이 있는데, 바로 폭포수 개발입니다. 그건 통하지 않았고 한 번도 통한 적이 없어요. 폭포수 모델을 다룬 원래의 윈스턴 로이스 논문을 보면 폭포수 다이어그램이 있는데, 바로 그 페이지에 이렇게 적혀 있습니다. 물론 이건 통하지 않는다고요. 나중에 내리는 결정이 앞서 내린 결정에 영향을 주기 때문이죠. 그래서 다음 페이지에는 폭포수가 내려가고 피드백이 올라오는 그림이 있습니다. 하지만 이미지의 힘이란 게 있죠. 모두가 그 폭포수 그림을 보고 "멋지지 않아? 충분히 좋은 스펙만 쓰면 소프트웨어가 완성될 텐데" 하고 생각했고, 그게 그대로 굳어버렸습니다. 설명할 때는 그만큼 조심해야 한다는 거죠. 형식 기법(formal methods)은 어떨까요? 좋은 질문입니다. 저는 즐겨 왔어요. 제가 대학원에 다닐 때 음대와 컴퓨터 과학 대학원을 격년으로 번갈아 다녔는데 하필 엇갈린 해에 끝나버렸죠. 그래서 지금 저녁이 아니라 낮에 이 무대에 서 있는 겁니다. 그래도 음악 공연장에 있으니 기분이 좋네요. 저는 프로그램 정확성 증명 수업의 조교였습니다. 그래서 그런 패턴들이 머릿속에 박혀 있고, 비공식적으로 항상 활용해요. 데이터 흐름 분석이나 제어 흐름 분석을 하고, 불변식을 정의하는 식으로요. 하지만 형식 증명은 1년 전쯤까지 해본 적이 없었는데, 한 친구가 Lean을 소개해 줬고, 지니와 함께 Lean을 써 봤습니다. 형식 기법에 대한 제 고민은 두 가지입니다. 첫째, 여전히 원샷 과정처럼 느껴진다는 점이에요. 형식 명세가 있고, 그 명세의 어떤 속성들을 증명하고 싶습니다. 많은 작업을 해서 그 속성들을 증명하죠. 그런데 요소 하나를 바꾸면 어떻게 될까요? 아, 되돌려야 해요. 지니가 도와줘서 더 빠르다고 해도 여전히 변경 능력에 발목을 잡는 짐이 됩니다. 저는 변화를 막는 대신 장려하는 시스템을 만들고 싶어요. 이게 첫 번째고, 두 번째는 형식 기법을 쓰더라도 이 수학적 모델과 구현 사이에 여전히 간극이 있다는 점입니다. 좋아요, 형식 명세가 있고, 거기서 어떤 속성들을 도출하고 그 속성들을 증명할 수 있습니다. 이 형식 명세에서는 속성들이 성립하죠. 그리고 이제 그걸 실제로 돌아가는 프로그램으로 바꾸고 싶은데, 그 도출 과정에도 여전히 간극이 있습니다. 프로그램을 정형 명세로부터 만들어내는 거죠. 그리고 그 간극을 어떻게 메워야 할지 저는 모르겠어요. 좋아, 이걸 C 코드로 바꾸고 싶다, 그러니까 C나 ARM 64로 바꾸고 싶다고 해보죠. 이제는 어셈블리어로도 프로그래밍할 수 있어요. 정말 멋져요. 제가 시작한 곳이 바로 거기였거든요. 아버지와 함께 6800 머신을 납땜해서 만들었죠. 이제는 그걸 할 수 있어요. 그냥 "좋아, 이 자료구조를 x86 어셈블리로 구현해 줘"라고 말하면 되죠. 짠짜잔 짠! 몇 가지는 직접 해볼게요. 놀라워요. 지니를 괴롭힐 수 있는 온갖 방법을 찾아내는 게 정말 재미있어요. 자, 이걸 더 어렵게 더 난감하게 만들어 보죠. 그래서 두 번째 부분은, 정형 기법에 대한 생각을 마무리하자면, 두 번째 부분은 명세와, 그 명세와 일치하는 구현 사이의 간극을 메우는 겁니다. 제가 보기에 명세는 아직 완전히 메워지지 않은 부분이에요. 그래도 좋은 소식은, 결함 밀도를 낮은 수준까지 줄일 수 있다는 겁니다. 예시, 자동화된 테스트, 신중하게 고른 설계의 오류 방지 장치를 조합하면요. 이 두 가지를 열심히 파고들면 신뢰할 수 있는 소프트웨어를 얻을 수 있어요. 안타깝게도 지니는 지름길을 택하려 하고, 설계를 오류 방지 구조로 만들려 하지 않으며, 테스트 케이스의 의도를 뒤엎는 짓도 합니다. 상수를 그냥 반환하는 걸 조심해야 하고, 14살짜리 프로그래머가 "네, 잘 돌아가요, 사장님"이라고 말하려고 할 법한, 상상할 수 있는 온갖 못된 짓을 조심해야 합니다. 그래도 지니와 함께 신뢰할 수 있는 프로그램을 작성하는 건 가능해요. 아, 그래서 원샷 대 반복 이야기로 들어갔는데요. 세상에 배포되어 가치를 지니는 소프트웨어를 만들고, 그걸 바꿔서 세상에서 더 큰 가치를 갖게 하고, 또 바꿔서 세상에서 더 큰 가치를 갖게 하는 건가요? 그게 한 가지 패러다임이고, 다른 하나는 명세를 쓸 건데 그 명세가 너무 훌륭해서 소프트웨어도 훌륭해질 거라는 거죠. 아, 아니네요. 명세를 더 쓰고, 더 큰 명세를 쓰고, 또 쓰고, 명세가 충분히 커지고 충분히 복잡해져서 소프트웨어가 올바르게 될 때까지요. 그리고 둘 다 해야 할 때가 있어요. 작은 앱을 만든다면 원샷도 괜찮습니다. 하지만 저처럼 내장 프로그래밍 언어를 갖춘 그래프 데이터베이스용 가상 머신을 만든다면 그걸로는 충분하지 않아요. 다른 방식이어야 합니다. 소프트웨어가 있고, 어느 정도 가치가 있고, 개선할 방법이 보이면 개선하는 식으로요. 명세 주도 개발에 크게 열광하는 사람들을 보면 이런 생각이 들어요. 사용자가 10억 명인 적은 없는 것 같다는 거죠. 왜냐하면 설치 기반이 정말 크고 트래픽이 많은 상태에서 소프트웨어를 바꾸려면 해야 하는 일들이 있는데, 원샷으로 만들고 "아, 아니다, 취소" 하고 다시 원샷으로 만드는 건 절대 통하지 않아요. 연속성 문제가 생기고, 데이터 마이그레이션 문제가 생기니까요. 처음부터 끝까지 반복적으로 진행한다고 가정하는 편이 낫습니다. 그런데 제가 다이어그램 업데이트를 보여드리겠다고 말씀드렸죠. 이런 걸 받을 때마다 신이 나요. 퍼즐이 하나 있는데 마침내 풀 수 있게 되면 정말 행복해지거든요. 그래서요. 저희 프로그래머들은, 저는 주로 프로그래머라서 그런 식으로 말해요. 우리가 하는 일을 살펴보면 이런 흐름이 있어요. 프로그래머로서 일정량의 노력을 들이면 예를 들어 새로운 기능이 생기고, 그걸 고객에게 전달할 수 있죠. 그게 산출물입니다. 그다음 고객이 그 기능을 사용하고 고객의 행동이 바뀝니다. 우리가 소프트웨어를 만들었는데 아무의 행동도 전혀 바뀌지 않는다면, 그 소프트웨어는 만들 필요가 없었던 거예요. 그게 성과입니다. 그리고 제 삶에서 큰 변화 중 하나는 웹으로 옮겨가서 고객이 소프트웨어로 실제로 무엇을 하는지 관찰할 수 있게 된 거였어요. 그전에는 소프트웨어를 CD에 담아 보냈죠. 사람들이 내 새 기능을 쓰고 있을까? 모릅니다. 알 방법이 없었어요. 그래서 성과를 관찰할 수 있게 된 것만으로도 큰 진전이었어요. 우리가 한 일 중 얼마나 많은 부분이 헛수고였을까요, 아무도 그 기능을 전혀 쓰지 않았으니까요? 하지만 제가 오늘 알게 된 건 고객에게 돌아가는 성과가 소프트웨어를 사용하는 사람들로 이어진다는 거예요, 예전에는 '임팩트'라는 말을 썼는데, 저는 '미션'이라는 말이 더 좋습니다. 미션은 우리가 이루는 성과의 변화로 이어지니까요. 그리고 미션은 프로그램을 만드는 사람과 프로그램을 사용하는 사람이 함께 나눕니다. 여기서 지표의 횡포 이야기가 나옵니다. 사람들은 놀랄 겁니다. 지니가 20만 줄의 코드를 만들어 냈다고요. 그건 노력의 척도일 뿐 미션과는 아무 상관이 없습니다. 그 미션이 내 다음 요트를 살 돈을 버는 일이든, 저는 요트가 없지만요. 그냥 설명을 위한 예시입니다. 아니면 나라를 더 안전하게 만드는 일이든 말이죠. 20만 줄의 코드를 만들었다는 사실은 중요하지 않습니다. 그리고 미션의 관점에서 20만 줄은 2만 줄의 10배만큼 가치 있는 게 아닙니다. 그냥 의미가 없습니다. 그런데도 그게 측정하기 가장 쉬운 것이죠. 그래서 우리는 가로등 아래에서 열쇠를 찾습니다. 그리고 지니는 아주 적은 노력으로 엄청난 양의 결과물을 만들어 낼 수 있으니, 이를 생산성으로 보기 쉽습니다. 결국 생산성이라는 것의 정의 자체가 산출물 대 투입물의 비율이니까요. 투입물. 그리고 코드 줄 수는 우리가 아주 오래전부터 헛소리라고 알고 있던 것인데 어찌된 일인지 이번엔 PR 개수로 돌아왔습니다. 노력의 척도이거나 산출물의 척도인 것은 정의상 47:33.920 --> 47:37.080 미션의 척도가 아닙니다. 미션을 측정할 때의 문제는 측정하기가 어렵다는 것입니다. 미션에서 나오는 가치는 종종 한꺼번에 터져 나옵니다. 위기가 닥치기 전에는 보이지 않다가, 위기가 오면 그제야 위기에 대비가 되어 있었다는 걸 깨닫는 식이죠. 그래서 미션 수준에서 측정하기는 어렵습니다. 하지만 그게 실제로 중요한 것입니다. 그러니 지니가 많은 노력을 제공해 줄 수 있고, 이제 지니를 10개 띄우면 노력이 10배가 된다고 해도, 그래서 뭐 어떻다는 겁니까. 그렇다고 사람들에게 정말 중요한 일에 진전이 있다는 뜻은 아닙니다. 그리고 이 사이클의 앞쪽에서 측정할수록 굿하트의 법칙을 마주할 가능성이 더 커집니다. 아시다시피 어떤 지표가 목표가 되는 순간 더 이상 좋은 지표가 아니게 되죠. 저는 굿하트가 낙관주의자였다고 생각합니다. 지표가 지표 구실을 못 하게 되는 것에 그치지 않고, 사람들이 시스템 전체를 뒤틀어 망가뜨립니다. 더 나은 지표를 얻기 위해 오히려 시스템을 나쁘게 만드는 겁니다. 그러니 단순히 지표를 목표로 삼아 가시성을 잃는 데서 끝나지 않습니다. 그렇게 하면 미션에서의 진전을 잃게 됩니다. 이 사이클의 뒤쪽으로 갈수록 기여도를 따지기가 더 어려워집니다. 이를테면 미션이 이제 7% 나아졌고 그중 제 몫이 0.075%라는 식으로요. 내가 한 일, 그가 한 일, 그녀가 한 일을 구분하기도 어렵고, 우리 중 누가 공을 인정받아야 하는지도 알기 어렵습니다. 이것이 오늘 앞서 나왔던 과제입니다. 미션의 진전을 어떻게 장려할 것인가 하는 문제죠. 이 주제로 몇 마디만 하고 마치겠습니다. 저는 운 좋게도 제 아이디어 몇 가지가 소프트웨어 개발 세계에 널리 퍼지는 경험을 했습니다. 그 과정에 대해 제가 아는 바는, 여러분이 이루려는 바, 즉 미션을 표현하는 방식을 찾아야 한다는 것입니다. 사람들의 머리와 가슴에 모두 와닿는 미션의 표현을 찾아야 합니다. 그런 다음 그것을 반복해야 합니다. 반복하고, 또 반복하고, 또 반복하는 것이죠. 그 반복, 즉 소프트웨어 개발이 어떠할 수 있는지에 대한 이야기를 지겨워하지 않고 되풀이하는 것이 리더십이라는 기술의 일부입니다. 천 번째로 말하는 그 똑같은 이야기를 마치 처음 하는 이야기처럼 들려주는 것이죠. 그러다 언젠가 누군가 찾아와 이렇게 말할 겁니다. "저한테 아주 좋은 아이디어가 있어요." 그리고 여러분의 아이디어를 그대로 들려주겠죠. 그게 여러분에게서 나왔다는 걸 모른 채, 공은 전혀 돌리지 않고요. 바로 그 순간이 리더로서 성공한 순간입니다. 그리고 저는 우리에게 세상에 만들어 내는 가치를 바꿀 수 있는 도구들이 있다고 생각합니다. 그리고 과제는 그 도구들이 인간의 목적에 맞게 들어맞을 미션을 찾아내는 것입니다. 저는 다음에 무엇이 나올지 알아보고, 그것을 만들어 가는 데 작게나마 기여하고, 또 여러분이 하는 일이 어떻게 미래를 만들어 가는지 지켜볼 날을 기대합니다. 시간과 관심을 내주셔서 정말 감사합니다.