It goes without saying that User Interfaces (UI) are extremely important to any program. This article will talk about some basic concepts and thoughts about building good User Interfaces. Compared to the previous articles, this is a bit more technical. However, I will try my best to keep the technical aspects still in a general sense for non-developers.
There is a ton of theory, academic and professional material behind what makes a good UI. In fact, there is an ISO Standard (9241) regarding this very topic. If you wish to read more visit ISO’s website and search for 9241.
As one can see in those links, there is a large amount of sub-standards (work place displays to TV panel displays, etc) for building good UI’s. I’m not going to talk about what is already published because anyone can read that. Instead, I am going to talk about my experiences in building UI’s and some of the points that I find important. All of this is my own opinion and what I have discovered during my times. I hope it proves to be useful!
Since the UI is essentially the way the End User uses the program, I feel a good UI must have several important key concepts done well: Usability, Accessibility and Consistency.
Usability is how easy it is to use the User Interface to do a task. Can you do your task easily and efficiently? How difficult is it to perform an action? Note: It is easy to confuse Usability with Accessibility.
Before I go into more detail. I want to define two terms:
Average Task: Is a task that a user performs on a regular basis. For example, saving/load files (or games), using common windows (research/planet/ship design/etc)s, and the like.
Complex Task: Is a task that the user doesn’t perform on a regular basis and usually gives/does a bit more than the average task. This type of tasks usually requires more clicking/window movement/etc than an average task. An example consists of the Planet Window and using filters to display a list planets based on parameters. Or, the Statistic Window where overviews of the Empires in the game can be seen through various filters.
I will now go over a few ways to determine how good Usability is in a UI.
One of the easiest ways to gauge difficulty in the usability realm is the number of clicks it takes to do a given task. This idea can be expanded to include moving the mouse on the screen, or clicking through various drop down lists/menus/etc. And finally, it can be further expanded to traveling through multiple windows in order to accomplish a task.
Another way to gauge difficulty is the usage and placement of components. How are the components arranged on the window? What types are used (Lists, Drop Down boxes, Tabs, Scroll Panels, etc) and are they the right ones? Is the screen cluttered? What is your initial reaction (how do your eyes feel?) to opening a window? And so on.
A pitfall of Usability is a lack of Consistency(which I will explain further below).
One other big issue I have with UI’s is the lack of feedback. There can be tasks that can take some time to process. Having absolutely no feedback creates a sense of mystery that the user should never have. At every moment during the User’s time with a UI they should always know what the UI is doing. There are times when it may be impossible to gauge how long a particular task will take but feedback should still be given in some way. Some examples are: use a progress bar that continually moves back and forth, a mouse cursor spinning or some other sense of animation. A User should never be thinking: “Is this locked up?” or “What is this thing doing!?” or “Will it end soon?”. This can be taken a step further and a label can be used to display the current step. This would be great feedback.
Another pitfall of Usability is not ensuring the UI scales with large amounts of data. Yes, the window with a list of 5 items behaves fine. How does it behave with 1,000, 10,000 or even 100,000? Time to check!
One last note is to ensure the UI has proper flexibility. There should be more than one way to do an average task. As a developer, that is a task that is left up to you. Shortcuts are the most common way to implement flexibility.
Some ways to ensure good Usability is to:
- Have good Consistency.
- Ensure the minimum number of possible clicks and mouse movements.
- Choose components that allow for the most logical sense of data arrangement.
- Give proper feedback.
- Ensure flexibility.
- Use tool tips, where appropriate and in a consistent manner.
Accessibility is how easy it is for a user to sit down and learn the User Interface by themselves, without the developer/manual nearby to help them.
If a user can sit down and start to use the program and be productive in a short amount of time with little problems – then the program is accessible.
Another way to describe Accessibility is the “Learning Curve”. What is the learning curve of the program? How much time does the user have to spend before they are able to be productive?
Describing the difficulties and pitfalls in accessibility is hard because there is no silver bullet that will cover every single aspect for every single program.
However, I do have a few tips as a fellow developer. I have noticed over the years, that much of the accessibility problems are due to the omniscient view a developer(s) has of their system. They designed the system and implemented it (not always but for example’s sake). As such, they know the inner workings and how to do every task. Thusly, they usually have very little issues using their own program. Of course they don’t have issues! They built it!
As one can see how this could be a huge pitfall. To overcome this problem what I like to do is to:
- Implement a UI and then walk away from it for weeks or months. I will then come back and use it. At this point, I have probably forgotten most of how it works. I will use the UI and generate my own feedback. I will make changes based on that.
- This is similar to 1, but, instead I hand it off to someone else to play with. Maybe it is a member of my team or a tester that is willing to suffer!
In both cases, the omniscient feel can be dulled and almost put to rest. This should give some decent feedback and ensure that the accessibility of the UI can be made better.
As mentioned above, Consistency is a very important part for UIs. Consistency goes a long ways and brings structure and order to a UI. It is very easy to have a UI spiral out of control and be absolutely a pain to use (MoO3 and from Adam’s review the original DW).
If a good level of consistency is instituted within the program, it will have a very overall positive impact. Good consistency raises the usability and accessibility.
Let me provide some examples of good consistency:
- Decide on the precise function(s) that a window will perform. Use proper components to break up function. For example, Tabs work wonders (don’t go overboard like MoO3 though).
- Decide on how many clicks/mouse moves an average task will take. 1 or 2?
- Decide on how many clicks/mouse moves a complex task will take. In most cases, it will obviously be more clicks/mouse moves than the average task.
- Use the same types of components for the same general functions in different windows. For example, always use a List component to list fleets (at star systems, and in the Fleet window). While this seems logical sense, it can be very easy NOT to do this.
- Use the same conventions for layouts and placements of components.
Consistency is very very important. But it can be implemented badly.
Let’s use MoO3 for example. Even though they used a Tabbing mechanism in the Planet window for consistency, it went completely over board. They simply had too much going on (item 1) and the number of clicks to perform the average task (item 2, editing the build queue), was unacceptable. Most times, the tabs where hidden or put in odd places (item 5). I could probably write (I’m not the only one!!) several articles, one for each window, for MoO3 on how the UI was bad and flawed.
Usability, Accessibility, and Consistency Summary
In all, the developer has to keep in mind that the End User is someone ELSE and envision how they will be using the UI. They need to sit down and think on how the UI can be made clear and concise in ALL of its windows. The End User needs to feel the same in every window in terms of how to use it. It makes no sense whatsoever to institute the idea of using Tabs in all of the windows but having one straggler window using buttons to open up sub windows instead. It will just confuse the user and lower the Usability and Accessibility.
I will now talk about some code tips. This particular section may not apply to all readers, so I shall keep it short.
Functional Decomposition – Functional Decomposition is vitally important for UIs. Functional Decomposition is taking a large system and breaking it down into smaller pieces. The reason why Functional Decomposition is so important is because the windows and parts in a UI’s generally have a lot in common with each other. It does no one any service by having repetitious code in many different locations. This makes the maintainability of the program extremely difficult, and it leads to buggy programs. Bugs lead to money, time wasted and the most important: unhappy customers. Of course, modular code can be reused so the UI can be extended for new function that much faster.
A good way to implement modular code is to have a Utility class/file that provides generation of generic components.
For example, in my SitRep Window, I have a Utility class that allows for the generation of various parts of the SitRep Entries. By doing it this way, I can simply write a new SitRep Class and call these methods to build my SitRep Entry. The benefits are:
I can easily develop new SitRep Entries by simply passing in the information (generally Strings). I don’t have to re-write the code to generate the entries and I ensure the code is not ridden with bugs since I am already using something that is known to work.
Here is a picture of my (Alpha) SitRep screen.
It is easily seen that each entry looks generally the same (+Consistency) and they all function very similar (+Usability, +Accessibility). This is because each SitRep Entry calls the identical underlying Utility methods. Each entry has their own line that can be fully expanded (+Usability) by clicking on the + or the line itself(+Usability). Under each entry very detailed information is provided and gives links to various important windows.
Above, the expanded Entry is about a Fleet arriving at a system. Detailed information is provided, and in this case, 4 planets are present with no owners. Buttons can be used to view the Star System immediately.
Layouts/Scaling – Having some underlying code mechanisms to automatically perform layouts and scaling (the Java Swing layouts for example) of UI Components is beneficial because it removes the fact that people run on different resolutions. You have to make sure your UI will look good on all supported resolutions.
I, personally, prefer using absolute positioning with built in scaling than layouts because I get more control that way. To me, control is power.
Time for Examples
In this case, I’ll talk about my 4X Game I’m developing. We all know that 4X Games need to display a large amount of information. Screen real estate is low and at a premium. So I have instituted a policy that windows will contain tabs to manage various portions of windows. For example, there is a Fleet Window that has tabs for Deployed Fleets and Fleet Creation. There is a Planet Window that has tabs on the right for Information, Construction and Resources – all the while the planet view is still viewed on the left side. In both cases, the tabs are top tabs. This is a good usage of consistency between windows.
This sums up my thoughts on making User Interfaces. As mentioned before, there is a lot of literature out there so most of this article is my own opinion. I am looking forward to reading what others have done and what parts of a UI they think are important.
In order to generate some good discussion on this topic, I pose the following questions to the readers:
- While designing and implementing your UIs what pitfalls/issues have you ran into and how did you solve them?
- What was the Best and/or Worst UI’s you’ve used, and why?
dayrinni has been a Space Sector contributor since October 2011. This is his first foray into writing articles for any review site. He is an avid gamer in the genres of 4X, Strategy, MMO’s and RPGs. Finally, he has been the implementor of several MUDs and is currently working on a 4X space game that offers large scope and complexity. See all dayrinni’s posts here.Subscribe RSS
- Making a Space 4X Game: Setting the Stage
- What Makes A Good Game – Challenge
- Wing Commander Saga: The Darkest Dawn – Preview Trailer and Release Date
- Buzz Aldrin’s Space Program Manager Giveaway Contest! [RESULTS]
- What Makes A Good Game – Immersion