Navigation

Freitag, 24. Februar 2017

Ever tried this? Planning out your entire gamedev project - at once. In every little detail.
I tried doing so - with Hack n Plan. I laid out the entire array of features as detailed as I could. It was nice in that it helped me how large it will become.
However: It did not work out at all for me. After a while, I found myself overwhelmed by the volume of tasks I've set up and ended up demotivated enough
to never touch that Hack n Plan project again.User error doesn't make the tool bad, however.

So what was the problem here?

I cannot focus because of too much clutter! And I'm clutter-minded already:

It starts with detailed and seemingly endless todo-lists. If I don't clean up and these lists grow to large, this is what happens in my head:

Out of 1000 important tasks let's pick the least important one because fuck progress!

There is SO MUCH to do!

Where the hell am I going to even start, oh my god, oh my god

Before I work this long list, let's take a look at this game I haven't played in forever!

What one must do is to trick oneself into working and getting comfortable with what one is doing.

That means, getting rid of all things that's preventing you from doing it: tuning down on the "lazyness threshold"; fostering a habit that comfortably enables you to get shit done. Like, going to the gym that just happens to be on your way home when calling it a day.

Something similar can be done using this 5-step-iterative approach:

Evaluate

Structure

Implement

Take Notes

Repeat

How does it work?

Evaluate the current state of your project: find out what bugs exist and what still needs work.

Structure the current iteration.

Create a todo list consisting roughly of:

10% new features

30% extending existing features/improving user experience

60% bug fixes

If you have a list from step 5 in a previous iteration, use that list as basis for bug fixes and extensions.
New features should be a lower priority; if they are "spontaneous features": Get rid of them. NOW. KILL IT WITH FIRE.)
Ensure the extensions/features/bugfixes are meaningful and leading you to your goal; which is finishing your game in time - NOT playing with your game mechanics until it's perfect which it will never be.

Implement the todo list.

Do it blindly. Do not think much. Do Shia a favor and JUST DO IT.

While implementing, take notes for the next iteration:

Bugs

Issues

UX improvements

Code refactoring

Avoid adding new features to this list AT ALL COSTS

Repeat.

How can you implement that into your work flow?

I've started to treat the changelog as my todo list when I am in step 2 (Structure). I will take notes there to solve problems or figure out how to implement or improve features. When I'm done implementing a feature, I remove the implementation notes and reword the feature for normal folk (gamers) to read and understand.

For step 3 and 4, taking notes while implementing, I have started to use a separate text file for bugs and issues I encounter in this iteration. I keep this one seperate from ideas for features. The file with ideas is the most spontaneous one and consequently its priority should be very low to zero.
So I don't lose track of what was done, these three files are included in my git repository and are regularly committed.

All these measures help me control the flow of features into my game. Ever since I've been applying this I haven't implemented new ones - most of what I do right now is improving the user experience. It seems to work well - or at the very least: better. :)

Sonntag, 19. Februar 2017

You likely came here because you also had that experience: Creating an interface for a client or software, just to proceed to do tedious coding work.

Sometimes that frustration is caused by dull coding: the kind of code you've done a dozen of times before in slightly different configurations. Creating getters and setters, adding listeners to buttons, blah blah blah.
Then again other times, it's simply a lack of knowledge and perhaps communication with the users on how to do things better.

In other words, UI design (often) both sucks for us programmers, who have to make it and do not like it, and for the users, who have to use the half-assed programs created by demotivated programmers.

Programmers aren't necessarily designers, after all, right?

So how can you make your life a bit easier as a programmer? I've summarized the following tips which I have collected via trial and error and pinches of design experience:

Group together what from a user's view logically belongs together.

Visually separateactions that are functionally different: don't place a delete button right next to an add button.

The box on the right would make multiple problems. One is: what happens if the user clicked on the remove button instead of add?

Critical actions, like removing data or changing a large set of data, need a higher use-threshold e.g. via a dialog: "Are you sure to do that...?". Those are the kind of actions you don't want to happen if you click on them by accident.

Important actions should be highlighted through movement, form, shape and color. Like this you can control the flow of your user's attention - and where they are likely to click next.

The look and design of your components should be aesthetically coherent. Think of it like this: In code, you set the rules for your code, how it looks like via style guides and so on. This is in fact very similar to interface design: you can also set a visual rules here and apply them your components: e.g. all interactive components like buttons, menus should be blue, background stays white.

Do not overload your interface with components or buttons. Instead, make information toggleable from display and use meaningful sub-menus, while keeping those sub-menus as accessible as possible, e.g. via shortcuts. Ideally, a single sub-menu should be like a red-black tree with a maximum depth of 3 to 4.

Menus like this often don't have a depth more than two or three.

The more a user uses a function, button or component in a program, the more accessible it should be. This helps the user's workflow and makes your software easier to use.

Give users the possibility to customize views so they can adapt the software to their special needs and workflow.

Support the users by assistants, in-app hints or tooltip texts.

I hope you found these tips helpful. You are more welcome to add more suggestions in the comments!