Archive for the 'Uncategorized' Category

19
Jul
13

What is the size of a signed data type in Visual C++?

So, I was compiling some code the other day with warnings-as-errors enabled, like you do, and I hit a curious one:

 warning C4309: 'initializing' : truncation of constant value

This particular warning is generated when the code attempts to initialize (or assign, or convert) a variable (or parameter) to a value that is larger than the variable’s type can handle. The thing that makes this curious is that the line in question looks something like this:

short const tmp = 0xFFFF;

I’ll save you the bitmath and the Googling for the size of a short in Visual C++ and just tell you that, according to the documentation, a short is 2 bytes (16 bits) and so is 0xFFFF, which sets all 16 bits to 1. The above statement will generate the warning for any values of 0x8FFF and higher. Even more interesting, setting an unsigned short to 0xFFFF does not generate the warning. Does this mean that in VC++, signed shorts are actually 1 bit shorter than unsigned shorts??

Probably not. More likely, this just means that the compiler is being a bit aggressive with this warning. You see, Visual Studio (and g++, for that matter) has no objection to this code:

short const tmp = -0x0001

This is theoretically the exact same value as the first line, because VC++ uses two’s complement (which is not enforced by the C++ standard, by the way, but is used by most compilers) for the binary representation of signed numbers. My (mostly unsubstantiated) guess, though, is that the VC++ compiler throws this warning on the first statement but not the second because 65535, the unsigned value of 0xFFFF, would have to be be truncated to fit into a signed short (where the maximum allowable value is 32767), so the compiler would prefer it if you just used your negative sign to indicate your negativity, rather than the most significant bit, like any sane programmer would.

In this case, I think I’ll just suppress the warning.

14
Jun
13

How to Make a Really Good Game with a Female/Gay/Person of Color Protagonist

Lately, it seems that a number of people believe it’s more difficult to write a game with a female protagonist than one with a male protagonist. As a game industry veteran (four years counts as a veteran, right?), I’m here to tell you that it can be done! Follow these easy tips, and you’ll have an awesome, high-quality game with the protagonist of your choice:

  1. Decide what kind of game you would like to make. You can use any combination of the below, though there are many more:
    1. Shooter
    2. Roguelike
    3. Music
    4. Point-and-Click Adventure
    5. Puzzle
    6. Turn-Based Strategy
    7. RTS
    8. RPG
    9. MMO
    10. Sports
  2. Come up with some really kickass mechanics.
  3. Write high quality code
  4. If your game has a story and a protagonist, construct a fun, relatable story with your protagonist
    1. Consider giving your player the option of choosing their gender/sexual identity/race.
    2. If you’re ever unclear on what sorts of encounters, relationships, or experiences that women, people of color, or gay people have, just ask yourself “What kinds of experiences do people have?”, then do that.
  5. Have a clear art direction.
  6. Playtest and iterate!
  7. Leave plenty of time for QA and bug fixing.
  8. Ship it.

That last one is the most important. Well, the last two. Well, okay, all of them.

Okay, yes, this is a bit snarky, and in fairness, it ignores stories that have a specific focus on gender-based relationships, like rescuing the princess (no, wait, it doesn’t have to be a princess, and the plumber can be male) or guiding a daughter-figure through a dangerous world (no, wait, it doesn’t have to be a daughter, or a father) or sexuality- or race-based relationships (I can’t think of any games that focus specifically on these).

There’s that snark again. Sorry. It’s just that it really is this simple. Of course gender/sexuality/race factors into a character, but for most people, it’s not the most interesting or pivotal aspect of their story.

</rant>

[EDIT: Ugh, I’m the worst. I knew I was forgetting something. You also have to have awesome audio design. Seriously, it’s critical.]

22
May
13

Default assignment operators and const values

