S07E05 - The Art of Teaching Programming using Unity: An Interview with Harrison Ferrone

Sponsors

Support for this episode of The Modern .NET Show comes from the following sponsors. Please take a moment to learn more about their products and services:

• Metalama, reduce your boilerplate code by up to 15% with Metalama’s C#-to-C# template engine and reduce your code complexity today!

Please also see the full sponsor message(s) in the episode transcription for more details of their products and services, and offers exclusive to listeners of The Modern .NET Show.

Thank you to the sponsors for supporting the show.

Embedded Player

The Modern .NET Show

S07E05 - The Art of Teaching Programming using Unity: An Interview with Harrison Ferrone

Supporting The Show

If this episode was interesting or useful to you, please consider supporting the show with one of the above options.

Episode Summary

In this episode, we welcome Harrison Ferrone back to the show after a gap of three years, marking the occasion with congratulations for his recent milestones. Harrison recounts his background, initially starting as an English major before discovering programming and making his way into game and iOS development. He explains how he transitioned into instructional authoring, creating programming courses and books that help make technology more accessible. He emphasizes his self-taught journey, aiming to assist others who may not have a formal education in computer science to avoid similar struggles.

The conversation shifts to the intrinsic value of quick wins in learning and how people who are self-taught often create educational content that resonates better with learners. Harrison and the host discuss the pitfalls of overly academic teaching methods that contain too many assumptions, which can alienate beginners. They highlight the importance of reducing scope and focusing on achievable goals to make learning engaging and motivating.

Harrison mentions his newly released book, “Learning Design Patterns with Unity,” which functions as both a primer and a reference guide on design patterns, specifically aimed at game development. He elaborates on the structure of the book, which includes multiple design patterns relevant to Unity and C#. Harrison explains that it is designed for learners at various levels and provides starter projects available on GitHub for hands-on practice.

The discussion delves into the relevance of understanding systems design and the interplay of various programming paradigms, emphasizing that the concepts presented in Harrison’s book are transferable across different object-oriented languages and frameworks. This discussion highlights the importance of having a solid foundation that allows readers to tackle problems creatively while using knowledge gained from the book in real-world scenarios.

Harrison categorizes design patterns according to established frameworks while also introducing unique interpretations tailored for game development. He reveals his intent to make complex concepts more approachable, avoiding dense theoretical jargon in favuor of practical examples and context that promote deeper understanding among readers.

Listeners are left with the details for accessing Harrison’s book, “Learning Design Patterns with Unity,” and ways to connect with him professionally. The two express mutual enthusiasm for future collaborations and further discussions about learning, unity, and game development.

Episode Transcription

Like the whole point is to learn a system of thinking, like to learn how to analyze; how to, like, pick out what’s happening and identify your problem, and then to implement a solution that fits your needs.

Welcome friends to The Modern .NET Show; the premier .NET podcast, focusing entirely on the knowledge, tools, and frameworks that all .NET developers should have in their toolbox. We are the go-to podcast for .NET developers worldwide, and I am your host: Jamie “GaProgMan” Taylor.

In this episode, Harrison Ferrone joined us to talk about his journey from being an English major to a self-taught programmer and instructional author focused on accessible tech education. Harrison also talks about his book, “ Learning Design Patterns with Unity,” which is designed as a practical guide for game development using well-known patterns while emphasizing the importance of quick wins in learning.

Like we do so much work in the later parts of each chapter with like pattern variations and customisations, because I want readers and students and learners to like, look at it, look at the first, you know, 70% and be like, "oh, but what, oh, oh, we’re going to talk about what ifs. Fantastic. Cause I have a lot of what ifs."

Anyway, without further ado, let’s sit back, open up a terminal, type in dotnet new podcast and we’ll dive into the core of Modern .NET.

Jamie : [0:00] So Harrison, welcome back to the show. It’s been like three years. My goodness.

Harrison : [0:04] I know. It’s been a while. It’s been a really long time. You were approaching another milestone for listeners in the podcast last time. I keep coming on at these odd milestones.

Jamie : [0:19] I mean, that’s totally fine with me. If you want to be on the show after a milestone, that’s cool.

Harrison : [0:25] Well I wanted to congratulate that’s that’s awesome you have so many listeners, and you’re you got the new MVP thing didn’t you did you get renewed?

Jamie : [0:33] Yeah thanks for that. Yeah so, we’re, for context for the listeners, we’re recording this August 8th 2024 only a few weeks ago I announced that we hit a million, over a million downloads. So thank you everyone one for that. And I’ve been renewed as a Microsoft MVP for the third time. So yeah getting closer and closer to that blue disc with five years on it.

Harrison : [0:57] You get, is it like working at Blizzard? Do you get like a different color sword every time you hit a milestone .

Jamie : [1:03] So no. As far as i’m aware you get these wonderful like frosted disc things with like a year that you’re made the MVP; and then when you get to five years you get like a blue one that says five years. And then when you get to 10, so it’s every multiple of five, you get one that says whatever your multiple of five is’ like 5 10 15 20 that kind of thing. Yeah it’s pretty cool pretty cool.

Harrison : [1:27] That’s awesome. Well congratulations.

Jamie : [1:28] Thank you very much. Thank you very much.

Jamie : [1:30] But yeah. So Harrison, for the folks who perhaps haven’t heard your previous appearance, which was is episode 87, whereas we’re thinking this is going to be episode 156, so you’re almost like double from last time.

Harrison : [1:45] Yeah, I’m almost we’re almost there.

Jamie : [1:46] Yeah, right. So for the folks who didn’t catch that episode, i’m wondering would you be able to, sort of, give everyone a bit of a like an elevator pitch about you and what you do that kind of thing?

Harrison : [1:56] Sure. I went, well I started out as an English major, I found programming kind of halfway through that a long, long time ago. Went into game development, went into iOS development.

Harrison : [2:13] Worked at that for a few years and then I kind of stumbled into a instructional author teaching kind of path. I can’t remember if it’s like WWDC for the Apple conference, the yearly Apple conference. I think it was in like 2014, I think. And someone at LinkedIn was very nice and was like, “if you’re going to be there, would you like to, you know, live blog? " I said, “sure.” And then I started making programming courses for LinkedIn and eventually started writing books for Unity and for doing tutorials for iOS and SwiftUI and Swift programming language in general. And now I’m pretty much all in on Unity and Swift for the past few years.

Harrison : [2:57] So there’s a broad spectrum, but I literally just make educational content and try and make people’s lives a little bit easier. Because, for the most part, even though I started programming in college I didn’t actually do very much computer science. So I was still am largely self-taught so I figured it would be it would be a logical connection to target that audience and help people out so they didn’t have to do what I did.

Jamie : [3:28] Oh man

Jamie : [3:31] .

