5 ms·
I've noticed a trend in many web apps to stop doing something that used to be standard It's this: you're displaying a list of things that have various properti
by andybak 10y ago
I've noticed a trend in many web apps to stop doing something that used to be standard
It's this: you're displaying a list of things that have various properties. It used to be the case that you're be allowed to sort and filter by any property. Many web apps nowadays seem to 'curate' my sort and filter options and in many cases a particular use is crippled because the property I want to sort or filter by is one that the author deemed a minority use-case.
Now the programming cost of allowing filtering by anything is minimal. The cognitive load on the user is minimal (once you've got the UI for one property then adding more doesn't make much difference)
I've found this deeply frustrating on many occasions.
- red_admiral 10y agoAnd further, the UI for sorting/filtering does NOT get in the user's way. Sure, a config screen with 100 check boxes on a page is bad UI, but a table that you can sort by any column looks almost exactly like one you can't sort, just that in the former case the column headers are clickable (or little arrows appear when you hover over the heading).
- dgoldstein0 10y agoOne reason for this is that if the list is lazy loaded (e.g. paginated) in any way, it can be more difficult to make sorting & filtering work on more dimensions - mainly it requires the list to be indexed in extra ways. Not impossible, but some applications weren't designed to support it from the beginning.
- Retric 10y agoIf it's common to sort by X, you should add an index. But, if it's rare to sort by X then doing it the hard way is at worst (O) x log x which is a generally a non issue out to a few billion records. Remember, give me the next 100 of X less than Y is an O(N) operation.
- gregmac 10y ago> But, if it's rare to sort by X then doing it the hard way is at worst (O) x log x which is a generally a non issue out to a few billion records. Not really true. Users aren't understanding if "sometimes the list page takes over 10 seconds to load". They don't understand (or care) that they are doing a non-indexed query or that the alternative is they don't get to do it at all. Removing a feature is often not acceptable, and so often the only resolution to a problem like this is to add an index. Of course, indexes increase the write times to your database. Indexes on every field increase the write times by a lot. Except sometimes you can't simply add an index, because you're displaying a calculated value and only calculate it for the page you're displaying. In order to sort by that value, you have to calculate for the entire system, so now you're into O(n^2) or worse complexity. You can also denormalize or pre-cache calculated values in some way (even going as far as adding something like ElasticSearch on top), but that introduces another dimension of problems (expensive updates, more potential for bugs and/or stale data). Do this for several fields, and you're now talking about quite a significant development effort, both up-front and for on-going maintenance, to support sorting that wasn't ever an actual requested feature and that only a small minority of users actually use. I know this because I have inherited exactly this problem before. Even as thousands turn to millions (let alone billions), anything worse than O(n log n) becomes painfully obvious rather quickly, and it tends to happen to the entire system at once. Suddenly you have to fix a whole bunch of "this feature is unusable slow, you broke my business" problems at the same time, while getting further and further behind your actual planned schedule. > Remember, give me the next 100 of X less than Y is an O(N) operation. ..IIF you spent the time to implement caching (and deal with the additional cache invalidation complexity problems). Many apps do paging on the database, or only do expensive joins after paging. Heck, many apps are even stupider and query the entire dataset from the DB, do paging in code, then throw it all away afterwards (so every time the client asks for the next page, it transfers the entire result set from the DBMS).
- Retric 10y agoEd: The specifics on how things get broken are complex and fixing them can be non-trivial. But, punting these issues often means they keep showing up when you want to do some other completely reasonable thing. People talk about unit tests as a huge thing, but when your software can't handle basic functionality things are already horribly broken. As to removing features to avoid slow pages when using the feature, that's a horrible tradeoff.
- OldSchoolJohnny 10y ago"Now the programming cost of allowing filtering by anything is minimal" Not only is this not true except in your imaginary app but it's also disregarding the incredibly bad UI that can come from allowing everything to be filtered. A good design has constraints and thoughtful choices. A shitty design has everything possible thrown on the screen because "allow filtering by anything is minimal".
- Joeri 10y agoA good metadata layer can generate appropriate filter controls, so it is the case that a system can be architected so that filtering by anything provides little programming overhead. The system that i work on is like this. Whenever you see a grid, you can filter by any column, with appropriate controls for that column's datatype. Whether it is desirable to do such a thing depends on the nature of the product and its users, but my point is that the dev overhead can indeed be minimal.
- sitkack 10y ago> except in your imaginary app That kind of language isn't going to further the discussion. --- Arbitrarily adding constraints doesn't make design better. The default container for tabular data probably should allow for sorting by any column. Show the OP the benefit of the doubt.
- wallacoloo 10y agoThis is highly application-specific. If you're looking for components to use in some design, for example, it's useful to have the component value, power rating, cost, form-factor, etc, all displayed together and filterable/sortable. If the application doesn't allow for filtering in this context, then that's something that the user ends up doing mentally. Worse, if the application doesn't allow all this information to be displayed as a summary, you end up with 50+ products for which you have to manually click a link and skim the product brief of each one individually. For example, here's Newarks's procuct chooser [1]. You can sort and filter by any field. It remains uncluttered by default-populating only the most commonly-used fields, but it avoids sacrificing any capabilities via making these hidden fields easy to access (click the "extended" button right above the table header). I'd like to point out that in lists like these, the parent comment is 100% correct in saying "[the] cost of allowing filtering by anything is minimal". And while I'm sure an experienced designer could improve the UI, this is a scenario in which sacrificing capability for beauty is absolutely an inappropriate thing to do. [1] http://www.newark.com/eeprom http://www.newark.com/eeprom
- dragonwriter 10y ago> Now the programming cost of allowing filtering by anything is minimal. The programming cost of allowing sorting/filtering on any field (especially if performance is not a concern) is small. Depending on the dataset, the resource (and programming, though this is usually less of an issue) cost of supporting efficient filtering and sorting on every column rather than a limited subset may not be.
- KallDrexx 10y ago> Now the programming cost of allowing filtering by anything is minimal Only in simple CRUD applications where the data being displayed is a 1-1 with how the data is stored. In any non-trivial CRUD application this is not the case, and paging/filtering/sorting on a field that is being displayed quickly becomes non-trivial if you are trying to do it for every field.