It’s been so long! Update: I’ve been working primarily in C++ for the past four months or so. Hooray! I have so many drafts. I’ve really got to just start posting stuff even when it’s not (gasp) perfectly complete. Today, we’ve got another thing that I didn’t actually learn today, and it’s pretty basic, but I encountered a surprisingly bad suggestion from Microsoft’s documentation, and it seemed worth commenting on. You C++ gurus can probably skip this one.

You may recall, lo these many months ago, I posted about warnings-as-errors and why you should enable it. Well, I’m in the position of taking a large existing project and trying to turn that functionality on, and let me tell you, even with a lot of the work done for me — I was not the first, or even the second, engineer to tackle this — it’s no picnic. Reminder: turn on warnings-as-errors from the start of your project.

Anyway, one of the issues that has come up is the following:

c4512: The compiler cannot generate an assignment operator for the given class. No assignment operator was created.

For those of you not in the know, the C++ compiler generates a default copy constructor and assignment operator for you, unless you’ve specified them yourself. This warning simply means that, for some reason, the default assignment operator cannot be generated. Note that if some part of the code were actually attempting to use this operator, the compiler would throw an error, rather than a warning. Microsoft’s documentation on the warning helpfully points out that if you have any const members in your class, you will get this warning because a const member is not modifiable and thus assignment to it will not work. It continues to add that your options for dealing with the warning are the following:

  • Explicitly define an assignment operator for the class.

  • Remove const or the reference operator from the data item in the class.

  • Use the #pragma warning statement to suppress the warning.

The engineer who looked at this before me went for both the first and the second option. The second option is the wrong option, and frankly, Microsoft should be ashamed for even suggesting it. And while the third option is appropriate for some warnings, in this case, completely ignoring the error is almost certainly never the right answer. Even the first option isn’t quite on target, or at least ignores a possible solution.

I haven’t talked about const much in this blog, but I’m a huge fan. If a member variable is declared const, any programmer using that API can assume that once the data is set in the constructor, it will not change. Removing const-ness should not be done lightly, especially when (as in this case) the member is public. Removing this type modifier opens up that member to modification by any other code. Scott Meyers would tell you to “use const whenever possible” because it is such a strong contract, and I’m inclined to agree with him.

As I mentioned before, if any code were actually attempting to use the assignment operator, you would get an actual error — the code could not be generated, so anything attempting to use that code would not compile. So we don’t need an assignment operator. We just need for the compiler not to generate one. The fix for this is easy — declare it private in the header file and don’t define it. You can do this yourself (there are a million examples on the internet), or you can just make your class inherit from boost::noncopyable, which will also declare the copy constructor private, if you happen to be using the Boost libraries already.

This is a really great practice even if you’re not getting this warning. (I believe it’s one of the first item’s in Effective C++.) If you don’t expect your class to be copied, go ahead and declare the copy constructor and the assignment operator private.

27
Nov
12

#1reasonwhy

Every now and again I get the itch to post about women in the game industry. There aren’t very many of us, comparatively speaking. In fact there are even less than there used to be. But usually, I stop myself because I’m not a psychologist, I haven’t done any studies, and who really wants to read my opinions about this sort of thing anyway? In the last 24 hours, though, there was this thing that happened, and I feel the need to comment. Don’t worry — I’ll be brief.

These moments are important. Most of the women I know in the game industry are badasses, mostly because they have to be. There are lots of wonderful, welcoming places for women in the game industry, but I guarantee you that every female game developer you meet has run up against the sexism in this industry at one point or another, whether it’s being groped at an industry event or being told that their successes are a result of their looks or gender. One such experience can be shrugged off — some jerk was acting like a jerk. But when it happens again and again, it gets hard not to believe the hype, and that’s where the badass part comes in.

So, gentlemen, please listen and think when we talk about these things.

And ladies, please stay in the industry or join it. I’m usually lost myself, but I’ll be happy to be your #1reasonmentor if it means you make this industry a little less lonely for women. It really is wonderful to be a part of making these magical experiences.

20
Sep
12

