All Things Unity

Hi there my fellow gamedevs and welcome to the 16th episode of the All Things Unity Podcast. In this episode we will check out chapter 4 of The Pragmatic Programmer called Pragmatic Paranoia. We dive into numerous interesting topics like the concept of designing by contract, assertive programming, when to use exceptions and balancing your resources.   Leave me a review or send me some comments if you like. You can also contact me at podcast@allthingsunity.com.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome to the 15th episode of the All Things Unity Podcast. In this episode we will continue where we left of last time, and that’s right in the middle of chapter three. We just started talking about debugging and the best is yet to come. In this episode we will also discuss the remaining sections of this chapter. These are Text Manipulation and Code Generators.   In this episode I mention;   My shameless plug to a little library I wrote called SjwagMeister. It’s in early development and far from perfect but it shows the basics. I see some potential in this tool to become one of my basic tools in Unity3D. You can learn more about it here: https://hamersoft.com/project/sjwagmeister/   I hope you enjoyed chapter 3 of The Pragmatic Programmer. Next time we will continue with chapter 4.   Leave me a review or send me some comments if you like. You can also contact me at podcast@allthingsunity.com.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome to the 14th episode of the All Things Unity Podcast. This time we are going to check out chapter three of The Pragmatic Programmer written by Andrew Hunt and David Thomas. Chapter three is all about the “Basic” tools. We are going to dive into the power of plain text as this is what really drives our industry. Furthermore, we discuss why learning a console interface is a good idea and why it is really important to invent time in really making an IDE your home. You need to know the hotkeys in your tools to really be productive.   Of course our tooling is not complete without source code control. David and Andrew spent some time talking about this too. And last, we will start with the section about debugging. So there’s a lot to cover in here :D.   In this episode I mention numerous things;   The “Git from the Bottom Up” blog I mentioned. Its truly a fascinating read if you are interested in knowing more. It’s also written in a friendly understandable way. https://jwiegley.github.io/git-from-the-bottom-up/   Next I mention a talk by Dylan Beattie about plain text. https://www.youtube.com/watch?v=gd5uJ7Nlvvo ( It think in the podcast I mention Ian Cooper, whoops)   I also mention the Continuous Delivery book by Dave Farley: https://www.amazon.nl/Continuous-Delivery-Reliable-Deployment-Automation/dp/0321601912   I hope you enjoyed the first part of chapter 3 of The Pragmatic Programmer. Next time we will continue where we left off.   Leave me a review or send me some comments if you like. You can also contact me at podcast@allthingsunity.com.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome to the 13th episode of the All Things Unity Podcast. We are going to continue our deep dive into The Pragmatic Programmer by Andrew Hunt and David Thomas. Last time we covered up to the first half of chapter 2 and today we are going to discuss the remainder of the chapter. We will cover the topics of Reversibility, Tracer Bullets, Domain Languages and Estimation. Really interesting stuff!   In this episode I mention numerous things;   First of all I mentioned this meta-programming language called Rascal. You can check it out here: https://www.rascal-mpl.org/. I also mention how we used certain code visualizations like CodeCity https://wettel.github.io/codecity.html.   While talking about DOTS and ECS I also mentioned this video on YouTube. You can check that one out here: https://www.youtube.com/watch?v=H7zAORa3Ux0.   And at the very end of the episode I mentioned Uncle Bob’s PERT (it’s not really his) technique for estimation. More information about PERT can be found here: https://projectmanagementacademy.net/resources/blog/a-three-point-estimating-technique-pert/   Or you can check out Uncle Bob’s talk: https://www.youtube.com/watch?v=eisuQefYw_o   I hope you enjoyed chapter 2 of The Pragmatic Programmer. Next time we will continue with chapter 3.   Leave me a review or send me some comments if you like. You can also contact me at podcast@allthingsunity.com.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome to the 12th episode of the All Things Unity Podcast. We are going to continue our discussion about The Pragmatic Programmer. We are discussing this as an alternative to Clean Code and A Philosophy of Software Design.   Today we will continue with chapter 2, A pragmatic approach. And in this episode I mention Dave Farley’s book, Modern Software Engineering, again which you can check out here: https://www.amazon.com/Modern-Software-Engineering-Discipline-Development/dp/0137314914   In the next episode we will continue with chapter 2 and check out the later sections of this chapter.   I hope you enjoyed this episode and learned something.   Leave me a review or send me some comments if you like. You can also contact me at podcast@allthingsunity.com.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome to the 11th episode of the All Things Unity Podcast. This time we are going to start with a new very interesting book; The Pragmatic Programmer by Andrew Hunt and David Thomas. This is one of my favorite books about software of all time and will definitely have a positive impact on you as a game developer.   In this episode I mention a couple of things;   First of all, I mention a book I’m currently reading called “Modern Software Engineering” by David Farley. You can find a link here: https://www.amazon.com/Modern-Software-Engineering-Discipline-Development/dp/0137314914 and the other book I mention, “Moonshots” by Naveen Jain: https://www.amazon.com/Moonshots-Creating-Abundance-Naveen-Jain/dp/099973640X.   I also mention I wrote a bunch of blogs about a course on Enterprise Architecture (EA) I did past year. You can read them here if you are interested: https://hamersoft.com/?s=enterprise+architecture   I hope you enjoyed this episode and learned something.   Leave me a review or send me some comments if you like. You can also contact me at podcast@allthingsunity.com.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome to the 10th episode of the All Things Unity Podcast. It’s been a while but we’re finally back. I’ve been far to busy lately but I finally got around to record this episode. In this episode we are going to end our discussion about a book called A Philosophy of Software Design by John R. Ousterhout. It’s a rather lengthy episode but I really wanted to wrap things up for this deepdive.   In this talk I mention Ivar Jacobson’s book again; Object-Oriented Software Engineering, A Use Case Driven Approach. I also quickly mentioned I wrote some blogs about this book which you can read here.   We were also discussing the state of SCRUM and it’s technical practices. I promised you to add a link to my blogs about SCRUM in the shownotes so here and here you go. Plus a link to Uncle Bob’s Clean Agile book.   Next I also mention Ian Cooper’s talk about TDD again, you can check that out here.   Last, I mentioned this class called the FastClassGenerator I first found in a course on Udemy. The course is this one: C# Performance Tricks: How To Radically Speed Up Your Code.   I hope you enjoyed this episode and all the previous ones about A Philosophy of Software Design by John R. Ousterhout. I’ve had a really great time explaining all of this so I hope you did as well, and learned something useful.   For the next episodes I’ll be doing another series of episodes about The Pragmatic Programmer by Andy Hunt and Dave Thomas. Plus I’m going to start and put some effort into getting guests on the show so you don’t have to listen to my voice only.   Make sure you join me with the next episodes as well and don’t forget to rate this podcast or leave me a review or send me some comments. You can also contact me at podcast@allthingsunity.com.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcombe back for another episode of the All Things Unity Podcast. Today we are going to continue our deep dive of the book A Philosophy of Software Design by John. R. Ousterhout. This episode will cover chapter 15, 16 and 17. Chapter 15 is about what I would call Comment Driven Development. I this chapter Prof. Ousterhout talks about the benefits of writing comments before you write the code. This is an interesting practice since it overlaps with some of the benefits of TDD, which I really like.   Chapter 16 is all about modifying existing code. In this chapter Prof. Ousterhout will discuss how to keep your comments in sync with the code, yet not so much about what strategies to take to actually change the code. He just says you need to do it with a strategic mind, but we’ll talk about it in this episode. But luckily we already have a lot of skills in our tool belt which we learned from Uncle Bob's Clean Code, so we can combine the two and make use these skills to modify existing code.   And the last chapter we will cover in the episode is chapter 17 which is all about consistency. This chapter contains a lot of really valuable information. Prof. Ousterhout talks about the value of consistency and provides us with some tips on how to keep things consistent.   If you have any comments or feedback, please let me know at podcast@allthingsunity.com or you can leave me a review on your favorite podcasting platform.   Thank you for listening, and remember; With Unity we can do great things!