Jamie : [3:31] So what I often find is: folks who didn’t go down that academic root of taking like a comp sci degree or a, you know, software engineering degree, or anything like that, when they come around to making that educational content, because they have a slightly different background to pull from. I often find that those folks are a little bit better at, sort of, creating that educational content, getting that idea across. Because it’s a case of, less a case of, “hey, here’s the math behind why it all works and here’s the theory behind it all,” and it’s more a case of, “right, let’s get you to the point where you’re making something and doing something immediately, " right?

Harrison : [4:10] Yeah.

Jamie : [4:11] Because I feel like when you’re teaching yourself, you have to get to that point very quick, don’t you? Because otherwise, you’re not going to get anywhere, right?

Harrison : [4:19] Oh, yeah. You have to get those quick wins early on. Like, our brains need that, you know, hit of dopamine that’s like, “ooh! We made something, you know, we created life. The program ran and printed out 10.” You know, you got to get there real quick.

Harrison : [4:35] Yeah, I find that too. You can tell a lot of times. And again, I kind of wish I had done, you know, a computer science degree because I’m, you know, I still struggle with like algorithms. Like data structures and algorithms are not my strong suit. I keep, you know, I keep plugging away, but like there are definite gaps in my self-taught journey, but you can sort of tell by the amount of assumptions that are in the learning content that you take. And you can usually pick out who’s been self-taught and who’s gone through academia because there’s a lot of assumptions with academic teaching. And there’s much, hopefully much less with people who are self-taught because they remember what it was like to try and figure this out on their own.

Jamie : [5:20] Absolutely agree agree on the little win,s and I agree on being able to identify perhaps sometimes those folks who are self-taught because of the way that they’re putting their content across always tell people like you know, i’ve got a friend who’s like, “i want to learn development, and I want to learn to develop a mobile app, and I want to learn game development, and I want to learn three different programming languages at once.” And i’m like, “whoa, whoa, whoa. That’s fantastic. You can have all of those goals if you like, but you want to make it as, what you want to do is, you want to make that learning journey as easy as possible. By reducing the scope, right?” You don’t want to be trapped in a situation where you’re like, “i don’t know whether it’s the language that i’ve maybe not learned this bit, or maybe it’s the tooling, or maybe it’s the process, or maybe…” you don’t want to be confused about what’s broken. I know that there’s a certain subset of people when they discover software development and computer science and stuff like that, they go, “oh my goodness. I’m going to install a Linux distribution even though my course details say you have to use Windows!” I’m like, “whoa, whoa, whoa. I get it, absolutely. Linux on the desktop is brilliant, in, but also if you get stuck, Your teachers, tutors, lecturers, whatever, whoever’s designed that course won’t be able to help you.”

Harrison : [6:48] Yeah, who’s going to help you?

Jamie : [6:50] Yeah, right?

Harrison : [6:51] Yeah, there’s nowhere to go to ask for help. Actually, the same thing happened in my C++ programming class. When I was first getting introduced, there was a guy that was so, like, he was whip smart at this. And you could just see his brain turning. And he got so far ahead that, like, he couldn’t get any help. It’s like, “well, okay. "

Harrison : [7:13] But like, you know, you figure it out, but you’re right. Like when you’re circling back to like curriculum development, you’re trying to take away as many variables as possible, and to teach as broadly and as, you know, like language or hardware agnostically as possible, I would say. Because if you learn, you know, like you said, your friend could, all those disciplines that he wants to learn and build. And, you know, all the projects he probably has in his head, you know, the bones are fairly similar if you start at the right place.

Jamie : [7:42] Yeah. I mean it’s it’s like you said, it’s to do with curriculum development, right. I have this background in teaching; I did like a out of uni I took a direction where I was learning to teach people, right. And just like you’re saying, right, you have to you can assume a certain amount of knowledge or assume a certain platform that you can bounce off of to be able to provide these metaphors, to be able to provide the information. But you also have to remember that some folks aren’t going to know a great deal. So you might have to sort of bring people up to speed as well. And that’s a real challenge when you’re making any kind of decision as to how are we both going to learn this or whatever?

Harrison : [8:31] Yeah, no, it is. And I mean, there’s a fairly simple answer. I mean, it makes it more complicated for the people making the resources. But like if you’re as inclusive as possible, which basically means you have the least amount of like entry, like barriers to entry or like obstacles that someone would need to understand or to have competencies in, you end up including everyone by default, which is wonderful. It makes it harder. Again, makes it harder for you as the teacher, but it includes everybody and it doesn’t it doesn’t leave anybody wondering anything.

Jamie : [9:02] Totally, totally. I remember back at uni—so I mean I graduated I often tell people, “i graduated in like the the triassic era.” But like I remember one of the first few lecturers, at one of the first few lectures sorry, at uni i’m you know making furious amounts of notes and someone turns to me and goes, “don’t you know this already? i’m like, “well thanks, dude. You just just put me off of coming to this class now. What are you doing?”

Harrison : [9:37] That would be so weird to have someone say that.

Harrison : [9:41] Like, I don’t even know how I would be able to take that. I’d be like, “no? Because if we did, we wouldn’t be here. I’m confused. "

Jamie : [9:52] It’s the weirdest flex ever.

Harrison : [9:53] Right? Did we miss something? Was this the class where you’re supposed to already have taken the class?

Jamie : [9:58] Yeah.

Harrison : [9:59] And, you know, we missed that.

Jamie : [10:02] Or are you not telling me that you failed it and having to take it again, right?

Harrison : [10:05] That’s a good point. “I see. You’re, what you’re really telling me is that you’ve already done all the homework because you didn’t pass the final last time. So we’re gonna be friends.”

Jamie : [10:15] Yeah, right.

Harrison : [10:16] But still a weird flex. Still weird.

Jamie : [10:21] It really is, it really is. Oh my goodness.

Jamie : [10:24] So that, I guess, leads us nicely onto this. You’re on the show, you had a book last time, you have a new book this time. Let’s talk about that.

Harrison : [10:32] Yes. So i’m trying to, I’m trying to work my way up into like a trilogy of like, you know, “zero to hero. " But like the last book, and there have been so many, there have been several editions, since then, but you know, the first book was very basic and like, “we’re going to teach you how to, you know, program in C#. But really we’re going to from scratch, but really we’re going to teach you how to think programmatically, and to think in systems. And to think about how to put things together in a way that, you know, makes sense and, you know is maintainable and flexible.” And we kind of introduce, you know, you go from like, “oh we’re going to write our name,” all the way up to like building a simple little like, Unreal Tournament kind of game if you know we’re dating, i’m dating myself with that reference. But whatever a little arena shooter. And it’s super fun.

Harrison : [11:19] And so I was , I get a lot of questions because the publisher that I work with, Packt, has a Discord server for the book. And I started to get a lot of questions about a year after I released, you know, like the sixth or seventh edition or whatever it was. And people were like, “well, you know, where do I go? Like, what do I do now?”

