In my application, there's a long list of user-created objects in a master-detail setup. All we show in the master list is the name of the object, and the list is alphabetized. I've noticed that my users have been naming their objects starting with special characters, to get those objects to rise to the top of the list.
What feature(s) should I add so that they won't need to do that anymore?
This user behaviour indicates a great opportunity to improve the usability of your application. Ask a few users why they rename items and try to understand the underlying need or problem that they are facing.
Depending on what answers you get, possible solutions might include:
In either case, don't limit the users by forbidding special characters. Until the underlying problem gets fixed, the current solution might be a life saver for them.
When it comes to optimising the design, users happen to be the best designers.
I would suggest that – instead of guessing - you should get in touch with these Users, who hacked the sorting mechanism to ask what they wanted to achieve.
Maybe they wanted just to pin some items to the top of the list, for which starring would probably be enough.
But maybe this is just a symptom of a deeper need, maybe it needs to be somehow ordered or structured. Without asking them it will be hard to implement the right mechanism in this case.
EDIT (after some discussion in comments below):
Thank you everyone for your valuable comments. I think this answer needs some clarification.
There are cases, when Users want to try to escape the boundaries planned by the designer. From their actions, some conclusions may arise, but quick conclusions about the solutions are not always the right ones.
A little digression first, you can skip it if you want. There is a meme about user experience, showing a gate and a path around it, made by Users. While it is easy to criticise, answering what the solution is, just based on this behaviour, is risky. Should it be removing the gate, it would be easy. However, maybe it has its purpose, actually? It may prevent animals from getting inside, it may be a legal requirement to have it and if one thinks more of it, probably they will find some more possible answers to the questions: "Why it is here?" and "Why people try to go around it?".
Asking Users should be a core part of creating a solution if we are not sure about the nature of the problem. And in this case – we may guess, but in my eyes, implementing any solution based on a conclusion would trigger a risk of the "solution" being inaccurate, not answering the actual need of the User.
In this particular case, this behaviour may mean that people want to have some items pinned to the top, but also here there are some more possible answers:
So, there is a lot to analyse here.
Now to the users happen to be the best designers line. When they use something - be it a computer or a desk or a cup or whatever else – people often change the way these things work in a tiny little bit. They place that sticker on the camera of the laptop, tie the teabag to the handle of a cup, organise their things on their desk so that it is comfortable for them. They invent solutions to their needs and implement them - so they are designers. This very design, if observed, can be a source of further evolution of the things (camera blocker, a cup with a teabag holder, a desk with a holder for pens built it).
Therefore, if they hack the naming of things within this solution, it is good to observe what they come up with. This may lead to a deeper knowledge of what they want to achieve. Having all this input, it is easy to ask them one crucial question: "Why do you do it like this? What do you want to achieve?"
And after gaining this knowledge, to conclude, ask them again if this is what they wanted, maybe suggest something better than they would come up with, of course. But only having this confirmation - to come up with the solutions and implement them.
In other words, the behaviour of Users in this case my be a direct indication of their need (and in this case, pinning might be a good choice), but it can be just a symptom (in which case, asking before implementing or even suggesting any solution is the best choice).
As well as pinning items to the top of the list, fake-alphabetical entries can be used to pin them to the bottom (a trivial example: I use a contact called ZZ spam with a silent ringtone on my phone). In other words it's quite a flexible system.
Consider how sorting by a range of parameters is built in so widely: All file managers allow you to get the recently-used items to the top as well as sorting by name, type, etc. Your users may also be familiar with sorting in spreadsheets, including the use of a column purely for priority.
With no priority/frequently used sorting this is actually a good workaround. In your users' position (with a shared list) I could be tempted to go for a naming convention like _<priority-level>_<item-name>.
When users add special characters to the beginning of the names they create two or more kind of objects, or categories, in the sort. These categories can be specific, as the ones in this example, or more general ones like favorite / not_favorite or objects_I_am_working_on / others.
You could provide the feature to make this distinction, to categorize objects, and sort them per category and then alphabetically. The idea is to take the "feature" your users have created themselves, out of the system features, and provide it within the system in a (hopefully) more convenient way.
Consider these points: extra characters alter the position in the list,make those elements stand out and group elements. Users might be altering the names for one or more of these reasons.
It's possible that no matter what feature you implement, users may still continue to do this (unless you forcibly disallow it).
Consider another system where this happens all the time: computer filesystems. Most file browsers sort names alphabetically, and you'll see users do all sorts of things to work around (or, I would say, with) that, like putting spaces, numbers, or AAAA in front of filenames. Even though modern file browsers typically have dozens of features that permit other types of sorting and labeling of files, you'll find in practice that many people still find it simplest to just give their files certain names to cause them to sort near the top. Another place where this is often seen, as commenters have pointed out, is address books.
The question is, does it break things? Are the names used in other parts of the system where the special characters or leading AAAs cause issues? If not, then maybe it's not a big deal. If so, then perhaps a solution is to sort by different field (like, for instance, a "display name" that isn't relevant anywhere else).
Sorting is a simple system. Anyone who knows the alphabet already understands how it works, and they can figure out unknown details (like how certain characters sort relative to the alphabet) with simple trial and error. This "something that you already know how to use" is a powerful UX property, and I think it would be a mistake to ignore.
Implement auto complete like filtering
Include a filter textbox they can enter A and only items stating with A are shown.
Enter AB then only items with AB are shown.
On a thick client this is can be very very fast. On a web client it may be a slower as may require a round trip back to the web server.
Also if the list can have objects from them and others give them a check box option to only see their objects.
rlo, rlo%, ^rlo, ^rlo.*, ctrl-A, shift-click, c:\utils\sys exporter.exe -> copy list contents -> paste into a half decent program -> filter words beginning with rlo
Commented
Mar 16, 2017 at 23:44
What feature(s) should I add so that they won't need to do that anymore?
At minimum, add a "starred item" feature where the starred items float to the top in the sorting order. The next level up is to have a separate priority field that defaults to normal but has a few settings above normal and a few below.
This used to be the case at my company, where a shared scanned had an addressbook used to e-mail scanned documents. This list was sorted by name associated with the e-mail. Since the UI was quite difficult to manipulate (tiny touchscreen, laggy), being on the top of the list was quite a perk, so people started being imaginative in the way you describe.
This was promptly solved by setting the addressbook to be sorted by creation date by default. This made the service self-regulating: everyone could re-create their entry to get to the top of the list, but only people who used the scanner a lot (like the secretary) would really benefit form the speedup. Most employees who only use the scanner once a month eventually realized that spending 1 minute browsing the addressbook alphabetically was faster than playing king of the hill every time they needed the scanner. And those who still wanted to play didn't have to mangle their name and ruin the alphabetical order for everyone else.
When you sort something by alphabet, you are, quite literally, prioritising words which have a lower value in ASCII encoding.
...why? What is the significance of this ordering?
Now you know and I know that it's to help find a thing in the list - that's the real goal. It's just that alphabetisation doesn't address that goal directly.
Bottom line, yes your user's might be considered naughty for exploiting your mistake, but let's be clear, you made the mistake. Not them.
Don't list out objects. Display a few random ones, perhaps group by function, perhaps implement a live-search for objects that partially match a phrase. That way you are designing a system where users aren't rewarded for having the lowest value is ASCII sorted order, but are rewarded for doing what you really want them to do - name their objects properly to describe their function.
I would say that since this is permitted by the system, then the user can do as they like.
A___My first item, yay! or 0___My first item, yay! instead. You'd need to ignore the special characters in ordering entirely, which is a whole another can of worms.