Hi there my fellow gamedevs and I’m pleased you join me on the 8th episode of the All Things Unity Podcast. In this episode we are going to continue our discussion on chapter 13 about a book called A Philosophy of Software Design by John R. Ousterhout. We are looking into this book because we are exploring alternatives to the practices and advise given in a book called Clean Code by Robert C. Martin aka. Uncle Bob.   In this episode we are going to continue right where we left off last time. We were talking about the types of comments Prof. Ousterhout thinks are useful and should be added to the code where possible. There are some really interesting contracts to Clean Code in this chapter so sit back and enjoy.   We will also take a look at chapter 14, which is all about naming things like fields, properties, variables, functions, arguments to these functions, return values and classes or interfaces. This is a subject where Prof. Ousterhout and Uncle Bob are pretty much on the same line. There’s still a lot really nice information in chapter since Prof. Ousterhout gives you some really nice high level or philosophical information, where Uncle Bob gives you lot’s of practical information.   I hope you enjoy this episode and make sure you join me on the next one as well. In the next episode we will continue our journey through the Philosophy of Software Design.   Please leave me a review on your favorite podcast platform or send me some feedback. You can also contact me at podcast@allthingsunity.com.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome to the 7th episode of the All Things Unity Podcast. In this episode we are going to continue our discussion about a book called A Philosophy of Software Design by John R. Ousterhout.   In this episode I mention a talk he gave, which you can check out here.   I hope you enjoyed this episode and make sure you join me on the next one as well as we will be continuing the ongoing discussion about comments. We just started chapter 13 in this episode and we will continue from there on.   Please leave me a review or send me some comments. You can also contact me at podcast@allthingsunity.com.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome to yet another episode of the All Things Unity Podcast. Today we are going to continue our discussion about A philosophy of Software Design. This is part of a series about clean code and currently we are exploring some of the alternatives to clean code by Uncle bob.   In the previous episode we covered the first five chapters of the book, and today we will continue with another five.   In the episode I mention a book called “The Structure and Interpretation of Computer Programs” which you can get for free here: https://mitpress.mit.edu/sites/default/files/sicp/index.html   I hope you enjoyed this episode and join me on the next one where we will continue our discussion about A Philosophy of Software Design. I think we will need about 2 more episodes to cover the remainder of the book, and then we will look at two other alternatives to clean code.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome to another episode of the All Things Unity Podcast. Today we are going to look at the first of three alternatives to clean code.   We’re going to dive into a book called A Philosophy of Software Design by John R. Ousterhout. It’s such an amazing book with a lot of really great information.   In this episode I mention a talk he gave, which you can check out here. The visuals of deep and shallow modules are in shown here plus you can see and hear how passionate he talks about this favorite (deep) interface. You should check it out, it’s really great to see.   I also mention a guy called David Parnas somewhere in this episode, but never explain who he is so if you would like some information about him you can read it here.   I hope you enjoyed this episode and join me on the next one where we will continue our discussion about A Philosophy of Software Design.   And remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome back to the All Things Unity Podcast. In this episode our adventure for in clean code comes to and end. Sort of… at least…  We are going to dive into the next four chapters of the book. Oh yes, again four chapters. We are going to look at chapter 10 Classes and find out what Uncle Bob has to say about those. We will discuss one of the often returning topics in this book, the Single responsibility principle. We will talk about coupling and cohesion of classes and much more.  Then we also discuss chapter 11, Systems. This is an important chapter to understand and since nice systems design will have big positive impact on your Unity3D application. In unity we are dependent on a really specific startup sequence of loading scenes and awake or start calls. In this chapter we dive into Uncle bob’s advise how to make nice systems, and I’ll try to convert this advise into something tangible you can apply in a unity3D context. Then we have yet another chapter to discuss and this is chapter 12, Emergence. Uuh.. What? Well with Emergence Uncle bob means that your code, your system evolves and grows. From a tiny little system a larger system emerges and you as a professional game developer need to be able to manage that in a clean way. So in this short 5 page chapter Uncle Bob will give you some advise on how to take on that challenge and slay the spaghetti monster. And at last, we talk about the last chapter we can meaningfully cover in a podcast, and that is chapter 13, Concurrency. And Concurrency is one of these topics I do not want to bother starting or junior developers with but it is the last chapter in the book we can cover nicely in a podcast format. The rest of the book are case-studies and refactoring examples. There’s also a chapter about code smells with a lot of examples but that’s also difficult to cover in a podcast. So to make this series complete I’m gonna cover the concurrency chapter anyway. Concurrency is really cool and it can result in some massive performance boosts in your game. But it can also be your worst nightmare and melt your brain into a sludge. Writing concurrent code requires a different mind set since you need to separate the what from the when. We are going to explore all of that in the latter part of this episode. I also mention a couple of things again: My blogs about SOLID: https://hamersoft.com/?s=solid The AbstractFactoryPattern (design pattern): https://www.tutorialspoint.com/design_pattern/abstract_factory_pattern.htm  Moore’s Law: https://www.intel.com/content/www/us/en/history/virtual-vault/articles/moores-law.html  The next episodes is going to be about alternatives about clean code and making some comparisons to clean code. As I said in the 0th episode, I’m not saying clean code is the best, the only way to go. I’ve also read and learned a lot from books like the original Pragmatic programmer, Code complete and A Philosophy of Software Design. I’ve read them all but I think the Clean code book is the easiest one to get started with since it has great advise for juniors, lot’s of code examples and even these case-study chapters. In the episode I mention that I will spend one episode talking about alternatives but I after quickly having reviewed the contents of these books I can tell you that I will make at least three episodes that dive into these books individually. Because there’s so much good information in there I can’t really do the book, or the author justice by spending like 15 minutes on each of them. So expect at least 3 more episodes in this series :) I hope you learned something today and join me on the next episode! And as always, remember; With Unity, we can do great things.