Harrison : [11:39] And I was like, “well, uh, that’s a good, good question. I don’t have a great answer for you.” You know, and I’d give people I had, I had a little like, resource cheat sheet of like, because like the last chapter in the book in the in the old book has like, “here’s next steps.” And I had some other ones too if people wanted to ask for them. And I started thinking like “what would have been useful to me in university? And in my, actually in my like in my first job, when I was um like a junior programmer and what would have helped me the most?” And it was really easy to come up with the answer, and it was like systems design. I was like, “okay. Well that’s not super helpful. Like what concrete tools would have helped me be better at my job faster?” I was like, “oh, design patterns. That’s easy. That’s an easy one.” Design patterns and testing. And I was like, “I don’t really want to write a testing book right now. " But maybe I will in the future. But design patterns kind of jumped out.

Harrison : [12:38] And they do all the things. Like, they take, like, the analytical soft skills that I was trying to teach in my first book. And kind of took them further. And took it out into, like, this, you know, kind of macro view of, you know, whatever you’re building. It could be an iOS application. It could be a game. it can be you know whatever it can be a website if you wanted but like how to think of, or how to think of projects in terms of like components and systems, and how to communicate effectively; how to reuse your code. How to i, don’t know, just be a more efficient programmer , and like be able to have enough I guess competency to like have someone else look at your code and be like, “oh I I see what you’re doing. I got it. Like we can, we’re talking and we can communicate.”

Harrison : [13:25] And so I started doing, writing this design patterns book and it took me, oh, two and a half years on and off. It’s a monster. It’s like, I don’t even know. It’s, I think it’s like 700 pages long. I think it’s heavy. It’s a good, it’s a good, uh, it’s a good books. It’s a good shelf. You know it’s a good bookend if you don’t read it it’s fantastic at that.

Jamie : [13:50] It just sits there flattening

Jamie : [13:54] your dollar bills with it right?

Harrison : [13:55] Yeah exactly. Or put your you know external laptop on there, your external screen, you know, if you need it a little bit higher; feel free. But yeah so that’s where that came about, and I was trying to like address all the questions of, “where do I go once i’m, kind of, once i’ve got a handle on a language, and I want to actually build something that works and that works well, not just like a prototype?”

Harrison : [14:22] And so that’s, that’s kind of where the design patterns came in. And I love Unity so much, even, you know, we don’t have to talk about all the craziness, but I still love unity and I still like it just because, I don’t know, maybe I’m too old to change, but I, it’s never, it’s never let, like, I’ve never wanted to jump ship. So I chose that and C# almost everything you know except for friend classes is available.

Harrison : [14:49] And I was looking through and I was like, “great there’s, you know, maybe one book in the world written in this, you know, kind of, market, and it seems like it’s missing.” And it’s funny while I was writing the book Unity started releasing these little like these PDF books And one of them is like, you know, “here’s five design patterns or something that, you know, are really, you know, helpful”. I was like, “aha, see, I see you. Someone has someone has someone has found the niche. They have found the gap.” And so I kind of had to speed up a little bit.

Harrison : [15:26] But I don’t know. I always felt like the like game design and development or game programming specifically always missed this. And like you had to learn it some mystical way, like through your job or through a mentor or that you know, if you were lucky enough to have one, that would teach you these you know secret arts. And yeah, soi set about, and like I don’t know this was I think this was the hardest thing i’ve done so far I gotta say.

Jamie : [15:54] Oh my goodness. So I guess um a couple of questions based off of that then just for the folks who…

Harrison : [16:01] Yeah sorry. I rambled on I got so excited.

Harrison : [16:03] No that’s cool No, it’s cool. It’s all good. So for the folks who are listening in, can you tell them what the name of the book is? Because we’ve sort of danced around it.

Harrison : [16:12] Yes. So it’s called “Learning Design Patterns with Unity.” Very simple title. You can get it on Amazon or from Packt. And we’re using Unity 2023 and C#. And yeah, it’s all updated. It all works for the current version that’s out right now. And let’s see we cover, I think there’s, I think we cover 19 patterns if Iremember correct. 18, sorry. 18 patterns and two bookend chapters so.

Harrison : [16:50] You know, like if anyone’s ever read, you know, there’s an original book called. ..

Jamie : [16:56] The Gang of Four.

Harrison : [16:58] Yeah, The Gang of Four. Yeah, and like elements of reusable software, object-oriented software. I can never remember the name because it’s so long. But yeah, The Gang of Four. And they have, you know, 20-something patterns. And then a guy named Robert Nystrom came out, I want to say like 10 years ago. And he wrote a really, really comprehensive book about additional patterns that are specific to game programming. But it’s in C++, and it’s really good, but it’s more on theory and example snippets. There aren’t any actual projects.

Harrison : [17:32] So in game programming, this is my journey, but I’ve confirmed this with loads of people. It’s like everyone tries to read these two books together. And, you know, somehow learn, you know, how to be a better software architect or a software engineer with games. And it’s really difficult because it doesn’t it’s hard to train. It’s like literally trying to translate like a different language. And, you know, some things don’t work. Some things aren’t directly applicable. Some things can’t be one to one translated. And Unity is a special case. One: because it’s, you know, built on the component design pattern; so it’s it’s already doing its own thing and you kind of have to learn how to, get everything working. You know, c- harp has its own way of working, Unity has its own way of working, and then they both work together in a third way. And this was all really, you know the research took took the longest time and the testing, because I wanted to make sure that the patterns I was teaching were, you know, you could actually like test it and be like, “oh, this is how it’s supposed to work.” You know, with a little tweak here, a little tweak there for the engine, um, that it would still be the correct content. And yeah, that’s, I hope that’s what we ended up with. I mean, we’ll see. It’s only been out for, you know, I think now it’s two months, but by the time this releases, it’ll be more than that, but it came out at the end of March, May, so basically June 1st.

Jamie : [19:09] Right.

Harrison : [19:10] Yeah.

Jamie : [19:12] What I really like, and we’ll actually, we’ll circle back to the thought I was just about to have. Let’s talk about the, you said there’s another design pattern of the book, and it’s very…

Harrison : [19:27] Oh, that’s right. Yeah, that’s right. Right.

Jamie : [19:33] It feels like it reads, I haven’t read it. So from your description, I’m inferring, right? It feels very much like it’s a, almost like a reference manual, right? “Oh, you, you’ve heard of this design pattern. Here’s a implementation, right?”

Harrison : [19:50] Yeah. Or like you, you definitely have to have to know about design patterns because the ones he kind of puts in there are new ones. They’re not in the gang. Most of them are not in the gang of four. Um, the game of vortex. So yeah, it’s definitely like a secondary, it’s almost like an appendix just for game programmers, but you know, it’s a, it’s a big book. And, but yeah, again, it’s in C++. And, you know, if you’re in Unreal, some of it will like a lot of a lot more of it will translate. But again, even if you’re in Unreal, and you’re in that development environment, it’s not going to take into account like blueprints or any of the other component components that you can use. So even if you’re doing that, it’s, you know, the book is really, it leaves a lot to, to you to the reader to kind of make the intuitive jumps into actual implementation. And that’s where I think a lot of people stumble and get frustrated.