The Safe Dereference Operator

Once again, I have gone months without writing, and I’m sure all two of my faithful readers are quite disappointed. Personally, I’m just shocked that summer is over already. If I’m being truthful, I thought about writing several times, but I could never come up with something that I learned that wasn’t so specific to my work that it was nearly irrelevant to anything else. (Though, as I write that, I think that I should put together a post about debugging. I do a lot of that, and there are a lot of things to learn there.) Today, however, I am inspired. I ran across this little gem while reviewing a coworker’s code:

foo?.getBar()?.getAttribute("baz")

At first I thought that the file might have been corrupted by the code review tool that we use. But just as I was about to open my mouth, I realized what was going on here. I have discovered a new operator, called the “safe dereference” operator, as it turns out, and I am in love.

If that syntax looks foreign to you, you’re in good company, or at least mine. Basically, that ?. checks if the preceding value is null, and, if it is, returns nullinstead of attempting dereference and throwing a NullPointerException. Because it returns null, you can chain these suckers and just check the final result for null before moving on with your code. Pretty neat, huh? I only see two possible, minor disadvantages. First, there’s no early out. If you have eighteen safe derefs chained, your statement will check for null eighteen times. If you have seventeen safe derefs followed by a regular deref, you may still get a NullPointerException. Second, it could potentially facilitate some really nasty code. Would you want to try to figure out which of those seventeen derefs returned null? Neither would I? That said, there are plenty of situations where you might not have to.

However, before you run off screaming, “I’m going to do this all the time now!” I do have some bad news. Shockingly, this amazingly useful operator isn’t present in every single language in the world. So far, I’ve only seen it in Groovy (a scripting language that compiles to JVM bytecode), and my coworker had previously used it in CoffeeScript (a language that compiles to JavaScript). So that’s very disappointing, but this feature is so useful, I have no doubt we’ll start seeing it pop up all over the place.

For more information, check out the Groovy documentation.

18
May
12

Five things to like about Perl

It’s been a while since I blogged, huh? Look, I never said I was reliable.

If you’re like me, you thought programming was for nerds until the year 2000, when you were surrounded by a bunch of nerds you liked, and then you gave in and admitted you were not-so-secretly a nerd all along and discovered you actually like programming. If that’s the case, you were probably raised to believe that Perl is evil. I certainly was. I heard all of the lousy things about how it’s totally unreadable, and how the variable scoping is weird and kind of leaky if you’re not careful, and how the subroutines are completely not self-documenting, and how it’s totally unreadable. Then I took a job that required me to learn Perl, and while I still don’t love it, I’m making an attempt to embrace new things and not become one of those people who is totally set in her ways and completely resistant to change of any kind. That’s a good thing, right? So, to that end, I give to you a list of things to appreciate about Perl. Read it before you go hatin’:

  1. Regular expressions support. Okay, this is the easy one. If you need to parse a string (or, say, a log file), Perl will make it real easy for you. If you don’t know what regular expressions are, dude, you are missing out. Start with the Wikipedia page (as always) and then check out this awesome cheat sheet. I could do an entire post on regular expressions (and I probably should!), so I won’t go into great detail, but basically, regular expressions provide a language for matching, grouping, and manipulating strings (or substrings) that allows you to operate on said strings in a concise and readable way. That’s right, I just said regular expressions and, by association, Perl were readable. Bring it on (in the comments), haters.
  2. String formatting. It’s a simple pleasure, but, boy howdy do I love the fact that I can reference a variable in a string in Perl. No concatenation, just embedded right in there. Love it.
  3. Compile-time failure. Obviously, this is a feature of all compiled languages, but Perl isn’t a compiled language! As a result, you get (some of) the benefits of a compiled language along with the development and iteration speed of an interpreted language. Pretty nifty, huh?
  4. Brevity. One of the reasons Perl is often unreadable is because you can do a lot in a one-liner. This can be incredibly frustrating, but it can also be incredibly awesome, especially if you do something crazy like add a comment.
  5. 37 ways to do anything. Another reason why people complain about the readability of Perl is the lack of consistency. This is because Perl provides eleventy billion ways to do anything. It’s a blessing and a curse, in that consistency is a good thing, and a hammer isn’t the right tool for every situation. So, it’s nice when you can come up with a screwdriver, even if that screwdriver doesn’t fit into your previously established pattern of hammers.

