How to - avoid burnout (programmers guide)

Warning: this has no code examples; this is purely just how to cope and deal with your issues and mistakes.

You probably clicked on this because you’re constantly running into 1 of the issues below when working on large projects, and it always leads to burnout! We will go over how to solve each of these issues pragmatically.

  1. Refactoring mess
  2. Pre-mature optimization
  3. Pre-mature and post planning, aka Overplanning or Underplanning
  4. Choosing the best “paradigm” for your project (ECS, OOP, Functional, Procedural, Data-Oriented, etc) > Absolute nightmare!
  5. Game structure issues
  6. Game hierarchy issues
  7. Game complexity issues (states, services, handlers, endpoints, scripted events, self-contained code, etc), “gosh, how do we handle this!”

Let me say one thing, YOU ARE NOT ALONE, this is apart of the learning curve! Games are not supposed to be easy. It’s a collection of logic, and all of that logic needs to cover every edge case and communicate flawlessly.

Read that again, that’s an incorrect and illogical statement. A game cannot be perfect; a game has its flaws, and it’s built upon those flaws. So let’s dive into each issue and how to solve them practically.

You’ll see me say the term “Plan your game” multiple times… Because that is the general solution. Some projects take months of planning before being developed, especially in research environments.

1.1 Refactoring Mess

Simple Solution: Planning your game, knowing what features you want, and making the correct abstractions from core systems/services.
Complex Solution: It’s really hard not to go back and refactor a module, function, or script itself. This is inherently not bad at all. It’s bad when you continue to refactor the same system over and over potentially polluting it with abstraction or length. This is due to poor decision-making and not planning it well, so really, the only solution to this is to start from ground zero and figure out 2 things about your current implementation. Where did I go wrong, and what did I do wrong? This image below has been shared and seen by a lot of people in many variants, but its general idea is that you cannot have a perfect system with everything. There are sacrifices and cuts you have to make in order to make something production-ready. In the end, you have 2 options: Work with what you have or start over. Stop the perfectionism and just work dirty to make a prototype. MY personal triangle I follow is Code Quality, Modularity, and Performance.

1.2 Pre-mature optimization and overplanning/underplanning

Simple Solution: Plan your game, work dirty, and refactor later.


Complex Solution: There isn’t really one; you just need to work with what you have, learn from your mistakes, and refactor later. Always follow the process until it becomes ABSOLUTELY necessary to refactor it because completing your future task is disrupted by it.

1.3 Game Structure and Heirarchy

At times, structuring your game can become one of the most challenging problems in game development if not approached correctly. For my math nerds, every game is like an augmented matrix that needs a linear combination. In other words, there are almost an infinite number of ways you could make a game, and there is always a unique solution to every game. A game engine will not work for every game. Sea of Thieves had to modify Unreal Engine with almost 3000+ mods to even make it the way they wanted it to. Now the big question is this, was that all done at once? No, over time, they accumulated changes and additions. So,

Simple Solution: Figure out a destination(by planning…), make a scrap up of it, did it work? If so, refactor it and repeat. Over time, it will begin to flesh itself out.
Complex Solution: Understanding game development cycles is extremely important. Remember those terms: Alpha, Beta, and release builds. Well, they all mean certain things about the state of development in that project. AN ALPHA RELEASE WILL BE COMPLETELY DIFFERENT THAN A BETA RELEASE. This is because they are 2 completely different game structures due to the refactorization that has occurred over time. So make your game the crappy way, this is your alpha product, refactor it to be more desirable, this is your beta product, add content to the game and refactor it to be more fleshed out, and this is your releasable product. Notice how the initial period in development is always crappy? Because it’s intended to be.

1.4 Game Complexity

This is a touchy subject because, while in words these subjects sound easy, they are hard to put into practice because they require practice to avoid failure. To get good at something, you need to not be afraid of releasing a crappy product and working with what you already have.

Simple Solution: Plan your game, create it, work with what you have, and learn from the mistakes
Complex Solution: It’s hard not to jump into a passion project, but you need to resist the urge and plan out your game. Passion projects work as long as you have passion, which inevitably will fall away as you work on the game, because the features you once hoped to implement become a mountain of research and work, and you become so focused on those things that you forget about the passion/motive of the main project. So it’s important to plan your game and work on the core gameplay mechanics before abstracting them and connecting them with your magical programming “glue”.

1.5 Programming Paradigms

I’m not sure why people become obsessed with learning paradigms in the beginning stages of programming, but it will absolutely hurt you more than help you, with the exception of OOP, because that is a necessary piece of knowledge needed to even use several languages that are object-oriented natively. The best advice I can give to people who are obsessed with finding the perfect programming pattern or whatnot is to just read people’s open-sourced scripting material. Programming is, quite honestly, best learnt through reading it, then writing it. My second piece of advice: at some point, you will hear the term ECS or Component Systems. There are a wide range of ECS implementations and component system implementations. THIS IS NOT YOUR PERFECT SOLUTION, as I said earlier, every single game is unique. Most games that use ECS, if not, have probably modified their implementation of ECS to work in their favor. Roblox is special because you can use all of these interesting ways of structuring code, but ultimately, if you want a product, you’re just gonna need to follow the same process everyone else does. Plan, Create, Refactor, repeat.

Summary: Return to the Stone Age and work with grit. Quality comes with time

Hopefully, this helps some of you and creates an interesting discussion to be brought up.

21 Likes

shouldn’t this go in Resources > Community Tutorials

2 Likes

Thanks changed it. Appreciate the warning

1 Like

Perfectionism is a trojan horse. If I had a penny for each time my perfectionism wanted to re-write a completely good project because one class looked wrong then I’d have maybe 10 pennies. If we we’re talking about the hours wasted then I’d be alot richer. Great post and I’m going to recommend this to anyone struggling with burnout.

1 Like

Appreciate. I know this post doesn’t apply to a lot of people, but it really was meant for those who struggle with this issue, because I know its a hard one to overcome. Thanks for reading it, and sharing it!

1 Like