Design for non-ideal UI states

[sadielbartholomew]

Issue #87 covers design in the case where the full Cylc-to-UI system is working seamlessly or ':+1:' (ample standard workflow data exists & is coming through to the UI without any noticeable delay). But we should also capture & discuss what we want the UI to show for states where there is not true, which will undoubtedly occur & can be designed with the aim to inform & guide users in each case.

I think a separate Issue is best for this, as #87 already records a lot regarding the "ideal" path.

There are three main "off-the-ideal" umbrella cases (& they are summarised nicely in e.g. this UX blog post) & in our context, I anticipate they could emerge as follow:

• the empty state: when there are...
  • no suites to show in the gscan-like sidebar;
  • no tasks left to show (the suite finished running, etc.) for a suite being viewed under any UI View component (e.g. the Tree);
  • no results for some user input e.g. a search or filter query;
  • no views in the main display component area.
• the loading state: for any component, where key things to aim for are:
  • providing feedback so the user knows the component is loading & how much progress has been made towards it being fully-loaded;
  • in appropriate cases, progressively rendering the component (c.f. 'skeleton screens' & 'lazy loading' in the UX sphere, with a nice summary post here).
• the failed/error state: some client or server problem that means that:
  • the whole page can't display & we get a bad HTTP response code such as a 404, e.g. when a URL is typed manually incorrectly or in rare cases where the whole UI is down;
  • the data is not getting through for whatever reason (see also tree view: on error, wrong (last) suite's tasks listed #103), meaning a component can't be populated initially or update at some point thereafter.

For each case above, we should try to put some consideration into the following aspects, at least:

• what, if any, message to display to indicate the cause & resolution to the non-ideal state (e.g. "You currently have no running suites. Start up any suite with cylc run & it will appear here.")
• what the UI component will look like otherwise, e.g. greyed out, blurred, displaying some image or symbol as an indicator?

Please add thoughts &/or sketches on this topic here, or discuss on Riot & we can summarise here as appropriate.

[sadielbartholomew]

I'll kick this off with one suggestion! (It includes a question, as it depends on whether this would data provision will permit this in an intrinsic way).

As we know the Graph View will take the longest to load of all the Suite Views, since it is the only one to show dependencies, & in the old (but surely less-performant) UI, gcylc, it could take ~10 seconds order of magnitude or even longer for large enough graphs.

From our Cylc 8 discussions, we are planning to implement the Graph View so that it displays only tasks within a configurable number of dependency connections from the currently selected task (see #81 (comment)).

Could we (i.e. 1. should we, & 2. would our data model allow this to be natural & efficient) have the task nodes load by increasing number of dependency connections? E.g. the task itself loads, then the tasks connected to it directly, then the tasks connected to those tasks, & so on?

That way the user can see the tasks closest along the dependency chain to the task in question they are concerned about, which is usually I imagine going to be the ones they are interested in? And perhaps they can stop the loading once they are satisfied they have a sufficiently large sub-graph to work with for their requirements?

[hjoliver]

Could we (i.e. 1. should we, & 2. would our data model allow this to be natural & efficient) have the task nodes load by increasing number of dependency connections? E.g. the task itself loads, then the tasks connected to it directly, then the tasks connected to those tasks, & so on?

I like that idea. If edges are paged by "level" that could work. If difficult though, as a first cut just gray out the view and display a throbber/loading animation until loaded.

[sadielbartholomew]

If difficult though, as a first cut just gray out the view and display a throbber/loading animation until loaded.

Yes, a more standard loading component would certainly be fine for now. There are lots of nice loading components on the Vue Awesome listing. Heck, we could even have a pac-man eat up (little representations) of tasks!

Though, I have also thought of an alternative to my own suggestion, too: if the data provision instead means that dependencies are (or could be) loaded in before full information is received on the tasks (&/or their associated jobs) included in the loaded dependency chain, we could as an intermediate state between entirely unloaded & fully loaded have a generic 'image & info' skeleton (like the one here, as a demo of this component) against displayed task nodes.

[hjoliver]

I like the skeleton idea too (if it proves to be feasible ... but again, it could potentially be a follow-up improvement, after initial basic functionality is implemented)

[oliver-sanders]

To answer the data provision questions above:

• We don't really have control over the order in which nodes and edges are delivered.
• The delay in rendering the graph is more to do with dagre than it is to do with the data provision.
• The type of graph layout system we need (e.g. dot/dagre) cannot do incremental layouts.

So an intermediate graph rendering isn't really possible, however the n-nodes solution should protect us against large graphs. Skeletons / placeholders with spinners / throbers as suggested above are probably the only option (dagre doesn't give progress information as far as I'm aware).

I think I've captured this in #334, #332 and #329 which if accepted should be sufficient to close this. If anything is outstanding please say / raise another issue.

[hjoliver]

The type of graph layout system we need (e.g. dot/dagre) cannot do incremental layouts.

I think Martin showed it can, sort-of, in Cytoscape - but it does not look very good!

[hjoliver]

We don't really have control over the order in which nodes and edges are delivered.

In the back end we (will) compute n=1, n=2 window etc. on demand. So, we could potentially page by "distance" from the active tasks. So, even if you want to see n=5, the UI could first quickly plot n=1, then n=2, while doing the more expensive n=5 layout in the background???

I don't know if that's feasible in reality, but it in principle it seems possible ... certainly not a high priority though, as the default n=1 window ought to be quite usable even for huge suites.

[hjoliver]

Anyhow, generally speaking happy to close this.

[oliver-sanders]

I think Martin showed it can, sort-of, in Cytoscape - but it does not look very good!

Nope that's the graph presentation layer, the layout engine (i.e. dagre) is still running over the whole workflow.

[hjoliver]

Nope that's the graph presentation layer, the layout engine (i.e. dagre) is still running over the whole workflow.

Yes but I assumed you wouldn't have to run the layout again if using the presentation layer to bodge in few nodes in some whacky box on top of the original layout. But maybe I misunderstood (I didn't really bother much because the result didn't look useful).

[hjoliver]

Shall we close this then, and come back later if a page-loading throbber isn't sufficient for large graphs?

[oliver-sanders]

Fine by me.

BTW I'm trying to split up some of the large umbrella issues like this one into bite-size tasks we can prioritise.

[oliver-sanders]

Closed as superseded by #334, #332 and #329