The course combines visual theory with intensive programmatic
implementation. While it builds directly upon your foundational analytics
tracks, it requires hands-on Python development to translate conceptual
design choices into automated, boardroom-ready visualization pipelines.
Program: MS in Data Analytics and Business Computing (NYU Stern)
Data visualization is the bridge between complex statistical computing
and strategic business decisions. This course trains analytics
professionals to think critically about data perception, construct
programmatically flawless visual assets, and present data-driven
narratives to C-suite stakeholders.
The course builds core core competencies across three primary pillars:
Visual Psychology and Perception: Understanding how the
human brain processes shapes, color axes, and positions before designing
any technical chart assets.
Programmatic Optimization: Eliminating visual noise,
calculating information densities, and automating clean, scalable visual
pipelines via Python libraries.
Strategic Narrative Delivery: Learning how to transform
exploratory internal models into explicit, persuasive, and highly clean
data presentations targeted directly to executive leadership boards.
Prerequisites
Foundational comfort with Python data operations (manipulating
structures, arrays, and basic parameters).
Materials
The course curriculum relies systematically on four foundational
literature texts:
Requiring attendance is necessary for several reasons. First, you
incorrectly assume you can catch up on a missed class by watching a
recording (if available). Videos do not engage your brain as much as a
live class. Second, less than 20% of you watch the recording (if
available). You are then lost in class, which provides the wrong signals
to me as an instructor. Third, your absence hurts class discussions.
Fourth, you miss out on feedback if you do not work through the questions
I pose in class. Fifth, I lose the feedback since there are fewer
questions.
The policy below will be in effect only after the add/drop
period.
Without mandatory attendance, attendance is often below 50%. Therefore,
though I dislike doing this, I penalize absences. If you anticipate being
absent for good reasons, please email me well in advance. Please enter
"Excused" on the attendance sheet described below to avoid the
penalty if approved. If you miss a class due to emergencies and cannot
tell me in advance, do not panic. Take care of the emergency first, and
then email me. I will permit you to change the "Absent" to
"Excused." But if you miss a class without a valid reason, there
is a penalty, as stated below.
For sections meeting in 150-190 minute sessions, you will lose one
grade (A to A-, A- to B+, B+ to B, B to B-, and so on) for EVERY missed
session unless you were explicitly excused via email. Thus, if you miss
two class sessions, you will lose two grades, and so on.
Please sit in the same seat in every class and display your name tags. For
Zoom classes, you must keep your video on AT ALL TIMES. You must also have
a good working headset or mic, as it is extremely rude to be inaudible and
force me to ask you to repeat yourself. After entering the class, please
mark yourself present on the OneDrive sheet within the first 20 minutes
(link posted on Brightspace).
You will be marked absent if you are more than 20 minutes late, unless
it is due to factors beyond your control (traffic, subway delays, or
interviews running late). You will also be marked absent if you leave
the class early unless you have my permission or get it afterward. You
will get an F in the course if you are caught cheating on the attendance
sheet.
Exams and Grading
There are no midterms, in-class quizzes, or written final exams.
Please read about the penalty for missing classes above.
Programmatic Python Labs / Assignments: 50%
Final Capstone Presentation & Slide Architecture: 50%
Hour 2 (Technical Lab): Restructuring visual
environments. Modifying default global matplotlib and seaborn
configuration structures programmatically inside Python.
Hour 3 (Corporate Application): Analyzing legacy
corporate pitch presentations to decouple raw business variables from
structural canvas markers.
Assignment Deliverable (Due Session 2): Take an
unformatted, default-styled chart from an open corporate data repository
and rewrite the functional code to explicitly follow Wilke's contrast
frameworks and scale definitions.
Session 2: Core Chart Typologies (When to Use What)
Core Learning Focus
Deploying tailored visual structures for distribution bounds,
proportional ratios, and time-series indexes without generating
cognitive overhead.
Hour 1 (Lecture): Structural typography selection.
Navigating bar structures vs. discrete point metrics; handling
multidimensional matrices cleanly on standard screens.
Hour 2 (Technical Lab): Multi-variable asset mapping.
Building advanced plotting environments (joint distribution grids,
conditional matrix arrays, and geospatial layouts using plotly and
geopandas).
Assignment Deliverable (Due Session 3): Build a static,
multi-panel visual analysis of an enterprise data framework (e.g.,
recursive user churn, financial investment volatility portfolios)
isolating specific chart patterns.
Session 3: Timeless Principles of Graphical Integrity
Core Learning Focus
Maximizing layout information metrics, stripping structural
presentation noise, and mapping the fundamental design geometry of
datasets.
Hour 3 (Executive Strategy): Migrating structural
Tufte paradigms into dynamic Business Intelligence interfaces
(dashboard view configurations inside Tableau, PowerBI, or Streamlit
tools).
Assignment Deliverable (Due Session 4): Refactor your
Session 2 dataset analysis by applying Tufte's constraints.
Quantitatively audit and optimize your output's data-ink metrics while
converting raw graphs into clean small multiples.
Hour 1 (Lecture): The cognitive transition from
Exploratory processes (uncovering model vectors) to Explanatory
narratives (delivering decisive executive solutions).
Hour 2 (Technical Lab): Programmatic Annotation
Frameworks. Injecting tailored highlight markers, muting secondary
context arrays into background gray hues, and printing conditional
label blocks via Python commands.
Hour 3 (Live Workshop): Real-world transformation
sprint. Stripping down a convoluted, overcrowded legacy corporate
tracking view into an isolated strategic brief.
Assignment Deliverable (Due Session 5): Package your
analytical dashboard assets into a target 3-slide C-suite presentation
deck following Knaflic's models for structural annotations and explicit
action paths.
Session 5: Data Literacy, Ethics, and Analytical Traps
Required Readings: Cairo: Selected Chapters
(Misleading axes, distorted scales, proxy metrics, correlation vs.
causation in visuals).
Session Breakdown
Hour 1 (Lecture): Deceptive architecture tracking.
Truncated baselines, comparative double y-axis problems, projection
map skewing, and cherry-picked date parameters.
Hour 2 (Technical Lab): Defensive Visualization
Scripting. Coding programmatic canvas parameters to secure safe visual
configurations (forcing matching element aspects, establishing true
zero baselines, normalization steps).
Hour 3 (Corporate Simulation): Auditing legacy
corporate reporting anomalies and investor disclosures to discover
structural metrics deceptions.
Assignment Deliverable (Due Session 6): Author a
corporate internal design safety brief tracking 5 distinct visual
metrics traps within your capstone market vertical, providing code
guardrails for each.
Session 6: The Capstone Boardroom Presentations
Core Learning Focus
Live tactical presentation, visual defensive argument handling, and
processing real-time C-suite feedback cycles.
Required Readings: Review Knaflic Chapter 10 and
Wilke Chapter 29.
Session Breakdown
Hours 1–3 (The C-Suite Pitch): Live group capstone
execution. Teams deliver a critical corporate case deployment using
their developed visual structures.
Each student cohort receives a 10-minute slot to deliver their core
analytical pitch deck, followed by an immediate 10-minute technical
cross-examination assessing their rendering pipeline, design
variables, and mathematical execution.