In all fairness, I still like Python better. I find that it has better support for object-oriented programming, a better (read:existing) type system, and is generally more human-parsable. In fact, I started this post with an attempt to come up with 10 things and gave up after 5. That said, as I learn Perl, perhaps I’ll grow to love it more. Perhaps.

19
Oct
11

The Definition of Irony

Normally, I don’t use social networks to complain about work. I don’t think it’s too much of an exaggeration to say that I pretty much never do it. I figure that it’s just not a great career move, given that everything you put on the internet can come back to haunt you. Yesterday, though, Batman: Arkham City came out. And I have been waiting for that game for months. And I was dealing with a really annoying linker error. So I gave in to my baser urges and sent this tweet:

A few hours later, I learned that my contract was being terminated.

It had nothing to do with the tweet. Or my performance, for that matter. They simply didn’t have work for me. So, I’m looking for work, as a programmer, hopefully with an Austin-area video game company. I have a bit more resume polishing to do, including adding this most recent job, but the most recent version is (and forever will be) here. So, if you’ve got any leads, please do send ’em my way, and if you don’t, just send good vibes. The good news, for all 2 of my loyal readers, is that I now have a lot more time to work on my personal projects, so I’ll probably be blogging a lot more about all of the stupid mistakes I make.

Today, though, I’m playing the hell out of Batman: Arkham City.

08
Aug
11

“Great idea. Please create a tracker.”

Sometimes my job is pretty calm. Nobody really needs anything. My tools seem to be functioning pretty smoothly. I have time to work on my own ideas and a normal and sane pace. Other times, it’s like juggling rabid beavers in the middle of a kindergarten playroom. Fur is flying, jaws are snapping, timing is essential, and I’m going to have to deal with a lot of angry parents if I let something drop. Now is one of those times.

Great idea. Please create a tracker.

I used to know this phrase by heart. I can’t believe I forgot it. It’s so incredibly necessary.

01
Aug
11

Inlining and #includes

I’m on build coverage tonight, meaning I’m working until 2AM. Not the most glamorous aspect of the game dev industry, but when you’re trying to hit beta, making sure we have solid builds for QA every day is pretty important. So at least I’m important. Right?

So, the incremental build failed on me in an interesting way this evening. A header failed to compile because there was a class method defined (inlined) in it that used a function that wasn’t declared in any of the included headers. This, in and of itself, isn’t a particularly interesting failure. In fact, it’s a fairly typical, easy-to-catch-on-your-own-machine failure, one that you can usually shoot your fellow devs with nerf darts for causing. What made this particular instance interesting is that the check-in that broke the build wasn’t the one that broke the code.

Of course, it’s fairly common for a perfectly valid piece of code to expose a flaw in another piece of code, but I just couldn’t seem to figure out how the original code, which clearly called a function that wasn’t declared in any of its included headers, had ever compiled. My first thought was that maybe before this check-in, the header had included another header that had included the necessary header, but when I checked, none of the included headers had changed. It turns out the issue was that the new code changed the method from private to public.

Previously, the method had been private, meaning that it was guaranteed not to be used by any other translation units, so, even though the header was included by other files, that particular method was expanded. In the source file for the defined class, the header include was preceded by an include for another header which did declare the needed function. Once the method was made public, that method became expandable in other translation units, ones that may not have had the missing header in their includes.

