A leopard can’t change his spots. (But he may change jobs.)

I won’t bury the lede: My last day at Tableau was July 6th, and tomorrow I start a new gig at Snowflake.HappySad

I joined Tableau in June of 2015, and spent most of my three years there starting, building, and ultimately shipping Tableau Prep. I’m incredibly proud of the Prep team, the product we put together, and the awesome functionality yet to come.

As I move on, I’ve been thinking a bit about the past projects that really excited me. In addition to Prep, my favorites were probably StreamInsight, which was a system for dealing with time-aware queries and streaming data, and the spatial types in SQL Server. (Those types are still going strong and motivating new integrations ten years later.)

A common theme through of all of these projects has been making it easy to do complex things with data. And Snowflake is most certainly out to do that with data warehousing. It feels like a wonderful match.

I’m going to miss Tableau — it’s a wonderful company — and I’m going to miss Prep. But I’m incredibly excited to be starting at Snowflake. (And a special thanks to those Preppies that slipped Snowflake support into the latest Prep release. That should save me some awkward moments.)

I’ll try to keep writing here — maybe with a broader set of topics, and hopefully with a bit more regularity. So do please check in and drop me a note.

Tableau Prep: The Power of Composability

When we built Tableau Prep, we put a premium on ensuring composability of operations: you can take the operations Prep supports and string them together in any combination you need. There are no restrictions based on where the data came from, or what operations came before.

This means that you never need to think about whether a particular operation is supported in your particular situation: if Prep supports it ever, Prep supports it always. Moreover, this gives you a lot of power to do what you need to with your data.


In the rest of this post, we’ll walk through a Superstore example that highlights this power.

Continue reading

Tableau Prep: The Flow

I’ve been a bit quiet lately, but Tableau Prep out the door and it’s time to make a little noise.

Clark recently wrote an excellent post on the basic UX architecture of Prep. Here I’d like to cover a key concept underlying Prep that may be a bit foreign to people coming from Tableau: the flow.


This isn’t the most glamorous part of Prep, but it is one of the most fundamental concepts in the tool, so it seems worth spending some quality time on.

Strap on your life jacket and read on for more.

Continue reading

When Live Beats an Extract

When using Tableau, taking an extract is always better than using a live query, right?

Well, no.

Of course. Obviously, when your data are changing and you want to get all of the latest updates in your viz, you’ll want to use a live query. But if that’s not the case, then an extract is clearly better, especially with Hyper in 10.5, right?

Well, no!

Shoot! This is complicated? When will live beat an extract? Let’s take a look at a few cases.

Continue reading

A Visual Guide to Telescope Eyepieces

Hi Folks,

Not too long ago, I bought a telescope. I guess that makes me an amateur astronomer.

If you buy a camera, you are a photographer. If you buy a flute, you own a flute.
Bob Kolbrener

So maybe I just own a telescope.

I certainly need some help when it comes to choosing things like eyepieces, so I was thrilled to come upon a very thorough list of eyepieces assembled by Starman1 (Don) over at Cloudy Nights.

But a spreadsheet is one thing—a viz is better. My take at an explorative viz is online over at Tableau Public. (I wish I could figure out how to embed something here, but all I can manage is a screenshot.)

eyepiecesGo ahead and tweak the parameters to find the eyepiece you’re looking for. Some details on how I built it are below the fold. Continue reading

The Fourier Series via Linear Algebra

I didn’t post last week because I was on vacation. But on vacation I decided to write about something a little out of my comfort zone: Fourier series. (Yeah. Try being my wife.)

Fourier series (and the related Fourier transform) made some sense to me for, but I never really learned how to derive them so they always seemed a bit magical. As I was going through Arthur Mattuck’s excellent differential equations course at MIT’s Open Courseware, the Fourier series clicked for me, so I thought I’d distill this out.

I’m tempted to categorize this post under “things Isaac should have learned in school (had he been paying attention), but I don’t think I ever had a course that taught this. If you’re still paying attention, I will assume that you recall your basic linear algebra and have some idea (and interest in) what a Fourier series is. But given that, this isn’t hard.

Continue reading

The Query Behind the Viz

Several posts here have explored the queries Tableau generates as it builds your viz, including last week’s write-up on custom SQL. This is a trend that will continue: it’s much easier to understand a machine when you can see its inner workings.

But how do I get at those queries? I was talking with Yvan Fornes, and he suggested that I write about how I do it.

Challenge accepted! Except I may have gone overboard: in this post I’ll explore three ways to find the queries underlying your viz.

Continue reading

Custom SQL in Tableau: Subqueries and SQL Injection

I recently answered a question on the Tableau Community forums that arose from confusion over why some (perfectly correct) SQL wasn’t working as custom SQL in Tableau. The poster wanted a list of Tableau’s supported syntax.

But as it turns out, that’s the wrong question: Tableau doesn’t have a list of all the custom SQL syntax it supports because it really is just passing along the SQL code as you’ve typed it.

So why would a perfectly reasonable custom query fail? And what’s the link to SQL injection? Read on!

Continue reading

Row-Level Security: A Cautionary Tale

Row-level security is a common requirement for people trying to control access to data. Some systems provide this natively, but when it’s not provided, people often roll their own using the tools they have—with mixed results

In this post we’ll explore a common way to implement row-level security on top of a relational database and see why it may not be as secure as it looks.

A Pop Quiz

But before we get to the crux of the issue, here’s a quick quiz. I promise it’s relevant.

What will each of the following languages do when a is equal to 0​?

  1. C, C++, C#, Java, and most other C-family languages:
    if (a != 0 && 1/a > 0) { /* Do something */ }
  2. Pascal:
    IF a <> 0 AND 1/a > 0 THEN (* Do something *)
  3. SQL:
    SELECT *
    FROM T
    WHERE a <> 0 AND 1/a > 0

Obviously, I’m asking about short circuiting behavior. I’ll let you ponder and reveal the answers in a moment. But first, back to row-level security.

Continue reading

A Dozen Notes, Give or Take


Western classical music typically uses twelve distinct notes: C, C#, D, D#, E, F, F#, G, G#, A, A#, B. After this, you hit an octave and repeat.

It always bugged me: why twelve?

Here I try to provide an answer with a few rules and a few graphs. This is a little hand wavy, I’m sure that it’s not original, and I know someone who knows more could make this more convincing and more rigorous.

But this is the internet. Who cares?

Continue reading