Hi there my fellow gamedevs and welcome back to the All Things Unity Podcast. In this episode we are going to continue our journey through clean code with the next four chapters of the book. We are going to discuss chapters 6 through 9. Object and Data structures, Error Handling, Boundaries and Unit Tests.   Chapter 6 is about objects and data structures, where we talk about the distinct differences between them; how objects hide implementation details and expose their data through functions and data structures do the exact opposite and expose their internals without providing an abstract interface.   Then we also discuss error handling in chapter 7 and how error handling can be really difficult in Unity3D since we don’t want to start throwing exceptions everywhere because it will impact performance greatly.   Next is chapter 8, boundaries, and it is about how to integrate with 3th-party code. How you explore it by covering it by tests and how you create facade classes around it to minimize dependencies.   And then, the final chapter, we discuss chapter 9 which is all about unit testing. As I said before finding a unity project that is properly unit tested is very very rare, and that’s for a reason of course. We’re all going to discuss it in this episode.   In this episode I said I wrote a blog about Polymorphism which you can read here: https://hamersoft.com/2021/03/10/14-solid-part-5-the-dependency-inversion-principle/   I also mentioned the Law of Demeter: https://en.wikipedia.org/wiki/Law_of_Demeter   Enjoy!   And as always, remember; With Unity, we can do great things.

