Opinion: Don't Use Global State To Manage A Local Problem

[In this reprinted #altdevblogaday-opinion piece, CCP's lead technical artist Rob Galanakis rails against the "nefarious criminals of the software industry," global states that mingle with the rest of your code unnoticed.] I've ripped off this title from a common trend on Raymond Chen of MSFT's blog. Here are a bunch of posts about it. I can scream it to the heavens but it doesn't mean people understand. Globals are bad. Well, no shit Sherlock. I don't need to write another blog post to say that. What I want to talk about is, what is a global. It's very easy to see this code and face-palm:

global spam = list()
global eggs = dict()
global lastIndex = -1

But I'm going to talk about much more sinister types of globals, ones that mingle with the rest of your code possibly unnoticed. Globals living amongst us. No longer! Read on to find out how to spot these nefarious criminals of the software industry. Environment Variables  There are two classes of environment variable mutation: acceptable and condemning. There is no 'slightly wrong', there's only 'meh, I guess that's OK', and 'you are a terrible human being for doing this.'

Commandline Args See everything about Environment Variables and multiply by 2. Then apply the following:

Singletons get slightly (or more than slightly) offended when people call the Singleton a 'pattern.' Patterns are generally useful for discussing and analyzing code, and have a positive connotation. Singletons are awful and should be avoided at all costs. They're just a global by another name -- if you wouldn't use a global, don't use a singleton! Singletons should only exist:

So, if you decide you do need to use a global, remember, treat it as if it weren't a global and pass it around instead (ie, through dependency injection). But don't forget: singletons are globals too! Module-level/static state Module-level to you pythonistas, static to your C++/.NET'ers. It's true- if you're modifying state on a static class or module, you're using globals. The only place this ever belongs is generally for caching (and even then, I'd urge you to reconsider). If you're modifying a module's state- and then you're acknowledging what you're doing by, like, having to call 'reload' to 'fix' the state, you're committing a sin against your fellow man. Remember, this includes stuff like 'monkeypatching' class or module-level methods in python. The Golden Rule The golden rule that I've come up with with globals is, if I can't predict the implications of modifying state, find a way not to modify state. If something else you don't definitely know about is potentially relying on a certain state or value, don't change it. Even better, get rid of the situation. This means, you keep all globals and anything that could be considered a global (access to env vars, singletons, static state, commandline args) out of your libraries, entirely. The only place you want globals is at the highest level application logic. This is the only way you can design something where you know all the implications of the globals, and rigorously sticking to this design will improve the portability of your code greatly. Agree? Disagree? Did I miss any pseudonymous globals that you've had to wrangle? [This piece was reprinted from #AltDevBlogADay, a shared blog initiative started by @mike_acton devoted to giving game developers of all disciplines a place to motivate each other to write regularly about their personal game development passions.]