Author: Ante Beslic
One of the most challenging and deep-influencing tasks in today’s applications is to improve user interaction. When I say improve, I mean simplify. A wise man once said: “If you can’t explain a complex concept in a simple way, you don’t understand it well enough.” This is very true for user interfaces as well.
There is a good reason why making a good enterprise application is exponentially more difficult than creating a specialized one, built for a relatively narrow, specific task sets. “Do one thing and do it well” is a known, established mantra in the Linux ecosystem, and it reflects everything that is good about it: it maintains simplicity of a tool/command, restricting functionality to a small context. Screen real-estate, data visualization and commands-to-execution paths are the three big factors that we need to pay attention to if we want to have/maintain high quality user interaction. Also, they influence, limit and provide context to each other – this is why complexity stops being linear after a certain point. Let’s try and explain it in more detail.
Various screen sizes and resolutions are something we cannot get away from today. Yes, it is a physical limit we have to design around, but it also provides us with A LOT more valuable information. To break down what we get across points:
- constraint on amount of things we can display at one time (affects data visualization)
- control context – touch interfaces behave different and have specific requirements
- time context – users on mobile devices tend to execute short tasks or those that require immediate action
- point-of-contact context – some mobile devices are used for constant monitoring, as a notification endpoint
- hardware context – mobile devices have limited compute/graphics performance, but also provide other environment inputs (camera, inertia sensor data, GPS data, etc.)
- network context – mobile devices are often in areas with limited coverage and variable data connectivity
And we got all this from only considering screen size! All of the above will affect how your user interface is structured and displayed, all of those should affect your interaction design decisions.
Data visualization – aside from depending on the above mentioned screen size, something that is maybe not really obvious, it defines who your user is if you analyze the usage data:
- preference context – some users are more familiar/comfortable with specific visualization concepts, you can optimize/customize (inter)actions based on this preference
- action context – repeated users actions reveal patterns, those can be crafted into macros and presets to automate and save time
- frequency context – knowing how often and at what time does a user request new data can help optimize requests, maybe some friction can be saved with caching and/or push service (live updates)
Commands-to-execution paths are like breadcrumbs of you users’ activity, provided you have sufficient logging that can help discover user click-through motions, backed by the statistics.
In theory, shorter the user path is, better the interface – this is only valid for simple apps and (non-existent) unlimited surface interfaces. It is a compromise between the amount of information directly available and clutter/level complexity.
If the data visualization provides contexts of what and how users display in your app, this should give insight based on the depth and timing of steps required to execute a certain function. Some examples:
- count context – high count means user has to drill through your menus and screens to perform specific actions often, it might indicate a “buried” important feature
- time context – user takes a long time to properly navigate in clutter, your UI might be too slow, user device might be inadequate/old
- traversal context – user going back and forth between menus/screens a lot might mean the required data should be composited in the same view or made more readily available (e.g. navigating to a certain screen to copy/paste info)
This is just some crude information, numbers that can be extracted and analyzed. But, we shouldn’t forget a very important way to improve your design and interactions – talking to your user base. Ask them what works, which parts suck, they might have more ideas since they are the ones using the software on a daily basis, probably in tandem with other solutions you don’t have integration with (yet).
In the upcoming Celayix products, we put in a lot of effort to create a modern user interface based on information and feedback from our customers.
What are your experiences with our latest Team Xpress and/or Time Xpress applications? If you haven’t had a chance to see them yet – please contact us to schedule a demo and let us know what you think!