Hello my fellow gamedevs and this is the second episode of the All Things Unity Podcast! In this episode we are going to talk about the next two chapters of the book. We are going to discuss Comments and a more aesthetic subject – Formatting. Both of these topics are important in a Clean Code Context.   In the podcats I talk about Clean Architecture and a book called Object-Oriented Software Engineering, A Use Case Driven Approach by Ivar Jacobson. So I’ll provide you some links:   Clean Architecture: https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164/ref=sr_1_1?keywords=clean+architecture&qid=1644468669&sprefix=Clean+Archite%2Caps%2C212&sr=8-1   OOSE: https://www.amazon.com/Object-Oriented-Software-Engineering-Approach/dp/0201544350/ref=sr_1_1?crid=R3I7ZA9JDCWR&keywords=object-oriented+software+engineering+Ivar+Jacobson&qid=1644468743&sprefix=object-oriented+software+engineering+ivar+jacobson%2Caps%2C189&sr=8-1   I also mentioned that I wrote a review about the OOSE book, you can read a couple of blogs about the book here: https://hamersoft.com/?s=ivar+jacobson   Lastly I mentioned the SOLID acronym and the fact that I wrote some blogs about SOLID before. You can read them here: https://hamersoft.com/?s=Solid   My Unity3D affiliate link still has not been approved yet so I still can’t put the link in here yet. But nonetheless, thanks for listening.   See you next time and as always remember; With Unity we can do great things – Game Over.

