Why is it often not possible to un-sort a table?

Question

When data is presented in tables, it is often crucial to be able to sort the table rows by one column. Usually this is achieved by making the header of the columns clickable, and showing pointers like ▲ and ▼ in the table header, indicating the sort order.

However, I noticed that one feature is missing in many cases. This affects websites as well as desktop applications, and it's illustrated in this example:

It is usually not possible to un-sort the table! Clicking the header just toggles the sort order, but it is not possible to restore the original order. And as the example says: This is very annoying. For me, this even has the effect that I hesitate to use the sorting functionality, because I'm always afraid that it will not be possible to restore the original order afterwards.

Is there any sensible reason of why it is so uncommon to offer the option of restoring the original order of the table?

I could imagine some vague, technical reasons, e.g. that the original order somehow has to be retained internally, and this might imply some memory overhead. But considering that the sorting often happens in the view, and the model remains unsorted anyhow, this can hardly count as an argument.

Offering the option to remove the sorting on one column would even allow sorting by multiple columns, using them as primary/secondary/... sorting criteria. But as long as it is not possible to remove one sorting criterion, this is not sensibly possible.

---

^{(The example is a JTable from Java/Swing, and for this case, I solved this using a custom TristateTableRowSorter, and a dedicated renderer that shows the ▼▲ arrows in different sizes to indicate primary and secondary sorting criteria. But most table presentations that I've seen so far lack this feature, and I wonder why)}

Answer 1

It is an interesting question that we probably don't think about too much as designers and developers, but I think there are some logical reasons for this depending on the specific context in which data is displayed in tables.

In tables where the data is dynamic (i.e. new entries are added), restoring the original sort order might mean that the actual sorting order is incorrect. That is, you can't just restore the order to what it was before because new items have been added and the sorting order needs to be readjusted. Therefore, you either choose to re-sort by one column or another with a new order.

In tables where the data is static (i.e. no new entries are added), restoring the original sort order is no more complicated than just allowing you to sort on multiple columns (in both ascending and descending order).

I can't think of many practical cases where being able to un-sort a table is very important, because if it is vital for the order to be preserved then you probably wouldn't allow the user to change the order. Instead you might allow them to search the table and return results instead (i.e. show a subsection of the table with the order remaining intact).

Answer 2

In your example, column A actually does have some implicit order (since its forming a sentence) and you could potentially have a sort either on that column, or an associated one which will maintain the same order.

Usually, the default row ordering is simply based on how the items were loaded into the model. If sorting is provided, then it doesn't make sense to do any pre-sorting of data at model level, so its just an unsorted presentation - why do you want to 'reset' to this state? If the table actually has some intrinsic order when displayed, its better to make that column sortable as well - this means it can also be reverse sorted.

If the table supported sorting on multiple columns, then yes perhaps an option to remove sort for a column makes sense. However most implementations only sort on a single column, and at best might use stable sorting which maintains previous column ordering for same values (so, to apply 3 level sort you'd choose tertiary, secondary and then primary column as the ones to be sorted).

Answer 3

Implementation difficulties.

Sorting a table is a meta-operation, which consists of a large number of row-swaps.

Most applications' undo functionality is based on a stack. The stack has a limited capacity. Recording each of the row-swaps as in individual entry would overwhelm the stack, and risk allowing (or forcing) the user to partially un-sort the table. It would also slow down the sorting operation, and require an interaction between the sorting code and the undo code. Most programs avoid these problems by treating sorting as an action that is not undoable.

Yes, it might be possible to hash the row order before-and-after the sort. And the sorting could be treated as an atomic action for purposes of undo. But ask yourself: Does this data structure scale to the table sizes you work with? And is there someone willing to write the custom code to enable the feature?