Jamie : [20:46] Sure, sure. Because when you’re learning, like we said at the beginning, right, when you’re learning something new, you’ve got to make it as easy as possible to get to that quick win, right? And the entirety of your learning journey can be made up almost exclusively of quick wins.

Harrison : [21:01] And it should.

Jamie : [21:01] But the great thing about them is they stack.

Jamie : [21:04] Oh, absolutely.

Harrison : [21:05] Oh, yeah.

Jamie : [21:05] And they stack so quickly, and stack so well. Well, and that’s how we get to like the end of a course and you get the final exam, right? You’ve already done it a whole bunch of times. All you’re doing there is just proving that you, you can recreate that thing. Right.

Harrison : [21:23] Yeah, exactly

Jamie : [21:25] curriculum design, right. A good curriculum for learning anything, right. Learning to walk; learning maths; learning, you know, English literature; learning software development with whatever programming languages. It starts with, “let’s go with, " like you said, right? “We’ll start with writing your name on the screen. Now that you’ve written your name on the screen, maybe we can introduce variables and say, well, we can hard-code it to say Harrison, but maybe we can have a variable that you can change to Jamie and then rerun it. And then we can change it to, I don’t know, Michael and rerun it or change it to Sarah and rerun it.” And then that’s teaching a little bit about variables and stuff. That’s another quick win. Boom, boom, boom, boom. Because, like you said, you need that dopamine hit of, “wow, I’ve achieved something. I’ve achieved something,” as fast as you can.

Harrison : [22:12] I don’t know enough about neurochemistry, but I really feel like I get it stamped harder in my brain, like a new concept, if I get that little hit of like, “ooh, that worked. I feel good about that.” That’s why we play video games in the first place. But when you’re learning to program, it’s almost the same thing if you can make it like that. And like each chapter, so I wrote my book, I decided not to have one project through the whole book because one: it would have been very difficult to have one single project that was naturally or that naturally needed all the design patterns that I was teaching. Because that’s kind of the central point of the book is like they are not all applicable all the time right tool for the right job. So like, I couldn’t think I would have had to unnaturally, you know, inject problems into a single game that probably wouldn’t have made sense.

Harrison : [23:07] So unfortunately, my book, or maybe fortunately, it is more of a reference book, but you can pick up any chapter, you get a, you know, a white box starter project, and you get you have the little block set up. So you have a client and you have like an empty system and your job is to build the design pattern into a workable system from scratch. And like you said, each little, you know, each couple of pages, you get a quick win that you’re stacking, stacking, stacking until at the end you have a almost fully ready, like plug and play system to take where then do whatever you want. You know, it’s not, I don’t use any art assets or anything crazy. Cause that, I feel like that always clutters learning and especially with stuff that’s more intermediate or advanced. I feel like this stuff is already hard enough. Like you don’t need to be worrying about audio, like to teach this. It’s not, it’s not necessary. But yeah, stacking those wins is definitely the way I prefer to learn, which, you know, then makes it my preferred way to teach, I suppose.

Jamie : [24:14] Totally, yeah. And like, if someone’s listening to this and going, “no, I want to go from no code all the way to the end goal without having any quick wins in the middle,” that’s totally fine too, if that’s how you want to do it. But I agree with you, Harrison. I’m very much a quick win type of person, right? When I’m learning a new programming language or using a new library, I’m like, “right, okay, I hate the defaults, but show me how to get it running with the defaults, and then I’ll go change it.” Because once I’ve got it up and running, I’ve achieved something, right? Whereas I don’t want to be sitting there for hours and hours on end just churning out code in the hopes that eventually when I hit go…

Harrison : [24:52] When you hit run it’ll work.

Jamie : [24:54] Yeah, yeah, yeah.

Harrison : [24:56] Yeah, that was the hardest thing. Like I kept finding solutions that I would look at and be like, “all right. I mean, I understand what’s happening. But I don’t think I could realistically like backward engineer, explain this to someone, to a student, like to how you got here.” Like you, there, there are a lot of missing steps, a lot of insider information, a lot of, you know, hidden choices that you made. And that was, that was really hard.

Jamie : [25:27] There’s only so many times when you can wave your hands and go, “don’t worry about this bit just yet.”

Harrison : [25:31] Yeah right. Like, you know it happens occasionally when you have dependencies; but like almost all the time that’s that seems to be either a flaw in the understanding of the theory or the in the setup or the implementation. There are very few things, at least in what I’ve found with like systems design, where you can’t have a solitary like starting point, like almost from scratch.

Jamie : [25:58] That’s the crazy thing about, especially with systems design, right? One of the things that I never really understood at the time when I was at uni, one of the semester long courses we had to take was on, it wasn’t called systems design, but it was in systems design. And it was one of those, sort of, “we’ll almost ninja the knowledge into you.” And I didn’t I didn’t appreciate it at the time, and I didn’t get it at the time, but the the lecturer wasn’t even a software developer right? We we’re all learning comp sci and different software development flavors, I guess.

Harrison : [26:32] Yeah.

Jamie : [26:32] And he was like, “right then. Let me talk you through how I built the fuel injection system for this airplane.” And we’re like, “what? what’s that got to do with software?”

Harrison : [26:43] Okay.

Jamie : [26:43] Yeah. But what I didn’t realize at the time was that he was talking through, “right. We have a problem: we have to get the fuel from this end of the plane to that end of the plane. It can’t go too fast, it can’t go too slow, it has to be warmed up along the way can’t stop and it can’t freeze or drop in temperature. We have to maintain pressure, although the outside pressure of the plane is going to drop because we’re going up, and then it’s going to come back up because we’re coming down.” And, like at the time, none of it made… I ended up passing the exam, but I was like, “what has this got to do with software development? Because I just want to write code.” And then actually thinking back on it over the last maybe… jeez, I don’t want to say how long it is since I’ve graduated, but let’s put it this way. If someone was born the year that I graduated, they’d be more than an adult now.

Jamie : [27:32] But in the years since, the more and more I think about it, the more I’m going, “wait. He’s actually teaching design, but from outside of a software development space. " And what I’ve actually done over the last few years with my own sort of practice and my own learning is I’ve been looking outside of software for ways that other people are applying the same knowledge that we have within software development, right? So it’s come up a whole bunch of times on the show already, but one of the examples I give is you know the KonMari method for tidying up?

Harrison : [28:07] Sure , yeah. “If it doesn’t spark joy,” yeah that’s literally what… yeah you’re totally right. Yeah no premature optimization , no unnecessary things that you’ll never need. Oh that’s genius, I never thought of that. Yeah my wife and I read that book a couple years ago “oh this is great.”

Harrison : [28:31] Oh here’s another one I was just looking it up—if you heard my little clickety clacks folks, i’m so sorry I couldn’t remember the name—but it’s called Thinking in Systems by Donella Meadows, and it’s exactly what you’re talking about. Because , they’re, the book is written for what do you call it economics and like, societal structures and, not zoology, but what do we call that? Like ecosystems, that’s what it is. And like how ecosystems function. And it’s such a great, like, you know, it’s not a, it’s not a super big book, but man, that just opened my eyes so much to have her talk about like, “oh yeah, we introduced, you know, we, we introduced some wolves into the system and what happened.” And like with all the systems graphs and you’re like, “oh, all this. Like we could do this with software”

