THINK FIRST·CODE LATER

← Interactive Information Visualization
Chapter 3 · Week 3

Task Abstraction: Why Is the User Looking?

Before You Start: What You Must Be Able to Do

Before the questions, make sure you can: rewrite a stakeholder's request as one or more {action, target} tasks in visualization vocabulary, naming the attributes from the data abstraction; place an action in the hierarchy (analyze, search, query) and choose among lookup, locate, browse and explore by asking what the user knows; choose the right target; decompose a goal into a chain of tasks and derive how many linked views it needs; explain the four nested levels of design, the threat at each, and which validation method belongs to which level; and critique a task analysis produced by an AI assistant.

The Big Idea

"I need a dashboard for air quality" is not a task — it names no action and no target, so it cannot tell you what to draw. Three users of the same data may need to discover outliers, compare distributions and look up one value — three tasks, three different designs. Task abstraction translates domain requests into a small, precise vocabulary. It is the step AI tools skip (they jump from data to chart) and the reason so many technically correct dashboards answer nobody's question.

Tasks as {action, target}

A task is one verb and one noun from the vocabulary, applied to attributes of the data abstraction:

{action} {target} in {dataset, attribute(s)} — e.g., discover outliers in pm25 across sensors.

If you cannot write a request in this form, you do not yet understand it well enough to design for it.

Same data, different tasks, different products: Netflix, IMDb and Letterboxd all hold film databases. Netflix serves browse (users do not know what they want: rows of covers, search hidden), IMDb serves lookup (users know the film: a dominant search box and a dense fact page), Letterboxd serves compare (how did this rate against that: histograms and side-by-side lists).

Actions: analyze

Branch Actions Meaning
Consume discover find something new — exploratory; the analyst is the audience
present communicate something already known to someone else; the conclusion exists before the chart
enjoy casual, curiosity-driven use
Produce annotate add notes to marks ("sensor fault here")
record save views, interaction histories, provenance
derive compute new attributes from existing ones

Discover vs. present matters most: Spotify's Discover Weekly (surprise is a feature) and Spotify Wrapped (a known fact, made memorable and shareable) use the same data with opposite designs. The Johns Hopkins COVID dashboard, built for experts to discover, became a presentation tool on the evening news — a mismatch that produced years of misinterpretation.

Derive is often the whole product: Uber's surge multiplier, Netflix's "% match", Google Maps' ETA and traffic colours are derived attributes; the raw data is never shown. For CityPulse, "days above the guideline per month" or "bikes available relative to capacity" may be more useful than any raw reading. When a visualization is not working, ask "what other attribute?" before "what other chart type?".

Actions: search

Two questions about the user — do they know what they are looking for (target)? and do they know where it is (location)?:

Target known Target unknown
Location known lookup (PM2.5 now at the Library sensor) browse (scan the stations in my district)
Location unknown locate (the station with the fewest bikes) explore (anything unusual this week?)

Each needs a different interface: lookup → search box or sorted table; locate → ranking by the attribute; browse → a spatially stable layout; explore → overview first, then filter and details. Google Maps offers four interfaces for the four cases. The most common failure in student projects: building an explore dashboard when the user's real task is lookup — they wanted one number. And "ugly" can be right: the Bloomberg Terminal is dense and old-fashioned because its users perform lookup thousands of times a day under time pressure; fitness to the task, not aesthetics, is the criterion.

Actions: query

How many targets at once: identify (one: the profile of the Library sensor), compare (some: three districts' PM2.5), summarize (all: the distribution over the whole city). Comparison is the hardest to support well and the most requested (Chapter 8: juxtapose, superimpose, partition).

Targets

  • All data: trends (overall pattern over an ordered attribute), outliers (items that do not fit), features (any structure the domain cares about).
  • One attribute: distribution (shape of the values), extremes (minimum and maximum).
  • Several attributes: dependency (does y depend on x?), correlation (do they vary together?), similarity (which items resemble each other?).
  • Networks: topology, paths. Spatial data: shape.

Dependency ≠ correlation: "does trip count depend on rain?" (a direction, possibly causal) is not the same question as "do temperature and PM2.5 move together?".

Targets drive design: a fraud dashboard is about outliers (0.1 % of transactions), so summarizing typical spending is useless; cloud operations watch extremes (99th-percentile latency), not the mean; A/B tests compare distributions, because two equal means can hide different shapes.

Writing tasks down

Stakeholder says Abstracted task
"Which sensors are misbehaving?" discover outliers in pm25 across sensors
"Is the new bike-rebalancing plan working?" compare distributions of empty-station minutes before vs. after
"Does rain reduce trips?" discover dependency between rainfall and trips
"What does a normal weekday look like?" summarize distribution of trips over hour of day
"Which station should get more docks?" locate extremes in time-full per station

Chains of tasks

Real goals are chains: summarize distribution (overview) → discover outliers (what is odd?) → identify one item (which sensor?) → compare before/after (did the repair help?) → present (explain to the city council). The chain tells you how many views you need and how they must be linked: overview steps share one view, identify needs selection plus a detail view, compare needs side-by-side views, and present needs a different artefact (a static, annotated chart or slide), not the dashboard.

The nested model: four levels of design

Munzner's nested model (IEEE TVCG, 2009):

  1. Domain situation — who are the users and what do they need? Threat: wrong problem.
  2. Data/task abstraction — what is shown and why (Chapters 2–4). Threat: wrong abstraction — showing the wrong thing.
  3. Encoding/interaction idiom — how it is shown (Chapters 5–8). Threat: wrong idiom.
  4. Algorithm — how it is computed efficiently. Threat: wrong algorithm — slow or incorrect.

Each level's output is the next one's input, so an upstream error cannot be fixed downstream: a beautiful idiom for the wrong task answers a question nobody asked. A real example of level 2: an operations dashboard showed mean latency while the service agreement promised the 99th percentile — the chart was correct and useless.

Validation must match the level:

Level Immediate validation Downstream validation
1. Domain interviews, observation adoption rate in real use
2. Abstraction — field study: does it help real work?
3. Idiom justification by perceptual principles lab study / controlled experiment, user performance
4. Algorithm complexity analysis benchmarks of time and memory

A timing benchmark (level 4) says nothing about whether the abstraction (level 2) was right; a lab study of task time (level 3) says nothing about whether the task mattered. Research papers — and course projects — are rejected for strong results at the wrong level. Always state which level you validate.

Industry spotlight

Product teams write jobs-to-be-done and user stories before designing dashboards ("As an operator, I want to locate stations that will be empty within an hour so that I can send a van"). These are task abstractions in business language — and the acceptance criteria become the evaluation plan.

Research spotlight

AI systems are now asked to "understand intent" in natural-language visualization requests. Research on NL2VIS shows that vague requests ("show me the data") are the hardest; systems that ask clarifying questions or infer explicit task types (compare, trend, distribution) produce better charts — task abstraction is becoming part of the AI pipeline itself.

Key takeaways

  • A task = {action, target} on named attributes; vague requests must be abstracted first.
  • Analyze: consume (discover, present, enjoy) and produce (annotate, record, derive). Search: lookup, locate, browse, explore (target known? location known?). Query: identify, compare, summarize (one, some, all).
  • Targets: trends, outliers, features; distribution, extremes; dependency, correlation, similarity; topology, paths; shape.
  • Goals are chains; the chain determines the views and links; present needs a separate artefact.
  • Nested model: domain → abstraction → idiom → algorithm; upstream errors cannot be fixed downstream; match validation methods to levels.

Ready? Close the notes and practise.

30 questions. Predict the output before you check — that is the skill the exam measures.