--- title: "Mapping Moves" url: "https://courses.osherove.com/courses/tdd-pairing-sessions-building-a-go-game/mapping-moves.md" canonical: "https://courses.osherove.com/courses/tdd-pairing-sessions-building-a-go-game/mapping-moves/" tags: [] author: "Roy Osherove" description: "Lesson 2 of 11 in TDD Pairing Sessions - Building a Go Game (The Sessions), 30:05. Free video by Roy Osherove." usage: "Licensed under CC BY 4.0 — reuse, quote and adapt with attribution (Roy Osherove, link to the original page)." license: "https://creativecommons.org/licenses/by/4.0/" --- # Mapping Moves 1. [Courses](https://courses.osherove.com/#courses) 2. [TDD Pairing Sessions - Building a Go Game](https://courses.osherove.com/courses/tdd-pairing-sessions-building-a-go-game/) 3. The Sessions Lesson 2 of 11 Duration: 30:05 [Watch on YouTube](https://www.youtube.com/watch?v=LUjsx2dqCJM) ## In this lesson In session two Roy Osherove and Raymond Lim list the missing moves and features in an Excel file, with Raymond explaining the rules of Go. The list includes surrounding groups, invalid moves, switching turns, the winner, handicaps, board sizes, saving games and komi, which means there is never a tie. Aiming for a game that can be finished, they test that white wins by default because of komi, through a public who-wins method, since komi is internal. ## Transcript 3,657 words [\[00:03\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=3s) Hey, Raymond. >> Hello. >> Welcome back to session number two. All right. >> How does it feel so far? Feels good. So far, I think I'm getting the hand hang of it. Although, I'm look I'm looking forward to when we start doing the isolation of responsibilities, I think you call it. We split into multiple objects. Yeah, we can do the refactoring now. As long as everything still works. [\[00:34\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=34s) So, just to make sure, let's run all the tests again. If I press Alt R, everything should still run. >> Yes. Let's see. Eight passed. Zero fail right here at the bottom. Okay, that's good. Okay. So what I think we should do is first of all let's try to to put the production code and the test code on a sidebyside basis. So we'll see maybe if that will make things bit more readable. [\[01:08\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=68s) So to do that we can just use some of the ReSharper goodness. Let's see is that the we have the board here. If I press F6, you can just move it. >> How do you do it? >> Just press F6. >> F6. >> Okay. And again, ReSharper annoys us with this. Okay. Let's move to another file. [\[01:43\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=103s) >> Sounds port. Yes, sounds good. >> Okay. Okay, that's good. So now we get to put the game board here and the test on the other side. >> Cool. >> let's see. 100% should be okay. What do you think? >> I think it's okay. [\[02:15\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=135s) >> Okay. Yeah. Okay. I think we'll we'll just zoom it for the for the maybe viewers later. >> as long as we both can read this. That's the important part right now. >> Okay. >> Well, I have the code on GitHub anyways, right? >> Mhm. And and I'll definitely I'll add a link to that in the blog post. >> Okay. >> Okay. Oh, so just to make sure last time we we finished everything with just the the initial moves of understanding when something is being surrounded and then to automatically remove the piece. [\[02:47\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=167s) Right. >> Right. >> it's interesting. I already got some comments about the video where someone says you're like a child who's trying to learn the rules of the game. And it's better if maybe an expert in the game would explain the rules and then you can go ahead and and and and try to write a test for it. And I think some of it is because we're doing things very incrementally. And another point is that I I haven't played Go in a long long time. [\[03:18\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=198s) I think last time I played it, my grandmother bought me some ice cream actually. So that might have been a long time ago. And it so I think what would be cool is if you had opened the Excel file here, just put it in front of Visual Studio so we can see it and you'll explain maybe some of the possible moves so that we can choose which one to try to implement next. >> Okay. So, so far we have it. We're just surrounding a single stone. [\[03:48\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=228s) So, a couple of moves that we need to, test is one where we surround a group of size two at least, like multiple size greater than one, right? And we should probably do >> How would you name that? >> is there a name for this pattern? I don't think so. At least I'm not a expert. [\[04:20\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=260s) Go. >> Okay. Can you can you write on You can write just write to the right of it maybe just the name of this as yeah surround multiple maybe okay should I generalize it more? >> I think it's around group. Do you think it will be different if we had B and just B just below it like like this one for example? [\[04:53\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=293s) Ctrl + C. Wait, I didn't use control, did I? Ctrl Ctrl + V. We would have a B like that, >> right? >> Is that a different scenario, do you think? It depends on how we implement it. Yeah. But I mean it probably another test just to verify [\[05:24\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=324s) That we should verify, right? >> Okay. So let's just call it surround group. I think they're both surround group. They're just different >> different groups, right? >> Yeah, different groups. Oh, wow. I'm not sure how we that would work, but yeah. Okay. So, that's around group. >> Okay. >> Surround group. Okay. What else? >> we also need to have a test where it's like if there's a edge [\[06:00\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=360s) And then there's a stone. This this surround is also considered surrounding. So maybe call >> I think that actually works right now. We can try it. I'm not sure if it works. >> Okay. >> Sure. >> Yeah. >> and and over to the right maybe here. >> what other scenarios here do we have? So we also [\[06:33\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=393s) We also want to verify that invalid moves such as if there is opposing color stones that the user trying to place here is an invalid move. So >> So placing B is invalid. >> Yeah, placing B is invalid. >> Okay, so you can write that down maybe. Just as a sentence [\[07:19\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=439s) I mean in this case you would just say that B is invalid. Right. >> Right. >> And to me that's more readable. I mean you can just write it just below B is invalid. Okay. >> What else? >> But then >> Mhm. >> another But then a scenario where placing B is valid is if it removes an adjacent group, an adjacent stone. So here B would be valid because W would be gone. [\[07:50\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=470s) >> Ah, nice. >> Okay, that's good. strict way to strike this up. Maybe just make it red. >> Okay. So, so here B is valid actually. >> Yeah. [\[08:20\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=500s) Or should I specify which B? B1. I mean call it B1. Okay. >> D1 is valid. >> When surrounding when when when Yeah. When surrounding W maybe. >> Okay. >> What else? >> say again. I think that's good enough for now. [\[08:51\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=531s) >> But where where where where is your if if we if we had unlimited time, money, resources, what other moves do you want to implement? >> I think that's basically exhausts all the basic options. >> Are there non-basic options? Is there something more complicated? Well, I mean, no, I think it exhaust all the options like the like once you play a game, this should this should take care of everything. That's what I think, right? [\[09:22\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=562s) But stuff that we need to do is also need like verify switching turns and then afterwards counting the territories to see who's the winner and who's the loser. >> Okay. Why didn't you write that down? Determining winner. >> Yeah, determining winner. >> But when is the winner determined? >> so the end of the game is deter is when both players pass consecutively. [\[09:54\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=594s) So determining end of game. So that means a player has the option to place a stone or pass. So they have two actions, two options, right? >> Mhm. >> And what else is any other what about switching turns? You said, right? >> Yeah, switching turns. [\[10:25\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=625s) >> And what what would that mean? Would that mean that now only white is valid or only black? >> Right. >> Okay. Anything else? >> There there are no dice in this game, right? >> Say again. >> There's no dice in this game, right? >> No dice, >> right? >> No dice, Roy. Okay, >> so setting up the board like handicaps. >> What does handicaps mean? So when there are two unequal players, they have the option to play a handicap game where [\[11:00\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=660s) The weaker player places sets up the board by placing stones >> on the board such that they have an advantage so it's more equal game starting from the beginning. >> Okay. Is handicaps a sub requirement of setup board or it's a different requirement? >> It's a sub requirement. I guess we also need to reset the board or clean board. [\[11:32\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=692s) >> We also need with the handicaps the person who goes first is different. So deciding who goes first but by default the if there is no handicap is there a default? >> Yes. >> And that is >> black goes first. >> Okay. So no handicapped. Who? So deciding who goes first. Yeah, that's that's the one we just have above. Okay. What else? [\[12:06\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=726s) There's also multiple size boards. 9 by9, 13x3, 19 by 19. Okay. And I kind of also want to do because the game could be long. >> load saving the game and loading the game. >> Very nice. Okay. >> so determine a winner with a couple things. There's accounting territories [\[12:42\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=762s) Plus for how you say minus stones removed. So that means in the future we're going to have to keep track of how many stones are being moved. And also another part of the setup would be something they call komi which is part of the handicaps thing. which actually so if so basically white would have a set starts with a set number of points to to offset the handicap a little bit. [\[13:15\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=795s) I also think in the original game like where there's no handicaps, white has like 0.5 points so that there always is a winner. There's never is never equal when they finish the game. >> Okay. So we can decide that begin game with begin game with some points or something like that. That's what you mean, >> right? Right. >> Is that komi as well >> or is that komi as well? >> Yeah. >> So komi is what does that mean exactly? [\[13:48\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=828s) >> So not equality >> because black >> has advantage when they go first. White gets a little bit of a a little bit of a few points like 0.5 point. It also allows the game so to always have a winner. There's never a tie. >> Okay. So I you can say komi and then next to it just say u always have a winner. >> How's that? >> All right. [\[14:21\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=861s) Okay. What else? I think this is basically it for just making the game engine. >> Okay. What's switching here? Switching turns. Okay. >> Yeah. [\[14:53\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=893s) >> Easy for >> Okay. So let's just do this just so we can see Okay. So now this is much more interesting because now we can choose what to implement next right and based on that [\[15:25\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=925s) Our design can easily easily change. >> so this would be interesting because there is no right way but it kind of reminds me of do you know those books where you're you have a dilemma and then based on the solution you choose you go to a different page in the book. >> Mhm. I think it kind of feels that way to me right now >> because each one of these u goals will lead us down a different path of implementation because the design will change and the refactoring will change based on the order of how we do this. [\[15:59\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=959s) So there is no one way we can try and see where something leads us. So usually what I try to do in [TDD](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-1#sigil_toc_id_27 "Test-driven development (The Art of Unit Testing, 3rd ed., ch. 1)") is to implement things in the [simplest way](https://osherove.com/blog/2010/1/6/tdd-4-questions-that-will-help-you-create-the-simplest-thing.html "TDD: 4 questions that will help you create the simplest thing that could possibly work (osherove.com)") the next simplest thing. Okay. But there are a few simplest things here. For example, determining the winner is its own separate goal and it's it's it might be rather simple. I'm not sure. Or just determining the end of the game. So, I'm not sure. Is there anything specific you want to try first to implement? [\[16:33\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=993s) To me, the next simplest thing would to expand surrounding the groups. Another simple thing would probably be setting up the board because that's like totally tangent I feel to what to what we already have. >> but in a way setting up the board is just creating a new instance of the board, isn't it? >> Yeah. Yeah, exactly. >> So, is there really a need to set up the board? Is there something specific that we don't have in board setup? [\[17:05\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1025s) We don't right now we don't have the option to select a smaller size board. Right now we only have a 19 by9 board. >> Okay. >> another thing is we don't have handicaps to like to add the board before. >> Well handicaps to me feels really complicated because we need to figure out where to place stones so that someone has an advantage. >> Right. You're right. >> That might be actually one of the more difficult things. >> I see. But a simple board setup is just a clean board, right? [\[17:39\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1059s) >> Right. >> maybe board size. Okay, we could do that. But then that would mean that the default board size would be 19 >> if we don't want to break existing tests probably, but not not necessarily. Okay. you we can also start with komi that we always have a winner. By the way, we don't have any scoring right now anyway. Right. >> Right. Right. [\[18:10\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1090s) >> So maybe adding score to might be something to do. What do you think? >> I feel scoring though is basically >> Sorry, what? >> Scoring is basically decided at the end with like the territories. But you say that there is a komi where someone already has some points. >> Komi is just like a set just set at the beginning and then it only comes in to play at the end when you decide the points the total number of points. [\[18:42\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1122s) >> Okay. So there is nothing to do with points so far you think? >> Yeah I I don't know. I was thinking of adding tests for dealing with points at the end after setting up everything else. >> So that means that our demos will never have a winner or a loser until we finish the whole thing. >> Yeah. >> Would you be okay with that? Because I I think it would be nice to have a game where we can finish a game. It's just we would have less features less abilities during the game. [\[19:16\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1156s) Like we can have a game with a winner or loser but no but we can't detect group surroundings or something like that or liberties are not yet no liberties are still not a not a problem etc. >> and that way we can basically have a game from start to finish and then we just keep adding features to it. >> Interesting. Okay. >> So that might be just one way to look at it. We can go either way. [\[19:46\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1186s) We could also decide to do switching turns. >> Mhm. >> That might be simple to do, right? So that we know whose turn it is. So we can just say >> basically which which stone color is allowed etc. What do you think? >> Right. Right. >> Okay. So, [\[20:21\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1221s) So what do you think? It's your call. It's your game. You're the driver. You're the expert. >> Whatever you decide can ruin the whole thing or make it a great success. No pressure. >> I'm just kidding. What you said about the komi part, starting with a with a basically making a whole game. That sounds very interesting to me. I want to see how that turns out. Okay. So, we want to be able to finish a game. >> Mhm. >> Right. Okay. So, to finish a game, we need to be able to have turns, >> right? [\[20:53\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1253s) >> We need to be able to determine the winner or at least in a very simple way, >> Right. And we need to have players to be able to pass, right? >> Yes. >> Okay. So, this one this one and this one. >> Mhm. Do we also need the komi for that or to be able to finish the game? No. >> No, we don't. >> Okay. So, I'll mark these in red so we'll know what we're working on, >> right? >> Okay. So, which one of them do you want to do first? [\[21:24\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1284s) >> probably determining winner. Well, maybe we might we should do with the komi because right now if we determine winner, they're both going to be have zero points and that's a tie and original game doesn't have ties. Aha. So you're saying the simplest test for determining a winner is that there is always a winner. >> That means we need to have a komi, >> right? >> Okay. So let's implement that as well. Okay, [\[21:56\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1316s) Cool. So I think we have something to do now. >> Okay. >> do you want to save this file so we can also then add it later to the source control? >> Sure. [\[22:33\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1353s) Okay. >> Okay, cool. Hold on, hold on, hold on. And we're on. Okay. So, let's switch back to Visual Studio and we're going to work on, as we said, Well, that's not mine. That's yours. Sorry. >> so can you switch back to to the Visual Studio? >> Okay. >> Okay. So, let's start with a test, right? What's the simplest test you can you can think of for combing? [\[23:08\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1388s) You shrink the visual studio. >> That didn't work. Great. What if I just said few show the whole desktop for now? Okay, that's much better. Okay, that's Visual Studio for you. And now let's try again to single window. this one. [\[23:39\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1419s) Now, can I also optimize your environment a bit by removing this toolbar? >> Go for it. >> it's just standard. I think there's a text editor. Yeah. Okay. We have more room now. So where were we? We're trying to write the first test, right? And this time we want to determine a winner. [\[24:10\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1450s) >> Mhm. >> Okay. Do you want to write you want to start? >> All right. Well, so actually maybe the first one should probably be the komi because that way we and then determine the winner after that. That way we always have a winner. >> So the way I think about it, komi is not an enduser feature. It's it's a feature of the game, >> right? >> So, it's built into the game, >> the player doesn't care if there is a komi or not. [\[24:41\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1481s) He just cares if there's a winner. I mean, in terms of engine, >> I mean, the way I think about it is that if you start a game and there are no moves, we we already have a winner. >> That is what komi is, right? >> Yes, I guess. Yeah. So in terms of the [unit of work](https://osherove.com/blog/2020/3/12/unit-testing-entry-points-and-exit-points "Unit Testing Entry and Exit Points (osherove.com)") here, the unit of work there is nothing called komi because komi is something internal. >> Okay. >> The the unit of work is probably some public method called who wins or something like that. [\[25:13\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1513s) >> I see. >> Okay. Does that make sense? >> I see. Makes sense. >> Okay. Oops. Okay. Where snar no moves >> or by default? >> By default you just shift tab if you want. >> All right. [\[25:48\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1548s) Expected behavior. >> Well, who who's the default? White. Yes, >> you don't have to say it's default winner because winner because it's it is by default. >> Perfect. Okay, that is the komi feature I guess right. >> Yes. So maybe if we would say by default or by default with komi it's white or something. [\[26:21\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1581s) What do you think? >> By default with komi enabled. What do you think? >> Say >> with by default or because of komi. >> What do you think? >> Like like this? >> Yeah. What do you think? I'm trying to to put the komi word in here so that people know that it it relates to that feature, >> but I'm not >> I think it's I think it's more clear. So, I I agree with it. >> Okay. So, Okay, let's do it. [\[26:54\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1614s) >> Oops. >> All right. So, >> by the way, hold on. You see how ReSharper hates this name? >> So, alt enter. Inspection options for inconsistent naming and then you say shut up. That's it. >> All right. >> Okay. All right. So, interesting part is how do we want to [\[27:25\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1645s) Do this? Oops. We already have stone color, right? So, we can just use that. What do you think? >> I agree. So will we have it border done? >> I would rather have a result and then say say see where we get the result from. >> Right. Right. I remember that. Okay. [\[28:06\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1686s) All right. So we can either have a board determine the winner itself or we have an object that looks at the board and determines the winner. >> Well, for now our point is to get something working to get feedback. So the simplest thing then we can refactor it. Okay. [\[28:54\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1734s) >> Okay. Then let's make it compile and see it fail. By the way, is there a possible result where there is a winner when there is no winner? >> No. >> Never. >> You should. >> I haven't heard of one. >> Okay. >> Okay. Just make it compile and so generate the method etc. >> What's the alt enter? It's always alt enter, dude. >> Alt enter should be burned into your mind. [\[29:41\]](https://www.youtube.com/watch?v=LUjsx2dqCJM&t=1781s) >> Oh, well, it should fail first. >> Oh, it fail. Okay. >> Okay. Alt R. Run all the tests. Let's see what happens. Okay. Failed. Now you can you can close this window with shift escape. this escape. >> Yeah, it closes tool windows. >> Nice. >> Okay, now let's make it pass. Simplest way possible. ## Related - [Avoid testing private or protected methods](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-8#sigil_toc_id_160) · The Art of Unit Testing, 3rd ed., ch. 8 Book section on avoiding testing private methods, matching the choice to test komi through the public who-wins method. - [Overcoming the encapsulation problem](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-3#ch03lev1sec6) · The Art of Unit Testing, 2nd ed., ch. 3 Book section on overcoming the encapsulation problem, relevant when komi is internal but must be verified. - [Entry points and exit points](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-1#sigil_toc_id_18) · The Art of Unit Testing, 3rd ed., ch. 1 Book section on entry points and exit points, the idea behind driving the komi rule through a public method. - [Test Naming Conventions With Unit of Work](https://osherove.com/blog/2012/5/15/test-naming-conventions-with-unit-of-work.html) · osherove.com Names tests after the public method that starts the unit of work, like the who-wins test written here. ### Also linked in this lesson #### The Art of Unit Testing, 3rd ed. - [Test-driven development](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-1#sigil_toc_id_27), ch. 1 #### osherove.com - [TDD: 4 questions that will help you create the simplest thing that could possibly work](https://osherove.com/blog/2010/1/6/tdd-4-questions-that-will-help-you-create-the-simplest-thing.html) - [Unit Testing Entry and Exit Points](https://osherove.com/blog/2020/3/12/unit-testing-entry-points-and-exit-points) [Previous lesson Understanding the Problem](https://courses.osherove.com/courses/tdd-pairing-sessions-building-a-go-game/understanding-the-problem/) [Next lesson Stoned and Board](https://courses.osherove.com/courses/tdd-pairing-sessions-building-a-go-game/stoned-and-board/) --- ## About the author **Roy Osherove**: Senior Solutions Architect at AWS working on AI for production and AI-driven development; author of The Art of Unit Testing and Elastic Leadership, with about 20 years of consulting and training on unit testing, TDD, team leadership and continuous delivery. ### Sites - [RobotPaper](https://robotpaper.ai/): This blog: AI patterns and anti-patterns, AI and coding agents, and engineering leadership. - [osherove.com](https://osherove.com): Roy's personal site. Author of The Art of Unit Testing and Elastic Leadership; consulting and training on unit testing, TDD, team leadership and continuous delivery, plus about 20 years of blog posts. - [The Art of Unit Testing](https://www.artofunittesting.com): The Art of Unit Testing, 3rd Edition (Manning): readable, maintainable, trustworthy unit tests, plus TDD workshops in C#, JavaScript, Java and Kotlin. - [5whys.com](https://www.5whys.com): Roy's writing on software team leadership: self-organizing teams, surviving chaos, learning mode and the Elastic Leadership model. - [Pipeline Driven](https://pipelinedriven.org): Continuous delivery and DevOps practices: build patterns, pipeline-friendly testing, DevOps metrics and enterprise DevOps. - [Elastic Leadership](https://www.elasticleadership.com): Elastic Leadership, Roy's framework for software team leaders (survival, learning and self-organizing modes). ### Social - X: https://x.com/royosherove - LinkedIn: https://www.linkedin.com/in/osherove/ ### Contact - Contact form: https://forms.gle/jQSx5KoXvrVA1JCK7 ### License Licensed under CC BY 4.0 — reuse, quote and adapt with attribution (Roy Osherove, link to the original page). License: https://creativecommons.org/licenses/by/4.0/