Jamie : [29:20] Mm-hmm. That chaos monkey, right.

Harrison : [29:22] Yeah. Yeah yeah, exactly. You’re like, oh you’re looking at all the connections and like the balances and counterbalances and the communication, like the the message of the stimuli being sent if that’s… If you go back far enough in software development it’s stimuli, not events, and you’re looking at it and you’re like, “oh I see we’re all doing the same job.”

Jamie : [29:44] Absolutely. Is it, “everything changes everything stays the same,” something like that?

Harrison : [29:49] Like yeah the more everything changes the more everything stays the same.

Jamie : [29:53] That’s it. That’s it.

Jamie : [29:56] But what I really like from the way you’ve described it is: using Unity as a teaching tool right. Because,

Harrison : [30:02] Oh yeah.

Jamie : [30:03] You know, we’ve both said it a couple of times those immediate quick wins, and how they stack up. i’m kind of obsessed at the minute with stacking things, and I don’t mean like piling things up in, you know, I recently read Atomic Habits, which talks about habit stacking.

Harrison : [30:21] Oh, yeah. Yeah, yeah.

Jamie : [30:23] I was at a talk a few days back at the time of recording where someone had said about skill stacking, which is the same kind of idea. You’re just taking skills from outside of your current interest and applying those into it. So this person was, as a teenager, they were into equestrian things. Um, and they got themselves a, a sports coach to help with that. And then they went in and worked in like the cereal industry and then worked in, uh, like the, the, uh, PR industry. Um, and then when they had a whole bunch of different industries and when they came to start their own business, they realized, hang on.

Jamie : [31:02] The stuff I did in the cereal industry is customer service. The stuff I did over in the PR industry is obviously PR, but it’s the interpersonal skills of being able to talk to people. The stuff I did in my sports stuff with my equestrian coach, that’s personal development. We can apply all of these to this one business idea. " I think that idea of taking the disparate ideas and skill stacking them is fantastic.

Jamie : [31:27] But that’s beside the point. Let’s get back to what I was actually saying. But like…

Harrison : [31:32] You’re obsessed with stacking things.

Jamie : [31:33] Absolutely. yeah What I really love about what you’re saying is: using the visual tool of Unity to take care of like most of the wiring up of creating a 3d environment, and creating that scene, and doing you know some of the difficult work, so that i, as a reader or I as a learner, can then apply the lesson you’re trying to teach me and make something happen right. I can push the button and then immediately, as long as it compiles and I haven’t done something silly, but then I can compare it to the code that’s in the book and go, “oh, right, I’ve missed a semicolon or whatever, right?” As soon as I hit go, as long as it runs, I literally have something that not only is displaying on screen, but I can interact with. I can grab a controller and actually interact with it, right?

Harrison : [32:18] Yeah, I mean, that’s one of the main reasons that I chose to teach C# with Unity for like super beginners. Exactly for that reason, because it’s so immediate. And it’s, like, I feel like I mean, you can be a visual learner and you can be, you know, what is it? Aural learner and, you know, you can have all different styles of learning. But I feel like when when most humans see things in motion, something clicks between like what you tried to create and then it starts to move or it starts to work. And if you see it, something happens like it just happens. And you’re like, “oh. Okay. That’s wonderful. Like, let’s give me some more of that. Like, I want more.”

Harrison : [33:03] And like that’s so that was my that was my approach to like the starter projects. Not all design patterns have super fun visuals behind them. Some of them do, and some of them can be applied to have those. But they’re not all applicable to having a character run around. Some of them are for inventory management. Some of them are for save systems that aren’t super flashy. But I still tried to make, especially with using the Unity editor tools and the components that you have accessible, to build out levels of abstraction that that lets you get your hands in it, like you said, that like make you be able to go and change things and to see it in action as you’re testing or something like that. Because that really does seem to bring systems alive. If it’s not, you know, if it’s not immediately apparent, it’s like, “ooh. Somebody did a really cool combo. " Like, you know, there are a few design patterns that do that. But that’s not the the prevailing use case, I would say.

Jamie : [34:06] Right, right. Okay yeah and that immediate feedback is, we keep talking about it right, the immediate feedback is incredibly important and especially if you’re just like reading through a physical book right. You’re working your way through a book you maybe got it open on your desk you’ve got your laptop open, and you know you’re leaning across it and you’re like, “i’m gonna type this thing in, and then i’m gonna hit go, and the book’s fun to read but I can’t say… Oh wait. Hand on. It’s happening ah, " right . That’s you can’t beat that, right. I get the feeling that…

Harrison : [34:38] No you really can’t.

Jamie : [34:39] It must be similar to like in maybe the film industry right. Because you can see as soon as you finish editing something , you don’t even have to edit the whole thing, as soon as you, well maybe now with visual tools you can see it as you’re editing right, but you’re seeing it happen in real time.

Harrison : [34:56] yeah.

Jamie : [34:56] And you can’t beat that, right. Because like when I started my programming adventures as a kid, it was with BASIC and we were on a like a green screen right. The screen was black with green text, and there was no visual anything no visual feedback. You would sit and type for hours, you’d hit go, and it wouldn’t work right and then you’d be like, “i don’t understand,” right but because it was…

Harrison : [35:19] “I got nothing.”

Jamie : [35:20] Yeah and because it was ephemeral, as soon as you hit go it would start interpreting it because it was BASIC. If it didn’t work or when you dropped out, that code listing didn’t exist anymore. You have to type it all back in again.

Harrison : [35:32] Oh, God.

Jamie : [35:33] Yeah, right.

Harrison : [35:33] See, that’s the thing. It’s almost like it’s like the mental equivalent of like doing martial arts or sports or something. You get that, like, agency where it’s not physical. It’s like, “ooh. Something came out of my brain and made something happen.” Instead of like, “oh my hand, you know, put the ball through the hoop.”

Jamie : [35:52] yeah.

Harrison : [35:53] But there’s still something very visceral about that and, like, there’s… this was one of the harder challenges to balance was like who was I writing the book for? Because at at some point skill level incompetency comes into the equation when you’re trying to like get those moments to people, to like the right people that you’re trying to get them to, right? And it was a weird balance between like, “well, i’m going to write this for people that know a little bit, like that know enough of know enough C# to hurt themselves, and you know a little bit of Unity, and that’s about all you need.” Like you could even start this just from a purely like, “i don’t know anything about this but I want to understand how systems work,” because, like, we’re not starting… like, everything is provided you know, there’s no hidden steps.

Jamie : [36:47] Right.

