"I've been doing that for years, and it's been totally wrong all this time!!?!". Surprisingly, In our field this sort of realization actually tends to be enjoyable. I call it "unlearning", and I get a kick out of it every time it happens to me. Lately, I've been giving other people kicks too. And since many of them seem to enjoy it, we've decided to put a whole track together around the theme of unlearning myths and mis-practices around performance and it's understanding. This track will tackle and attempt to slay myths around how performance is thought about, measured, and described, as well as things that we can do to affect it. We'll cover throughout and response time behaviors, how code profiling works (and doesn't), what network protocols APIs, and associated design choices actually do well (and badly), how compilers and runtimes do or don't work, and how practical scaling interacts with performance. Each talk will include unlearning points, and some may also include helpful learning to fill in the vacuum created. Our track goal is simple: you will leave each talk knowing less than you did coming in. And that's a good thing.