Hi there my fellow game devs and welcome to the first episode of the All Things Unity Podcast. This is the first episode of a series dedicated to the clean code and focused on the first three chapters of the book. Future podcasts will focus on the remaining chapters.   In this podcast we are talking about the book called Clean Code by Robert C. Martin. He is one of the old school software guru’s out there and is a big voice behind agile, TDD, SOLID, Clean Architecture for example and lots more. He has written a number of books like Clean Code, The Clean coder, Clean architecture, Clean Agile, and of late Clean Software Craftsmanship. He also has a site of his own where he makes very cool video’s about many topics in software engineering which is at https://cleancoders.com. He’s also a very good public speaker with many very interesting keynotes at multiple conferences all around the world. He has a well respected reputation in the software industry and I hope this gives you an idea about who he is.   Oh and somewhere in the podcast where I was talking about trying to keep functions as less as four lines I said that a simple guarding if-statement at the top of your function would result in 3 lines, but it should have been 4 of course, the condition, a curly bracket, the body, and closing bracket.   I hope you enjoyed this information and if you have any feedback or comments, please leave contact me :)   The affiliate link is still not setup, so I guess I’ll tell you to wait again.   Thank you for listening, and as always, remember: With Unity we can do great things.    

Hi my fellow gamedevs, and welcome to the 0th episode of the All Things Unity Podcast. My name is Ruben and in this first episode I’m going to talk a bit about why I started this, what the podcast is about, who I am, future topics, monitization, yeah I would like to be transparent about this, and some other general housekeeping topics.   This is a podcast about Unity3D development. Not just developing games, but also business apps, simulations and other applications you can use unity for. Heck we might even loose ourselves in the metaverse. We are going to dive into best practices, popular design patterns and game architectures. Software development methodologies and processes. And of course game design and everything that revolves around it.   The aim is to be an entry level platform while still diving deep into the trenches of game development every now and then. And, of course, in the end having fun and producing valuable content for everyone involved!   The episodes of the debug log podcast I mentioned can be found on your favorite podcasting platform, or here for example: https://the-debug-log.simplecast.com/   I mentioned this talk by Uncle bob called “The Scribes Oath” from the GoTo conference 2017. You can watch the talk here: https://www.youtube.com/watch?v=Tng6Fox8EfI.   Also here is an old blog from Uncle Bob himself where he explains why he thinks the number of programmers double every 5 years: http://blog.cleancoder.com/uncle-bob/2014/06/20/MyLawn.html. He talks about this in many more keynotes, but I think the Scribes Oath is the most recent one.   If you are thinking about setting yourself, or your team, up with some Unity3D licenses, please consider using my affiliate link if you want to support me. Also, buying assets in the Unity AssetStore through my link will help me out as well. I really want to be transparent about this and this is a nice passive way to gather some funds to support the podcast.   My request to become an official Unity3D affiliate is still pending and I’ll update the show notes when I get everything set up.   If you have any feedback please leave me a comment, and also if you would like to hear a podcast about a certain topic, feel free to propose it to me :)   The next couple of episodes will probably be about Clean Code in C# and Unity.   Thank you for listening, and remember; With Unity we can do great things!