Harrison : [36:47] So I mean that wouldn’t be the ideal target like that but you could totally do that. But I wrote it mostly for people that are coming from C# or some kind of object-oriented language. And Unity is kind of like the visual, I don’t know, the sugar, the flavour for what we’re doing. Because most of the code in the book, I’d say even probably above 90% could be taken to any other C# application in like .NET if you were working with object-oriented systems.

Jamie : [37:25] Yeah, I think that’s an important lesson for folks to learn, especially if they’re in the early part of their journey: is that you can take the knowledge, right? Like I could possibly teach someone, say, a builder pattern, right? But depending on where they are in their personal journey of, “how I’m learning about the way I learn,” they may go, “cool, I will learn this, and be able to repeat that code exactly as it is.” And that’s fine. But the problem is that it’s not always going to fit the actual problem you’re trying to solve.

Harrison : [38:01] Yep.

Jamie : [38:01] That may not be the class name or whatever, right? But having a visual tool that you can actually run it and then go, “oh, cool. Yeah, so I know enough C#. Why don’t I, " and I’m not saying this is in the book. I’m not going to ask you if this is in the book. “Why don’t I try and recreate this pattern somewhere else in something completely different, right? " Because that’s the key. That’s the key thing, right?

Harrison : [38:22] Yeah, exactly. No, that’s, I spend so much time drilling that in the book. It’s like, I like the whole point is to learn a system of thinking, like to learn how to analyze how to, like, pick out what’s happening and identify your problem, and then to implement a solution that fits your needs, like the reader’s needs, not your needs. Like we do so much work in the later parts of each chapter with like pattern variations and customisations, because I want readers and students and learners to like, look at it, look at the first, you know, 70% and be like, “oh, but what, oh, oh, we’re going to talk about what ifs. Fantastic. Cause I have a lot of what ifs.” Like the what ifs are what I feel like that’s where the real skill or the real tool is learned, that you can take into anything else you’re going to do with software engineering.

Jamie : [39:19] Right, right.

Jamie : [39:20] So you talked about how there’s, I think you said around, I may be misremembering because we’ve talked about a lot of stuff so far. So I apologize, everyone who’s listening, but I think you said something around 20? No…

Harrison : [39:32] And yeah, there’s like 18 more or less evenly split between the three. And then that’s only about 60% because there’s 34, I think, with the Gang of Four and the Game Programming Pattern book combined.

Jamie : [39:51] Right, right. And I think that’s an important lesson for anyone who’s learning anything, right? There’s a quote that I use in any of the talks that I do. And it’s Yamaoka Tesshū and he says what is itDo not think that this is all there is, wonderful teachings exist, the sword is unfathomable," right. Just because you’re learning this small part of something doesn’t mean that that’s all there is to learn. And that isn’t meant to put anyone off, it’s meant to say, “hey, these are some of the things you might need. But also you can then use the knowledge you’ve learned learning these things to help you learn those other things faster.”

Harrison : [40:26] Right. I think that’s actually more of a positive, like, “ooh, let’s get up and go.” Because if you can’t ever learn everything, then the simple act of trying you’re like you win, you win by continuing to try. And I like that. I like that there’s no like gatekeeping with that. Like, “learn it this way or you fail.”

Jamie : [40:49] Oh, I hate that.

Harrison : [40:50] Yeah, I’m like, “no, no. " I mean, if I could take up an extra page every chapter, I’d be like, “and this is not the only way to do it. All of this could be, you could been the entire thing and start over from something else. And it would still, if it addresses the problem with similar or the same results, wonderful. You did it. Congratulations. Like you don’t have to use exactly what we do in in the book.”

Jamie : [41:22] Absolutely, absolutely

Jamie : [41:24] So let’s let’s not worry about which design patterns are in the book, but I like the idea there’s the three different types of design patterns. So can you talk real quick about the different , I guess some of the different types of design patterns that you’ve chosen-

Harrison : [41:38] Sure.

Jamie : [41:38] And then how you’ve categorized them? Like are they categorized based on like how other the people categorize them or is this the-

Harrison : [41:46] Yes.

Jamie : [41:46] This is the “Harrison” way of categorizing them?

Harrison : [41:49] That’s fair. They are categorized, the main ones are categorized according to the gang of four because it’s it’s a very good metric, they have a very good idea of what goes where. And the additional game programming ones, some of them were categorized some of them were not, some of them were in different new categories; I put them where I thought they would best fit. So you know, for example, like creational deals with problems arising from object creation and how to do that more efficiently in a variety of scenarios. Behavioural is how to have usually, you know, how to achieve different behaviors without having crazy unmaintainable code in different situations and structural. Again, you can think about this, it’s the bones of the, or these design patterns are more like the bones of certain systems that make communication, usually communication, but sometimes behavior and data sharing work more efficiently.

Harrison : [42:51] And there are a couple, like the ones from the game program patterns that weren’t, that were in, you know, new ones. So for instance, like object pooling, you could call that an optimization pattern. But it is, you know, it’s also a creational pattern. You’re dealing with lots of objects being created in your memory and how to manage them effectively. So things like that, I don’t quibble about that minute kind of theory because that doesn’t help anyone learn the skill. But I put things where I thought they would be most understandable. But for the most part it’s, the theory behind everything is still back to the gang of four because it’s, I mean i’m not trying to beat that or rewrite that like it’s very usable, and it’s very you know it’s very well researched, and it’s lasted so long, and it’s helped so many people make better software. But on the flip side it is really dry it’s really dense it’s very hard to, like it takes multiple rereads and like, oh again like, if you’re lucky enough to have a mentor like you take it to them and be like, “yeah, I don’t understand what’s happening.” And if you don’t have those things, you know, a book like that can seem like it’s not accessible.

Jamie : [44:13] Yeah.

Harrison : [44:14] And that really, like, got me. Like, I don’t want that to happen. Like, this stuff is really useful.

Jamie : [44:20] Yeah, yeah, sure. A couple of thoughts on that then. So first one, I guess, if, from my perspective, and I haven’t read the book, folks. I’ve not read it, but it is on my list. If your design patterns are organized similarly to the ones in, say, the gang of four then if folks graduate from your book to the gang of four they’re gonna go, “oh wait. I remember this one because Harrison told me this one,” and then they’re gonna see-"

Harrison : [44:46] Oh absolutely

Jamie : [44:47] A different way of of implementing it; but it’ll also be categorized the same way right. So it’s like everybody wins.

Harrison : [44:54] Yeah exactly. Like and the the tools are the same, the underlying material is all the same. It’s just the veneer that’s a little bit different; you know the nails are different, the hammer’s not different, nails are a little different, the wood’s a little different but yeah like that’s a good point, I would encourage people to like start with something like mine and then graduate like you said, and like go read gang four, and go read game programming patterns; because they will, it’ll fill in more of those “what if” gaps on a more advanced level, and you won’t be starting from scratch. Like I feel like those books missed, like there was a primer missing, and I tried to write the primer for that.

Jamie : [45:40] Yep, yep. I remember when I tried to read… the first time I tried to read gang of four it was very early in my career, and hadn’t really gotten the idea of design patterns. And so I’m reading this book thinking, “it’s not even in a programming language that I use. How am I supposed to learn this?”

