I recently had a discussion about the use of contextual help in applications with my colleagues and the argument was if there is a need for it these days or if it's something that many companies do but does not actually have any significant benefit to the end user. Would we be better off having just pdf files or chm files without any context sensitive help in our applications? I was just curious as to what other developers think about it, primarily because context sensitive help is a bit of pain to set up and especially if you depend on a small number of developers.
As I see it, most applications seem to provide one topic per screen.
If you see a phrase that is not clear in a dialog, you want to be simply able to press F1, and be in the topic.
But of course, the commenters are also right. If it considered a chore, and that topic consists out of a screenshot of the form and the exact same texts mechanically repeated, it won't be any help.
But then of course, the manual won't be any more help when created with such attitude either.
Related
I currently have 3 very similar, but slightly different mfc applications, which would normally be opened at the same time as part of their workflow and usage in a Windows environment. I would like to keep them as 3 separate applications, but somehow group them together, under a single UI container to provide more clarity to the user.
I've so far considered using named pipes to send data from two of the applications to the third, the latter one being solely responsible for drawing the GUI (possibly having 3 different tabs at the highest GUI level, one for each application). I got this idea from SergeWautier's answer from this post. After looking into the possibility of doing this, there seems to be a lot of work involved in achieving this.
Is there any other (possibly simpler) way of achieving something similar?
Old answer
I have in the mean time come across the TaskSpace tool, which is the closest thing to what I'm looking for. It's liteware and getting the full functionality (e.g. saving a particular tabbing configuration, which I am most interested in) requires purchasing a licence. What would be really cool would be to restrict the user from adding any other windows apart from the 3 applications and have better control over the titles of the tabs & top-level window. At this point, writing a similar tool to TaskSpace would be the ideal solution.
I've also been playing around with tidytabs. It's not exactly what I want, because it doesn't provide a 'wrapper GUI', but I thought it's worth mentioning here in case it helps someone else.
Update
I've found exactly what I was looking for in Window Tabifier, which is open source and I can modify to fit my needs in accordance with the CPOL Licence provided. Very nicely written code too.
we're currently developing a fairly complex web portal. To improve the user experience, we want to provide a context-sensitive online help system that can aid the user in understanding certain aspects of the site.
In our case, the site has a variety of widgets that display all kinds of tabular data, graphs, etc. For instance, one such widget may display the VIX and a the help system would offer a brief description of what the VIX is.
Now, I've looked around in the internet and found some interesting articles such as the Design Checklists for Online Help, but most of what I found seems fairly outdated. What I'm specifically interested in are design issues such as these:
whether (or when) to use popups, divs, or link to external pages
how comprehensive should the help entry be? how much is the average user willing to read?
what's a good way to provide access to the help system? cluttering the UI with questionmark-icons is certainly not optimal
should the help entry be loaded on demand with AJAX (kinda sucks, you want the info right away) or preload it (causing tons of unnecessary traffic)
other dos and don'ts
The answers to some of these questions may seem obvious, but when it comes to usability I've made the experience that the intuitive answer isn't always the best. Secondly, I'm a software developer and as such I tend to look at things from an engineer's point of view. And I think we all know that this is, more often than not, a pretty poor angle from which to approach the design of a user interface. This is why I would very much like get some feedback from people more experienced in this field.
See here:
https://ux.stackexchange.com/questions/1351/best-practices-for-online-help
Many applications are let down by the quality of the 'writing' in their user interfaces: typically, poor spelling, grammar, inconsistent tone, and worse yet, "humour" are the usual offenders.
Are there good resources that can help developers to write UI messages that give a professional and positive impression to your customers, even when your code's going to hell in a handcart?
Thanks, all — Some great resources here, so I will CW this question. I'm accepting Adam Sill's answer because it's the one that (as a developer of desktop apps) I found most pertinent.
Since XP, I've been a fan of the Windows UX Guidelines sections that cover how to properly structure text (how to ask questions, how to make assertions in dialogs, etc).
http://msdn.microsoft.com/en-us/library/aa974176.aspx
http://msdn.microsoft.com/en-us/library/aa974175.aspx
Read The Elements of Style. Then re-read it.
Also, anytime you are working with a program or website make a conscious effort to notice how they choose to do their writing. Imitate those you like.
The resources found at Writing for the Web might be useful to you.
The best tool for this is called "primary education". Many developers seem to have missed this, and I don't know how to fix that problem.
Also, this may be a British thing, but I think you mean "humor" and "going to Hell in a handbasket". :)
This book has a lot of good advice:
GUI Bloopers 2.0
Short version:
Be consistent throughout your application or app suite. Don't call the same feature two different names, even if they're in different dialogs, etc. Develop a product lexicon that everyone references.
Use the same terms that people who use your software use (i.e. users don't refer to themselves as users).
Don't call two different things by the same name.
Put all of the messages displayed to the user in a central place (i.e. a resources file of some kind). This makes it easy to review all of the messages for spelling, tone, consistency, and whatever else you want to check.
Usability test your software to see if the messages make sense and people can use your software easily. If they can't, change the resources file and test it again.
I would suggest showing your UI to as many people as you can--preferably people who read a lot (Just because reading does wonders for your grammar and vocabulary).
Getting something out that people can examine, however, is awesome--even if it's just a demo of the GUI.
If you work at a company, get to know your QA and Tech Support people. They are usually really wonderful once they understand what you are trying to do--they will review your UI, give you input on text and usability as well as possibly new requirements nobody in engineering would come up with.
If you work on your own, try to find a potential customer or two to review your UI. Ask them to pay attention to the text...
The more eyes, the better. You might even ask your parents, wife or other family. What can it hurt?
Get your application's texts proofread by someone who does just that for a living. Then the UI walked through by someone who does usability for a living. Neither of these two people should have been involved in the development.
It's the only way to make sure.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 9 years ago.
Improve this question
I really want to know if I'm missing anything obvious in the software I'm developing.
What User Interface features that you consider important are often missing in most software?
Undo is bitchy to code, but very useful to the end users.
Save the location and size of all/any windows, so they are restored whenever the program is restarted.
Read this article on Undo from a usability expert (Aza Raskin): Never Use a Warning When you Mean Undo. Coding undo is not all that hard: examples [1], [1.5], [2].
These are some of the UI features that I often find are done badly, or are even missing:
Restoring window state properly.
Conforming to the average (non-beginner, non-expert) user's mental model.
Restricting the number of choices that the user has to make.
Restricting the amount that users have to read while using the app.
Strong consistency with other apps of the same genre running on the same platform.
A well-done Undo / Restore facility.
As somebody else remarked, context-sensitive help.
Allowing an app to be navigated without the aid of a mouse.
Good multi-monitor support.
keyboard Shortcuts
What's usually left out in UI's? Nothing! (literally. empty space). The question is better asked "What can be taken out?". When you have to think of what else your UI needs, you have already gone too far. Leaving out empty space is something UI programmers need to work on. Nobody likes feature creeping.
Remember the KISS rule.
A help menu with more than About...
Context sensitive help
Tool tips
An API and a scripting language so I can bypass the UI.
Seriously. Nothing is more tedious (and error-prone) than having to point-and-click through some repetitive process.
Right click context menu on things like tree views and grids.
We have an record management application here at work that I have to use now and then and they don't have right click on any of the documents in the treeview so you have to keep going to the bottom of the screen to mark a task as completed grrr, and no keyboard shortcuts too grrr
Consistency in your design... There are too many apps that "look" like a programmer wrote them. I can't stress enough!
Automation... Office has it, I wish more apps did.
CLI... As mentioned above, especially if it's a repetitive-wizard-type process
Templates/Presets... like Handbrake... make life easier, not to mention handy in the training process
Error/Confirm messages which don't get in the way... Unless the user needs to take immediate action, don't display a dialog. If the error is obvious, fix it for me and then tell me why
Scalable UI. With WPF this is getting easier, but it is annoying if I'm on a large monitor and I have to squint to see anything. Not to mention my click accuracy isn't that great.
UI Consistency.
I know I've been guilty of leaving out printing support in the past. I would never use it, but some of my users do.
drag and drop
clipboard
Good design.
Leave room in your dialogs so if you internationalize it, you have room for longer words (think Italian) and bigger fonts (think Chinese).
I'll add a few myself that have't been mentioned yet:
Non-modal forms that can remain open while other work is done.
Ability to view multi-windows at once (instead of tabs which show only one at a time)
Ability to have multiple views of a single window at once, i.e. split mode, or panes, or actual multiple windows into the same object.
Clean and intuitive.
Clean icons. Good icons. Meaningful icons.
I am very disappointed with a lot of icons inside applications — especially on Windows ;-)
actual consideration for the user seems to be left out quite frequently:
using terminology that makes sense to the programmer, but not the user
organizing the application's workflow for the convenience of the programmer, but not the user
not considering the user's work processes in the first place, and finding ways to help him/her eliminate steps and simplify things
Being able to use drag and drop to customise the toolbar and to be able to remove/hide unwanted toolbars without leaving an unused button whose only purpose is restore/unhide them.
Freezing the application when it's doing something that takes more than a second.
Not showing users what's happening, and not indicating how long it's going to take.
IMO, user name and password login options need work. I understand there are security concerns with each of these options. The risk-trade off is different for each application and needs to be assessed on an app by app basis.
Often forgotten or poorly implemented features include:
Remember Me
Forgot password
If you have a restrictive password policy, give me a hint as to what it is!
Range for # of characters, no special characters, required numbers or capitol letters, etc
Forgot username
If my username is not my email address, give me a hint to your username policy
Kind of too general a question. It would depend on what does the application do. One thing I see often missing from gui applications is an easy way undo mistakes and not only in the object you're manipulating but also on program UI elements. Closing some floating options panel or toolbar by mistake and then having no idea where is the thing enabled frustrates me to no end. Is it under Windows? Or under View? Was it this one? no that one is for something else entirely. Gah! what's it called?
Cycling through links and fields using the tab button.
Left click drag to highlight, right click for context menu with option to copy highlighted text. Found missing from some applications coded in Java.
Windows that snap to other windows and screenboarders. KDE and Winamp do this, and are the ones most famous for it. Why don't a whole host of other applications and DEs do this?
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 5 years ago.
Improve this question
Back in the days of Unix, you couldn't even close a software without reading the man page first. Then came Mac and Windows with consistent menu layout and keyboard shortcuts, but you still saw paper user manuals shipped in the shrinkwrap box, which described each and every single operation possible in the app. After the Internet, help files became html documents.
Nowadays with Web 2.0 applications, you hardly see the Help. Even if it's there, they simply describe some specific tasks. In other words, the apps are relying more on the common sense or don't-make-me-think factor of the user base.
Years ago Microsoft came up with a concept called Inductive User Interface, which basically tells programmers to put in instructions on the apps itself, but I am not sure how popular that idea is.
Are help files, user manuals, and context sensitive online help with F1 key dead? Have I failed if user could not find out what to do from the UI? If not, what degree of help should I provide? (both for desktop and web app)
EDIT: How does documentation/help file mesh with agile development methods? For example, should the developers think twice before UI changes that may obsolete a bunch of screenshots?
Three notes on help:
F1 / stand-alone context-sensitive help was always doomed. It was hidden by default, and so the people who most needed it were least likely to read it. There was hope at one time that we would be able to train users to always hit F1 when they ran into trouble, but too many applications without useful context-sensitive help... combined with too many bizarre help interfaces... pretty much killed this.
Manuals are as important now as they ever were. Not so many printed manuals anymore, but online manuals are better than ever. The proliferation of wiki-as-a-manual systems has helped here, reducing the up-front cost of creating good online documentation. Of course, plenty of people just don't read...
The beauty of using web pages as an application interface is that you can combine useful context-sensitive help with the UI, removing the barrier for novices and others who otherwise couldn't be bothered to look for relevant information when they get stuck.
Of course, there are still plenty of apps, even online apps, designed with obtuse interfaces and a tiny little help icon in a corner somewhere, presumably hoping that the latter mitigates the former. Pity them.
No way. You look at the amount of documentation and training and marketing expenditure even MS puts up.. you'll get your answer.
Try using someone else's product, and you will learn the true value of documentation - I'm learning Godiagrams right now.. :)
So I can say without a doubt.. NO and it never will.. no matter how intuitive user interfaces get.. beyond a certain size, you will need help and training. But by understanding the user and what he needs to get done, you could design it such that the time he/she needs to learn the system to do his/her routine tasks is minimal.
Have I failed if user could not find out what to do from the UI?
If not, what degree of help should I provide? (both for desktop and web app)
They should be able to use your your app to do basic things from the UI. eg say for an image editor, they should be able to create a new image, and draw some lines then save it just by looking at the UI.
This is best done by following common layouts (like having new, open and save under file in the menubar, and using the standard open and save dialogs).
The same goes for webapps, people exspect to be able to do the basic stuff without having to read the docs, but for more advanced features people will still read the docs. (eg most pople will read the docs for say BB code, or markdown at least sometimes, but they expect to be able to post without having to know them)
Are help files, user manuals, and context sensitive online help with F1 key dead?
They still have their place. People will use them to learn about how to best use various features, for example markdown or bbcode, or how to use filters to get certain effects in an image editor.
I've been incorporating context-sensitive screencasts into my applications. I've found this helps non-technical users grasp the application quickly, without asking for live help.
The Idiot/Dummy books must be doing quite well. Imagine if the standard application help was as good as those books. The standard F1 help for a lot of apps is just awful.
Is help dead? No, but some of it should be taken out and shot.