Data Visualization Tools: Desktop, Online, Libraries, and Open Source
Prerequisite Knowledge
This lecture builds on the following concepts from earlier lectures. If any feel unfamiliar, review the linked notes before proceeding.
Previously Covered in This Subject
- Data Visualization Tools in the Market — covered in Lecture 4 (the Gartner quadrant and the major tools: Tableau, Power BI, Looker Studio, Qlik, Flourish)
- Choosing a Visualization Tool — covered in Lecture 4 (the tool-selection criteria this session extends)
- Flourish — covered in Lecture 4 (first introduced as a market tool, now demoed in depth)
- Power BI versus Tableau: A Tool Comparison — covered in Lecture 3 (the comparison logic reused for desktop tools)
- Tableau Public versus Desktop — covered in Lecture 3 (the free online versus desktop distinction revisited)
- Storytelling Foundations — covered in Lecture 3 (the storytelling lens behind Flourish's animated charts)
- Generative AI and the Future of Visualization Tools — covered in Lecture 3 (the AI trend resurfaces in the five trends)
This module closes with a survey of the data visualization tool landscape. We start from what any visualization tool does, look at the trends reshaping the space, compare desktop tools against online tools, walk through the main visualization libraries (JavaScript, Python, and R), and separate open source tools from proprietary ones. Two live demos anchor the practical half: Flourish, a modern online storytelling tool, and a side-by-side rebuild of the same chart in Tableau. The next phase of the course is a hands-on, three-week Tableau journey, so the wrap-up material here is the vocabulary and mental model you will carry into it.
5.1 The Changing Data Visualization Tool Landscape
This is the final stop of module one, which mapped the data visualization tool landscape. From the next phase onward the course shifts into a hands-on, three-week Tableau journey, so this wrap-up is the vocabulary you carry into it; today's session also closes with a short quiz.
5.1.1 What a Data Visualization Tool Does
Hook: What does a free online chart maker share with a billion-dollar BI platform? More than you would guess. Every data visualization tool on the market — cheap or enterprise, web or desktop — is built around the same four-step contract: take data in, apply a template, drag and drop fields, and show a graph out.
A data visualization tool is software built to help you understand and see data. Every tool follows the same basic contract: it expects data from you — a CSV file, an Excel sheet, or a direct connection to a data source — and it builds its visualizations on top of that data. The features it then offers depend on the tool's maturity, but the fundamental approach stays the same across products: accept data, apply ready-made templates, drag and drop fields, and show your data as a graph.
The universal tool contract. Think of the tool as a kitchen: your data is the raw ingredient, the template is the recipe, the drag-and-drop area is the counter, and the finished graph is the dish on the table. Every product performs the same four steps:
- Data in — the tool expects a CSV, an Excel sheet, or a live connection to a data source. No data, no picture.
- Templates applied — the tool offers ready-made chart types (bar, line, map, and so on) so you never draw anything from scratch.
- Drag and drop — you drag a field (say, "country") onto an axis or a color slot, and the tool maps it for you.
- Graph out — the rendered visualization appears, ready to read, publish, or embed.
The pipeline is identical everywhere. What varies is how much power each stage gives you — and that is where tools choose their identity.
Where tools differ is in emphasis. Some ship more templates and more interactive templates, which makes them great for quick storytelling. Others lean into engineering heavy, complex data and may compromise on interactivity to do so. So the raw input and the drag-and-drop model are universal, but every tool picks a different point on the trade-off between easy interactivity and raw data power.
To picture the trade-off, draw a horizontal line in your head: easy interactivity on the left end, raw data power on the right end. A social-media-friendly online tool sits near the left — fast, animated, but shallow when data gets huge or complex. A scientific graphing package sits near the right — steeper to learn, but it handles datasets and analysis the left-hand tools choke on. Once you can place a product on this line, you already know most of what matters about it before you ever log in.
Scope of the contract. The universal pipeline assumes your data is already in a usable shape. No tool rescues you from genuinely messy data: you still decide which columns matter, which rows are junk, and what the numbers mean. The contract says "data in, graph out" — it does not say "mess in, insight out."
Two more beginner traps are worth naming early. First, template count is not quality — a tool with 200 templates still needs you to pick the right one for your data, which is a thinking task, not a clicking task. Second, drag and drop is not a substitute for judgment: the tool maps what you drag, but you decide what to drag and how to read the result.
Recap + bridge. Every visualization tool follows the same contract — data in, templates, drag and drop, graph out — and the differences between products reduce to where they sit on the interactivity-versus-data-power line. With that baseline in place, the next question is how the whole space is shifting, and the answer is five trends.
5.1.2 Five Trends Reshaping the Space
Ease of use is climbing fast. Reports used to be painfully manual. In the era of Visual Basic, a reporting product like Crystal Reports demanded nearly the same effort as the main application it reported on. Writing reports was almost as big a job as writing the application itself — you were programming a report, not filling one in. Today, smart tools detect data types automatically, suggest the right graph immediately ("it tells you you can use this graph"), and let you drag and drop almost everything. You can still do heavy calculation when needed, but by and large people get comfortable with modern tools within a few weeks. This is accessibility and democratization: the skill floor has dropped dramatically. The change is like the shift from hand-cranking a car to a keyless start — the job got faster not because people got stronger, but because the machine took over the hard part.
Static charts are giving way to interactive dashboards. The old model was multipage reports — "here is our presentation and here is our report." That model is fading. Visualization is becoming interactive and narrative-driven: the viewer clicks, filters, and follows a story rather than flipping pages. The reader stops being a passive page-turner and becomes an explorer who controls what they see next.
Tools are getting smarter with AI and machine learning. Expect visualization tools to become more intelligent — automatically filtering data, automatically cleaning it, and eventually making insight and prediction the default. You drag and drop your fields, and auto-prediction does the rest. Machine learning and AI are gradually working their way into every one of these products.
Scope and caution on the AI trend. Automatic filtering and cleaning are conveniences, not cures. An auto-cleaner can drop what looks like a bad row and silently change your result, so you still need to know what your data contains and why. "The tool did it automatically" is never a substitute for "I checked what it did."
Most tools are moving to the cloud. The old workflow — save a file on a server, log into the office network, work client-server — is disappearing. You save your work on the cloud, log in from anywhere, and continue where you stopped. That makes creating and sharing reports much easier, which the Flourish demo will show concretely (Flourish is cloud-based).
Visualizations are becoming social-media friendly. With attention spans getting shorter, reports are shrinking into short snippets — animated, visual graphical representations you absorb in a few seconds before moving to the next graphic. Expect more GIFs, animations, and short videos. Nobody wants to read a big multipage report anymore; they want good animation that communicates within seconds. Real-world: these are the animated race charts and looping graphs you see on Twitter and similar platforms today — the same genre of chart that the Flourish demo will build live.
Recap + bridge. Five forces are moving the tool landscape at once: ease of use up, interactivity up, AI inside the tools, the cloud under everything, and social-media-style brevity in the output. These trends also explain why the newest products look so different from the old reporting suites — which is exactly the theme of the next subsection.
5.1.3 Emerging Players and the AR/VR Frontier
Two clusters of new players are emerging. First, storytelling tools — products specialized in telling stories with data, of which Flourish is one example. Second, open source visualization libraries like Plotly and Vega-Light, which make it easy for developers to configure rich charts inside their own applications. A useful habit for staying current: instead of trying to master every product, explore one tool at a time. The day before this session, logging into Flourish for the first time showed that within a single day one can do a lot — a concrete proof that the barrier to entry has collapsed.
The next frontier is AR/VR. The prediction here is confident: data visualization will soon integrate with augmented and virtual reality, letting you see the power of your analytics in a fully immersive space. Nobody in the class had any AR/VR exposure yet — no training, no corporate projects — so the concept was still theory for everyone.
Why AR/VR is more than a gimmick: the oil and gas example. AR/VR is already proven in safety-critical training, and the oil and gas example explains why. Plants and assets there are risky: one wall at the wrong pressure or a slight gas leakage can turn into a very dangerous situation. Workers must always stay trained, but you cannot train them in a real fire. Instead, organizations build AR/VR-driven case-study modules: trainees go to labs, put on the gadgets, and see and react to an emergency as if it were real — what checklist they would follow, how they would respond to a fire. It is rehearsal without the danger, exactly like a flight simulator for pilots.
That is one of many use cases, and the same immersive logic is where data visualization is heading: instead of reading a 2D dashboard about a plant, you will stand inside the plant and walk up to the exact component at risk. For the analyst, the payoff is the same as for the trainee — context and physical intuition that flat charts cannot deliver. In the broader field, this is the endpoint of the interactivity trend from the previous subsection: charts first became clickable, then animated, and eventually they will become places you can enter.
Recap + bridge. New storytelling tools and open source libraries are entering the space, and AR/VR is the confident prediction for where immersive analytics goes next. This landscape view sets up the rest of the session: first the two big delivery models — desktop and online tools — and then the libraries and the licensing question.
5.2 Desktop-Based Visualization Tools
5.2.1 The Mainstays: Tableau Desktop and Power BI
Hook: When an organization says "we need a BI tool," the conversation almost always starts with two names: Tableau and Power BI. Why those two? Because they dominate the analyst rankings on exactly the two things that matter most: how easy the tool is to use and how well it transforms your data.
A desktop-based tool is installed and runs on-premises — on your own machine or your organization's infrastructure. It is the software you launch like any other application, and its heavy lifting happens on your hardware rather than in a browser tab. In the Gartner positioning these two sat at the top: very user-friendly and strong in data transformation capability. They focus on AI and automation, support enhanced collaboration (you can connect to the cloud, and both desktop and web versions exist), and handle advanced data handling easily — it is much easier to manage massive datasets, and the tools give more optimization control. For exploring large datasets, desktop tools have a slight edge.
What "on-premises" buys you. When a tool runs on your own machine, the raw processing power available to it is the machine's full power — no network latency, no shared cloud throttling, no upload size limits. That is why desktop tools handle massive datasets more comfortably and give you more optimization control: you can tune memory, queries, and refresh behavior to your hardware. The trade-off is that you are responsible for installing, updating, and managing the software yourself.
Tableau Desktop is the version you have been watching on screen in this course — the desktop machine version. There is also Tableau Public, a free online version, which we come to in the online section. Power BI is closer to the Microsoft product family, which makes it easy for Windows users, and it is strong in data handling with many advanced features and good stability.
Choosing between the two mainstays. If your organization already lives inside the Microsoft ecosystem — SharePoint, Excel, Azure, Teams — Power BI plugs into that world with minimal friction. If you want the best-known dedicated visualization canvas with a larger public gallery of community examples, Tableau is the classic pick. Both are enterprise-grade: the choice is more about your surrounding technology stack than about raw capability.
5.2.2 Niche Scientific Tools: Origin Pro and Igor Pro
Beside the mainstream giants sit very niche scientific tools: Origin Pro and Igor Pro. These cater to research and heavy engineering, not the typical commercial IT world. Their audience is the laboratory bench and the engineering analysis desk — people fitting curves to experimental data, not building sales dashboards.
Worked example: an Origin Pro session, step by step. A product video walked through Origin Pro's workflow, and the session is worth replaying mentally because it shows how a scientific tool thinks:
- Start by dragging a file in. You drag and drop a file into the workspace to get started. Data connectors support a wide variety of file formats, and your worksheet stays connected to the data file — the connector menu lets you reimport data whenever the external file is updated.
- Select and plot. You select the data on the worksheet and click the desired plot button to create a graph, then zoom and pan the axis scales to interactively explore, using tools such as a vertical cursor to read exact values.
- Pick from 200+ templates. Origin ships with over 200 graph templates arranged by category under the plot menu. The Graph Maker app lets you drag and drop columns to create publication-quality graphs, and toolbar buttons handle quick customization. For worksheets with many columns you can switch to a compact list view.
- Compare and analyze. A browser graph with a navigation panel lets you explore and compare multiple datasets. Gadgets analyze the data, and results update as you switch between datasets. The data highlight tool highlights a region in one graph layer, and the corresponding points light up in every other graph created from the same worksheet.
- Fit curves and get a report. Curve fitting gives you full control, and every analysis produces a detailed report sheet with parameter values, statistics, and embedded graphs.
- Publish a custom report. You can even build a custom report with HTML or markdown syntax in a notes window — add graphs, tables, and a company logo. If you drag in a new data file, the analysis results and report update automatically, all without writing a line of code.
Sense-check: the whole loop — import, plot, analyze, fit, report, refresh — is data-driven end to end, and the tool is trusted by over 500,000 scientists and engineers worldwide. A fully functional trial is available.
The look of these tools tells you the story: the complexity of the graphs they produce requires a different skill set. "If we go wrong, one should have that knowledge of where and what I could have done wrong." In other words, these tools assume you understand the science behind the graph — the error bars, the fit function, the axis transforms — so that when a plot goes wrong, you can diagnose it. These tools are paid and premium — they serve a small market with premium services, unlike Microsoft-style volume products.
Pitfalls for scientific tools. First, don't buy one because it looks impressive: Origin Pro and Igor Pro are overkill (and expensive) if your work is simple reporting. Second, expect a real learning curve — the skill set these tools demand is closer to technical computing than to dashboarding. Third, don't assume "graphing software" means "statistics software": each tool has its own analytic strengths, and the one your lab or supervisor already uses is often the pragmatic choice because of shared templates and workflows.
5.2.3 Digital Twins: Replicating Physical Assets
Real-world: a related concept from industry is the digital twin — a digital replica of a complete, big physical asset. You cannot see a multi-acre asset on a screen, so engineering tools build a digital copy of every component.
The digital twin intuition. A digital twin is to a plant what a map app is to a city: a complete, clickable copy of something too big to see at once. You zoom into any area of the plant or any section, click a wall, and see its current pressure, its volume, when it was last serviced, what the challenge was the last time it broke down, when it was replaced. Every physical component has a digital record, and every maintenance event is a data point.
All of that requires a different level of processing power and machinery, and such tools come with a premium cost. It sits at the edge of data visualization, but it shows where specialized engineering visualization is going: the future of visualization is not just better charts but richer models of the physical world that you can walk through and interrogate. For safety-critical industries — oil and gas, power plants, manufacturing — the digital twin is where pressure, volume, and service history become a single navigable picture, and it pairs naturally with the AR/VR frontier from section 5.1.
5.2.4 When Desktop Tools Fit Best
There is no right or wrong tool — it depends on what you are comfortable with and what you actually want. Tableau and Power BI are good for beginners or people who know a bit of technology. QlikSense and the scientific tools (Origin Pro, Igor Pro) require more technical know-how. QlikSense is known for managing large data handling capabilities; if your dataset is massive, tools like QlikSense are the typical choice. That said, the enterprise versions of Tableau and Power BI are very well catered to medium-to-large corporate datasets, so it is not that they cannot cope — every tool has pluses and minuses.
| Dimension | Tableau / Power BI | QlikSense | Scientific tools (Origin Pro, Igor Pro) |
|---|---|---|---|
| Skill level | Beginner-friendly | Technical | Expert |
| Best fit | Corporate BI, quick wins | Massive datasets | Research, heavy engineering |
| Data handling | Strong; enterprise versions handle medium-to-large datasets | Built for very large data | Deep analysis, curve fitting |
| Cost model | Paid subscriptions, enterprise versions | Enterprise licensing | Paid, premium, niche market |
Desktop versions also give you more customization and control than web pages and online versions: you can absolutely tweak the tool, build complex queries, and configure it around your organization's needs. On cost, desktop tools typically come with paid subscriptions (a few free services exist), so budget is part of the decision.
Scope and cost watch. Desktop strength is not unlimited: "desktop" means the data must fit comfortably in what your machine and the tool's engine can handle, and heavy data users may still outgrow even enterprise Tableau or Power BI. Budget is part of the decision: desktop tools typically come with paid subscriptions (a few free services exist), and enterprise editions scale in price with features and user counts.
Recap + bridge. Desktop tools are installed, powerful, and customizable: Tableau and Power BI for the mainstream, QlikSense for very large data, Origin Pro and Igor Pro for scientific work, and digital twins for industrial asset visualization. That is one half of the delivery-model story — the other half lives in the browser, which is where we go next.
5.3 Online Visualization Tools
5.3.1 What Online Tools Emphasize
Hook: The most persuasive demo of an online tool is a phone. Open the same dashboard on your laptop, then on your phone — and if the second view still looks great, the tool was built for the web-first world.
Online tools run in the browser and are much more mobile-friendly: you save work, view it on your phone or tablet, and the charts are responsive. Desktop tools can do this too — a Tableau graph can be published to a portal and previewed on web and mobile. Online tools simply take it to the next level with a very light touch and easy navigation.
What "responsive" means concretely. A responsive chart reflows itself: the layout, text size, and click targets adapt to the screen it is rendered on, so a dashboard built once can be read on a desktop monitor, a tablet, or a phone without a separate mobile build. That is the mobile-friendliness online tools are built around, and it pairs with the cloud model from section 5.1 — the work lives online, so the same file is reachable from any device wherever you log in.
Their second strength is storytelling and social media integration. With attention spans shrinking, people do not want to integrate big charts themselves; they want good animation. Online tools are GIF- and animation-based, which makes them very social-media-consumption friendly. Third, API integration is easier because the product is web-based, which matters when you are pulling real-time data: a web tool can reach an API directly from the same environment it runs in, instead of routing through a desktop connector.
Scope of online strength. Online tools win on reach, not on raw capacity. Heavy data processing is still better done where the machine power is, and a browser session depends on a working connection — offline work is not their natural habitat. Also, "animation-friendly" and "analysis-friendly" are different design goals: a tool that optimizes for social-media consumption is not automatically the right place for deep statistical work.
5.3.2 Popular Online Tools
The familiar names exist in online form too: both Tableau and Microsoft offer online versions. Tableau Public is the free public version — a very diluted version with fewer data sources and fewer options than the desktop, but still decent. Microsoft's online BI is the web side of Power BI. Looker Studio is the current name for what used to be Google Data Studio — it was rebranded to Looker, and the look and feel stayed identical. Datawrapper is another online tool that has not been personally used. Infogram and Flourish are very rich, highly interactive online tools — Flourish is the one we will demo in depth, and it gives a concrete sense of what online tools bring: pre-populated templates, animation, publishing, and embedding.
| Tool | What it is | Notable point |
|---|---|---|
| Tableau Public | Free public version of Tableau | Diluted — fewer data sources and options than desktop |
| Power BI (web) | Microsoft's online BI | Web side of the desktop product |
| Looker Studio | Formerly Google Data Studio | Rebranded to Looker; identical look and feel |
| Datawrapper | Online charting tool | Not personally used in the session |
| Infogram | Rich interactive online charts | Highly interactive |
| Flourish | Storytelling-focused online tool | Demoed in depth; templates, animation, publishing, embedding |
Recap + bridge. Online tools emphasize mobile-first responsiveness, storytelling and social-media-ready animation, and easy API integration for real-time data — with familiar brands available as web versions, plus specialists like Infogram and Flourish. The natural next question is when to reach for which model, and that is exactly the comparison that follows.
5.4 Desktop vs Online: Comparison and Choosing
5.4.1 The Comparison Table
Hook: The classic way to choose a tool is to ask who else chose it. A sharper way is to compare desktop and online tools on five dimensions — and the surprises are in the data-handling and collaboration rows.
| Dimension | Desktop tools | Online tools |
|---|---|---|
| Ease of use | Beginner-friendly; library versions are advanced | Varies — some are complex, some straightforward |
| Data handling | Can manage much larger datasets | Not as strong as desktop, but scalable because they run on the cloud |
| Customization | High — you can tweak everything | Moderate |
| Cost | Paid subscriptions; premium pricing | Combination — free features plus paid enterprise versions |
| Collaboration | Good, but slightly less advanced than online | Advanced sharing and versioning on the web |
The data-handling row is the key nuance: for huge data, online tools are not as strong as desktop, but they are scalable. Because they are cloud-based, the vendor can add more servers as usage grows. They need not invest heavily in infrastructure upfront — scalability comes with popularity. Think of it as the difference between owning a single powerful truck (desktop) and renting an unlimited fleet (online): the truck is better at one very heavy load, but the fleet can grow the moment demand does.
On collaboration, desktop tools can share versions online too; they are just not as advanced at it as the online products. Sharing, permissions, and version history are native to the web model, while desktop tools bolt sharing on as an extra path.
Scope: the scalability caveat. "Scalable" is a capacity ceiling that grows over time, not an instant equalizer. An online tool is only as strong as the plan you pay for and the vendor's current infrastructure — the moment you need heavy in-house data processing, offline access, or deep customization, the desktop model takes the lead again.
5.4.2 Decision Factors
How do you choose? The decision checklist:
- Do you need everything online all the time? Offline access needs point you toward desktop. If your analysts work from sites, plants, or networks where connectivity is unreliable, a tool that runs locally is the safer bet.
- Data size and complexity. Big, complex data pushes you toward desktop (or tools like QlikSense); lighter, shareable data works well online. Match the machine model to the data, not to the trend.
- Usage and technical capabilities. What is your skill pool? Tools are getting easier, and people can be retrained, but an organization must still consider whether the team can operate the tool. A powerful tool in unskilled hands produces bad charts; a simple tool in skilled hands produces good ones.
- Customization needs. If you need heavy customization, desktop usually fits better. Watch the distinction between market-standard tools and customizable ones. Products like Salesforce or SAP are market standards: organizations usually configure rather than customize them. Vendors cannot manage wildly different customized versions across the globe, so they do not encourage deep customization. Configuration is handled by third parties; deep customization is a different game.
- Collaboration needs. Heavy sharing and versioning favors online tools. When a dozen people must comment, co-edit, and track versions of the same dashboard, the web-native collaboration model wins.
Recap + bridge. The decision checklist runs: offline needs, data size, skill pool, customization, collaboration — with desktop winning on power and control and online winning on sharing and growth. Whichever model you pick, there is a third route that changes the economics entirely: skip the paid product and build the chart with a library, which is the next topic.
5.5 Visualization Libraries
Not everyone has access to a paid visualization tool — and that is not the end of the world. Libraries can create graphs good enough to embed in web pages and applications, even if they do not reach the same scale of complexity as the full tools. This section builds the mental model: what a library is, the four types, the main JavaScript, Python, and R families, and how to pick one.
5.5.1 What Is a Library?
Hook: Paid tools are not the only road to a chart. A developer with a code library can produce publishable, interactive graphs for the price of their time — and the concept behind it is one everyone has already used without knowing it.
Q: What does the term "library" mean in the programming world? A: One student's guess: common functionality packaged together so you can extend it and use it. That is exactly right. A library is a set of previously written code that you call upon when building your own code. Someone else did the work; you reuse it instead of redoing it. If the code were private intellectual property, there would be no reason to publish it as an API — a library exists to be publicly consumed.
The definition, formalized. A library is a packaged set of previously written code that your program calls on demand. The key properties:
- Pre-written — someone else already solved the problem; you do not reinvent it.
- Callable — you invoke its functions from your own code (for example, a plotting call from your language's charting library).
- Publicly consumable — a library is published as an API precisely so other programs can use it; if it were private intellectual property, publishing it would make no sense.
So a library reduces code duplication: specialized functionality is written once, as an interface or library, and reused across future deployments. It also promotes collaboration and code reuse — that is why every major library has a massive community where you post your problem and get answers, alternatives, and bug fixes.
Why the community matters. A library's true value grows with its user base: more users means more bug reports fixed, more examples posted, more extensions written, and faster answers when you are stuck. That is why community size is a legitimate selection criterion, not a soft feature.
5.5.2 Library Types and Benefits
Libraries come in four types:
- Static libraries — pre-compiled; you cannot make a change to them. They are linked into your program before it runs.
- Dynamic libraries — loaded at runtime when your program runs, so updates can swap in without recompiling everything.
- Standard libraries — included with the language or platform, available to every program by default.
- Third-party libraries — built by somebody else but usable by you, which covers most visualization libraries.
The generic benefits apply to any library or API, not just visualization ones: faster development, improved code quality, lower cost (you do not spend time and effort re-inventing), and the freedom to focus on your core functionality while integrating wherever required via API.
5.5.3 JavaScript Libraries
JavaScript is where you literally call a library and create a graph. The common ones:
- Plotly JS — the live demo showed the pattern: you give the parameters — what your X and Y are, what your title is — and the graph renders. It is interactive: hovering shows tooltips. A few years back, such interactivity on a webpage was considered advanced; now it is standard.
- D3.js — requires a bit more coding expertise, but with that comes a lot of control.
- Chart.js — comparatively a light touch and easy to integrate.
The control-versus-effort trade-off. Plotly JS gives you a graph from a few parameters, D3.js asks for real coding skill but lets you control every pixel, and Chart.js sits in between as the easy-to-integrate option. Pick the point on that line that matches your coding comfort: the pattern across all of them is the same — call the library, pass your data, get a chart.
There are many JavaScript libraries; these are the commonly used few, and their syntax varies, but the pattern is the same: a little programming knowledge lets you produce visualization without buying any tool.
5.5.4 Python Libraries
Python's visualization libraries will get a dedicated session later in the course, but here is the landscape:
Worked example: one dataset, three charts in matplotlib. The demo was minimal — import the library, give sample data, and one call plots it:
- Line chart:
plt.plotdraws a line chart; you set up the axis and title. - Bar chart: calling
plt.barinstead — changing a single line — redraws the same data as a bar chart. - Scatter plot: the same data becomes a scatter plot with another one-line change.
- Styling: add a marker style (for example, circles on the line), change the line color, and change the line width — all through parameters.
Sense-check: the code, not the data, decides the chart type. One line of change converts the identical numbers into three different visual stories — which is exactly the flexibility the demo highlighted.
matplotlib is the foundation of many Python visualization libraries — a foundation library that others are built on top of. It is very versatile with a lot of chart types, comparatively simpler to learn and integrate, cross-platform, open source, used for both 2D and 3D, and supports rich drawing types. The only difference from a GUI tool like Tableau is that you write the equivalent code instead of clicking; the library is mathematically very strong.
seaborn is built on top of matplotlib. It is known for statistical graphs and looks a little more pleasing than plain matplotlib, though it is a bit more advanced. You import it (it is conventionally aliased as sns), and because it is built on matplotlib, matplotlib's basics are still there. It works easily with data frames — in the demo, data was passed in as a DataFrame and the graph was drawn automatically with just a few lines of code. Switching from a bar plot to a scatter plot was again a matter of one line, with the same data.
Worked example: bokeh's interactive page. The demo showed what interactivity means on a webpage with Python: you can zoom into any specific part of the graph, move the axes, and export the picture to a GIF or an image any time. Giving that kind of interactivity on a webpage is quite unique, and for complex graphs it is amazing — the viewer is not staring at a static picture but exploring a live surface.
Sense-check: interactivity that used to require a dedicated BI portal is available from a Python library on any webpage — that is the payoff of the library route.
plotly in Python is more like a wrapper around Plotly JS, bringing the same interactivity to Python. bokeh is the interactive-visualization standout.
5.5.5 R and Other Libraries
R has its own commonly used set: ggplot, lattice, and plotly (Plotly is common across languages — it extends to all these applications). Beyond those, there are many newer libraries such as Vega-Light — not yet personally used, but representative of the wave of new libraries getting better and better. People who have used these for a while produce really good graphs with them.
Pitfalls when adopting libraries. First, don't assume your favorite language has the best charting: plotly works across languages, and each ecosystem (matplotlib/seaborn in Python, ggplot/lattice in R) has its own idioms. Second, a newer library like Vega-Light may be excellent but unproven in your team — check maturity before betting a project on it. Third, "no cost" from a library is not "no license terms": open source libraries still come with licenses you should read (section 5.6 returns to this).
5.5.6 Choosing a Library
The decision checklist for a library: (1) which programming language are you comfortable with; (2) what complexity will your visualization have; (3) if your business wants interactivity, choose libraries with strong interactivity and customization options; (4) ease of use — be clear about the coding expertise required; (5) community support — these libraries typically have rich, massive support communities already available.
Recap + bridge. A library is previously written, callable code that removes duplication: static, dynamic, standard, and third-party types, with JavaScript (Plotly JS, D3.js, Chart.js), Python (matplotlib, seaborn, plotly, bokeh), and R (ggplot, lattice, plotly) as the main families. Choose on language, complexity, interactivity, ease, and community. With libraries in hand, the last landscape question is the licensing model — open source versus proprietary — which decides what you can legally do with what you build.
5.6 Open Source vs Proprietary Tools
5.6.1 Open Source: Definition and Trade-Offs
Hook: Who owns the code that draws your charts? The answer decides what you can legally do with it, what happens when the product changes hands, and what you pay — and the word "free" is the most misleading part of the whole discussion.
Before giving the definition, the class was invited to guess — no one answered, so here is the theoretical definition. Open source means the source code is freely available and accessible: anyone can view, modify, and distribute it. "View, modify, distribute" is the whole contract in three verbs: you can read the code, change it, and share your changes.
Why open source matters: three pluses.
- Transparency and community-driven development — people interact, hold Q&A sessions, share bug fixes, host webcasts and webinars, and work like a community maturing the product. Because anyone can read the code, problems are found and fixed in the open.
- Cost-effectiveness — most open source software is free to use and modify.
- Flexibility — customization is easy; you can tailor the tool to your needs.
One correction worth keeping in mind: free does not always mean the cost is free. Highcharts and AnyChart are open source, yet they involve costing because premium features are requested for. So "open source" and "zero cost" are not synonyms. The license grants access to the source; the business model decides which features you pay for.
Pitfall: equating "open source" with "free." The professor's correction is the one to remember: Highcharts and AnyChart are open source yet charge for premium features. Before you commit to a project, read the licensing terms and the feature tiers — otherwise your "free" stack can acquire a surprise line item.
The caution is enterprise adoption. Traditionally there has been hesitancy about formally using open source in a production solution. You never know whether the community or product will still exist tomorrow, or whether it will be acquired by somebody else. That is why contract and procurement teams ask specific questions about open source whenever development work or services are taken: what is the dependency, what is the risk, what happens if there are legal changes in the usage terms. Open source is becoming more and more used with time, but rolling it out as an enterprise solution requires being absolutely clear about those dependencies and risks.
5.6.2 Proprietary: Definition and Trade-Offs
Proprietary tools are the opposite: the source code is closed. The code is the company's bread and butter, so companies like Tableau and Microsoft will not give it out. You access proprietary tools only through licenses; you can never get the underlying code.
Development and updates are controlled: the company decides what releases and features to roll out ("next quarter we will launch another release"). Even big clients can only give recommendations or asks — the roadmap, prioritization, and rollout timing are the company's call. Cost is higher because you need paid licenses, but that buys support surveys, SLAs, and consultancy and support services. Customization is limited: the core product stays the same, and at most you can configure it — altering how these products are built is mostly out of scope.
The configuration/customization distinction. With proprietary tools you configure, you do not customize: configuration means setting options within the product's boundaries (permissions, themes, data connections), while customization would mean changing the product itself — which is mostly out of scope. The company deliberately keeps the core identical for every customer because maintaining wildly different versions across its customer base would be unmanageable.
5.6.3 Head-to-Head Comparison
| Dimension | Open source | Proprietary |
|---|---|---|
| Cost | Generally cheaper; most are free to use and modify | Higher — paid licenses, plus support services |
| Technical expertise | More required — setup, maintenance, reading documentation, installing from scratch | Less hands-on; vendor-supported |
| Flexibility | Flexible — changes with what the community wants | Less customizable; must maintain versions across many customers |
| Support | Community resources (forums, bug fixes, webinars) | Dedicated support and SLAs |
| Enterprise safety | Riskier at scale — dependency and continuity risk | Preferred for enterprise deployment |
On enterprise safety: single usage of open source is fine, because it does not impact a wider community. But when you deploy to multiple clients, multiple users, and multiple geographical locations, open source can become challenging — you never know what support will go off the radar. Open source requires more scaling solutions, and not just technical ones; many other factors need consideration.
Scope: enterprise risk is a scale problem. A single team using an open source tool carries little risk. Multiply by many clients, many users, and many geographies, and a vanished maintainer, an abandoned release, or a license change touches everyone at once. That multiplication is exactly why procurement teams scrutinize open source dependencies — the question is not "does it work today?" but "will it still be supported when we depend on it at scale?"
5.6.4 Popular Tools in Each Camp
Open source: R — a very powerful open source library; there are two camps between R and Python, and many argue R is still the niche choice. Python — anyone can download packages and start doing data science and statistical tasks. D3.js — interactive and highly available. Apache Zeppelin — a notebook-based environment where you collaboratively explore and visualize. Plotly — also free/open source.
Proprietary: Tableau (now part of Salesforce), Power BI (Microsoft), Looker (Google's web-based dashboard), and QlikSense — all tools you can use only through licenses, with no ability to alter them.
Recap + bridge. Open source means view-modify-distribute freedom with transparency, low cost, and flexibility — but "open source" is not "zero cost," and enterprise-scale adoption carries dependency and continuity risk. Proprietary tools buy control, stability, and vendor support with paid licenses and closed code. That completes the landscape; the live demo that follows makes it concrete — a modern storytelling tool where the theory from the whole module shows up in practice.
5.7 Flourish: A Live Demo of a Storytelling Tool
5.7.1 What Flourish Is
Hook: The charts you scroll past on social media — animated rankings, racing bars, looping maps — are mostly not built in BI suites at all. Many come from a single UK-based company's tool, and the live demo shows how little effort they actually take.
Flourish is a web-based, online visualization tool from a UK-based company. Flourish Studio is its portal, and it is impressively rich. There is a decent free plan: free for students, free for small newsrooms, and the free plan itself already offers unlimited projects and plenty of graph templates — more than enough for an individual. Visualizations can be published or embedded, graphics are very responsive, and these are the kinds of canvas-specific, animated charts that power a lot of the data graphics you see on social media. Sign-in works with email or your Google account, and everything auto-saves.
5.7.2 Worked Example: Bar Chart Race (Country Population)
The template tour starts from "new visualization": every graph type sits there as a template — area charts, pie charts, donuts, all the fundamental graphs, all the map-based graphs, scatter plots, 3D maps, and bar graphs. The maps even come with country- and district-level data pre-populated (for example, India down to district level), and every template has a preview tab and a data tab, with your own data uploadable whenever you like.
Worked example: the bar chart race on built-in population data. A bar chart race is the animated ranking chart you see often in media: bars slide past each other year by year, so the leaderboard visibly changes over time.
- Start from the template. The template's built-in data was year-wise country population — a table with one row per country and one column per year.
- Map the label. The mapping is done by column letters: the label is the country column (column A); tell it your label is column B and the whole chart re-summarizes by region instead.
- Set the values. The values span from column D through to the last column.
- Let the animation build. Give the parameters, and the animation builds itself — year by year, countries race up and down the rankings, no coding required.
- Filter by clicking. Filtering is click-based: click Asia and the Asian countries leave the chart; ask for only Asia and everything else stops.
Sense-check: one table, two mapping choices (country or region), one value range — and the tool produces the exact animated race charts the media runs, with zero code.
5.7.3 Worked Example: Bar Chart Race with Your Own CO2 Data
From scratch, with our own data: a CO2-emission dataset (by country and year, sourced from the World Bank) was uploaded — 7 rows imported.
Worked example: rebuild the race with your own data.
- Upload. Choose "upload data" and confirm the import — the tool reports the row count (7 rows imported).
- Map the label. Set the label to column C (country), and the chart immediately re-summarizes at the country level.
- Scope the values. Set the values to the range D–N. The range was also narrowed — "don't go till year BC, only show me till one decade" — by changing the range endpoints, a one-range edit.
- Watch it rebuild. The animated graph was created fresh, automatically.
- Edit data in place. Data editing happens in place: you can remove a column (the chart updates instantly), copy-paste columns from Excel, and make changes straight away.
Sense-check: a full animated visualization from a raw World Bank table in under a minute — the upload, the column mapping, and the range scoping are the only three decisions required.
5.7.4 Publishing and Sharing a Flourish Visualization
Flourish shines at distribution. The publish-and-share menu gives a public URL for the visualization, an embed code (copy-paste to put the graph inside your own website or a social media post), and downloads as an image or as HTML. The same graph previews automatically on tablet and mobile — all mapping and pixel calculation handled for you — so you can see exactly how it will look on a phone before you send it. You can even add the graph to a Canva presentation. Every project auto-saves; name it (the demo one was called "class demo one") and it appears on your home dashboard, where you can return anytime, upload new data, and rework it.
The distribution contract, in one picture. Picture a single chart at the center. Around it, four doors: share (public URL), embed (code for your website), download (image or HTML file), and preview (phone and tablet mockups). All four open from one menu, and because everything is cloud-hosted and auto-saving, the same visualization can be a tweet, a blog embed, and a slide in the same afternoon.
5.7.5 Worked Example: Diverging Bar Graph (Nifty 50 Gains and Losses)
A diverging graph shows positive and negative values in one glance — the bar chart splits into bars going both up and down from a center line. The demo data was an NSE (Nifty 50) dataset: 51 rows covering stocks, sectors, and each stock's day gain or loss.
Worked example: diverging bars for a trading day.
- Import. Upload the NSE data — 51 rows imported.
- Map the label. Map the label to column C (the stock symbol).
- Map the value. Map the value to column J (day gain loss), and the chart rendered in one shot: on that particular day, Tata Com was the maximum gainer and BPCL was the minimum.
- Customize. Show labels; reduce the bar height with a slider; change colors; add a header ("50:50 overview"); add a legend title based on gain/loss; hide the axis.
- Conditional color. The striking feature is conditional color: Flourish lets you override a color based on a condition, with a syntax that uses two columns and one colon — the field (day gain loss) was typed in and yellow requested, overriding the default coloring per column.
Sense-check: 51 stocks, one glance — every gainer above the center line, every loser below it, top and bottom immediately identifiable, all styled in a few clicks.
5.7.6 Same Graph in Tableau: A Side-by-Side Comparison
The same data was rebuilt in Tableau Desktop for contrast. There you drag the symbol field yourself, add the day-gain-loss measure, sort, and color by the same parameter — all doable. Two differences stood out.
Side-by-side: Flourish versus Tableau on the same chart. First, data changes are easier in Flourish: you drop or modify a column directly on the visualization, while in Tableau you have to go into the data source pane and work there — the editing is one step removed from the chart. Second, the animation: there was a real desire to draw the animated race-style chart, and the confirmation that this kind of animation is simply not available in Power BI or Tableau. Fundamentally the tools do the same job; the animation and the editing convenience are where Flourish separates itself.
| Aspect | Flourish | Tableau Desktop |
|---|---|---|
| Getting started | Template-first; you pick a template and map columns | You decide how to start and drag fields yourself |
| Editing data | In place on the visualization | Via the data source pane |
| Animation | Built into templates (bar races, dancing lines) | Not available for these animated chart types |
5.7.7 Worked Example: Gauge Chart (Batting Averages)
A gauge chart shows a needle-style, single-value reading — like a speedometer. The demo used a batting-average dataset of a few batsmen (8 rows imported).
Worked example: batting-average gauges.
- Import. The batting-average dataset of a few batsmen — 8 rows imported.
- Map the player. Map the name to column B (the player).
- Map the value. Map the value to column L (the average), and the gauges render: Kambli at 54, Gaikwad at 30, and the rest between.
- Control the layout. You control how many gauges show at once (one at a time or three).
- Define the segments. You define the segments by number ranges — for example, 0 to 25 is an average batsman, 25 to 30 is good — and the tool colors the dials accordingly.
Sense-check: a single measure per person, compared at a glance with colored segments — exactly what a needle-style display is for.
Exam note: this was tied back to theory — you should know which kind of graph is best suited to which kind of data. Because the batting data is small and visual, a gauge fits; knowing that pairing is exactly what the conceptual part of the course trains. The reverse also holds: a gauge would be a poor choice for hundreds of rows or for comparing many measures at once.
5.7.8 Worked Example: Survey Bubble Chart and the Dancing Line
The next template was a survey-oriented bubble chart. The data was gender, name, height, and weight.
Worked example: survey bubble chart. With the categories given upfront, you just upload the data and map:
- Shade by gender — females blue, males a different color.
- Size by weight — size the bubbles by weight, and the chart animates with bigger bubbles for higher weight.
- Adjust alignment — alignment tweaks aside, it is ready immediately.
Sense-check: the chart encodes three variables at once (gender by color, weight by size, individuals by position) — the kind of multivariate reading a survey needs.
The contrast with Tableau: there you have to think about how to start — maybe build a bubble chart, then wire it up — while Flourish hands you the category options upfront and you pick. There is even a "dancing line" template — the same animation applied to a line graph instead of bars — and moving-line visuals for time series.
5.7.9 The General Flourish Workflow
The recurring five-step workflow. For any graph, the flow is the same:
- Choose your template — what you want to present (race, diverging bars, gauge, bubble, and so on).
- Import your data — upload your own table or start from the built-in data.
- Match the right columns and values — tell the tool which column is the label and which range holds the values.
- Customize — on the right-hand side, where all the values, parameters, and properties live.
- Publish — make it public or push it to social media.
One can master the tool within a few days; no technical expertise is needed, and a report can be built and published to the outside world within a day.
Q: Any comments so far? What was your first impression of Flourish? Is it easy? A: The first impression was that one can easily make graphs with it. That is exactly the point — and the tool goes further; there is a template that makes line graphs dance, running the same animation along a line instead of bars.
Pitfalls when using Flourish. First, template-first ease can hide mapping mistakes — check which column the tool is actually reading when the graph looks wrong. Second, the free plan is generous but not everything is free; features outside the free tier gate behind pricing. Third, animated charts are great for storytelling but poor for careful comparison: the race animation hides the exact values, so export the static image when precision matters.
Recap + bridge. Flourish is a UK-based, cloud-hosted storytelling tool: templates in, data mapped by column letters, customization on the right, publish and embed anywhere — with bar races, diverging bars, gauges, and bubble charts all created in minutes. This demo closes the tool landscape of module one; the next phase applies the same mental model hands-on in a three-week Tableau journey.
Exam Guidance Summary
Exam note — what to carry out of this session. Module one closes here, and this summary is the distillation of everything the session said about preparing for what comes next.
- Module wrap-up: this class closes module one, which covered the data visualization tool landscape. A short quiz wraps up today's session.
- What is next: the next module is a hands-on, real-life learning journey with Tableau, lasting three weeks — expect to work with Tableau throughout the coming weeks, so the vocabulary from this session is the working language of the course from here on.
- Know your graph choices: a recurring theme — you should know which kind of graph best suits which kind of data (the gauge-for-small-visual-single-value example is the model). This pairing of data to chart type is the conceptual core to carry forward.
- Tool landscape vocabulary: be comfortable comparing desktop vs online tools, open source vs proprietary tools, and naming the major libraries (matplotlib, seaborn, plotly, bokeh, D3.js, Chart.js, ggplot) and tools (Tableau, Power BI, QlikSense, Looker, Flourish).
- Comparative frameworks: the two comparison tables (desktop vs online; open source vs proprietary) are the organizing skeleton of the whole module — if you can reproduce both tables and the reasoning behind each row, you have the landscape covered.
- No mark distribution or specific question pattern was given in this session.
Key Industry Applications
- AR/VR safety training in oil and gas — case-study modules, lab gadgets, and simulated emergencies for fire response and checklist practice (5.1).
- Social media data journalism — animated bar chart races, GIFs, and short looping visuals on Twitter and similar platforms, many built with Flourish (5.1, 5.7).
- Digital twins in plant engineering — full digital replicas of multi-acre assets with pressure, volume, and service-history drill-down (5.2).
- Scientific computing — Origin Pro, trusted by over 500,000 scientists and engineers for curve fitting, report sheets, and publication-quality graphs (5.2).
- Enterprise BI — Tableau (Salesforce), Power BI (Microsoft), Looker (Google), and QlikSense as the industry-standard proprietary stack (5.6).
- Financial dashboards — Nifty 50 / NSE gain-and-loss diverging charts for daily stock performance (5.7).
- Sports analytics — batting-average gauges for player comparison (5.7).
- Open data — World Bank CO2 emission datasets powering animated country-level visualizations (5.7).
- Market-standard enterprise software — Salesforce and SAP as configure-not-customize tools (5.4).
Why these applications matter. Each item on this list is a concrete instance of the session's theory: the immersive logic of AR/VR training, the animation-first economics of social media, the model-first approach of digital twins, the power of desktop scientific computing, the license-and-support logic of the proprietary BI stack, and the template-first workflow behind financial, sports, and open-data visualizations. If you can connect each tool concept to its industry setting, the landscape is not vocabulary — it is a map.
DVI Lecture 5 notes · Data Visualization Tools: Desktop, Online, Libraries, and Open Source
Sections Breakdown
The universal four-step tool contract, five trends reshaping the space, and emerging players including AR/VR.
Tableau Desktop and Power BI mainstays, scientific tools Origin Pro and Igor Pro, digital twins, and when desktop tools fit best.
What online tools emphasize - responsiveness, storytelling, and API integration - plus Tableau Public, Looker Studio, and Flourish.
The five-dimension comparison table and the decision factors for choosing between delivery models.
What a library is, the four library types, and the JavaScript, Python, and R library families.
Definitions and trade-offs of open source and proprietary tools, the head-to-head comparison, and tools in each camp.
Worked examples of bar chart races, diverging bars, gauges, and bubble charts, plus the five-step Flourish workflow.
Exam Revision Notes
Below is the distilled, exam-ready core. Every entry comes from the full explanation above. Use this section for rapid review; return to the main notes when a point needs more context.
The Changing Data Visualization Tool Landscape
Must-know: All visualization tools share one contract: accept data, apply templates, drag and drop fields, show a graph. Five trends — ease of use, interactivity, AI/ML, cloud, and social-media brevity — are reshaping the tool landscape.
⚠️ Top pitfall: Assuming template count equals quality, or that drag and drop replaces judgment; auto-cleaning by AI is a convenience, not a substitute for checking the data.
Self-check: Name the four steps of the universal tool contract.
Connects to: Desktop-Based Visualization Tools (5.2), Online Visualization Tools (5.3).
Desktop-Based Visualization Tools
Must-know: Desktop tools are installed on-premises; Tableau and Power BI lead on user-friendliness and data transformation, QlikSense suits massive datasets, and scientific tools (Origin Pro, Igor Pro) demand expert skill.
⚠️ Top pitfall: Buying a premium scientific tool for simple reporting, or assuming desktop tools can handle any dataset size without checking capacity.
Self-check: Why do desktop tools have an edge when exploring large datasets?
Connects to: Online Visualization Tools (5.3), Desktop vs Online (5.4).
Online Visualization Tools
Must-know: Online tools are browser-based, mobile-friendly, responsive, animation-oriented, and API-friendly; Tableau Public is the diluted free Tableau, and Looker Studio is the renamed Google Data Studio.
⚠️ Top pitfall: Assuming online tools match desktop raw data capacity, or relying on them for heavy offline processing.
Self-check: What were Google Data Studio and Looker Studio called before the rebrand?
Connects to: Desktop vs Online (5.4), Flourish (5.7).
Desktop vs Online: Comparison and Choosing
Must-know: Desktop: larger data, high customization, offline, paid subscriptions. Online: scalable cloud, moderate customization, advanced sharing and versioning. Choose on offline needs, data size, skill pool, customization, and collaboration.
⚠️ Top pitfall: Treating "scalable" as instant capacity, or choosing a market-standard tool (Salesforce, SAP) expecting deep customization — those are configure-not-customize products.
Self-check: List the five decision factors for desktop versus online tools.
Connects to: Desktop-Based Visualization Tools (5.2), Online Visualization Tools (5.3).
Visualization Libraries
Must-know: A library is previously written code you call — the student's "packaged common functionality" guess was exactly right. Four types: static, dynamic, standard, third-party. Python: matplotlib (foundation), seaborn (statistical, sns), plotly (wraps Plotly JS), bokeh (interactivity). JavaScript: Plotly JS, D3.js (control), Chart.js (light). R: ggplot, lattice, plotly.
⚠️ Top pitfall: Assuming "no cost" means "no license terms"; betting a project on an unproven newer library without checking maturity and community support.
Self-check: Name the four types of libraries and one library from each language family (JavaScript, Python, R).
Connects to: Open Source vs Proprietary Tools (5.6).
Open Source vs Proprietary Tools
Must-know: Open source = view, modify, distribute; pluses are transparency/community, cost-effectiveness, and flexibility — but free does not always mean zero cost (Highcharts, AnyChart premium features). Enterprise adoption needs clarity on dependency, risk, and legal terms. Proprietary = closed code, licenses, controlled releases, configuration-only.
⚠️ Top pitfall: Equating "open source" with "zero cost" and ignoring premium feature tiers and licensing terms.
Self-check: Why do procurement teams ask about open source dependencies before enterprise adoption?
Connects to: Visualization Libraries (5.5).
Flourish: A Live Demo of a Storytelling Tool
Must-know: The Flourish workflow: choose template, import data, match columns and values, customize on the right, publish. Key examples: bar chart race (label column A/B, values D to last), CO2 data (label C, values D–N), diverging bar (Nifty 50, symbol C, day gain loss J), gauge (batting averages, player B, average L; segments 0–25 average, 25–30 good). Gauge fits small visual single-value data.
⚠️ Top pitfall: Template-first ease can hide column-mapping mistakes; animation hides exact values, so export a static image when precision matters.
Self-check: What are the five steps of the general Flourish workflow, and why does a gauge fit batting-average data?
Connects to: Online Visualization Tools (5.3), Desktop vs Online (5.4).
Exam Guidance Summary
Must-know: Reproduce the desktop-vs-online and open-source-vs-proprietary comparison tables; name the major libraries (matplotlib, seaborn, plotly, bokeh, D3.js, Chart.js, ggplot) and tools (Tableau, Power BI, QlikSense, Looker, Flourish); pair chart type to data (gauge for small single-value).
⚠️ Top pitfall: Treating "open source" as "zero cost" and forgetting the license and premium-tier check.
Self-check: Which graph type fits small, visual, single-value data, and why?
Connects to: Desktop vs Online (5.4), Open Source vs Proprietary (5.6), Flourish (5.7).
Key Industry Applications
Must-know: Connect each tool concept to its industry: AR/VR to oil and gas training; digital twin to plant engineering; Origin Pro to scientific computing; Tableau/Power BI/Looker/QlikSense to enterprise BI; diverging charts to Nifty 50 finance; gauges to sports analytics; World Bank data to open data journalism.
⚠️ Top pitfall: Learning tool names without connecting them to the industry context that motivates them.
Self-check: Why is AR/VR used for oil and gas emergency training instead of real fires?
Connects to: The Changing Data Visualization Tool Landscape (5.1), Desktop-Based Visualization Tools (5.2), Open Source vs Proprietary (5.6), Flourish (5.7).
Was this lecture useful?
BitsNotes AI Assistant
Subject Notes AssistantConfigure AI Chat
Choose how to access the chatbotSigned in as
Powered by BitsNotes — 20 messages per day. No API key needed. Want unlimited access? Use "Bring Your Own Key" mode.
Sign in to use AI Chat
Get 20 free AI messages per day to ask questions about your lecture notes. Sign in with Google or GitHub — it takes 5 seconds.
Sign In to BitsNotesSwitch to "Bring Your Own Key" tab above for unlimited access with any OpenAI-compatible provider.