Harrison : [45:59] Yeah. I mean, that is one of the fundamental things that is difficult with learning this level of skill. Because I don’t think, like, systems design is easy by any means. But it is a core competency that people should have early on. So it’s a weird, you know, it’s a weird double think. Like, oh, it’s really hard, but I should learn it early when I may not be able to fully grasp it. It I still I still maintain that you should do that because you’ll be farther ahead either way uh but yeah like you know I can kind of yeah I can read c c plus plus I can understand what’s happening but even for me it was it was difficult and like the the lack of um complete projects where you could reach out and touch them and like try and figure like try and break it apart and put it back together, you know, like a, like an old watch, like, Oh, I want to see how it works. Not that it works, but how, and can I replicate it? Because that’s how, you know, we’ve talked about that a bunch. That’s how we learn.

Jamie : [47:06] Yeah, exactly, right? Like, looking at the page and it showing me a factory pattern written in whatever language I don’t use isn’t as useful as, “here is a factory pattern in the language that you use, so you can implement it yourself and then tear it to pieces,” like you said, and figure out how it works and change something and see if that works. And then understand why that pattern exists and what problems it can help to solve. And then I guess if folks are reading your book and they can recognize the patterns and recognize how these patterns are built up, then if they do graduate up to the Gang of Four, they can look at your implementation of, say, I’m going to use factory pattern again because I just said it. They can look at your factory pattern implementation. implementation they can look at the gang of four factory pattern and go, “oh I see how these languages map to each other. So when I look at the options pattern or the visitor pattern… wait I get this now. so that, so you know line one in Harrison’s pattern mapped to line four on the original whatever and then I can then start to make inferences about how the languages are working and maybe I can take a whack at re-implementing one of the gang of four patterns in my chosen language, C# whatever Because I have a little bit of background knowledge.” It’s like how you how people translated old texts.

Harrison : [48:35] I was gonna say it’s like a Rosetta Stone for going back to this. Yeah 100%. And like that’s why I chose the patterns I did to include. Because the ones, for the most part, the ones that I left out are familiar enough once you get through the ones that I’ve been teaching that you can jump in and be like, “oh, I see what we’re doing. This is this pattern, but with a little bit of a twist.” And like that’s kind of the reasoning for like what didn’t make the cut, you know, in this in this volume.

Jamie : [49:06] Yeah. Nice.

Jamie : [49:09] Okay. So I guess, um, just before we drop off then, I think you answered this one earlier, but I’m going to ask it again anyway. So this can be read by someone who is like early in their career, they know a little bit about C#, a little bit about Unity, or maybe just some about one or the other, as long as they’re-

Harrison : [49:30] Yeah.

Jamie : [49:30] Willing to hit like road bumps along the way.

Harrison : [49:33] Yeah, yeah. Absolutely, like, everything starts very basic. You really, you don’t need very much specialized C# knowledge the few places that you do I either explain what you need to know or show you where to get ito really like, you know a few months in of playing around with you know of really getting to know C# you don’t have to be you know much more than a beginner intermediate level you’ll still get something out of the book. Likewise, if you’re more heavily on the Unity UI side of things, you’ve been doing everything in the editor, totally fine you’ll still be okay. And if you’re straight up just C# and you’ve never used Unity like all you really need is to watch one of you know Unity Learns—which is their learning platform—you really just need to watch like their quick video on like “how to use the editor.” Because everything else, you know like, if you learn how to use the editor, and sort of conceptually understand what scriptable objects are that’s it. Like everything else i, you know, we build up block-by-block. And everything all the starter projects are on on github so you can just you download the whole thing you start each you start each chapter with a new project with a new problem.

Harrison : [50:53] I mean, every chapter, the problem is framed as like, “how would you implement, you know, such and such game mechanic?” But really, it’s, “how would you solve this problem? If you were told, you know, as a junior developer, hey, I need this new feature implemented.” And then you think to yourself, “okay. Well, what do I do? Where do I start?” So that’s how every that’s how every chapter starts is like this, you know, kind of made up feature task from you know your dev lead or something, “here go do this,” and then we start.

Jamie : [51:26] Right, right. And I guess, and this is me just extrapolating and guessing something right ne of the things, because you said earlier on about, you know, “i chose Unity; i’m happy with Unity . This is one that I really like, let’s not talk about the weird licensing stuff that happened, because if you’re reading this book you’re probably not going to be publishing a game at the end of it. You’re reading this one to learn right.” So-

Harrison : [51:48] yeah

Jamie : [51:49] But you’re learning how to use the tools, you’re learning how to use the language, you’re learning how to produce some stuff. And I feel because i’ve played around with Unity, i’ve played around with godot—or godot, or however you’re supposed to pronounce it-

Harrison : [52:00] Yeah. I say godot . But I don’t…

Jamie : [52:03] .

Jamie : [52:06] And then, like, I’ve played around with a few of the others, the free versions of a few of the others.

Harrison : [52:11] Sure.

Jamie : [52:11] But I’ll tell you something, right? As someone who knows nothing about these things, they all look and behave quite similarly. So if you’re happy with using Unity, you know, you’re going to be, you’re already two steps ahead of someone who hasn’t used Unity a nd then some. Because you’ll be able to perhaps transfer this knowledge over to Godot, Godot, however we’re pronouncing it. Maybe even Unreal if you can get a license for that or whatever right. I t’s not like these tools are all designed differently, they’re kind of all they’re all-

Harrison : [52:42] Yeah. They’re all, yeah exactly. And the learning curve for each one to get to the stage you need to start learning this material is very small, like it’s not very steep at all. And even the learning is kind of a system in itself, it’s like abstracted right. Like you can what we really want to to teach is how to think like an object oriented, you know, engineer. And then we go, “oh, well, how do we do that in this specific language? Ooh, how do we do this in 3d? Ooh, how do we do this in Unity components?” But, you know, the top level is really the most important one is like, “how do I learn these analytical skills to be a better engineer?”

Harrison : [53:23] Again, the one caveat is that this is all object oriented. So take that for, take that in to keep that in mind. But, you know, you know 85-90% of these skills are directly transferable to any other object-oriented framework, or a problem I guess would be the better word, like a problem area that you’re trying to solve. And that’s the big that like I focus on when i’m trying to teach: I don’t want you to get pigeonholed into you know some crazy, dogmatic version or viewpoint about you know, what you’re learning. And then, you know, you’re so narrow and you’re so inflexible that you can never grow.

Harrison : [54:04] It’s a hard line to walk, but, you know, anyone can pick this book up after, you know, a few, you know, two or three months of C# programming or Unity just bopping around their tutorials or whatever, as long as you are curious about how systems work. I mean, that’s the main thing, isn’t it? If you’re curious or not.

Jamie : [54:27] Cool. Okay. So let’s say someone’s listening along and thinking, “wait. I didn’t write down the name of the book.” Give me the name of the book again.

