The conversation: data due diligence
Recently, Allison (a data scientist advocate) and Maria (a marketer and writer) were talking about data workflows. They got on the topic of “due diligence” during data exploration.
Maria got curious when Allison said that Observable helped her with responsible EDA. Here's that chat:
MARIA
Allison, did I just hear you say that Observable has helped you explore data more responsibly?
ALLISON
Yes you did.
MARIA
Like, compared to other tools? Observable has made it easier for you to do ‘responsible EDA?’
ALLISON
Yes! With big, complex datasets, sometimes trade-offs are made between time, effort, and thoroughness of data exploration — which is not great. You could miss out on some important insights, or interesting questions. If you’re limited to faceting or making a bunch of individual static charts to explore different variable combinations, it can be pretty tedious to really dig into patterns. And, the lift of making interactive viz for EDA like building out and publishing an app can be high.
MARIA
Huh. So what’s different about Observable?
ALLISON
The game-changer for me is the combo of Observable Plot and Inputs, because you can quickly and easily create interactive charts that allow you to explore complex datasets, painlessly. And, there are a bunch of other cool features and tools, like the Data Table Cell to get quick views of your data out of the box.
MARIA
Wow, that sounds helpful.
ALLISON
It is. I think data exploration is one (of many) ways that Observable shines. And even more so on the important collaborative side of data exploration. It’s built for asking-questions-together, poking around the data, letting other folks try different variations and participate in the discussion.
MARIA
Hey, we should write an article about this.
ALLISON
Let’s do it.
So, here is that article.
It’s about how you can use Observable for more thorough and responsible data exploration.
Low barriers to fast viz
Time-to-viz is reduced for all team members in Observable because:
All it takes to get started in Observable is logging in. No software installation, no package installation, no environment set-up, no git. Reduced barriers to entry mean that the whole team can jump in immediately.
Observable provides code snippets for common exploratory chart types (choose a snippet, then replace the example data and variables with your own) using Observable Plot.
Observable Plot is a simple, expressive charting tool that lets you quickly pull together analytics dashboards that entire teams can multiplayer edit in real time.
And here's another reason Plot expedites your data workflow: Observable Plot lets non-technical stakeholders ask and answer questions, self-serve insights, and just … see what’s happening in a notebook.
If you are just getting started with Observable Plot, be sure to check out these helpful Observable Plot Cheatsheets.
Inputs, for frictionless interactive EDA
With complex datasets, thorough data exploration usually falls into two camps:
Making a bunch of static visualizations to explore each relevant combination of variables and/or levels that may be of interest. This work is tedious, and not conducive to exploration, tinkering, sharing, or giving others (including non-coding teammates) agency to explore the data in new ways.
Building out a dashboard or web app to use to interactively explore different combinations. This requires having someone on your team who has the skills to build an app or dashboard. Even then, it’s a big lift to create and share.
Neither of the options above are “quick and painless” when exploring complex datasets.
Observable facilitates faster, more thorough, and even fun (it’s true) data exploration. In Observable, Inputs are lightweight interface components (aka widgets) — buttons, sliders, dropdown menus and more — that when linked to visualizations let us explore data interactively.
When working in Observable, there’s no intermediate between you and interactive data visualization. Since you’re working in the browser, in the language of the web, there are just two steps to make an interactive visualization:
Create the Input, quickly, using our Inputs snippets.
Connect the Input to your data or visualization to add interactivity.
That’s it. Two steps to create interactive visualizations that extend you, and your team’s, ability to explore more variations and combinations in your data, quickly. Here’s an example:
MARIA
Allison, do you recall when you discovered Inputs on Observable? What was that like? How did it change how you worked?
ALLISON
Yes, I do remember! It was the first week I was working at Observable. I was following along with the Tutorials. I got to “Inputs”. Upon seeing how easy it was, I was:
(1) blown away by the ease and "lightweight" feeling of it, and
(2) dismayed at how much time I'd spent creating interactive visualizations previously. :)
Like...creating interactive visualizations is no longer a burden??? It can be fun? What have I been doing all this time? It's not even really more difficult than creating a STATIC dataviz.
Inputs help you explore data and build interactive displays, and empower team members to poke around the data to reveal and answer their own questions. For a walkthrough of how you might use these to support data analysis, see Hello, Inputs!
Fast EDA in the UI with Data Table Cell
Data Table Cell is a data analysis tool that allows you to quickly explore and analyze your data directly in the UI.
It's a scannable, tabular display that supports direct manipulation of data, with automatically generated summary charts for the data columns. So, you can see a quick overview of your data in a few clicks without writing a single line of code, or having to use multiple tools.
Streamlined sharing, exploring and feedback
No matter what tools you and your team are using for EDA, sharing work, exploring the data together, and giving feedback is vital.
This is also where things can often get clunky and exclusive, sometimes leading to siloed EDA by data scientists or engineers that may miss important questions and insights from non-coding team members.
In fact, this step made Maria get curious, and ask Allison the following:
MARIA
Allison, wait. How did you share, collaborate, and give feedback before you were using Observable?
ALLISON
Oh yeah. Before I started using Observable, here’s what interactive EDA options looked like for me:
(1) Working solo, rendering, then either emailing or publishing an html (e.g. using GitHub pages) and sending the link, or —
(2) Building then publishing an app. In either case, if someone had a question beyond the current options, then I’d personally need to make changes, re-render or re-publish the output, and push or send changes to wherever my teammates could access it again.
MARIA
Oof.
ALLISON
Exactly.
Observable lets you efficiently share, explore, ask questions and give feedback, in one place, giving everyone on your team agency to work with the data.
Add people to an Observable notebook just as you would with a google doc or a figma file — something team members of all skill sets understand. Observable is purpose-built to remove setup headaches and the limitations of GUI-only tools.
Instead of emailing back and forth to get team members and other stakeholders involved, you can just share your Observable notebook with them and start working in the browser together. No setup required.