This fix for this particular issue is incredibly simple — add the necessary header to the includes. But what’s the moral here?

  1. Always include all of the necessary headers for your code, and don’t rely on compilation to tell you whether you’ve done so. If you’re worried about build times or violating the one definition rule, use include guards. Actually, always use include guards. It’s a tiny amount of effort and extremely low-risk for a potentially epic payoff. (If you name your guards after the namespace and class that they guard, your chance of naming collisions is slim.)
  2. Please, for the love of all that is good, compile your code before you check it in.
30
Jul
11

ThreadHead

Some people don’t like threads, and with good reason. They complicate a program and introduce a whole new class of potential bugs that you don’t see in unthreaded software. However, while I’m the first to espouse the KISS principle, I think there are certain situations (like trying to render 60 fps on an Xbox 360), where the benefits outweigh the dangers.

That said, I always feel really embarrassed when I introduce a deadlock into the codebase, especially an easily avoidable one, like I did a few days ago. Once they’re in, deadlocks are devious little bastards and managing to reproduce them with a debugger attached is a royal pain. Assuming you’re lucky enough to discover that they exist before your game ships. That’s why you have to catch them before they make it into your code repository. So how do we avoid this terrible scourge? With this one simple rule:

Always grab mutexes in the same order.

It really is that simple. If you know exactly what mutexes are being acquired, in what order, by every part of your code, you’ll be absolutely fine! Of course, this is akin to someone telling me to eat right and exercise. Sure, it’s simple and effective, but with that kind of effort involved, I’m more likely to go for the tube of cookie dough and some miracle drug featured in 3AM infomercials. But, just as every dieter has their own tips and tricks for avoiding brownies and hitting the treadmill, I have a small but growing collection of guidelines for writing thread-safe code.

  1. Minimize the scope of your mutex grab. This one is easy. The greater the number of lines of code executed while you’ve acquired a mutex, the greater the chance that one of them acquires a different mutex. The more mutexes acquired, the greater the chance of deadlock. So restrict the scope of your mutex to what it is supposed to protect. No more, no less. If you haven’t yet subscribed to the Resource Acquisition Is Initialization philosophy, now would be a good time to start, and apply it to your mutexes.
  2. Know what your mutex meant to protect. This goes hand-in-hand with the previous guideline. If you don’t know what you’re trying to keep consistent, you can’t know what the scope of your mutex should be.
  3. (Try to) know the order of mutex acquisition in the codepath you’re modifying. This one is a bit trickier. The advice I’ve always heard is to designate a mutex order from the start and always abide by it, but in practice, I’ve yet to see that happen, and honestly, I can’t think of a good way to document and communicate that to new coders, especially with a changing codebase. Instead, you usually have to determine the order by reading the code. Going down the chain is pretty straightforward (if sometimes a bit tedious), but determining  all of the clients of your code and what order they grab mutexes can be nearly impossible, especially if you’re working in a large codebase or your mutex is embedded in low-level code (like, say, new or alloc). Theoretically, it seems like it would be pretty easy to make a tool that crawls your code (like test coverage tools do) and writes out an ordering, though I’ve never done it.
That’s all I’ve got. It’s not perfect — even if you do know the order of mutex acquisition in your codepath, it still might be different in another codepath. But I think these guidelines make some of these nasty bugs a bit more avoidable. The bug I fixed today, for example, could probably have been avoided if I had not assumed that the code it called didn’t acquire any mutexes. If I’d noticed that, I might have then gone on to see where else that mutex gets acquired, and noticed that I was introducing an out-of-order mutex grab. Or maybe not. But at the very least, I’d have been aware of the order for the next time I modified the code, something that has saved me some pain multiple times already.



About

My name is Maitland Lederer, and I’m a video game developer. I learn stuff you probably already knew and have opinions you've probably already heard. I figured it might be a good idea for me to start writing down the stuff I've learned so I don't have to relearn it. It's not, like, great wisdom or anything. It's just things I happened to learn, usually today.

Header photo by D Sharon Pruitt, used under a Creative Commons License.