Make harmful objects look harmful

Make it easy to recognize an object. If an image is harmful, make it look harmful. Something looks harmful not only by giving it a specific color, it also needs a threatening shape. Round is not threatening. Make harmful pickups anything but round.

The excellent game Geometry Wars Touch works great on the iPad.

However, the game does not adhere to the guidelines: rotating the device does not rotate the graphics.

This game looks great on the iPad. However, it doesn't adhere to the design goal of any orientation. Another less obvious point is that the game could have been less frustrating if the designers only had followed the principles of natural mapping when calibrating the controls.

Natural mapping: Setting the thumb reach in Settings would be a perfect opportunity to use natural interation. Simply ask the user to move the thumb the way they’ll move during play, and in that way register the reach of the thumb. Currently, the game uses a silly slider.

Sailboat Pro is a great game for the iPhone, also available on the iPad. The game controller is updated to better fit the larger screen. However, the menu interface has not been adjusted to the larger screen.

This is an awesome game with possibly a less general appeal than GWars:Touch. The iPad edition of the game feels a bit rushed; the menus are not at all adjusted for the size of the iPad. The game is exactly the same as the iPhone version, except for better graphics.

Buttons to be operated during gaming should preferably be placed within reach of the players hands, that most likely is holding the device. This means buttons and controls used in-game should be placed along the edges. To have to balance the iPad with a single hand while interacting with the buttons is no good.

When I am drawing the paper is my main focus. I don’t want to focus on the tools. The tools should get out of the way and never demand any attention; they should just work. This to me is the only way to remain focused on what I am actually drawing. However, drawing apps on the iPad have tools that keep breaking the flow. Tools that need attention which is just plain wrong.

The perfect drawing app for the iPad should have multiple pencils, each with its own settings. The artist should be allowed to easily switch between these drawing tools, and the state of each tool should be clearly visible on screen. This does not have to take up a lot of space if implemented in a clever way. The main point here is to not have to think when using the app.

Which leads me to another annoyance with most drawing apps: the confirmation dialogs. Penultimate is a good example of a pretty well made drawing application that recently introduced a confirmation dialog when clearing the page. To force the user to confirm an action breaks the flow. The problem here is of course that the clear action is triggered by a button.

Why not use sliders for critical functions, then the confirmation dialog would no longer be needed..

To very easily create the much needed .gitignore file, simply execute this command in the terminal when inside the project folder (root of project):

echo -e "build/\n.DS_Store" > .gitignore

Do a cat .gitignore to check that the file indeed has build/ and .DS_Store on two separate lines, then you are done. I suggest you do this before your initial commit, as these files are likely in your project folder already.

Only days ago I start using Git. So, naturally I am far from an expert. Still I think someone could find this useful. Briefly, this is what you do on any computer to get started (only once):

1. Download and install Git (eg. adding the necessary path to .bashrc).
2. Download and install the GUI wrapper GitX for OS X 10.5+.
3. Introduce yourself to Git: git config –global user.name “Joey Doe”

For each project you do the following in Terminal:

1. From within the project (create one if needed) initialize Git: git init
2. Create the .ignore file to avoid Git caring about the build folder (and others Git should disregard).
3. Add all the project files, which includes the hidden .ignore file.
4. Commit the added files to the log and write a good multi-line commit message (short title followed by listed details).

After the project files are committed on one computer, you can fetch the project from any other by doing the following:

1. Use git to pull down the entire repository. Do this in terminal from the folder that should contain the project folder.
2. Open GitX to verify that the repository is in fact intact (simply open the project folder).
3. Continue developing the project as normal.
4. The changes needs to be staged (comitted) before they can be pulled by another computer.

Changes made on one computer is basically pulled to the other using the same steps as above. So every time you switch computer, repeat those 4 steps. Easy. More details follow.

Installing Git

Download Git from the main site: http://code.google.com/p/git-osx-installer/downloads/list?can=3 If you are not sure, go for the installer and make sure it is targeted for your platform (Intel vs. PPC). After the normal installation you should be able to run Git. Open the Terminal and type in:

which git

This shows you where Git was installed, which also means it is ready for use. If nothing shows up, you might need to add the path to .bash_profile, in a similar fashion as below. However, when connecting using SSH, only the .bashrc file is actually loaded, so you should also make sure the path is there as well. This can easily be done by executing this in terminal:

echo export PATH=/usr/local/git/bin/:$PATH >> ~/.bashrc

This will create the file if needed, or append the path to the existing .bashrc file in your home directory. Now download and install GitX from http://gitx.frim.nl/ – a very nice GUI rapper for Git on OS X 10.5+.

You are now ready to actually start using Git.

Initial Cloning

To get a clean copy of a project on the LAN, you need the local IP address (eg. 10.0.1.4) or the alias (imac.local) of the computer hosting the project. You can connect using either SSH (enable remote login) or HTTP (enable web sharing). However, in this post I will only use SSH.

To get the initial project from another computer, you run the git clone command from within the folder that should contain the cloned project (you can move it later). Type the following at the command line:

git clone ssh://home@imac.local/~/Projects/TheOne

This copies the entire project folder (including the hidden .git repository) to the current destination. In the example above I used ssh to connect to the local computer imac.local. The home@ informs git to connect using home as the user name on the remote system. Following the server name are ~/Projects/TheOne which means to access Projects contained in the Home folder of the specified user which contains the project called TheOne.

Having cloned the project, you can now inspect the project history using GitX. Launch GitX (if needed click File > Open) and select the project folder (no need to expand or enter it). Nice.

Get the latest changes

To update your project with the latest changes, you simply pull the changes from the other computer:

git pull ssh://away@macbp.local/~/Projects/TheOne master

The added word master lets git know that you want everything, not just a single branch. When you have changed some files on your laptop, you could push the changes back to the other computer. However, this is not a good idea if the files are checked out on the other end as your changes could get lost.

“By the way, behind the scenes, a pull is simply a fetch followed by git merge; recall the latter merges a given commit into the working directory.” (from GitMagic)

Until I get more familiar with Git I will simply pull the changes from the most current computer as needed.

GitX Contributions and Further Reading

You can easily download the source for GitX and contribute to the project by running:

git clone git://github.com/pieter/gitx.git

Read more about contributions from the contribution section of their own web page. Read more about using Git with remotes: http://progit.org/book/ch2-5.html

As a quick reference, if this page won’t do, visit Git for the lazy.