What is Snowflake?
Snowflake explained from scratch: warehouse vs database, OLAP vs OLTP, storage vs compute, why companies adopt it, its history, and how it compares to BigQuery, Redshift, and Databricks.
Quick answer
Snowflake is a cloud data warehouse built for analytics (OLAP): large scans, joins and aggregates for dashboards and ELT, not row-by-row app transactions. Its defining idea is separating storage from compute, so each team's compute scales independently over one shared copy of the data.
- OLTP databases (Postgres, MySQL) run apps; OLAP warehouses answer analytical questions.
- You pay for storage and for compute while it runs, separately.
- Compared with BigQuery, Redshift and Databricks mainly on pricing and operating model.
SELECT s.city, COUNT(*) AS orders, ROUND(SUM(o.total_amount), 2) AS revenue
FROM orders AS o
JOIN stores AS s ON s.store_id = o.store_id
GROUP BY s.city
ORDER BY revenue DESC
LIMIT 5;Result · 5 rows
| city | orders | revenue |
|---|---|---|
| New York | 8 | 461.83 |
| Seattle | 6 | 252.92 |
| Portland | 4 | 198.37 |
| Chicago | 5 | 149.64 |
| Austin | 3 | 119.87 |
Snowflake Is a Cloud Data Warehouse for Analytics
Snowflake is a cloud data warehouse. That means it is built to store and query large volumes of business data for analytics, reporting, data engineering, data science, and machine learning. It is not usually the database behind the button a customer clicks in your application. It is the analytical system where data from many operational systems is collected, cleaned, modeled, and queried.
If a customer places an order, the checkout application usually writes that order to an operational database such as PostgreSQL, MySQL, SQL Server, DynamoDB, or another OLTP system. Later, a pipeline copies that order into Snowflake so the company can answer questions such as: how much revenue did we make yesterday, which customers are churning, which product categories are growing, and what changed after the latest promotion?
If you have never touched a data platform before, think of it this way: every company runs two very different kinds of software against data. One kind keeps the business running right now — the app that lets a customer log in, add an item to a cart, and pay. The other kind helps humans understand the business over time — which products sell, which markets are growing, which customers are worth keeping. Snowflake is built for the second kind of work, at a scale that would overwhelm the first kind of system.
Plain-English definition: Snowflake is where a company brings together data from many systems so people can analyze the business with SQL, dashboards, models, and governed data products.
| System | Optimized for | Example question |
|---|---|---|
| PostgreSQL / MySQL | Small fast application reads and writes. | Can this user log in right now? |
| Kafka | Durable event streaming between systems. | What events happened and who needs to react? |
| S3 / ADLS / GCS | Cheap file storage at huge scale. | Where can we keep all raw data files? |
| Snowflake | Analytical SQL across large curated datasets. | What was revenue by customer segment last quarter? |
Before Snowflake: What Problem Does a "Data Warehouse" Solve?
A modern company does not have one database. It has dozens: a Postgres database for the web app, a separate database for the mobile app, a support-ticket tool, a payments processor, a marketing platform, spreadsheets, and log files from servers. Each of those systems is good at its own job, but none of them can answer a company-wide question by itself. "What was total revenue last month, broken out by marketing channel and customer segment?" touches data that lives in at least three or four completely different systems.
A data warehouse is the system built to hold a copy of all of that data, reshaped into a form that is easy to query together. Data is copied out of source systems (this process is called ELT or ETL, extract-load-transform or extract-transform-load), landed in the warehouse, cleaned up, and modeled into tables that answer business questions. The warehouse itself does not run the business; it explains the business.
Before cloud warehouses like Snowflake existed, "data warehouse" usually meant a physical or virtual-machine cluster a company owned or rented, running warehouse software (Teradata, Oracle Exadata, on-prem SQL Server, early Hadoop/Hive clusters) that someone on the infrastructure team had to size, patch, back up, and scale by hand. Snowflake's pitch, when it launched, was: what if the warehouse itself lived entirely in the cloud, and nobody on your team had to manage a single server to run it?
Why Snowflake Is Different From a Normal Application Database
The fastest way to understand Snowflake is to separate OLTP from OLAP. OLTP means online transaction processing: many small reads and writes that keep an application running. OLAP means online analytical processing: fewer but much larger queries that scan, join, aggregate, and analyze data.
A checkout flow is a textbook OLTP workload. When a customer clicks "place order," the application needs to: check that the item is in stock, write a new row to an orders table, decrement inventory, charge a payment method, and confirm success — all within a few hundred milliseconds, for potentially thousands of customers doing this at the same second. The database backing that flow is tuned for exactly this: fast, tiny, highly concurrent transactions that touch a handful of rows each, with strict guarantees that a write either fully happens or does not happen at all.
An analytics question is the opposite shape of workload. "What was our conversion rate by traffic source, for every day in the last 90 days, broken down by device type?" touches millions of rows, reads far more than it writes, and one query might scan an entire year of order history. Running that kind of query against the same database that handles live checkout traffic would compete for the exact same CPU and disk I/O that customers need to complete their purchases — which is why companies do not run heavy analytics directly against their production OLTP database.
| Dimension | OLTP database | Snowflake / OLAP warehouse |
|---|---|---|
| Main job | Run the live product. | Analyze the business. |
| Typical query | Find one customer by id. | Scan millions or billions of rows. |
| Write pattern | Many tiny inserts/updates every second. | Bulk loads, ELT, batch or streaming ingestion. |
| Storage pattern | Row-oriented in many OLTP systems. | Columnar storage for analytical scans. |
| Concurrency shape | Thousands of short, isolated transactions. | Fewer, larger, longer-running queries. |
| Users | Application backend services. | Analysts, engineers, BI tools, ML workflows. |
| Failure impact | Checkout/login/payment breaks immediately. | Reports, dashboards, and models are delayed or wrong. |
Storage Is Shared, Compute Is Isolated — Snowflake's Single Biggest Idea
If you remember only one thing about Snowflake's design, remember this: Snowflake separates data storage from query compute. Your data lives in Snowflake-managed cloud storage — conceptually similar to S3 or Azure Blob Storage under the hood. Queries run on virtual warehouses, which are independent compute clusters that can start, stop, resize, and operate without touching the storage layer at all.
This is fundamentally different from how a traditional database server, or an older on-prem warehouse, works. In Postgres, MySQL, or a classic Oracle-style warehouse, storage and compute live on the same machine (or tightly coupled machines). If you need more query power, you generally need a bigger machine — and that bigger machine also holds all your data, whether you need more storage or not. Storage and compute scale together, whether you want them to or not.
Snowflake breaks that coupling apart. A data loading job can run on one warehouse while analysts query the exact same tables from a completely different warehouse, at the same time, without fighting each other for CPU. Both warehouses read from the same shared storage. Neither one "owns" the data — they are temporary compute that attaches to data that exists independently of them. This is the payoff of storage/compute separation made concrete, and it is covered in far more depth, with real warehouse-sizing tradeoffs, in the next lesson on architecture.
| Layer | Purpose | Simple analogy |
|---|---|---|
| Storage | Keeps compressed table data and metadata. | The library shelves. |
| Virtual warehouse | Runs SQL and loads/transforms data. | The workers reading books and answering questions. |
| Cloud services | Handles metadata, optimization, auth, transactions. | The catalog, security desk, and coordinator. |
-- Loading warehouse ingests raw files into RAW.ORDERS
USE WAREHOUSE WH_LOAD_XS;
COPY INTO RAW.ORDERS FROM @raw_stage;
-- Meanwhile, a completely different warehouse serves BI dashboards
-- against the same underlying tables, with zero contention.
USE WAREHOUSE WH_BI_S;
SELECT DATE(order_ts) AS order_date, SUM(total_usd) AS revenue_usd
FROM SILVER.ORDERS
GROUP BY 1
ORDER BY 1 DESC;What Actually Changes When a Warehouse Moves to the Cloud
It helps to be concrete about what companies used to have to do, and what Snowflake removes. A traditional on-prem warehouse required someone to forecast capacity months in advance, buy or provision hardware sized for the busiest expected day of the year, and then leave that hardware mostly idle the rest of the time. Growing the warehouse meant a procurement cycle, a migration project, and real downtime risk. Two teams running heavy queries at the same time slowed each other down because they shared one fixed pool of compute.
| Concern | Traditional on-prem warehouse | Snowflake |
|---|---|---|
| Adding compute | Buy/provision hardware, plan for weeks or months. | Resize or spin up a warehouse in seconds. |
| Idle cost | Hardware sits idle outside peak hours but still costs money. | Warehouses auto-suspend and stop billing when idle. |
| Workload isolation | One shared cluster; heavy jobs slow everyone down. | Separate virtual warehouses per workload, same data. |
| Operations burden | DBAs patch, tune, back up, and monitor physical/VM infrastructure. | Fully managed; Snowflake operates the platform. |
| Scaling direction | Usually scale up (bigger single machine). | Scale up (bigger warehouse) and out (more warehouses/clusters) independently. |
None of this means Snowflake is "free" or that it removes all operational thinking — someone still has to size warehouses sensibly, control who can spin up expensive compute, and watch for runaway costs. What changes is where the effort goes: less time keeping infrastructure alive, more time on data modeling, governance, and making sure the numbers are right.
What Problems Snowflake Solves
Before cloud warehouses, companies often ran data warehouses on fixed clusters. Scaling was slow. Storage and compute were tightly coupled. One department's giant query could slow down everyone else. Administrators spent time tuning infrastructure instead of helping teams deliver data.
- ✓It separates storage from compute so teams can scale query power independently from stored data.
- ✓It is fully managed, so teams do not manage warehouse servers, disks, patches, or cluster nodes.
- ✓It supports SQL, semi-structured data, sharing, governance, and elastic compute in one platform.
- ✓It lets multiple workloads use different virtual warehouses against the same stored data.
- ✓It supports Time Travel and zero-copy cloning, which make recovery and development workflows easier.
- ✓Compute is elastic: a warehouse can be resized up for a heavy backfill and back down for routine work.
- ✓Pricing is consumption-based — you are billed for compute-seconds actually used, not for owning idle hardware.
- ✓It runs the same way across multiple clouds, so a company is not locked into one cloud vendor's warehouse.
Application DBs SaaS tools Event streams Files
│ │ │ │
└────────────── ingestion / ELT / CDC / batch ──────────┘
│
Snowflake
│
┌───────────────┬──────┴──────┬────────────────┐
│ │ │ │
BI dashboards dbt marts data science governed sharingWhere Snowflake Came From
Snowflake was founded in 2012 by a small team of database engineers, several of whom had previously worked on Oracle's database engine. The founding idea was deliberately radical for its time: instead of adapting an existing database to run in the cloud, build a brand-new warehouse whose architecture assumes the cloud from the very first line of code — cheap, effectively unlimited object storage, on-demand compute you can start and stop by the second, and no physical hardware a customer ever touches or even sees.
That "built for the cloud from day one" framing matters because many older warehouse products took the opposite path: they started as on-prem software and were later ported, wrapped, or bolted onto cloud infrastructure. Snowflake's storage/compute separation, its automatic micro-partitioning (covered in the next lesson), and its multi-cluster elastic warehouses were all designed around cloud primitives from the start rather than retrofitted onto them.
Snowflake runs on top of infrastructure from AWS, Microsoft Azure, and Google Cloud — a company can run its Snowflake account on whichever of those clouds it prefers, and Snowflake's core feature set behaves consistently across all three. The company went public in 2020, and Snowflake has since become one of the standard names alongside BigQuery, Redshift, and Databricks when a company is choosing a cloud analytics platform.
Why this history matters practically: because Snowflake was never adapted from an on-prem product, its defaults, its pricing model, and its operational habits (like "just resize the warehouse, don't provision a new server") reflect cloud-native thinking end to end — which is part of why it behaves so differently from tuning a self-managed Postgres or Oracle instance.
How Snowflake Compares to BigQuery, Redshift, and Databricks SQL
Snowflake is not the only cloud analytics platform, and it is worth knowing the landscape at a high level — without overstating any one product's advantages, since all of these platforms are competitive and evolve quickly. What follows is a rough, practical orientation, not a benchmark.
| Platform | Origin / cloud model | Rough positioning |
|---|---|---|
| Snowflake | Cloud-native from founding (2012); runs on AWS, Azure, or GCP. | Multi-cloud SQL warehouse, strong separation of storage/compute, broad ecosystem and sharing features. |
| Google BigQuery | Google's serverless warehouse, tightly integrated with GCP. | Serverless query model (less manual warehouse sizing), strong fit if a company is already GCP-centric. |
| Amazon Redshift | AWS's warehouse, originally based on an older columnar database engine. | Deep AWS integration; newer serverless options reduce some of the older cluster-management overhead. |
| Databricks SQL | Built on top of the Databricks lakehouse (Spark-based) platform. | Strong when a company wants one platform spanning data engineering, ML, and SQL analytics together. |
In practice, the decision between these platforms usually comes down to factors beyond raw SQL capability: which cloud a company already standardizes on, whether the team wants a lakehouse model where open file formats are the source of truth, existing tooling and vendor relationships, pricing model preferences (consumption-based compute vs. other billing structures), and team familiarity. All of them can run large-scale OLAP workloads well. None of them should be assumed to be categorically faster or cheaper without measuring a company's actual workload.
The Consumption-Based Pricing Model, at a High Level
Snowflake bills primarily on consumption rather than on owning fixed infrastructure. The two big cost drivers a newcomer should know about are compute and storage, and they are billed completely separately — another direct consequence of storage/compute separation.
| Cost driver | What drives the bill | How to control it |
|---|---|---|
| Virtual warehouse compute | Credits consumed per second a warehouse actually runs, scaled by warehouse size. | Right-size warehouses, use AUTO_SUSPEND aggressively, isolate workloads so nobody over-provisions "to be safe." |
| Storage | Compressed bytes of table data and retained history (Time Travel, Fail-safe) held over time. | Set sensible retention periods, avoid unbounded raw-table growth, clean up unused clones. |
| Cloud services compute | Usually absorbed unless cloud-services usage crosses a small daily threshold relative to warehouse usage. | Rarely a concern unless the account has extremely metadata-heavy query patterns. |
The practical upshot for a beginner: a warehouse that is left running with AUTO_SUSPEND disabled, or set to an unnecessarily long idle window, is the single most common way a new Snowflake account accidentally spends money for no benefit. Because compute is billed by the second while a warehouse is up, an idle warehouse quietly consumes credits doing nothing.
Hands-On: Sort These Workloads Into OLTP or OLAP
Before moving into Snowflake's architecture in the next lesson, it helps to practice recognizing which category a real workload falls into — this judgment call comes up constantly when deciding what should and should not touch Snowflake directly.
1. A mobile app checking whether a promo code is valid at checkout.
2. A finance team building a quarterly revenue-by-region report.
3. A recommendation model retraining nightly on six months of clickstream history.
4. A support agent's dashboard looking up one customer's order history by customer_id.
5. A marketing analyst comparing campaign performance across 18 months of ad spend data.
6. An inventory service decrementing stock counts as orders are placed in real time.
Sort each into OLTP (belongs in the app's operational database)
or OLAP (belongs in Snowflake or a similar warehouse).Lab questions
- ✓Which of the six workloads above are OLTP, and which are OLAP? Justify each in one sentence.
- ✓Item 4 looks like a simple lookup — why might it still belong in an OLTP database rather than Snowflake?
- ✓If item 3's training pipeline reads its features from Snowflake, does that make the training job itself OLTP or OLAP?
- ✓Which of the six would you expect to run on a small, cheap Snowflake warehouse versus a larger one, if all six did run in Snowflake?
The Misunderstandings That Cause Bad Snowflake Designs
- ✓Snowflake is not a queue; use Kafka, SQS, Pub/Sub, or similar tools for event transport.
- ✓Snowflake is not a low-latency serving cache; use Redis, Elasticsearch, or an application database for that.
- ✓Snowflake is not automatically cheap; bad warehouse settings and dashboard queries can burn credits quickly.
- ✓Snowflake is not automatically clean data; it stores what you load, including duplicates and bad rows.
- ✓Snowflake constraints such as primary keys are not a full replacement for dbt tests and pipeline quality checks.
- ✓Snowflake is not a replacement for your OLTP application database, no matter how fast a single query looks in a demo.
Senior framing: Snowflake is an analytical platform. The value comes from combining the platform with good data modeling, reliable ingestion, explicit quality checks, sensible warehouse sizing, governance, and cost ownership.
The People and Roles Around a Snowflake Account
A useful way to finish grounding this lesson is to see who actually works with Snowflake day to day, since the platform serves several different roles at once rather than one narrow job.
| Role | What they typically do in Snowflake |
|---|---|
| Data engineer | Builds ingestion pipelines, models Raw/Silver/Gold layers, manages tasks and warehouses. |
| Analytics engineer | Writes dbt models and tests on top of raw and staged Snowflake tables. |
| Data analyst / BI user | Queries curated Gold tables through SQL or a BI tool connected to a small warehouse. |
| Data scientist / ML engineer | Pulls modeled data for feature engineering and training, sometimes via Snowpark. |
| Platform / governance owner | Manages roles, access grants, cost monitoring, and account-level policy. |
Each of these roles typically uses a different, appropriately sized virtual warehouse, and often a different set of database roles and grants, even though they are all reading from and writing to the same underlying Snowflake account. That combination — one shared platform, many isolated ways of using it — is the practical, everyday expression of the storage/compute separation idea from Part 04.
Snowflake Is a Platform, Not Just a SQL Engine
By the time you finish this track you will use far more of Snowflake than plain SQL SELECT statements, so it is worth knowing the shape of the wider platform now, even before you have touched any of it hands-on. Snowflake has grown from "a place to run SQL against a warehouse" into a broader platform with several adjacent capabilities that show up repeatedly in real jobs.
| Capability | What it is for |
|---|---|
| Snowpark | Write data transformations and UDFs in Python, Java, or Scala that run inside Snowflake compute, instead of only SQL. |
| Snowflake Marketplace | Discover and directly query third-party and public datasets without building your own ingestion pipeline for them. |
| Secure data sharing | Share live, governed access to specific tables with another Snowflake account, without copying or exporting files. |
| Streams and tasks | Native change tracking and scheduled SQL execution for building incremental pipelines inside Snowflake, covered in a dedicated later lesson. |
| Time Travel and zero-copy cloning | Query or restore data as it existed at a past point in time, and create instant, storage-efficient copies of databases/tables/schemas. |
You do not need to understand any of these deeply yet — most get their own dedicated module later in this track. The point here is just to set correct expectations: "learning Snowflake" is not the same scope as "learning to write SELECT statements." It includes a data-sharing and governance model, a scripting surface beyond SQL, and native orchestration features that increasingly replace what used to require separate external tools.
Snowflake Handles JSON and Semi-Structured Data Natively
Not every source system hands you clean rows and columns. Event payloads, API responses, and log data commonly arrive as JSON, and sometimes as Avro or Parquet. A traditional relational database often forces you to flatten this into rigid columns before you can query it at all, or store it as an opaque text blob you have to parse in application code. Snowflake instead has a native VARIANT column type that stores semi-structured data directly, while still keeping it queryable with SQL.
CREATE OR REPLACE TABLE RAW.EVENTS (
event_id STRING,
payload VARIANT,
loaded_at TIMESTAMP_NTZ
);
INSERT INTO RAW.EVENTS
SELECT 'E-1', PARSE_JSON('{"type":"page_view","user":{"id":"U-9","plan":"pro"}}'), CURRENT_TIMESTAMP();
SELECT
event_id,
payload:type::STRING AS event_type,
payload:user.id::STRING AS user_id,
payload:user.plan::STRING AS plan
FROM RAW.EVENTS;This matters for the "what is Snowflake" mental model because it means Snowflake is not narrowly a rows-and-columns-only warehouse — it can land raw, irregular data first and let modeling happen in SQL afterward, which is a common pattern in modern ELT pipelines where transformation happens inside the warehouse rather than before loading.
Snowflake Has Governance Built In, Not Bolted On
Because Snowflake is where data from many sensitive source systems converges, access control is a first-class part of the platform rather than an afterthought. Snowflake uses role-based access control (RBAC): every action — querying a table, creating a warehouse, granting access to someone else — is governed by roles that are granted specific privileges on specific objects, and users are granted roles rather than being given permissions directly.
| Concept | What it controls |
|---|---|
| Role | A named collection of privileges that can be granted to users or other roles. |
| Privilege | A specific allowed action on an object, such as SELECT on a table or USAGE on a warehouse. |
| Object | What the privilege applies to — a database, schema, table, warehouse, or other Snowflake object. |
| Masking / row access policies | Column- and row-level rules that restrict what specific roles can see, even within a table they can query. |
None of this needs to be memorized yet — governance gets a dedicated module later in this track. The point at this stage is only that "who can see what" is a designed, queryable part of the platform from day one, which is part of why companies trust Snowflake with sensitive, regulated data rather than treating access control as something layered on top after the fact.
Following One Row From Checkout to Dashboard
To tie every earlier part together, walk through what actually happens to a single order between the moment a customer clicks "buy" and the moment an executive sees it reflected in a revenue dashboard the next morning. This end-to-end picture is the practical answer to "why do we need Snowflake at all" for anyone still unsure.
1. Customer clicks "place order" in the app.
-> Written to the OLTP application database (e.g. Postgres) in milliseconds.
2. A change-data-capture or batch pipeline picks up new/changed order rows.
-> Loaded into Snowflake's RAW layer, largely as-is.
3. Transformation logic (SQL or dbt) cleans, types, and models the row.
-> Lands in a SILVER layer: deduplicated, typed, business-ready.
4. Aggregation logic rolls SILVER up into business metrics.
-> Lands in a GOLD table like DAILY_REVENUE, ready for consumption.
5. A BI tool queries GOLD through a small Snowflake warehouse.
-> The executive's dashboard shows yesterday's revenue by region.Notice what did not happen: the dashboard query never touched the OLTP database, so the checkout flow was never put at risk by an analyst's report. The report never had to invent its own copy of "what is an order" — it inherited a clean definition built once, in Snowflake, from raw data. And the whole pipeline, from RAW to SILVER to GOLD, ran on Snowflake compute that could be resized, scheduled, and monitored independently of the live product.
| Stage | System | Workload type |
|---|---|---|
| Order placed | Application OLTP database | OLTP — small, fast, transactional. |
| Order loaded | Snowflake RAW layer | OLAP ingestion — bulk load, not row-by-row. |
| Order modeled | Snowflake SILVER layer | OLAP transformation — SQL/dbt, batch or incremental. |
| Metric built | Snowflake GOLD layer | OLAP aggregation — summarized for consumption. |
| Dashboard viewed | BI tool over Snowflake | OLAP read — small, curated result set. |
How to Explain Snowflake Clearly
In an interview, say: Snowflake is a fully managed cloud data warehouse for analytical workloads, founded in 2012 and built cloud-native from the start rather than adapted from an on-prem product. It separates storage from compute. Data is stored in compressed columnar micro-partitions in Snowflake-managed cloud storage, and queries run on virtual warehouses that can be sized, suspended, resumed, and isolated by workload — so a loading job and a BI dashboard can hit the same tables without competing for the same compute. Snowflake supports SQL, semi-structured data, Time Travel, zero-copy cloning, secure data sharing, RBAC, streams, tasks, and integrations with tools like dbt, and it runs on AWS, Azure, or GCP. It is used for analytics and ELT — OLAP workloads — not as a low-latency OLTP application database, and it competes in the same general space as BigQuery, Redshift, and Databricks SQL, each with different architectural tradeoffs.
You should now be able to answer
- ✓What is Snowflake in one sentence?
- ✓Why is Snowflake not the same as PostgreSQL?
- ✓What does separating storage and compute mean, and why does it matter in practice?
- ✓What is the difference between an OLTP workload and an OLAP workload?
- ✓Why do companies adopt Snowflake instead of running their own on-prem warehouse?
- ✓What kinds of workloads should not run directly on Snowflake?
- ✓How would you briefly compare Snowflake to BigQuery, Redshift, or Databricks SQL without overclaiming?
🎯 Key Takeaways
- ✓Snowflake is a cloud data warehouse for analytics, not a normal app database.
- ✓It is built for OLAP workloads: scans, joins, aggregates, dashboards, ELT, and governed data products.
- ✓Its core architectural idea is separated storage and compute — the single biggest thing that makes it different from Postgres/MySQL/traditional warehouses.
- ✓Virtual warehouses provide isolated compute over shared data, and compute is billed only while running.
- ✓Snowflake was founded in 2012, built cloud-native from day one, and runs on AWS, Azure, or GCP.
- ✓It competes with BigQuery, Redshift, and Databricks SQL — each has different tradeoffs, none is universally "better."
- ✓Snowflake still requires good modeling, ingestion, security, quality checks, and cost governance.
Quick check
What is Snowflake mainly built for?
HELP US IMPROVE
How was this lesson?
Your note is shared with the Chaduvuko team for review. Please don’t include personal or sensitive information.
Spotted a mistake or something unclear? Suggest a fix on GitHub or email us. Select the text first and it is quoted for you.
Discussion
0Have a better approach? Found something outdated? Share it — your knowledge helps everyone learning here.