Harrison : [54:35] All right. So it’s Learning Design Patterns with Unity. It’s the only one on anywhere. You can get it from Amazon or Pact. One or the other is honestly usually having a sale at some time. So grab it. We do, like I said at the beginning, we do have Discord servers for all our Unity content, which is great. So PACT has actually a pretty solid offering for Unity. So all the authors are on the servers. You can ask any question to any of the authors or any of the mods about whatever book you’re following along with. And you know it’s kind of just a nice place to post ongoing work and where you go from there and kind of just share I mean it’s discord so it’s it’s community driven uh but i’m on there most every day and you get the you get the server invite from uh the you know the ebook or the print copy or both whichever whichever way you grab it so definitely don’t leave out like don’t leave about that step because that especially with this kind of content it’s important to talk about it to like have your stuff almost you know peer reviewed in a nice way to make sure that it’s it’s getting through and.

Jamie : [55:50] And you also have a server full of people who are likely could be mentors as well right. “Oh I need some help with this i’m a bit stuck.” “oh well let’s jump on a session and we’ll work on it together, we’ll pair program or whatever.”

Harrison : [56:03] Right. It’s, I mean, the community aspect kind of surprised me, because you know a lot of the times now, you know because it’s years and years later, a lot of the times if because of time difference you know i’ll be asleep, and by the time I get up and look at a prop… you know look at someone’s question or a problem somebody else will have jumped in like some other learner, and been like, “oh I ran into this,” you know this is how everyone’s… it’s they’re like solving each other’s problems, which is wonderful like everyone’s kind of learning learning by doing.

Jamie : [56:32] Yeah. That’s interesting, because that’s almost the exact same feeling that fellow author of yours Mark J Price had said, that-

Harrison : [56:43] yeah yeah.

Harrison : [56:44] Helping out, but other people will jump in and help out as well.

Harrison : [56:48] Yeah it seems to be like that there’s you know after a certain number of people join and are involved you get to this line where just explodes. Like there’s so many eyes on it that somebody will help, which is great. Yeah oh man, Mark just released his is awesome Tools and Services or tools and tricks right for C#? His books are great.

Harrison : [57:12] They really are.

Harrison : [57:14] Right.

Jamie : [57:16] Amazing.

Jamie : [57:16] Okay, so someone’s listening in. They’re like, “this is amazing. I’ve got a question for Harrison. " Is there a way for folks to get in touch?

Harrison : [57:24] Yeah, I’m always on LinkedIn. I’m the only Harrison Ferronr, F-E-R-R-O-N-E. You can inbox me or DM me or whatever it’s called on LinkedIn anytime. That’s the main way or through Discord. Those are my only two social media hooks that I have.

Jamie : [57:43] Right right. Yeah I totally get that went through a period during the time when everyone was sent home, shall we say. I don’t like to talk about that during

Harrison : [57:59] “The dark time.”

Jamie : [57:59] That’s it right actually went through all of my socials and was like, “am I actually using this? Do I have the time? Even though i’ve got nothing to do with it at this moment in time, do I even have the time that is required to keep this up?” And going, “no I don’t It’s gone

Harrison : [58:16] And gone. No I probably have it I have a twitter and insta somewhere for programming. But I honestly couldn’t tell you what they are. I focus on Discord and through LinkedIn it keeps it easy, keeps everyone in one place and i’m much more likely to see any of your wonderful questions.

Jamie : [58:34] Absolutely. Okay, cool. Well Harrison, it’s been a wonderful conversation with you. I absolutely love these conversations and

Harrison : [58:43] Oh thanks so much for having me on again.

Jamie : [58:45] Hey no worries You know, you’re always welcome on the show, just get in touch and we can talk more Unity, we can talk education, we can talk development, we can talk whatever you want.

Harrison : [58:55] Oh man that would be a fun one. Because I feel like Unity’s taking kind of a hit, so but it’s such a, they’ve really put… I mean this isn’t just recently but, like they’ve always put a lot of their backing into their educational content and I like that. Like maybe that’s why I keep using them, because I always see them trying to make that better, and like useful for not who they think their audience is but for their actual audience.

Jamie : [59:21] Yeah.

Harrison : [59:22] I think that’s an important distinction . So, oh man, I could talk Unity and curriculum development all day do something.

Jamie : [59:28] Absolutely. Maybe you, me, and Mark can do an episode huh?

Harrison : [59:32] Oh that’d be awesome because his books are very like mine, just like with, like his are so nitty-gritty like with like comp, like, each little piece is so important to learn. And like I think that’s that’s wonderful but like his books are massive you know and he’s got so many. So, oh, yeah i’d love that that’d be that’d be good fun

Jamie : [59:54] Well there you go we’ve said it now and it’s on an episode so maybe it’s gonna happen.

Harrison : [1:00:01] Mark, i’m sorry. I didn’t, i’m sorry I didn’t message you before this. I should have.

Jamie : [1:00:08] Well look right, for the listeners who’ve gotten this far: we talked about it just before we hit record let’s just freeform jazz this, and we freeform jazzed it-

Harrison : [1:00:16] Yeah.

Jamie : [1:00:16] And we’ve come out with, we’ve got a trio for the next one.

Harrison : [1:00:20] Oh, that’ll be good. All right.

Harrison : [1:00:22] Amazing.

Harrison : [1:00:23] That sounds like a plan.

Jamie : [1:00:24] Yeah, yeah. Well, thank you ever so much, Harrison. I’ve really enjoyed this recording, this episode.

Harrison : [1:00:30] Oh, me too.

Jamie : [1:00:31] Amazing.

Wrapping Up

Thank you for listening to this episode of The Modern .NET Show with me, Jamie Taylor. I’d like to thank this episode’s guest for graciously sharing their time, expertise, and knowledge.

Be sure to check out the show notes for a bunch of links to some of the stuff that we covered, and full transcription of the interview. The show notes, as always, can be found at the podcast's website, and there will be a link directly to them in your podcatcher.

And don’t forget to spread the word, leave a rating or review on your podcatcher of choice—head over to dotnetcore.show/review for ways to do that—reach out via our contact page, or join our discord server at dotnetcore.show/discord—all of which are linked in the show notes.

But above all, I hope you have a fantastic rest of your day, and I hope that I’ll see you again, next time for more .NET goodness.

I will see you again real soon. See you later folks.

Useful Links

• Learning Design Patterns with Unity
• Design Patterns (AKA “The Gang of Four”)
• Game Programming Patterns by Robert Nystrom
• KonMari method
• Thinking in Systems by Donella Meadows
• Chaos Monkey
• Atomic Habits by James Clear
• Rosetta Stone
• Unity Learn
• Explore the Unity Editor - Unity Learn
• GitHub repo for the book
• Harrison on LinkedIn
• Supporting the show:
  • Leave a rating or review
  • Buy the show a coffee
  • Become a patron
• Getting in touch:
  • via the contact page
  • joining the Discord
• Music created by Mono Memory Music, licensed to RJJ Software for use in The Modern .NET Show