That incident points at a question you have probably asked about your own stack: what is actually in my dependency tree? Not just the 30 packages in your package.json. Everything they pull in, and everything those pull in, all the way down.

In a relational database, dependencies live in a self-referencing join table. "Everything, all the way down" means a recursive CTE. Here is that query on a snapshot of the npm registry. It finds the full runtime dependency tree of express:

WITH RECURSIVE closure(name, depth) AS (
  SELECT depends_on_name, 1
  FROM dependencies
  WHERE package_name = 'express' AND dep_type = 'runtime'
  UNION
  SELECT d.depends_on_name, c.depth + 1
  FROM closure c
  JOIN dependencies d
    ON d.package_name = c.name AND d.dep_type = 'runtime'
)
SELECT count(DISTINCT name) AS transitive_deps, max(depth) AS max_depth
FROM closure;

Here is the result:

It works. Here it shows 63 packages, 11 levels deep. But it is twelve lines, and every line matters. There is an anchor part, a recursive part, and a UNION doing quiet work to remove duplicates. A graph asks the same question in two lines:

MATCH (:Package {name: 'express'})-[:DEPENDS_ON*]->(dep)
RETURN count(DISTINCT dep) AS transitive_deps

That is not a shortened excerpt. That is the whole query. It returns the same 63 packages.

Cypher is Neo4j's query language. For a SQL developer, it is less a new language than a new notation for questions you already know how to ask. This article proves that claim with ten translations. They run from "this is just SQL with arrows" up to the query above, plus one final twist that SQL has no clean answer for. By the end, you should be able to read Cypher on sight and write the first seven queries yourself, today.

The dataset, so you can check my work

Every query runs against a fixed snapshot of npm. It starts with the top 5,000 most-used packages, then follows their runtime dependencies until the set is complete. The result is about 5,600 packages, their maintainers, and every dependency link among them. The exact same data exists twice.

Relational (SQLite): four tables. This is the shape the data naturally takes in a relational model.

• packages(package_name, description, license, latest_version, weekly_downloads, deprecated)

• dependencies(package_name, depends_on_name, dep_type, semver_range), the join table

• maintainers(username) and package_maintainers(username, package_name)

Graph (Neo4j): the same facts as nodes and relationships.

• (:Package) and (:Maintainer) nodes with the same properties

• (:Package)-[:DEPENDS_ON {range}]->(:Package) for runtime dependencies

• (:Package)-[:DEV_DEPENDS_ON {range}]->(:Package) for dev dependencies

• (:Maintainer)-[:MAINTAINS]->(:Package)

From join table to relationships

Notice where the join table went. Each row of dependencies became a relationship. Its columns split in an interesting way. The semver_range is a fact about the dependency itself, so it became a property on the relationship. But dep_type became the relationship's type. Runtime and dev dependencies are different kinds of link, not different values in a column. Query 3 will show why that choice pays off.

Note: this snapshot collapses versions. There is one node per package, and the links come from each package's latest version. The semver ranges are saved as text but not resolved. So the graph answers "what does the current ecosystem depend on," not "what exact files does npm install produce." Version-level modeling is a different and much bigger graph.

Both databases, the CSVs, and the build pipeline are in the companion repository. You can load the graph into a free Aura instance by pasting this script. Or download npm.db and follow along in SQLite.

Queries 1 to 3: the automatic translations

For filtering, sorting, and picking columns, Cypher works just like SQL. The main change is how you point at your data. Instead of FROM packages p, you write MATCH (p:Package). The parentheses draw a node, the label picks which kind, and p is an alias, doing the same job it does in SQL.

1. SELECT with WHERE

Start with every MIT-licensed package:

SELECT package_name, description
FROM packages
WHERE license = 'MIT';

The same query in Cypher:

MATCH (p:Package)              
WHERE p.license = 'MIT'        
RETURN p.name, p.description   

And as you can see the output is identical to the result of the SQL query.

2. ORDER BY and LIMIT

Now the ten most-downloaded packages:

SELECT package_name, weekly_downloads
FROM packages
ORDER BY weekly_downloads DESC
LIMIT 10;

The same question in Cypher:

MATCH (p:Package)
RETURN p.name, p.weeklyDownloads
ORDER BY p.weeklyDownloads DESC
LIMIT 10

Same keywords, same meaning. There is nothing to learn here. That is the point.

3. Your first JOIN becomes a pattern

The direct runtime dependencies of express:

SELECT d.depends_on_name, d.semver_range
FROM packages p
JOIN dependencies d ON d.package_name = p.package_name
WHERE p.package_name = 'express'
  AND d.dep_type = 'runtime';

In Cypher:

MATCH (:Package {name: 'express'})-[d:DEPENDS_ON]->(dep:Package)
RETURN dep.name, d.range

This is the first translation where the shape changes, not just the keywords. The JOIN ... ON clause is gone. The connection between two packages is stored as a relationship, so the arrow -[:DEPENDS_ON]-> is the join, already built.

Look at what happened to AND d.dep_type = 'runtime'. It disappeared. Runtime and dev dependencies are different relationship types, so asking for DEPENDS_ON filters by itself. Want dev dependencies instead? Write -[:DEV_DEPENDS_ON]->. Want both? Write -[:DEPENDS_ON|DEV_DEPENDS_ON]->.

In SQL, this is the filter you always have to remember, and the bug you ship when you forget it. In the graph, it became part of the question's grammar.

Both queries return 28 rows. Express pulls in 28 packages directly. Hold that number. Query 10 will tell you what it grows into.

Queries 4 to 6: aggregation without GROUP BY

4. The join you write twice

The dependencies of express's dependencies, two levels down, by hand:

SELECT DISTINCT d2.depends_on_name
FROM dependencies d1
JOIN dependencies d2
  ON d2.package_name = d1.depends_on_name
 AND d2.dep_type = 'runtime'
WHERE d1.package_name = 'express'
  AND d1.dep_type = 'runtime';

The same question in Cypher:

MATCH (:Package {name: 'express'})-[:DEPENDS_ON*2]->(dep:Package)
RETURN DISTINCT dep.name

Each extra level in SQL costs another self-join of the dependencies table. You add d3, d4, d5, each with its own ON clause and its own dep_type filter to not forget.

In Cypher, depth is a number. Write *2 for exactly two hops, or *1..3 for one to three. This query is a preview. You can feel where hand-written depth stops working, and query 10 is waiting there.

5. GROUP BY is implicit

Which packages have the most direct dependencies?

SELECT p.package_name, COUNT(*) AS dep_count
FROM packages p
JOIN dependencies d ON d.package_name = p.package_name
WHERE d.dep_type = 'runtime'
GROUP BY p.package_name
ORDER BY dep_count DESC
LIMIT 10;

In Cypher:

MATCH (p:Package)-[:DEPENDS_ON]->()
RETURN p.name, count(*) AS depCount
ORDER BY depCount DESC
LIMIT 10

There is no GROUP BY in Cypher. After a week, you will not miss it. The rule is simple. Any plain expression that appears next to an aggregate in RETURN (or WITH) becomes a grouping key. Since p.name sits next to count(*), Cypher groups by it. This also removes SQL's most tedious error: the "column must appear in the GROUP BY clause" dance, where you repeat every selected column a second time.

One more detail. The empty node () is anonymous. We are counting edges to anything, so the target needs no name. Say only what you need.

6. HAVING becomes WITH ... WHERE

The load-bearing packages: the ones that more than 100 other packages depend on directly:

SELECT d.depends_on_name, COUNT(*) AS dependents
FROM dependencies d
WHERE d.dep_type = 'runtime'
GROUP BY d.depends_on_name
HAVING COUNT(*) > 100
ORDER BY dependents DESC;

The same question in Cypher:

MATCH (p:Package)<-[:DEPENDS_ON]-()
WITH p, count(*) AS dependents
WHERE dependents > 100
RETURN p.name, dependents
ORDER BY dependents DESC

Two things happened here. First, the arrow flipped. The pattern <-[:DEPENDS_ON]- counts incoming links: who depends on p, not what p depends on. Direction is visible in the pattern. SQL hides it in which column you group by. Quick, was it package_name or depends_on_name?

Second, meet WITH. It is the construct SQL never gave you: a pipe between query stages. Aggregate, then filter the result, then keep going. HAVING exists in SQL only because WHERE runs before aggregation. Cypher does not need a special keyword. You place the WHERE after the aggregation in the pipeline. One mental model replaces two keywords.

Reach for WITH any time you catch yourself wanting a subquery or a second CTE stage. It covers most of both.

Queries 7 to 9: the patterns that replace subqueries

7. LEFT JOIN ... IS NULL becomes OPTIONAL MATCH

Leaf packages: in the dataset, but nothing else depends on them:

SELECT p.package_name
FROM packages p
LEFT JOIN dependencies d
  ON d.depends_on_name = p.package_name
 AND d.dep_type = 'runtime'
WHERE d.package_name IS NULL;

The anti-join translates straight across. OPTIONAL MATCH is exactly LEFT JOIN: match if you can, bind NULL if you cannot, then keep the rows where the match failed.

MATCH (p:Package)
OPTIONAL MATCH (p)<-[d:DEPENDS_ON]-()
WITH p, d
WHERE d IS NULL
RETURN p.name

But the graph does not need the join at all. The LEFT JOIN ... IS NULL pattern makes you assemble every non-match just to count that it is missing. The real question is simpler: does anything depend on p? An EXISTS predicate in WHERE asks exactly that:

MATCH (p:Package)
WHERE NOT EXISTS { (p)<-[:DEPENDS_ON]-() }
RETURN p.name

This is where the graph pulls ahead. EXISTS { } is an existence check: it stops the moment one incoming DEPENDS_ON is found and never enumerates the rest. Because Neo4j stores the relationship degree on every node, the question, does p have any incoming DEPENDS_ON, is answered by reading one number, without ever expanding a relationship or building a row to discard. It is a small query doing something the relational model has to work for, and a clean example of a graph-native advantage.

A fun detail about this dataset: the leaves are mostly the famous top-of-tree packages, like express, chalk, and lodash. They start dependency trees rather than sit inside them. The snapshot contains what they depend on, not the millions of apps that depend on them.

8. EXISTS subqueries become pattern predicates

Packages that depend on both react and vue. Rarer than you might think:

SELECT p.package_name
FROM packages p
WHERE EXISTS (
  SELECT 1 FROM dependencies d
  WHERE d.package_name = p.package_name
    AND d.depends_on_name = 'react' AND d.dep_type = 'runtime')
AND EXISTS (
  SELECT 1 FROM dependencies d
  WHERE d.package_name = p.package_name
    AND d.depends_on_name = 'vue' AND d.dep_type = 'runtime');

The same query in Cypher:

MATCH (p:Package)
WHERE EXISTS { (p)-[:DEPENDS_ON]->(:Package {name: 'react'}) }
  AND EXISTS { (p)-[:DEPENDS_ON]->(:Package {name: 'vue'}) }
RETURN p.name

Same keyword as SQL, and you have already met it: query 7 used NOT EXISTS { } to find packages that nothing depends on. Here it does the positive job, with far less machinery. A correlated SQL subquery is a full nested query. It has its own FROM, its own filters, and its own correlation condition you wire up by hand. Cypher's EXISTS { } takes a pattern. The correlation is free, because the pattern reuses the variable p that is already bound. Ten lines become four, and the four read like a sentence.

By the way, if you're following along and running these queries yourself, the result is zero in this snapshot.

9. The self-join

Packages that share a maintainer with lodash:

SELECT DISTINCT pm2.package_name
FROM package_maintainers pm1
JOIN package_maintainers pm2
  ON pm1.username = pm2.username
WHERE pm1.package_name = 'lodash'
  AND pm2.package_name <> 'lodash';

In Cypher:

MATCH (:Package {name: 'lodash'})<-[:MAINTAINS]-(:Maintainer)-[:MAINTAINS]->(p:Package)
RETURN DISTINCT p.name

The SQL joins the association table against itself. That takes two aliases, a join on the shared key, and an inequality to skip the starting row. The Cypher walks through the shared maintainer instead. It goes into lodash from its maintainer, then back out to everything else that maintainer touches. There are no aliases and no inequality, since a path cannot reuse the relationship it arrived on. The query reads like the question itself: who else does lodash's maintainer maintain?

This pattern (entity, through a shared link, to entity) is the skeleton of collaborative filtering, fraud-ring detection, and "people also bought." In SQL it is always a self-join on the association table. In a graph it is always this V-shaped walk. Learn it once here.

Query 10: where the languages stop being comparable

Back to the opening question, now with the numbers filled in. Express declares 28 direct dependencies. Its full runtime tree, the true answer to "what am I actually installing," is 63 packages, reaching 11 levels deep. The recursive CTE at the top of this article computes that correctly. I want to be precise about what is and is not hard about it.

The naive CTE finishes just fine on this dataset. Dependency graphs are nearly free of cycles, and the UNION step keeps the working set small by removing duplicates. This is a friendlier graph than, say, a social network. There, loops and highly connected nodes can make path-listing CTEs blow up.

What are the honest differences? First, the CTE is a program and the pattern is an expression. Twelve lines describe how to traverse: the anchor, the recursion, the dedup, the depth tracking. One line states what you want.

Second, and this is the one that matters in practice: now reverse the question. Not "what does express depend on," but the left-pad question. What breaks if this package disappears? In SQL, that is a second CTE, a mirror image of the first. The recursion now runs along package_name instead of depends_on_name. The anchor flips. You maintain both queries forever:

WITH RECURSIVE blast_radius(name) AS (
  SELECT package_name FROM dependencies
  WHERE depends_on_name = 'debug' AND dep_type = 'runtime'
  UNION
  SELECT d.package_name
  FROM blast_radius b
  JOIN dependencies d ON d.depends_on_name = b.name
                     AND d.dep_type = 'runtime'
)
SELECT count(*) AS affected FROM blast_radius;

In Cypher, reversing the question means reversing the arrow:

MATCH (affected:Package)-[:DEPENDS_ON*]->(:Package {name: 'debug'})
RETURN count(DISTINCT affected) AS affected

Same query. Flipped arrow.

This is not Cypher being shorter for its own sake. The query language has a native concept, the path, that SQL lacks. Once paths are built in, "everything downstream," "everything upstream," "shortest chain between," and "is there any connection at all" become expressions instead of programs.

That is the difference between a notation gap and a capability gap. It is also the clearest signal for when a graph database is the right tool. If your hard queries are about how things connect, at unknown depth, then you are implementing algorithms in your query language that Cypher gives you as syntax.

The cheat sheet

The full mapping, for reference:

Look at the rightmost column. Most rows are automatic or close to it. You can read those today. A few rows each require one new idea: implicit grouping, the WITH pipeline, or joins as stored relationships. Only the last row is truly new territory, and it is the row you came for.

When to stay in SQL

This comparison is only honest if it cuts both ways. Nothing here argues for replacing your relational database wholesale. In fact, several of these queries are evidence against moving certain workloads:

• Flat filtering and aggregation (queries 1, 2, and 5): SQL is at parity. Your team already knows it, and the tooling around it (BI layers, ORMs, decades of operational habit) is mature. A GROUP BY over one table is not a graph problem.

• Bulk reporting over wide tables with few relationship hops is exactly what relational engines are tuned for.

• The modeling cost is real. The graph's elegance was paid for at load time. Someone decided that dep_type should be a relationship type, that maintainership should be an edge, and that versions should collapse. Change a decision, rebuild the graph. If your access patterns are stable, tabular, and shallow, that cost never pays off.

The signal to reach for a graph is specific. Your queries routinely chain three or more joins. The depth is variable or unknown ("all upstream dependencies," "how are these two things connected"). Or you find yourself writing recursive CTEs against self-referencing tables. That last one is the tell. If query 10 looks like something in your codebase, this article was written for you.

Try all ten yourself

Everything above is reproducible. The companion repository has both databases prebuilt: npm.db for SQLite, and one paste-and-run script that loads the graph into a free Aura instance. The CSVs and the pipeline that built them are there too, if you want to regenerate the snapshot yourself. No setup appears in this article because none is needed to follow it. The repo README is the whole install.

But the fastest route to writing Cypher rather than reading it is a course with a graph already loaded and live checking.

Cypher Fundamentals is free, runs in the browser, and takes about an hour. It covers exactly the constructs in queries 1 through 8, and turns "I can read this" into "I wrote this" in one sitting:

From there, Intermediate Cypher Queries picks up the variable-length paths and the WITH pipeline behind queries 6 and 10.

One teaser before you go, because query 10 probably raised the question. The dataset in this article is generic npm. Your package-lock.json is the same graph shape, with your project as the root node. Converting it to this schema is a small script away. Running a blast-radius query against your own application's real dependency tree is a great next step.

Frequently asked questions

Is Cypher hard to learn if I already know SQL? No, and this article is the argument. Most of the ten translations are simple keyword swaps. The ideas that take real learning are implicit grouping (query 5), the WITH pipeline (query 6), and thinking of joins as stored relationships (query 3). This tends to click quickly for SQL developers.

Do I have to give up SQL to use Neo4j? No. The common production pattern is to use both. The relational database keeps the transactional, tabular workloads. The graph handles the relationship-heavy queries. The dataset in this article exists in both databases at once, built from the same CSVs.

Is Cypher actually faster, or just shorter? Shorter is what this article shows. Faster depends on the workload, and it deserves measurement. The structural argument goes like this: graph traversal follows stored pointers (called index-free adjacency) instead of recomputing joins at every hop. So cost scales with the part of the graph you touch, not the size of the tables you join. That difference grows with depth. For single-hop lookups, a well-indexed relational database is extremely hard to beat. And the naive recursive CTE handled this nearly cycle-free dataset without drama.

Why did dep_type become a relationship type instead of a property? Because runtime and dev dependencies are different kinds of connection, and queries almost always want one kind or the other. Making the difference structural means the common case needs no filter, and the forgotten-filter bug cannot happen. The semver range stayed a property because it is a fact about an edge you already selected, not a way of selecting edges. That is the general rule. Things you filter on want to be types. Things you read afterward want to be properties.

Does Cypher work outside Neo4j?

Increasingly, yes. Cypher was the main input to GQL, the ISO-standard graph query language published in 2024. Open implementations of Cypher exist for several other engines. The skills transfer.

While learning about graph databases and Neo4j I realized it was the perfect tool for answering a question I was curious about. We've all seen or heard of "Six Degrees of Kevin Bacon" where nearly any actor can be traced back to the Footloose star. I wondered: could this work for F1 drivers? By comparison it's a much smaller dataset than famous actors.

Photos via Wikimedia Commons, licensed under CC BY‑SA 4.0.

Is Max Verstappen connected to Juan Manuel Fangio? Could a driver who retired in 1958, decades before Max was born, connect to him through a chain of teammates? And if so, how many links does it take?

This post is how I answered that, and it doubles as a gentle introduction to Neo4j and graph databases. By the end you'll have built a real graph of every F1 driver since 1950 on your own machine, and you'll run a query that answers my Verstappen-to-Fangio question in a single line. No prior graph experience needed.

Let's get into it.

Why this is a graph problem

Before we start: My question isn't really about drivers. It's about the connections between drivers.

If all I wanted was a list of drivers, or each driver's win count, or how many races happened at Monza, a plain old relational table handles that beautifully. Even a spreadsheet can do it. Spreadsheets are wonderful at facts about things. Where they start to sweat is questions about relationships and chains of relationships. Specifically long relationship chains.

Think about what "is Verstappen connected to Fangio?" actually requires. You don't know in advance whether the answer is three hops or nine. So in SQL you'd be writing a recursive common table expression that joins a results table to itself, over and over, to a depth you can't predict, while trying not to drown in duplicate paths.

I tried do this very thing and locked up the application trying. It's possible to do queries like this, but they rarely run fast, if they run at all. Relational databases weren't designed for things like this.

A graph database flips the whole thing around. Instead of storing drivers in one table and hoping to reconstruct their connections later with joins, it stores the connections themselves as useful entities. That's the one idea underneath everything else in this post:

In a graph database, the relationships are first class data. They're not something you compute at query time. They're something you store, traverse, and count directly.

That single design choice is what turns this tough question into a one liner. Let me show you the model before we build it.

The property graph model, in four pieces

Neo4j uses the Labeled Property Graph model. It sounds fancy; it's just four building blocks. I'll introduce each one using our F1 data.

Nodes are the things in your domain. The entities. For us, that's drivers and teams. In a diagram you draw them as circles. Ayrton Senna is a node. McLaren is a node.

Labels are the type of a node, written with a colon: :Driver, :Constructor. (Constructor is just F1's official word for "team".) Labels are how Neo4j knows a Senna node is a driver and a McLaren node is a team. By convention they're written in PascalCase.

Relationships are the connections between nodes, and this is where graphs shine. Every relationship has a type in SCREAMING_SNAKE_CASE, a direction, and a start and end node. Senna DROVE_FOR McLaren is a relationship. Crucially, that connection is stored in the database. Neo4j keeps a pointer from one node to the next. This is why hopping across relationships stays fast even when your graph gets huge. The cost of following one relationship remains small, whether your database has a thousand nodes or a billion.

Properties are key-value pairs you can hang on either a node or a relationship. A :Driver node has forename: 'Ayrton', surname: 'Senna', nationality: 'Brazilian'. Here's something that might be surprising if you come from a table world: a relationship can carry properties too. Our DROVE_FOR relationship will carry season: 1988, because which season someone drove for a team is a fact about the connection, not about the driver or the team on their own.

That last point is worth thinking about, because it was an "aha" moment for relational-to-graph thinking. Senna drove for McLaren, but when he did it doesn't belong to Senna and doesn't belong to McLaren. It belongs to the link between them. Put it on the relationship and a whole category of modeling headaches evaporates.

Here's our entire starting model:

(:Driver {forename: 'Ayrton', surname: 'Senna'})
  -[:DROVE_FOR {season: 1988}]->
(:Constructor {name: 'McLaren'})

Two circles, one labeled arrow between them. If you want to make that concrete right now, open Arrows (a free browser diagramming tool) and draw it. Click to make a node, give it a label and some properties, drag from its edge to a second node to create the relationship. It's helpful to sketch your schema there before writing any code.

Design for the question you want to ask

Before building anything, I did the single most useful thing you can do when modeling a graph: I wrote down the question I actually wanted to answer, first, and let it drive every decision afterward.

My question — "how are two drivers connected through shared teammates?" This tells me exactly what my graph needs. It needs drivers. It needs some notion of two drivers being teammates. Everything else is optional scaffolding.

But notice the dataset doesn't hand me "teammate" directly. It gives me who drove for which team in which season. Two drivers are teammates when they drove for the same team in the same season.

So my plan has a nice shape to it:

1. Load Driver and Constructor nodes.

2. Connect them with DROVE_FOR relationships (one per driver, per team, per season).

3. Derive a brand-new TEAMMATE_OF relationship between any two drivers who share a team and season.

4. Walk the TEAMMATE_OF web to answer my question.

In step three we are creating relationships that weren't in the raw data, by reasoning about the graph you already have. This is one of my favorite things about working in Neo4j, and you'll see why shortly. Let's build.

What you'll need

• Neo4j Desktop — free, from neo4j.com/download. I'm on the current version (Desktop 2.x) on a Mac; Windows and Linux are the same journey.

• The dataset — the "Formula 1 World Championship (1950–2024)" dataset by Rohan Rao on Kaggle. Free Kaggle account, one download, clean CSVs.

• An afternoon. Realistically a couple of hours, most of it spent going "oh that's cool" at the results.

• No prior Cypher. I'll explain every query as we go. Cypher is Neo4j's query language and it's genuinely readable. If you already know SQL you'll be nodding along within minutes.

A quick note on the data: For about a decade, the go-to source for F1 data was the Ergast API. It shut down at the end of 2024. The Kaggle dataset we're using preserves Ergast's exact structure as downloadable CSVs, and if you later want live current-season data, the community-run Jolpica-F1 API (api.jolpi.ca/ergast/f1/) serves the same schema. Build against the CSVs today; top up from Jolpica whenever you like. Nothing in this tutorial changes.

Once Neo4j Desktop is installed: under local instances, click create instance to create a new local instance.

Give it a name and a password you'll remember, and start it. Then open the Query tool (in Desktop 2.x this is where you run Cypher — it's the modern replacement for what older tutorials call "Neo4j Browser"). That's our workbench.

We need four files from the Kaggle download:

• drivers.csv

• constructors.csv

• races.csv

• results.csv

We can stage these files for import by placing them in our imports folder. Select your local instance, and look for the ... button.

Select Open then Instance folder:

This is the folder for your Neo4j instance. Next select the import folder. This is where you want to place the files.

macOS:

/Users/[your username]/neo4j-community-2026.x/import

Windows:

C:\Neo4j\import

Linux:

/var/lib/neo4j/import

Now that the files are in the import folder, we can access them with Cypher later.

Step 1: Constraints first

Before loading a single row, I created uniqueness constraints. A constraint guarantees you'll never accidentally create two copies of the same driver. Neo4j automatically builds an index behind each one, which makes all the lookups during import dramatically faster.

In Neo4j Desktop you can run queries by selecting query from the left hand panel and entering your queries in the window in the upper right.

Here's the query to create the constraints:

CREATE CONSTRAINT driver_id IF NOT EXISTS
FOR (d:Driver) REQUIRE d.driverId IS UNIQUE;

CREATE CONSTRAINT constructor_id IF NOT EXISTS
FOR (c:Constructor) REQUIRE c.constructorId IS UNIQUE;

CREATE CONSTRAINT race_id IF NOT EXISTS
FOR (r:Race) REQUIRE r.raceId IS UNIQUE;

Run SHOW CONSTRAINTS to confirm all three landed. That's your data-integrity seatbelt fastened.

Step 2: Load the nodes

Now we bring in the entities. LOAD CSV reads a file row by row; MERGE is Cypher's "create this if it doesn't already exist, otherwise match the existing one" command.

Drivers:

LOAD CSV WITH HEADERS FROM 'https://raw.githubusercontent.com/JeremyMorgan/Six-Degrees-Senna/main/import/drivers.csv' AS row
MERGE (d:Driver {driverId: toInteger(row.driverId)})
SET d.forename  = row.forename,
  d.surname   = row.surname,
  d.fullName  = row.forename + ' ' + row.surname,
  d.nationality = row.nationality,
  d.dob   = CASE WHEN row.dob <> '\\N' THEN date(row.dob) END;

That CASE WHEN row.dob <> '\\N' is guarding against a quirk you'll hit constantly with this dataset: missing values are stored as the literal text \N. If you don't filter them out, you'll end up with drivers whose birthday is the string "backslash-N", which is exactly as useful as it sounds. Consider that your first real-world data-cleaning lesson, delivered by Formula 1.

Constructors:

LOAD CSV WITH HEADERS FROM 'https://raw.githubusercontent.com/JeremyMorgan/Six-Degrees-Senna/main/import/constructors.csv' AS row
MERGE (c:Constructor {constructorId: toInteger(row.constructorId)})
SET c.name    = row.name,
  c.nationality = row.nationality;

Races (we mostly need these to know which season a result belongs to, but full Race nodes cost nothing and set you up for future projects):

LOAD CSV WITH HEADERS FROM 'https://raw.githubusercontent.com/JeremyMorgan/Six-Degrees-Senna/main/import/races.csv' AS row
MERGE (r:Race {raceId: toInteger(row.raceId)})
SET r.year  = toInteger(row.year),
  r.round = toInteger(row.round),
  r.name  = row.name,
  r.date  = date(row.date);

Quick check: you should see something in the ballpark of 861 drivers, 212 constructors, and 1,100-plus races:

MATCH (n) RETURN labels(n)[0] AS label, count(*) ORDER BY label;

If those numbers look right, you've just loaded three-quarters of a century of motorsport into a graph. We haven't done anything clever yet, but we're about to.

Step 3: Connect drivers to teams

The results.csv file has one row per driver, per race — around 26,000 rows. I don't want 26,000 relationships cluttering my graph. I want one clean fact per driver, per team, per season: this person drove for this team that year. So I aggregate as I load.

:auto
LOAD CSV WITH HEADERS FROM 'https://raw.githubusercontent.com/JeremyMorgan/Six-Degrees-Senna/main/import/results.csv' AS row
CALL (row) {
  MATCH (d:Driver  {driverId:  toInteger(row.driverId)})
  MATCH (c:Constructor {constructorId: toInteger(row.constructorId)})
  MATCH (r:Race    {raceId:    toInteger(row.raceId)})
  MERGE (d)-[s:DROVE_FOR {season: r.year, constructorId: c.constructorId}]->(c)
  ON CREATE SET s.entries = 1,
      s.wins  = CASE WHEN row.positionOrder = '1' THEN 1 ELSE 0 END
  ON MATCH  SET s.entries = s.entries + 1,
      s.wins  = s.wins + CASE WHEN row.positionOrder = '1' THEN 1 ELSE 0 END
} IN TRANSACTIONS OF 2000 ROWS;

There's a lot of learning packed into that one statement, so let's unpack it:

• MERGE (d)-[:DROVE_FOR {season, constructorId}]->(c) is the key move. The first time we see Senna-at-McLaren-in-1988, this creates the relationship. Every subsequent race that season just finds the existing one and bumps its counters. Twenty-six thousand rows collapse into roughly 3,600 clean driver-season-team facts. This is the graph-modeling principle in action: store relationships at the granularity you plan to query.

• ON CREATE / ON MATCH let you do one thing when the relationship is brand new and a different thing when it already exists — here, initialize the counters versus increment them.

• :auto and IN TRANSACTIONS OF 2000 ROWS tell Neo4j to commit the import in batches rather than one giant transaction, which keeps memory happy on a big file.

Version note: CALL (row) { … } is the modern syntax (Neo4j 5.23 and up) for passing a variable into a subquery. If your Neo4j is older, you'll get a syntax error on that line — use the legacy form CALL { WITH row … } instead. And don't copy an abbreviated snippet with ... in the middle into the Query editor; Cypher will try to parse the dots. Use the full block above.

Let's make sure it worked by looking at a career I know:

MATCH (d:Driver {surname:'Senna', forename:'Ayrton'})-[s:DROVE_FOR]->(c:Constructor)
RETURN c.name AS team, s.season AS season, s.wins AS wins
ORDER BY season;

Toleman in '84, Lotus '85 to '87, McLaren '88 to '93, Williams in '94. If that's what you see, your graph is alive and correct.

Step 4: Derive the teammate network.

Everything so far was setup. This is the payoff of graph thinking.

Nowhere in the data does it say "Senna and Prost were teammates." But we can derive that: two drivers are teammates if they each have a DROVE_FOR relationship to the same constructor with the same season. And in Cypher, describing that pattern is close to describing it in English:

MATCH (d1:Driver)-[r1:DROVE_FOR]->(c:Constructor)<-[r2:DROVE_FOR]-(d2:Driver)
WHERE r1.season = r2.season
  AND d1.driverId < d2.driverId
MERGE (d1)-[t:TEAMMATE_OF {season: r1.season, team: c.name}]->(d2);

Read that MATCH line like a picture: driver one points to a constructor, and driver two points to the same constructor from the other side. The WHERE says "same season." And then we MERGE a shiny new TEAMMATE_OF relationship between them.

We just created around 10,000 relationships that didn't exist in the source data, purely by reasoning about the shape of the graph.

Two small things worth understanding:

• d1.driverId < d2.driverId stops us creating each pairing twice (Senna→Prost and Prost→Senna). By only linking the lower ID to the higher one, each pair gets a single relationship. When we query it, we'll just ignore direction — because "teammate" goes both ways, and Cypher happily traverses a relationship in either direction when you leave the arrowhead off.

• A deliberately imperfect definition, and why I'm keeping it. "Same team, same season" isn't exactly "raced side by side." Midseason driver swaps mean, for example, that Senna and David Coulthard both count as 1994 Williams drivers. Coulthard was Senna's replacement, and they never actually raced as teammates. I could tighten this up by deriving teammate links per-race instead of per-season.

I'm keeping the looser version on purpose, for two reasons. First, it makes the network richer and more connected across eras, which is the whole point. Second, every graph model is an argument about what a relationship means. There's no universally correct answer; there's only the definition that serves your question. Naming that trade-off out loud is important.

Step 5: Answer the question

Here it is. The reason I built the whole thing. Two drivers separated by half a century, and one line of Cypher to connect them:

MATCH (max:Driver {surname:'Verstappen', forename:'Max'}),
  (fangio:Driver {surname:'Fangio'})
MATCH p = shortestPath((max)-[:TEAMMATE_OF*]-(fangio))
RETURN p;

That * after TEAMMATE_OF is the star of the show. It means "follow this relationship any number of times" — a variable-length path. shortestPath then finds the tightest chain of teammate links between the two drivers. This is the exact query that would've been a page of recursive SQL. In Cypher it fits on a napkin.

When you run it, the Query tool draws the answer as a chain of driver nodes, each link labeled with the team and season that connects them. This is how close Max really is to Fangio.

Once that lands, you'll want to push further. Here are the three queries I couldn't stop running.

Every driver's "Senna number" — like the Bacon number, but for F1. How many teammate-hops is each driver from Ayrton Senna?

MATCH (senna:Driver {surname:'Senna', forename:'Ayrton'})
MATCH (d:Driver) WHERE d <> senna
MATCH p = shortestPath((senna)-[:TEAMMATE_OF*..25]-(d))
RETURN length(p) AS sennaNumber, count(d) AS drivers
ORDER BY sennaNumber;

The shape of those results is the real insight: almost the entire history of the sport sits within a handful of hops of Senna. That's a "small-world network," demonstrated with race cars.

The most connected drivers in history — the human bridges holding the whole web together:

MATCH (d:Driver)-[:TEAMMATE_OF]-(other:Driver)
RETURN d.fullName AS driver, count(DISTINCT other) AS teammates
ORDER BY teammates DESC
LIMIT 10;

Watch who tops this list: long career journeymen and team-hoppers, not necessarily the champions. Connectedness rewards longevity and movement, not podiums. I find that interesting. The people stitching F1's social fabric together are often not the ones holding the trophies.

Is it really all one network? Are there isolated islands of drivers?

MATCH (d:Driver)
WHERE NOT (d)-[:TEAMMATE_OF]-()
RETURN count(d) AS unconnectedDrivers;

A small handful of true loners from F1's chaotic early days, and then one enormous connected web containing basically everyone else. Seventy-five years, one family.

What you just learned (it wasn't really about F1)

• The property graph model — nodes, labels, relationships, and properties, including the quietly powerful idea that a relationship can carry properties of its own.

• Designing for questions, not entities — writing the question first and letting it shape the model.

• LOAD CSV, MERGE, and constraints — the everyday mechanics of getting real data into Neo4j cleanly.

• Deriving new relationships — creating structure that wasn't in your source data by reasoning about the graph you already have.

• Variable-length paths and shortestPath — the thing graphs do effortlessly and relational databases do through gritted teeth.

And here's the part that matters beyond motorsport: swap the dataset and every one of these skills transfers directly. The teammate network is structurally identical to a fraud ring, a supply chain, a social graph, an org chart, or the knowledge graph behind an AI application. "Who is connected to whom, and how?" is one of the most valuable questions in software, and you now know how to ask it.

Download the code here

Where to go next

If this clicked for you the best next move is to get the fundamentals properly, in order. That's exactly what GraphAcademy is for. It's Neo4j's free, hands-on learning platform.

A path I'd suggest, roughly in this order:

1. Neo4j Fundamentals — the property graph model, cemented, with exercises.

2. Cypher Fundamentals — everything we hand-waved past today, done properly.

3. Importing data with Cypher — LOAD CSV and friends, beyond our quick version.

For future articles I'm thinking: turn this same graph into a fair fight, deriving "who-beat-whom" links between teammates and running an algorithm called PageRank to settle the greatest-of-all-time argument without ever touching the points table.

They get that we’re not just managing APIs. We’re building complex systems, and increasingly, those systems involve AI. And as AI technologies race ahead Postman is right there to help you keep up.

I’ve been using Postman for years, and I was thrilled to be invited to POST/CON 2025 in Los Angeles. It was an amazing experience, and I want to share some of the highlights.

If you want the full rundown of the conference, you can check out the official recap here. I want to share my personal highlights and thoughts on the event.

Day 1: Full day workshop - “Mastering AI agent Automation with Postman Flows”

There I learned:

🔥 How easy it is to connect things together with flow

🔥 How to tie together AI agents into a seamless workflow and deploy it

🔥 Learn best practices for design

Then a fireside chat with Ryan Reynolds and Justine Davis that had almost nothing to do with code and everything to do with building great products that solve real problems, and taking care of people.

Day 2: Keynote and Sessions

Attended the Keynote where I learned about

🛠️ Postman VS code extensions

🛠️ GitHub Integration

🛠️ Postman Insights (lots of great analytics)

🛠️ AI Agent Builder

🛠️ Model Comparison Template

🛠️ MCP Server Generator (REALLY)

and so much more. You can get all the details here.

Sessions

I attended some amazing sessions, where I learned a ton about

🧠 Agent Orchestration using API-driven workflows

🧠 Building multi-agent experiences with Agent Builder

🧠 Automating API Testing in CI/CD pipelines with CircleCI and Postman

🧠 Composable API Ecosystems and the MCP Protocol

and tons of great lightning talks.

One of the best conferences I’ve attended

The energy at this conference was amazing. It’s one of the best I’ve attended. Postman is at the forefront of tech. They’ve created great tools to keep YOU ahead of the game. They focus on building their product well and help you create your best products, too.

I highly suggest going to the next POST/CON. If you do, let me know and let’s meet up!

Thank you so much to Postman for sending me to this conference. Now, if you’ll excuse me, I have some new tools to try out!

– Jeremy

I got lucky and got my hands on the newest, very affordable Jetson, the Jetson Orin Nano.

Today, we’ll dive into everything from unboxing this little gem to testing its performance with AI models. Ready to explore what makes this device so cool? Let’s get started!

If you’d rather see a video version of this review here it is.

What’s Inside the Box?

First impressions matter, and the Orin Nano’s packaging is as clean and straightforward as you’d expect. Here’s what you get:

• A robust power supply with both European and American plugs.

• A quick start manual (kinda)

• And, of course, the star of the show: the Jetson Orin Nano.

You do need to purchase an SD card for it, aas it’s not shipped with one.

The device is sleek, lightweight, and full of potential. It includes HDMI, USB, Ethernet, GPIO, and video input ports. Whether you’re making an AI robot or building computer vision stuff (I know I will), this device has you covered.

The Specs: Why It’s Called a “Raspberry Pi on Steroids”

Let’s talk hardware. Look at what’s packed into this small device:

• CPU: A six-core ARM Cortex 64-bit processor.

• GPU: NVIDIA Ampere architecture, tuned for AI workloads.

• RAM: 8 GB of high-speed memory.

• Connectivity: Ethernet and wireless ready.

• Storage Options: NVMe support for all your AI model needs.

Think of it as a supercharged Raspberry Pi with a serious focus on AI.

Setting It Up: The Good, The Tricky, and The Rewarding

Getting the Orin Nano up and running wasn’t exactly plug-and-play, but it wasn’t rocket science either. Here’s how it went down:

1. Firmware Update: Before diving in, I updated the firmware to version 36.x. This step required temporarily installing Jetpack 5.1.3. Then, you update the firmware from there. (Pro tip: don’t skip this. You want the new firmware and Jetpack)

2. Jetpack 6.1 Installation: After the firmware update, I installed Jetpack 6.1, NVIDIA’s tailored OS for the Jetson lineup. It’s smooth, intuitive, and optimized for AI tasks.

If you’re purchasing this devcie, then burning SD cards and flashing firmware shouldn’t be a problem.

Performance Tests: How Does It Handle AI Models?

Here’s where the fun begins—I tested the Orin Nano with AI models using Ollama, a platform designed for running large language models (LLMs).

Check out Ollama here

Here’s what I discovered:

• 1 Billion Parameter Models: Smooth sailing! These models ran effortlessly, perfect for tasks like chatbots or real-time applications.

• 3 Billion Parameter Models: Still impressive, though with slightly longer loading times.

• 7 Billion Parameter Models: Houston, we have a problem. The Orin Nano hit its limits here, occasionally freezing or locking up.

While it’s not designed for massive models, this performance is impressive for a device in this price range.

You can view the performance tests I did in this video.

Pros and Cons: The Real Deal

What I Loved:

1. Compact and Lightweight: Perfect for edge AI projects where space is a premium.

2. Impressive Performance: At $250, you’re getting serious bang for your buck.

3. Quiet Operation: Even under load, it’s quiet—a big plus for home projects.

4. User-Friendly OS: Jetpack is intuitive and packed with features.

What Needs Improvement:

1. Limits on Larger Models: It’s not a deal-breaker, but don’t expect it to handle anything beyond 7 billion parameters comfortably.

2. Occasional Glitches: Some random lockups and an odd “system throttled due to overcurrent” error. I’m looking into it. Manageable, but worth noting.

Final Verdict: Is It Worth It?

Absolutely. The NVIDIA Jetson Orin Nano is a fantastic choice for developers exploring AI at the edge or prototyping innovative solutions.

It’s not built for heavy-duty production workloads, but for $250, it’s hard to beat the value and potential.

What’s Next?

I’ll explore the Orin Nano’s features more in upcoming projects, so stay tuned. If you’re interested in edge AI or want to try out large language models, this device is a perfect start.

Have questions or suggestions for tests? Just drop a comment or message me on social media. Let’s see what this small device can really do!

Happy experimenting! 🚀

You can order the NVIDIA Jetson Orin Nano from the following places (Though right now there is no stock, check back!)

• Amazon

• Arrow Electronics

• Sparkfun

• Seeed Studio

Questions, comments? Want more details? Yell at me!!

Let’s make the game more fun with scoring and difficulty progression.

1. Adding a Score

Modify the create function to display a score:

this.score = 0;
this.scoreText = this.add.text(16, 16, 'Score: 0', { fontSize: '24px', fill: '#fff' });

Now you'll see a score in the upper left hand corner of the screen:

Let’s update the score when the player catches an item. In the update function where we created collision detection, add the following to update the score:

this.score += 10;
this.scoreText.setText('Score: ' + this.score);

So change this:

if (Phaser.Geom.Intersects.RectangleToRectangle(this.player.getBounds(), this.item.getBounds())) {
        console.log('Caught an item!');
        this.item.y = 50;
        this.item.x = Phaser.Math.Between(50, 750);
}

to this:

if (Phaser.Geom.Intersects.RectangleToRectangle(this.player.getBounds(), this.item.getBounds())) {
        console.log('Caught an item!');
        this.item.y = 50;
        this.item.x = Phaser.Math.Between(50, 750);
        this.score += 10;
        this.scoreText.setText('Score: ' + this.score);
}

And now every time you catch a block, the score updates:

2. Increasing Difficulty

Let's make this more difficult and make the items fall faster as the score increases:

In our create function, add this:

this.itemSpeed = 3;

in our update() function, delete this:

    // Move falling item
    this.item.y += 3;

And replace it with this:

  this.item.y += this.itemSpeed;

    if (this.score > 0 && this.score % 500 === 0) {
        this.itemSpeed += 0.5;
        console.log('Going faster! Speed is now: ' + this.itemSpeed);
    }

Now, every time you get 500 points, your speed increases, and it gets more difficult!

3. Retro Feel Enhancements

So let's add some graphics to this to make it more exciting.

I just drew up these images, don't judge me.

You can download the pail.png from here

in preload, add the following:

// Load the player sprite
this.load.image('player', 'pail.png');

Then remove this:

// Player (Blue rectangle)
this.player = this.add.rectangle(400, 550, 50, 50, 0x0000ff);

And replace it with this:

   // Replace rectangle with sprite
    this.player = this.add.sprite(400, 550, 'player');
    this.player.setScale(1); // Adjust this value if needed to match desired size

Let's turn the falling objects into apples.

You can download the apple.png from here

In preload(), add:

this.load.image('apple', 'apple.png');  // Loa

In create(), delete this:

    // Falling item (Green rectangle)
    this.item = this.add.rectangle(400, 50, 50, 50, 0x00ff00);

and replace it with this:

    // Apple sprite
    this.item = this.add.sprite(400, 50, 'apple');
    this.item.setScale(1); // Adjust scale if needed

And now you'll see a different look!

Now we see an apple and a pail, but it's in a dark room. Let's enhance our look by adding in a background.

You can download the background.png from here

In preload():

 this.load.image('background', 'background.png');  // Load background image

and in create():

    // Add background first so it appears behind other sprites
    this.add.image(400, 300, 'background');  // Position at center of game (800/2, 600/2)

And let's make the score black so we can see it:

this.scoreText = this.add.text(16, 16, 'Score: 0', { fontSize: '24px', fill: '#fff' });

Now save it and reload it:

Hey that looks awesome!

Final Thoughts

Congratulations! 🎉 You’ve built a working "Catch the Items" game using Phaser 3. Here’s a playable version of it as well.

Next Steps to try on your own:

• Customize the shapes with images or sprites.

• Add sound effects.

• Experiment with game parameters like speed and item spawn rates.

Keep practicing, and have fun creating your games. The possibilities are endless—go make something awesome! 🚀

Note: If you'd rather have a video tutorial, here it is:

Note: If you'd rather have a video tutorial, here it is:

The full source code is here. Here’s a playable version of the final game.

1. Adding Placeholder Graphics

Update the create function to add shapes representing the player and falling items:

function create() {
    // Player (Blue rectangle)
    this.player = this.add.rectangle(400, 550, 50, 50, 0x0000ff);

    // Falling item (Green rectangle)
    this.item = this.add.rectangle(400, 50, 50, 50, 0x00ff00);

    // Enable physics
    this.physics.add.existing(this.player);
    this.physics.add.existing(this.item);

    // Player controls
    this.cursors = this.input.keyboard.createCursorKeys();
}

2. Moving the Player Left and Right

Add movement logic to the update function:

function update() {
    // Move player left
    if (this.cursors.left.isDown) {
        this.player.x -= 5;
    }
    // Move player right
    else if (this.cursors.right.isDown) {
        this.player.x += 5;
    }
}

• The player can now move left and right using arrow keys!

3. Adding Simple Collision Logic

We need to update our config:

change:

   type: Phaser.AUTO, // Auto-detect WebGL or Canvas
   width: 800,        // Game width
   height: 600,       // Game height

To this, to add physics and gravity to our scene.

type: Phaser.AUTO,
            width: 800,
            height: 600,
            physics: {
                default: 'arcade',
                arcade: {
                    gravity: { y: 0 }
                }
            },

Make the falling item reset its position when it reaches the bottom:

function update() {
    // Move falling item
    this.item.y += 3;

    // Reset item position
    if (this.item.y > 600) {
        this.item.y = 50;
        this.item.x = Phaser.Math.Between(50, 750); // Random x-position
    }

    // Check for overlap
    if (Phaser.Geom.Intersects.RectangleToRectangle(this.player.getBounds(), this.item.getBounds())) {
        console.log('Caught an item!');
        this.item.y = 50;
        this.item.x = Phaser.Math.Between(50, 750);
    }
}

Now you'll see a screen that looks like this: and you should see green blocks falling. You can also move the player with your arrow keys:

📝 Recap: You added player movement, falling items, and basic collision detection. Your game is interactive! Now on to part 3

Note: If you'd rather have a video tutorial, it’s available here.

Note: If you'd rather have a video tutorial, here it is:

The full source code is here. Here’s a playable version of the final game.

Tutorial 1: Project Setup & Basics

Let’s start by setting up the environment, introducing key JavaScript concepts, and creating our first Phaser scene.

Note: In many of our tutorials we use Node/Vite to set up our games. But I want to keep this as simple as possible. To run this you can install the NPM package serve or just open the document with Chrome.

1. What is Phaser 3?

Phaser 3 is a popular 2D game development framework for creating browser-based games using JavaScript. It’s beginner-friendly, flexible, and powerful—perfect for making retro-inspired games like this one!

2. Setting Up Your Development Environment

To keep things simple, we’ll use Phaser via its CDN link. Here’s the setup:

1. Create a project folder:

   • Make a new folder on your computer, e.g., catch-game.

   • Inside the folder, create a file named index.html.

2. Add the basic HTML structure: Paste the following code into your index.html file:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Catch the Items</title>
    <script src="https://cdn.jsdelivr.net/npm/phaser@3.55.2/dist/phaser.js"></script>
</head>
<body>
    <script>
        // Phaser Game Configuration
        const config = {
            type: Phaser.AUTO, // Auto-detect WebGL or Canvas
            width: 800,        // Game width
            height: 600,       // Game height
            scene: {
                preload: preload,
                create: create,
                update: update
            }
        };

        const game = new Phaser.Game(config);

        function preload() {
            // Preload assets (none yet)
        }

        function create() {
            // Add game objects here
            this.add.text(300, 250, 'Hello, Phaser!', { fontSize: '32px', fill: '#fff' });
        }

        function update() {
            // Game loop (empty for now)
        }
    </script>
</body>
</html>

3. Run your game:

   • Open the index.html file in any browser (Chrome is recommended).

   • You should see a simple canvas with the text "Hello, Phaser!".

🎉 Congratulations! You’ve set up Phaser and displayed your first scene!

3. JavaScript Basics for Phaser

Before diving deeper, let’s quickly review some JavaScript concepts:

• Variables: Store data.

    let playerName = 'PhaserHero';
  

• Functions: Reusable blocks of code.

    function greetPlayer() {
        console.log('Welcome to the game!');
    }
    greetPlayer();
  

• Objects: Collections of properties and methods.

    let player = {
        name: 'Hero',
        score: 0,
        jump: function() {
            console.log('Player jumps!');
        }
    };
    player.jump();
  

You’ll use these concepts as you develop your game in Phaser.

4. Creating a Minimal Phaser Scene

Modify the create function to display a basic game canvas and some text:

function create() {
    this.add.text(300, 250, 'Catch the Items!', { fontSize: '32px', fill: '#fff' });
    this.add.rectangle(400, 300, 50, 50, 0xff0000); // Red square
}

• Reload the browser—you should see a red square in the center of the screen.

What does create() mean?

Phaser uses three core functions to manage the game lifecycle: preload, create, and update.

Let's break down what each function does:

• preload(): This function is called before the game starts. It's where you load your game assets like images, sounds, and more.

• create(): This function is called after the assets are loaded. It's where you create your game objects, set up the game world, and define initial game settings.

• update(): This function is called repeatedly throughout the game loop. It's where you update the game state, handle user input, and make things happen in your game world.

This diagram may not make sense now but it will as you get deeper into Phaser.

We'll be using these functions extensively as we build our games in this tutorial and future tutorials.

📝 Recap: You’ve set up a Phaser game, learned some JavaScript basics, and displayed simple shapes on the canvas. Great start! Now on to Part 2!

Why Python?

First off, why should you learn Python? Well, Python is one of the easiest programming languages to get started with. It’s used everywhere—web development, data science, automation, artificial intelligence, you name it! Whether you’re automating boring tasks or building the next big app, Python has your back.

But the best part? Python is super beginner-friendly. Its syntax (fancy word for how code is written) is clean and straightforward, so you can focus more on what you want to do rather than how to do it.

Pretty cool, right?

What Can You Build with Python?

• Websites (ever heard of Django or Flask?)

• Automation scripts (goodbye repetitive tasks!)

• Data analysis and machine learning models

• Games (even 2D ones like the classics!)

• IoT projects (you know, like controlling lights with a Raspberry Pi)

Okay, enough hype—let’s get started!

Step 1: Setting Up Python

Before we can write any Python code, we need to set up our environment. Don’t worry, this is easier than it sounds.

Install Python

First, you'll need to install Python if you don't have it already. Go to the official Python website python.org, download the latest version, and follow the instructions.

For Windows: During installation, make sure to check the box that says “Add Python to PATH.” This will let you run Python from anywhere on your system.

For macOS/Linux: Python usually comes pre-installed, but if you need the latest version, you can install it via a package manager like Homebrew (brew install python3).

If you want, you can also run Python in a Web Browser here.

Verify the Installation

Once installed, open a terminal (or Command Prompt on Windows) and type:

python --version

If you see something like Python 3.x.x, congratulations! Python is ready to roll.

Running Python Code

You can run Python code in two ways:

1. Interactive Mode: Just type python in your terminal, and you can start writing Python code line-by-line. This is great for quick tests.

   Demo idea: Try it out right now! Type python in your terminal and then type:

    print("Testing in interactive mode!")
   

   Hit enter, and you’ll see the result immediately. This is a fun way to experiment.

2. Script Mode: Write your Python code in a .py file (like hello.py), then run it by typing:

    python hello.py
   

Step 2: Your First Python Program

Alright, let’s write your very first Python program. We’re going to create the classic “Hello, World!” program.

Write Your Code

Open your favorite text editor (VSCode, Sublime, or even Notepad), and type the following:

print("Hello, World!")

Save the file as hello.py, then run it from the terminal:

python hello.py

Boom! You should see:

Hello, World!

🎉 Congrats, you just wrote your first Python program! 🎉

Make It Interactive (Optional Demo)

Want to take this a step further? Try prompting the user for input:

name = input("What's your name? ")
print("Nice to meet you, " + name + "!")

Save it as hello_interactive.py and run it. When prompted, type your name and see how Python responds! This little demo shows how Python can interact with users, making it feel more like a conversation and less like static code.

Step 3: Understanding the Basics

Let’s go over some fundamental concepts in Python. These are building blocks that we’ll use in the next parts of this series.

Variables

Think of variables as boxes where you can store information, like numbers or text.

# This is a variable storing a number
age = 30

# This is a variable storing a string (text)
name = "Alice"

You can use these variables later in your code:

print("My name is", name)
print("I am", age, "years old")

Data Types

Python has several data types you’ll use frequently:

• Integers: Whole numbers (e.g., 42)

• Floats: Decimal numbers (e.g., 3.14)

• Strings: Text (e.g., "Hello, World!")

• Booleans: True or False

You can even check the type of any variable with:

print(type(age))  # Outputs: <class 'int'>
print(type(name)) # Outputs: <class 'str'>

Comments

Sometimes you need to add notes to your code. Python ignores comments, so they’re just for you (or anyone else reading the code).

# This is a comment. Python won't run this.

Math Operations

Python can handle math like a calculator:

x = 10
y = 5

print(x + y)  # Addition
print(x - y)  # Subtraction
print(x * y)  # Multiplication
print(x / y)  # Division

Make a Simple Calculator (Demo)

Now that you know variables and math, let’s make a tiny calculator program:

num1 = int(input("Enter a number: "))
num2 = int(input("Enter another number: "))
print("Sum:", num1 + num2)
print("Product:", num1 * num2)

Run this, and you can quickly see Python doing something practical—performing math operations on the fly!

A Quick Variable Experiment

Try this short experiment to understand how strings can be combined:

message = "Hello"
message += ", World!"
print(message)

This shows you how variables can evolve as your program runs.

Step 4: Next Steps

Now that you've got Python set up and written your first program, you're ready to take the next step. In Part 2 of this series, we’ll explore conditions and loops, where Python will start making decisions for you and performing repetitive tasks. It’s going to be fun!

Practice Challenge

Before we wrap up, try writing a Python script that does the following:

• Stores your name in a variable.

• Prints a greeting like "Hello, [Your Name]!"

• Multiplies two numbers and prints the result.

Here’s a hint for the multiplication part:

result = 8 * 7
print(result)

Got it? Awesome! You’re on your way to becoming a Python pro. 🚀

See you in Part 2, where we’ll make Python even more powerful!

Happy coding!

Reminder: This is also available on LinkedIn if you’d rather receive it there.

AI in the News

Introducing ChatGPT Pro

OpenAI releases ChatGPT Pro, a subscription service with powerful new features

OpenAI has released a new subscription service called ChatGPT Pro. This service provides unlimited access to OpenAI’s most advanced models, including o1, o1-mini, GPT-4o, and Advanced Voice. It also includes o1 pro mode, which uses more compute to provide more reliable and accurate answers to difficult questions. ChatGPT Pro is designed for researchers, engineers, and other professionals who need to use AI for complex tasks.

Details:

ChatGPT Pro provides unlimited access to OpenAI’s most advanced models, including o1, o1-mini, GPT-4o, and Advanced Voice. It also includes o1 pro mode, which uses more compute to provide more reliable and accurate answers to difficult questions. ChatGPT Pro is designed for researchers, engineers, and other professionals who need to use AI for complex tasks.

Why it Matters:

ChatGPT Pro is a powerful new tool that can be used for a variety of tasks, including writing, research, and development. With its unlimited access to OpenAI’s most advanced models, ChatGPT Pro can help you to be more productive and creative.

Click here to read more

Make Movies with Text! This AI Writes Videos for You

OpenAI Unveils Sora, a Powerful New Video Generation Model

OpenAI has released a new AI model called Sora that can create realistic videos from just a text description. This means you can create movies, explainer videos, or even home videos using just your imagination and some text!

Details:

Sora can generate videos in a variety of styles, from photorealistic to cartoonish. It can also be used to create videos with special effects or to animate existing images.

Why it Matters:

Sora is a powerful new tool that could revolutionize the way videos are created. It could make it possible for anyone to create professional-quality videos, even if they don’t have any filmmaking experience.

Click here to read more

Unleash Your Creativity with Amazon Nova, the Powerful New AI

Generate Stunning Videos and Images, and More!

Do you ever feel limited by your imagination? Amazon Nova is here to help! This new generation of AI can be used to generate all sorts of creative content, from videos and images to who-knows-what-else. Amazon Nova is also being used to improve the customer shopping experience on Amazon. Keep reading to learn more about how Amazon Nova can help you!

Details:

• Amazon Nova is a new generation of foundation models that can be used to generate creative content.

• Amazon Nova is also being used to improve the customer shopping experience on Amazon.

Why it Matters:

Amazon Nova is a powerful new tool that can be used to generate creative content and improve the customer shopping experience. If you’re looking for a way to boost your creativity or make shopping on Amazon even easier, then Amazon Nova is definitely worth checking out.

Click here to read more

Google Releases Revolutionary AI Model, Gemini 2.0

Google unveils its latest AI model, Gemini 2.0, promising to revolutionize the field of AI agent creation. Gemini 2.0 boasts advanced capabilities that push the boundaries of what’s possible in AI. But with great power comes great responsibility, and Google emphasizes its commitment to developing AI responsibly, with safety and security at the forefront.

Details:

• Gemini 2.0 is more capable than previous versions, with native image and audio output and tool use.

• Gemini 2.0 Flash is available to developers and trusted testers, with wider availability planned for early next year.

• Google is exploring agentic experiences with Gemini 2.0, including Project Astra, Project Mariner, and Jules.

• Google is committed to building AI responsibly, with safety and security as key priorities.

Why it Matters:

Gemini 2.0 has the potential to revolutionize various fields by enabling the creation of powerful and intelligent AI agents. Google’s commitment to responsible AI development ensures these advancements are made with safety and security in mind.

Click here to read more

Apple’s New AI Can Turn Your Thoughts Into Emojis!

Tired of boring emojis? Apple Intelligence has just received a major upgrade, bringing you Image Playground and Genmoji to revolutionize the way you express yourself.

Image Playground lets you unleash your creativity and create unique images using your imagination. It’s like having a mini art studio right on your device!

Genmoji takes emojis to a whole new level. Generate custom emojis that perfectly capture your mood or personality.

Apple Intelligence is available now as a free software update, so you can start creating and expressing yourself in exciting new ways. But hurry, this update is only available for iPhone 16 and later, iPad with A17 Pro or M1 and later, and Mac with M1 and later!

Why it Matters:

Apple Intelligence’s new features offer a fun and creative way to express yourself through images and emojis. It’s a free update available for compatible devices, so there’s no reason not to try it out!

Click here to read more

Apple Secretly Developing AI Chip to Rival NVIDIA

Apple is reportedly working with Broadcom to develop its own AI chip, code-named Baltra, to power its AI services and reduce reliance on Nvidia. This move positions Apple alongside other tech giants like Google in the race to develop cutting-edge AI hardware.

Details:

• Apple is developing its first server chip specifically for AI processing.

• This move aims to reduce reliance on Nvidia’s high-priced and often unavailable processors.

• Baltra is expected to be ready for mass production by 2026.

• Apple and Broadcom have a history of collaboration, including a recent multi-billion-dollar deal for 5G components.

• This development highlights the growing importance of AI hardware and the increasing competition in the AI chip market.

Click here to read more

Talk to Santa AND See Him Live!s

OpenAI just dropped a major update for the holiday season! You can now chat with Santa Claus in real-time using video calls and screen sharing. This new “Advanced Voice Mode” feature allows you to:

• Ask Santa anything: Get advice on beard care, hear about life at the North Pole, or have him tell you a story!

• See Santa’s jolly face: Experience the magic of Christmas firsthand with live video chat.

• Get help with tricky responses: Brainstorm the perfect reply to a friend’s Christmas message using screen sharing.

• This feature is rolling out now:

Available on mobile apps first, then desktop apps and web. Free for everyone to chat with Santa on the first try, even if you’ve used your voice limit. Full access to video and screen sharing for Plus, Pro, and Teams users (Europe rollout coming soon). Enterprise and EDU plans get access early next year.

Click here to read more

Anthropic’s New AI Model: Is it Worth the Hype (and the Higher Price)?

Claude 3.5 Haiku is here, but does it live up to the promise?

Anthropic has released Claude 3.5 Haiku, a powerful new AI model that boasts improved coding, data analysis, and content moderation capabilities. However, this upgrade comes with a higher price tag, sparking debate among developers.

Details:

Claude 3.5 Haiku surpasses its predecessor, 3 Opus, in key areas, offering enhanced performance in coding, data extraction, and content moderation.

It can generate longer pieces of text and boasts a more up-to-date knowledge base. However, 3.5 Haiku lacks image analysis capabilities, limiting its versatility compared to other Anthropic models. The model’s release was initially met with controversy due to an unexpected price increase.

Click here to read more

AI Tools

Create Engaging Video Training Content in Minutes with Lupo

Lupo is a platform that helps businesses create high-quality video training content quickly and easily. With Lupo, you can use Markdown and Marp to create courses, and even leverage their agency services if needed.

Why you might need this tool:

• Create high-quality video training content quickly and easily

• Use Markdown and Marp to create courses

• Leverage their agency services if needed

Click here to read more

Want to Build AI Tools Like a Pro? This Low-Code Platform Makes it Easy (Even Without Coding Skills!)

AISmartCube is a low-code AI tool platform that allows users to build AI tools without any coding required. The platform provides access to global large models, various plugins, a shared knowledge base, and ready-to-use tools and assistants. It also offers flexible pricing with points and a free credit allowance.

Click here to read more

Want to run any program automatically?

Pinokio is a browser that lets you install, run, and programmatically control any application, automatically. You can use Pinokio scripts, which are shared by the community, to automate tasks or create new functionalities.

Why you might need this tool:

With Pinokio, you can:

• Automate repetitive tasks

• Create custom functionalities for your favorite applications

• Be more productive by letting Pinokio handle the boring stuff

Click here to read more

Build Stunning Websites in 3D, Without Code - Dora!

Dora is a no-code platform that allows you to create 3D animated websites. With Dora, you can create beautiful and engaging websites without having to write any code.

Why you might need this tool:

Create stunning and unique websites that will stand out from the competition. No coding required, so even those with no coding experience can create professional websites. Large community of users to help you learn and grow.

Click here to read more

Build Websites and Landing Pages in Minutes - No Coding Required!

Sitekick AI is an AI-powered tool that allows you to create landing pages and websites easily. It can generate text, images, and code for your website, so you don’t need any coding or design skills.

Why you might need this tool:

Easy to use: Sitekick AI does not require any coding or design skills, so it is perfect for people who do not have any experience with web development. Affordable: Sitekick AI is affordable, and it has a 30-day money-back guarantee, so you can try it out risk-free. Saves time: Sitekick AI can help you create websites and landing pages quickly and easily, so you can save time and focus on other important tasks.

Click here to read more

Learn about AI

Learn Anything Faster with the Power of AI

KodeKloud has recently released an AI tutor that can personalize the training for you, providing real-time feedback and guides to craft a custom learning sequence just for you. Each task is validated for accuracy and it supports multiple languages.

Personalized learning: The AI-powered learning suite tailors the learning experience to your individual needs and goals.

Real-time feedback: The AI Assistant provides real-time feedback on your progress, so you can identify and address any areas of difficulty.

Custom learning sequences: The AI Tutor creates a custom learning sequence for any tech topic you want to master.

Accuracy validation: Each task is validated for accuracy, so you can be sure that you are learning the correct information.

Multilingual support: The AI Assistant supports multiple languages, so you can learn in your preferred language.

Click here to read more

Build a Multimodal AI Agent with Gemini 2.0

In this tutorial, we’ll build a Multimodal AI Agent using Google’s Gemini 2.0 Flash model that can simultaneously analyze videos and conduct web searches. This powerful combination allows the agent to provide comprehensive responses by understanding both visual content and related web information.

Click here to read more

Learn AI Assisted Development

A course built by yours truly, you can learn AI-assisted programming, project planning, backend and frontend development, plus documentation using tools like ChatGPT, GitHub Copilot, BlackboxAI, Tabnine, and Cursor

Click here to read more

Thanks for reading!!

I started this newsletter to share all the cool stuff I’m finding in AI over time. Keep updated on the latest stuff with this newsletter. I’m glad you’re here.

Share this on your LinkedIn page if you think your friends might be interested in this stuff.

BTW Check out my YouTube Channel for more cool stuff with Generative AI. Tips, tutorials, reviews of AI tools and more.

Think of Python’s syntax like the grammar rules of a language. Just as English has rules about how to structure sentences to make meaning clear, Python has rules about how to write code so both humans and computers can understand it.

Understanding Python’s Basic Syntax

The Building Blocks

Let’s start with the simplest elements of Python syntax:

# This is a comment - Python ignores anything after the '#' symbol
student_name = "Alice"    # A variable holding text (string)
student_age = 15         # A variable holding a number (integer)
# Using variables in a sentence (string formatting)
print(f"Hello, my name is {student_name} and I'm {student_age} years old.")

In this example, we’re using several basic elements of Python:

• Comments (lines starting with #)

• Variables (student_name and student_age)

• String formatting (the f”…” syntax)

• The print function

Basic Operations

Python can perform calculations and comparisons just like a calculator:

# Basic math operations
total_score = 95 + 87    # Addition
average = total_score / 2 # Division
# Comparisons
if student_age >= 15:
    print(f"{student_name} can take advanced classes")

The Heart of Python: Understanding Indentation

Here’s where Python gets truly unique: instead of using brackets or special symbols to group code together, Python uses indentation. This might seem strange at first, but it makes Python code exceptionally clear and readable.

How Indentation Creates Structure

Think of indentation like the way you might organize a detailed outline:

def make_sandwich():
    print("1. Get two slices of bread")  # First level
    if has_cheese:
        print("2. Add cheese")           # Second level
        print("3. Add tomatoes")         # Still second level
    else:
        print("2. Add butter")           # Second level in else block
    print("4. Put the slices together")  # Back to first level

Each indented block tells Python “these lines belong together.” It’s like creating a sub-list in an outline — everything indented under “if has_cheese:” is part of that condition.

The Rules of Indentation

Let’s look at the key rules for Python indentation:

def process_grade(score):
    # Rule 1: Use exactly 4 spaces for each indentation level
    if score >= 90:
        print("Excellent!")
        if score == 100:
            print("Perfect score!")
# Rule 2: Aligned blocks work together
    elif score >= 80:
        print("Good job!")
        print("Keep it up!")  # This line is part of the elif block
    # Rule 3: Unindented lines end the block
    print("Processing complete")  # This runs regardless of score

Nested Indentation: Going Deeper

As your programs get more complex, you’ll often need multiple levels of indentation:

def check_weather(temperature, is_raining):
    # First level: inside function
    if temperature > 70:
        # Second level: inside if
        if is_raining:
            # Third level: nested condition
            print("It's warm but raining")
            print("Take an umbrella")
        else:
            print("It's a warm, sunny day")
            print("Perfect for outdoors")
    else:
        print("It's cool outside")
        print("Take a jacket")

Complex Structures and Indentation

Let’s look at a more complex example that shows how indentation helps organize code:

def process_student_grades(students):
    for student in students:            # First level loop
        print(f"Checking {student['name']}'s grades...")
total = 0
        for grade in student['grades']: # Second level loop
            if grade > 90:              # Third level condition
                print("Outstanding!")
            total += grade
        average = total / len(student['grades'])
        # Back to first loop level
        if average >= 90:
            print("Honor Roll")
            if student['attendance'] > 95:  # Another level
                print("Perfect Attendance Award")

Common Patterns and Best Practices

Handling Multiple Conditions

# Good: Clear and easy to follow
def check_eligibility(age, grade, attendance):
    if age < 18:
        return "Too young"
if grade < 70:
        return "Grades too low"
    if attendance < 80:
        return "Attendance too low"
    return "Eligible"
# Avoid: Too many nested levels
def check_eligibility_nested(age, grade, attendance):
    if age >= 18:
        if grade >= 70:
            if attendance >= 80:
                return "Eligible"
            else:
                return "Attendance too low"
        else:
            return "Grades too low"
    else:
        return "Too young"

Working with Functions and Classes

class Student:
    def __init__(self, name):
        self.name = name
        self.grades = []
def add_grade(self, grade):
        # Notice the consistent indentation in methods
        if isinstance(grade, (int, float)):
            if 0 <= grade <= 100:
                self.grades.append(grade)
                print(f"Grade {grade} added")
            else:
                print("Grade must be between 0 and 100")
        else:
            print("Grade must be a number")

Common Mistakes and How to Fix Them

Indentation Errors

# WRONG - Inconsistent indentation
if score > 90:
print("Great job!")    # Error: no indentation
    print("Keep it up!")   # Error: inconsistent indentation
# RIGHT - Proper indentation
if score > 90:
    print("Great job!")
    print("Keep it up!")

Mixing Tabs and Spaces

# WRONG - Mixed tabs and spaces (don't do this!)
def calculate_average(numbers):
    total = 0
    count = 0    # This line uses a tab
    for num in numbers:    # This line uses spaces
        total += num

Practice Exercise: Putting It All Together

Try writing this program to practice indentation and syntax:

def grade_assignment(score, late_days):
    # Start with the base score
    final_score = score
# Check if the assignment is late
    if late_days > 0:
        if late_days <= 5:
            # Deduct 2 points per late day
            final_score -= (late_days * 2)
        else:
            # Maximum lateness penalty
            final_score -= 10
    # Ensure score doesn't go below 0
    if final_score < 0:
        final_score = 0
    # Determine letter grade
    if final_score >= 90:
        return "A", final_score
    elif final_score >= 80:
        return "B", final_score
    elif final_score >= 70:
        return "C", final_score
    else:
        return "F", final_score
# Test the function
score = 95
late_days = 2
letter_grade, final_score = grade_assignment(score, late_days)
print(f"Original Score: {score}")
print(f"Late Days: {late_days}")
print(f"Final Score: {final_score}")
print(f"Letter Grade: {letter_grade}")

Key Takeaways

1. Python uses indentation to understand code structure

2. Always use 4 spaces for each level of indentation

3. Be consistent with your indentation throughout your code

4. Simpler, flatter code structure is usually better than deeply nested code

5. Proper indentation makes code more readable and helps prevent errors

Next Steps

Now that you understand Python’s basic syntax and indentation:

• Practice writing simple programs focusing on proper indentation

• Learn about different data types (strings, numbers, lists)

• Explore functions and classes

• Study loops and control structures

• Start working with Python modules and libraries

Remember: Good indentation habits form the foundation of becoming a skilled Python programmer. Take your time to master these concepts, and the rest will follow naturally!

Why This Matters

First things first—why should we care about syntax and variables in Python? Here’s the deal:

• Readability: Python’s clean, intuitive syntax means less time decoding code and more time solving problems.

• Efficiency: Proper use of variables keeps your code efficient and streamlined.

• Debugging: A solid grasp of syntax helps you pinpoint errors faster than a debugger.

• Scalability: Writing clear, organized code ensures that your projects can grow without turning into a tangled mess.

Convinced? Great. Let’s start with the basics.

Python Syntax Basics

Indentation: Python’s Secret Sauce

In Python, indentation isn’t just for looks—it’s how you define blocks of code. Forget braces ({}) and semicolons—just align your code with consistent spacing.

Here’s an example:

if True:
    print("Hello, Python!")

That’s it. The print statement is indented to show it belongs to the if block. Forget to indent, or mix spaces and tabs, and Python will call you out with a syntax error.

Comments: Talk to Your Future Self

Comments in your code are lifesavers when you revisit it months (or years) later. Python supports:

• Single-line comments: Start with #.

• Multi-line comments: Enclose with triple quotes (''' or """).

Here’s how:

# Single-line comment
"""
Multi-line comment
spanning several lines.
"""

Python is Case-Sensitive

Python distinguishes between Variable, variable, and VARIABLE. Keep this in mind to avoid pesky bugs.

Variables in Python

What Are Variables?

Think of variables as labeled storage containers for your data. Python is dynamically typed, so you don’t need to declare types upfront. Here’s a quick example:

x = 10  # Integer
y = 3.14  # Float
z = "Hello, World!"  # String

Naming Variables

To keep your code clean and readable, follow these rules:

• Rules:

  • Start with a letter or underscore, not a number.

  • Use only letters, numbers, and underscores—no spaces or special characters.

  • Avoid Python keywords like if, class, or def.

• Conventions:

  • Use snake_case (e.g., user_name).

  • Choose meaningful names—score is better than s.

Assigning Values

Assigning values is as simple as:

a, b, c = 1, 2, 3  # Multiple assignments

Common Python Data Types

Here’s a rundown of Python’s built-in data types:

• Numeric:

  • int: Whole numbers (e.g., 42)

  • float: Decimal numbers (e.g., 3.14)

• Strings: Enclosed in single, double, or triple quotes:

    greeting = "Hello, Python!"
  

• Booleans: True or False

    is_active = True
  

• Lists: Ordered, mutable collections:

    fruits = ["apple", "banana", "cherry"]
  

• Dictionaries: Key-value pairs:

    person = {"name": "Alice", "age": 25}
  

Performing Operations with Variables

Arithmetic

Python handles math like a champ:

x = 10
y = 3

print(x + y)  # Addition
print(x - y)  # Subtraction
print(x * y)  # Multiplication
print(x / y)  # Division

Strings

You can concatenate or repeat strings easily:

name = "Alice"
print(name + " Smith")  # Alice Smith
print(name * 3)  # AliceAliceAlice

Logical Operations

Logical operators (and, or, not) are super handy:

x = True
y = False

print(x and y)  # False
print(x or y)  # True
print(not x)  # False

Best Practices

Write clean, efficient Python by following these tips:

• Descriptive Names: Use meaningful variable names.

• DRY Principle: Don’t Repeat Yourself—reuse your code.

• Follow PEP 8: Stick to Python’s style guide.

• Comment Smartly: Explain why, not what.

• Avoid Globals: Keep variables local to their functions when possible.

Common Pitfalls (And How to Avoid Them)

1. Indentation Errors: Stick to spaces or tabs (not both), and use four spaces per level.

2. Scope Issues: Know the difference between local and global variables.

3. Type Mismatches: Python doesn’t mix types:

    x = "5"
    y = 10
    print(x + y)  # TypeError
   

FAQ

Q: What’s the difference between variables and constants?

Variables can change; constants stay fixed. Use all caps to indicate constants (e.g., PI = 3.14).

Q: How can I check a variable’s type?

Use type():

x = 10
print(type(x))  # <class 'int'>

Q: Can I change a variable’s type?

Sure can! Python allows dynamic typing:

x = 10
x = "Now a string"

Wrapping Up

Mastering Python syntax and variables is your gateway to writing cleaner, more effective code. With practice, these basics will become second nature. In our next article, we’ll dive into conditional statements (if/else) and explore how they can help you write more dynamic and responsive code.

Whether you are a beginner or an experienced developer, you'll be up and running in no time. This is a great way to evaluate different open-source models or create a sandbox to write AI applications on your own machine.

We'll go from easy to use to a solution that requires programming.

Products we're using:

1. LM Studio: User-Friendly AI for Everyone

2. Ollama: Efficient and Developer-Friendly

3. Hugging Face Transformers: Advanced Model Access

If you'd rather watch a video of this tutorial, here it is:

1. LM Studio: User-Friendly AI for Everyone

LM Studio is an excellent starting point for both beginners and experts. It provides an intuitive interface for exploring and using various AI models.

Getting Started with LM Studio

1. Visit lmstudio.ai and download the appropriate version for your Mac.

2. Install LM Studio by dragging the downloaded file into your Applications folder.

3. Launch LM Studio and accept any security prompts.

Exploring Models

1. In the main interface, click "Load a model" or select a model from the "New and Noteworthy" list.

2. we'll use the "llama2 3B" model for this tutorial. Click on it to download.

3. Once downloaded, click "Load model" to activate it.

Using the Chat Interface

1. With the model loaded, you can start interacting with it in the chat interface.

2. Try asking a question like "Tell me a funny joke about Python."

3. Observe the model's response and the performance metrics (tokens per second, context usage).

Utilizing the API Server

LM Studio also provides an OpenAI-compatible API server, making it easy to integrate with your applications:

1. Click on the server icon in the left sidebar.

2. Start the server by clicking the "Start Server" button. [6]

3. Copy the provided server address (usually http://localhost:1234).

You can see a set of endpoints available:

GET http://localhost:1234/v1/models
POST http://localhost:1234/v1/chat/completions
POST http://localhost:1234/v1/completions
POST http://localhost:1234/v1/embeddings

You can now use this address to send requests to the model using tools like Postman or your own code. Here's an example using Postman:

1. Create a new POST request to http://localhost:1234/v1/chat/completions.

2. Set the body to raw JSON with the following content:

{
        "model": "lmstudio-community/Qwen2.5-14B-Instruct-GGUF/Qwen2.5-14B-Instruct-Q4_K_M.gguf",
        "messages": [
            {
                "role": "system",
                "content": "You are a helpful jokester who knows a lot about Python"
            },
            {
                "role": "user",
                "content": "Tell me a funny Python joke."
            }
        ],
        "response_format": {
            "type": "json_schema",
            "json_schema": {
                "name": "joke_response",
                "strict": "true",
                "schema": {
                    "type": "object",
                    "properties": {
                        "joke": {
                            "type": "string"
                        }
                    },
                    "required": [
                        "joke"
                    ]
                }
            }
        },
        "temperature": 0.7,
        "max_tokens": 50,
        "stream": false
    }

3. Send the request and observe the model's response.

LM Studio is perfect for quickly testing different models and integrating them into your projects with minimal setup.

2. Ollama: Efficient and Developer-Friendly

Ollama is a lightweight and powerful tool for deploying LLMs, which is ideal for developers who prefer working from the command line.

Installing Ollama

1. Visit the Ollama website and download the Mac version.

2. Install Ollama by dragging the downloaded file into your Applications folder.

3. Launch Ollama and accept any security prompts.

Using Ollama from the Terminal

1. Open a terminal window.

2. List available models by running: Ollama list

3. To download and run a model, use: Ollama run <model-name> For example: Ollama run qwen2.5-14b

4. Once the model is loaded, you can interact directly with it in the terminal.

Ollama Commands and Features

• Use /? to see available commands within a model session.

• Exit a model session with /bye.

• Run models with verbose output using --verbose flag.

Using Ollama's API

Ollama also provides an API for integration with your applications:

1. Ensure Ollama is running (you'll see the icon in your menu bar).

2. Send POST requests to http://localhost:11434/api/generate.

Example using Postman:

{
      "model": "qwen2.5:14b",
      "prompt": "Tell me a funny joke about Python",
      "stream": false
}

Ollama Python Library

For Python developers, Ollama offers a convenient library:

1. Install the library: pip install ollama

2. Use it in your Python scripts:

import ollama
response = ollama.chat(model='qwen2.5:14b', messages=[
  {
    'role': 'user',
    'content': 'Tell me a funny joke about Golang!',
  },
])
print(response['message']['content'])

Ollama provides a great balance between ease of use and flexibility, making it an excellent choice for developers building AI-powered applications.

3. Hugging Face Transformers: Advanced Model Access

Hugging Face Transformers is a powerful library that gives you access to many models and more control over their usage.

Setting Up Hugging Face Transformers

1. Create a new Python virtual environment:

python -m venv env    source env/bin/activate

2. Install required libraries:

pip install torch transformers accelerate

3. Install Hugging Face CLI:

pip install -U huggingface_hub[cli]`

4. Log in to Hugging Face:

huggingface-cli login

(You'll need to create a user access token on the Hugging Face website)

Using a Model with Transformers

Here's a simple example using the LLaMA 3.2 3B model:

import torch
from transformers import pipeline

model_id = "meta-llama/Llama-3.2-3B-Instruct"
pipe = pipeline(
    "text-generation",
    model=model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
messages = [
    {"role": "system", "content": "You are a pirate chatbot who always responds in pirate speak!"},
    {"role": "user", "content": "Who are you?"},
]
outputs = pipe(
    messages,
    max_new_tokens=256,
)
print(outputs[0]["generated_text"][-1])

Advantages of Hugging Face Transformers

1. Access to a vast library of models

2. Fine-grained control over model parameters

3. Ability to fine-tune models for specific tasks

4. Integration with popular deep learning frameworks

While Hugging Face Transformers requires more coding knowledge, it offers unparalleled flexibility and access to cutting-edge AI models.

Conclusion

We've explored three powerful tools for running AI models locally on your Mac:

1. LM Studio: Perfect for beginners and quick experimentation

2. Ollama: Ideal for developers who prefer command-line interfaces and simple API integration

3. Hugging Face Transformers: Best for advanced users who need access to a wide range of models and fine-grained control

Each tool has its strengths, and the choice depends on your specific needs and technical expertise. By running these models locally, you gain more control over your AI applications, ensure data privacy, and avoid the costs associated with cloud-based services.

Consider your Mac's specifications when working with larger models, as they can be resource-intensive. Start with smaller models and work up as you become more familiar with the tools and your hardware capabilities.

Happy coding, and enjoy exploring the world of local AI on your Mac!

If you have any questions or feedback feel free to reach out or leave a comment below.

Bookmark this page because it will be updated frequently. I’ll also do this with some other tools I use (image generation, code generation, video, etc.).

Am I missing anything? Feel free to reach out to me!

Here are the top conversational AI tools out there right now.

Perplexity

• URL: https://www.perplexity.ai/

• Title: Perplexity AI

• Description: Perplexity — Where Knowledge Begins

• Why it’s awesome: It pulls from different sources to verify the information presented. Very magic.

Claude

• URL: https://claude.ai

• Title: Claude

• Description: Talk with Claude, an AI assistant from Anthropic

• Why it’s awesome: Excels in writing, and analysys.

Globe Explorer

• URL: https://explorer.globe.engineer/

• Title: Globe Explorer

• Description: No description found

• Why it’s awesome: It pulls from many different sources to really deep dive into a subject.

Poe

• URL: https://poe.com/

• Title: Poe — Fast, Helpful AI Chat

• Description: Poe lets you ask questions, get instant answers, and have back-and-forth conversations with AI. It gives access to GPT-4, GPT-3.5-turbo, Claude from Anthropic, and various other bots.

• Why it’s awesome: There are so many connections to other services, and the interface is very cohesive.

Grok

• URL: https://x.com/i/grok

• Title: x.com

• Description: AI Assistant, powered by X

• Why it’s awesome: It uses X as an additional source, and it is very up to date.

Gemini

• URL: https://gemini.google.com/app

• Title: Gemini — chat to supercharge your ideas

• Description: Bard is now Gemini. Get help with writing, planning, learning, and more from Google AI.

• Why it’s awesome: Backed by Google, exciting and factual results.

Groq

• URL: https://groq.com/

• Title: Groq is Fast AI Inference

• Description: The LPU™ Inference Engine by Groq is a hardware and software platform that delivers exceptional compute speed, quality, and energy efficiency. Groq provides cloud and on-prem solutions at scale for AI applications.

• Why it’s awesome: Screaming fast and smart, great for applications.

ChatGPT

• URL: https://openai.com/chatgpt/

• Title: ChatGPT by OpenAI

• Description: A conversational AI system that listens, learns, and challenges

• Why it’s awesome: It’s the OG, and Custom GPTs are awesome

Hugging Face Chat Models

• URL: https://huggingface.co/chat/models

• Title: HuggingChat — Models

• Description: The first open source alternative to ChatGPT.

• Why it’s awesome: A wide variety of models to choose from

Bing AI (Copilot)

• URL: https://www.bing.com/chat

• Title: Microsoft Copilot in Bing

• Description: Chat, get answers, create amazing content, and discover information effortlessly with Bing’s AI-powered chat. Transform the way you search and get answers with Microsoft Copilot in Bing.

• Why it’s awesome: Fast and great for programming/coding stuff.

Conclusion

This is the list of Conversational AI models I use constantly. I will update this as I go. If you can think of one I’m missing out on, Contact me!

Also if you’re into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

This tutorial will help you learn about image compression with OpenCV, covering theory and practical applications. By the end, you’ll understand how to compress photos successfully for computer vision projects (or any other projects you might have).

What is Image Compression?

Image compression is reducing an image’s file size while maintaining an acceptable level of visual quality. There are two main types of compression:

1. Lossless compression: Preserves all original data, allowing exact image reconstruction.

2. Lossy compression: Discards some data to achieve smaller file sizes, potentially reducing image quality.

Why Compress Images?

If “disk space is cheap,” as we often hear, then why compress images at all? At a small scale, image compression doesn’t matter much, but at a large scale, it’s crucial.

For instance, if you have a few images on your hard drive, you can compress them and save a few megabytes of data. This is not much of an impact when hard drives are measured in Terabytes. But what if you had 100,000 images on your hard drive? Some basic compression saves real time and money. From a performance perspective, it’s the same. If you have a website with a lot of images and 10,000 people visit your website a day, compression matters.

Here’s why we do it:

• Reduced storage requirements: Store more images in the same space

• Faster transmission: Ideal for web applications and bandwidth-constrained scenarios

• Improved processing speed: Smaller images are quicker to load and process

Theory Behind Image Compression

Image compression techniques exploit two types of redundancies:

1. Spatial redundancy: Correlation between neighboring pixels

2. Color redundancy: Similarity of color values in adjacent regions

Spatial redundancy takes advantage of the fact that neighboring pixels tend to have similar values in most natural images. This creates smooth transitions. Many photos “look real” because there is a natural flow from one area to the other. When the neighboring pixels have wildly different values, you get “noisy” images. Pixels changed to make those transitions less “smooth” by grouping pixels into a single color, making the image smaller.

Color redundancy, on the other hand, focuses on how adjacent areas in an image often share similar colors. Think of a blue sky or a green field—large portions of the image might have very similar color values. They can also be grouped together and made into a single color to save space.

OpenCV offers solid tools for working with these ideas. Using spatial redundancy, OpenCV’s cv2.inpaint() function, for example, fills in missing or damaged areas of a picture using information from nearby pixels. OpenCV lets developers use cv2.cvtColor() to translate images between several color spaces regarding color redundancy. This can be somewhat helpful as a preprocessing step in many compression techniques since some color spaces are more effective than others in encoding particular kinds of images.

We’ll test out some of this theory now. Let’s play with it.

Hands on Image Compression

Let’s explore how to compress images using OpenCV’s Python bindings. Write out this code or copy it:
(you can also download the source code here)

import cv2
import numpy as np

def compress_image(image_path, quality=90):
    # Read the image
 img = cv2.imread(image_path)

    # Encode the image with JPEG compression
 encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
 _, encoded_img = cv2.imencode('.jpg', img, encode_param)

    # Decode the compressed image
 decoded_img = cv2.imdecode(encoded_img, cv2.IMREAD_COLOR)

    return decoded_img

# Example usage
original_img = cv2.imread('original_image.jpg')
compressed_img = compress_image('original_image.jpg', quality=50)

# Display results
cv2.imshow('Original', original_img)
cv2.imshow('Compressed', compressed_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

This example contains a compress_image function that takes two parameters:

• Image path (where the image is located)

• Quality (the quality of the image desired)

Then, we’ll load the original image into original_img. We then compress that same image by 50% and load it into a new instance, compressed_image.

Then we’ll show the original and compressed images so you can view them side by side.

We then calculate and display the compression ratio.

This example demonstrates how to compress an image using JPEG compression in OpenCV. The quality parameter controls file size and image quality tradeoff.

Let’s run it:

While initially looking at the images, you see little difference. However, zooming in shows you the difference in the quality:

And after closing the windows and looking at the files, we can see the file was reduced in size dramatically:

Also, if we take it down further, we can change our quality to 10%

compressed_img = compress_image('sampleimage.jpg', quality=10)

And the results are much more drastic:

And the file size results are more drastic as well:

You can adjust these parameters quite easily and achieve the desired balance between quality and file size.

Evaluating Compression Quality

To assess the impact of compression, we can use metrics like:

1. Mean Squared Error (MSE)

Mean Squared Error (MSE) measures how different two images are from each other. When you compress an image, MSE helps you determine how much the compressed image has changed compared to the original.

It does this by sampling the differences between the colors of corresponding pixels in the two images, squaring those differences, and averaging them. The result is a single number: a lower MSE means the compressed image is closer to the original. In comparison, a higher MSE means there’s a more noticeable loss of quality.

Here’s some Python code to measure that:

def calculate_mse(img1, img2):
    return np.mean((img1 - img2) ** 2)

mse = calculate_mse(original_img, compressed_img)
print(f"Mean Squared Error: {mse:.2f}")

Here’s what our demo image compression looks like:

1. Peak Signal-to-Noise Ratio (PSNR)

Peak Signal-to-Noise Ratio (PSNR) is a measure that shows how much an image’s quality has degraded after compression. This is often visible with your eyes, but it assigns a set value. It compares the original image to the compressed one and expresses the difference as a ratio.

A higher PSNR value means the compressed image is closer in quality to the original, indicating less loss of quality. A lower PSNR means more visible degradation. PSNR is often used alongside MSE, with PSNR providing an easier-to-interpret scale where higher is better.

Here is some Python code that measures that:

def calculate_psnr(img1, img2):
 mse = calculate_mse(img1, img2)
    if mse == 0:
        return float('inf')
 max_pixel = 255.0
    return 20 * np.log10(max_pixel / np.sqrt(mse))

psnr = calculate_psnr(original_img, compressed_img)
print(f"PSNR: {psnr:.2f} dB")

Here’s what our demo image compression looks like:

“Eyeballing” your images after compression to determine quality is fine; however, at a large scale, having scripts do this is a much easier way to set standards and ensure the images follow them.

Let’s look at a couple other techniques:

Advanced Compression Techniques

For more advanced compression, OpenCV supports various algorithms:

1. PNG Compression:

You can convert your images to PNG format, which has many advantages. Use the following line of code, and you can set your compression from 0 to 9, depending on your needs. 0 means no compression whatsoever, and 9 is maximum. Keep in mind that PNGs are a “lossless” format, so even at maximum compression, the image should remain intact. The big trade-off is file size and compression time.

Here is the code to use PNG compression with OpenCV:

cv2.imwrite('compressed.png', img, [cv2.IMWRITE_PNG_COMPRESSION, 9])

And here is our result:

Note: You may notice sometimes that PNG files are actually larger in size, depending on the image.

1. WebP Compression:

You can also convert your images to .webp format. This is a newer method of compression that’s gaining in popularity. I have been using this compression on the images on my blog for years.

In the following code, we can write our image to a webp file and set the compression level from 0 to 100. It’s the opposite of PNG’s scale because 0, because we’re setting quality instead of compression. This small distinction matters, because a setting of 0 is the lowest possible quality, with a small file size and significant loss. 100 is the highest quality, which means large files with the best image quality.

Here’s the Python code to make that happen:

cv2.imwrite('compressed.webp', img, [cv2.IMWRITE_WEBP_QUALITY, 80])

And here is our result:

These two techniques are great for compressing large amounts of data. You can write scripts to compress thousands or hundreds of thousands of images automatically.

Conclusion

Image compression is fantastic. It’s essential for computer vision tasks in many ways, especially when saving space or increasing processing speed. There are also many use cases outside of computer vision anytime you want to reduce hard drive space or save bandwidth. Image compression can help a lot.

By understanding the theory behind it and applying it, you can do some powerful things with your projects.

Remember, the key to effective compression is finding the sweet spot between file size reduction and maintaining acceptable visual quality for your application.

Thanks for reading, and feel free to reach out if you have any comments or questions!

Also if you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

I’ve been running several LLMs and other generative AI tools on my computer lately. I’ve discovered this web UI from oobabooga for running models, and it’s incredible. You have a ton of options, and it works great.

That’s what we will set up today in this tutorial.

The easy way

If you’re in Windows using WSL, you can run a simple batch file, and it might work great. Super easy.

Clone the repo:

git clone https://github.com/oobabooga/text-generation-webui.git

Then run the batch file:

start_wsl.bat

It will ask you to choose your GPU/platform setup:

And it’s up and running:

If this works, skip to the Run the WebUI step.

But if it fails (which I’ve seen), you must do it manually. Below are the instructions to install it manually in WSL. It’s also the instructions to install this in regular old Linux. Let’s get started.

Install Anaconda

I’m using Ubuntu in WSL. So here are the commands we’ll run:

sudo apt-get update

Always a good idea.

sudo apt-get install wget

Change into the tmp directory:

cd /tmp

Then, we want to get the latest version of the installation script from this directory. At the time of this writing, this is the most current version for Linux-x86_64:

wget https://repo.anaconda.com/archive/Anaconda3-2023.09-0-Linux-x86_64.sh

This script is huge. After it’s done downloading, you should see something like this:

Then you’ll want to validate it:

sha256sum Anaconda3-2023.09-0-Linux-x86_64.sh

and if you don’t see any errors, you’re good to go:

Now it’s time to run it!

bash Anaconda3-2023.09-0-Linux-x86_64.sh

Accept the license terms (if you want to use it) and press enter.

It will ask where you want to install it. I chose the default location:

Then, grab a beverage and wait a while. I prefer ice water with lemon.

It’s going to ask if you want to initialize Conda automatically. I do a ton of Python stuff, so I select yes. Choose whatever works best for you.

Now exit the shell and restart your WSL window.

Install the Text UI

Next, we will install the Web UI interface for our models. This is a Gradio web UI for Large Language Models.

As stated in the repo, their goal is to become the AUTOMATIC1111/stable-diffusion-webui of text generation.

Clone it into a folder you’ll want to work in:

git clone https://github.com/oobabooga/text-generation-webui.git

Now type in

conda deactivate

If you have a base version running. We’ll then create a new environment:

conda create -n textgen python=3.11
conda activate textgen

If you see (textgen) in front of your prompt, it’s working.

Now, we need to install PyTorch. I’m using an NVidia card, so I type in:

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

If you aren’t using an NVidia card and want to do CPU only, use this:

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

You’ll see a lot of this:

Wait for it to finish. If you are running an NVidia card, you may need to do this:

conda install -y -c "nvidia/label/cuda-12.1.0" cuda-runtime

Next, we need to install some more dependencies. This will depend on your machine.

cd text-generation-webui
pip install -r <requirements file according to table below>

Requirements file to use:

(this comes from the instructions)

After everything is installed, you should be ready to run the WebUI.

Run the WebUI

Now we’re ready to run! In the text-generation-webui directory, run the following:

python server.py

And you should see this:

Awesome! Let’s load it up in the web browser:

If you see this, you’re golden! However, you can’t do anything with it yet. You’ll need a model.

Downloading an LLM model

Your models will be downloaded and placed in the text-generation-webui/models folder. There are several ways to download the models, but the easiest way is in the web UI.

Click on “Model” in the top menu:

Here, you can click on “Download model or Lora” and put in the URL for a model hosted on Hugging Face.

There are tons to choose from. The first one I will load up is the Hermes 13B GPTQ.

I only need to place the username/model path from Hugging Face to do this.

TheBloke/Nous-Hermes-13B-GPTQ

And I can then download it through the web interface.

After I click refresh, I can see the new model available:

Select it, and press load. Now we’re ready to go!

Having a Chat

There are a ton of parameters you can adjust. You can get lost in the settings, and once I learn more about it, I’ll certainly share it here.

Here was my test chat:

Hey! It works! Awesome, and it’s running locally on my machine.

I decided to ask it about a coding problem:

Okay, not quite as good as GitHub Copilot or ChatGPT, but it’s an answer! I’ll play around with this and share what I’ve learned soon.

Conclusion

You may want to run a large language model locally on your own machine for many reasons. I’m doing it because I want to understand LLMs better and understand how to tune and train them. I am deeply curious about the process and love playing with it. You may have your own reasons for doing it, such as content generation or a chatbot to joke around with. The fact that you don’t have to be connected to the internet or pay a monthly fee is awesome.

What are you doing with LLMs today? Let me know! Let’s talk.

Also if you have any questions or comments, feel free to reach out.

Happy hacking!

If you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

What is OCR? Tesseract?

Optical Character Recognition, or OCR has been around for a long time. It's a technique that “reads” different types of documents into editable and searchable text. It works by recognizing characters in the image and converting them into machine-readable text. It’s a lot of magic, but it works well.

Tesseract is an open-source OCR engine developed by Google. It is highly accurate and supports multiple languages. This library will do all the heavy lifting for us. We’ll use it in this tutorial to quickly read the text in some images.

Step 1: Set up your Python Environment

First, you’ll need to make sure Python is installed. We’re going to create a virtual environment.

• How to install Python and set up a virtual environment in Windows

• How to set up your Python environment on a Mac

• How to setup Python environment in Linux

I’m using Linux, so I’ll create a directory named textreader and type in

python -m venv textreader

Then

source textreader/bin/activate

Step 2: Install the Required Libraries

First, we’ll need to install Tesseract on your system. Here are the instructions to install Tesseract on your chosen operating system.

Make sure Tesseract is installed by typing:

tesseract -v

and you should see output that looks like this:

Then, we’ll install a couple of Python libraries.

Pytesseract is a Python library that is a wrapper for the Tesseract OCR engine. This makes it easy to use in Python applications. We’ll install that and Pillow.

Pillow is the Python Image Library. It’s used for image processing and manipulation. It’s used to pre-process images before applying OCR techniques. It does things like image thresholding and other steps to the image to enhance the accuracy of the reading.

Next, we’ll install Pytesseract and Pillow together for our first application:

pip install pytesseract
pip install pillow

Your output should look something like this:

In some cases, like above, it may say the requirement is already satisfied for Pillow.

And we’re ready to go.

Step 3: Select your Image

To start, I’m going to choose something easy. I’ll use a screenshot from my website. This will be clear, easy-to-read text that should work great.

I’ll save that as image-1.jpg in my folder.

Step 4: Write the Script

Now, we’re ready to build our Python script to read the text from that image and output it to the screen.

First, we’ll import the libraries:

import pytesseract
from PIL import Image

Then open the image:

image = Image.open('image-1.jpg')

And then, we’ll use Tesseract to convert the text in the image to a string. Didn’t I say this library does all the heavy lifting for us?

text = pytesseract.image_to_string(image)

Finally, we’ll print it out:

print(text)

Let’s run it and see what it looks like.

Step 5: Watch the Magic Happen

We run our script and get this:

Awesome! So it’s not perfect, but it’s pretty darn good. You can read the text from the image we sent, and it’s somewhat formatted the way it is in the image. That’s awesome!

Congrats! You can now read the text from images in Python. Next, we’ll look at some more advanced stuff.

Learning the Limitations

In our first example, we had a very clear image. The text is formatted and crisp in that image, so it’s easy to read. Let’s step it up a bit.

I picked a more challenging image, one from Pexels, that isn’t quite so easy.

Let’s see what the output is when reading this image:

Oof. Nothing. I included this because it’s important to know the limitations of this process. Unusual fonts and different angles will affect how well this works. There isn’t much we can do to read this image without some extensive work.

Conclusion

In this tutorial, we learned how to use Tesseract to read text from an image and put it into a machine-readable form. We can read many other things with OCR, and we’ll deep dive into some of this stuff in future articles.

Feel free to play around with this and see what you can come up with! In a future tutorial, we’ll use OpenCV to refine things and do more pre-processing of the images we’ll read from. It will be fun.

Bookmark this blog and come back for more cool Python tutorials.

Questions? Comments? Yell at me!

If you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

Recently, I’ve been using Midjourney more for image generation. Dall-E 2 was good, but not as good as Midjourney. Has that changed? Let’s throw a few simple prompts at it to see.

Prompt: A realistic portrait of a cat wearing a wizard’s hat

Dall-E 3

Midjourney

This first example is clear. Midjourney definitely looks better. More realistic and detailed. Our prompt may be too simplistic. Let’s try something else.

Prompt: A red Tesla Roadster driving down a highway. Illustrated in the style of Looney Tunes. In the background is a typical Looney Tunes city. However, the car is a modern Tesla.

Dall-E 3

Midjourney

Okay, once again, Midjourney is blowing Dall-E out of the water. Neither look like a Looney Tunes cartoon, but Midjourney certainly comes closer.

Let’s take some prompts from “The 30 best Dall-E 2 prompts for amazing results” and see what we can come up with.

Prompt: Whimsical painting of an enchanted forest with mythical creatures, vibrant colors, and intricate details.

Dall-E 3

Midjourney

Prompt: Victorian-era painting of a masquerade ball with elaborate costumes, contrasting colors, and soft lighting.

Dall-E 3

Midjourney

This one is a little closer. I like the Midjourney one better, but only because of the paintings’ additional detail and different framing. The angles and framing of the Dall-E renderings are dull, and the subject isn’t clear. But it’s fairly close.

Let’s try the #1 best prompt according to that article.

Prompt: Realistic painting of a dystopian industrial city with towering factories, pollution-filled air, and a gloomy sky.

Dall-E 3

Midjourney

With this one, the style and the rendering of Dall-E 3 aren’t bad. It looks more like an actual painting. However, the Midjourney one is far more exciting and engaging.

Let’s try one of my favorite prompts: putting a 2005 Mustang GT Like mine in different settings.

Prompt: a 3D render of a red 2005 Ford Mustang GT on a deserted country highway

Dall-E 3

Midjourney

The difference here is drastic. One certainly looks more like a 3D rendering than the other.

Conclusion

Midjourney still produces better images overall than Dall-E. However, this is my experience, and with enough prompt tuning, I’m confident someone can make a fool of me and generate a much better image with Dall-E. Also, the ChatGPT integration is a nice bonus. Being able to tweak prompts using advanced techniques makes all the difference.

What has your experience been like? Let me know!

If you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

Why would anyone do this? Here are a few reasons:

• It’s educational

• You can generate as many images as you want

• It’s free

With this tutorial’s help, you can generate images with AI on your own computer with Stable Diffusion.

Let’s get started.

Step 1: Requirements

There are some requirements for doing this on your own machine. It must have:

Hardware:

• A modern AMD or Intel CPU

• 16 Gigabytes of RAM

• SATA or NVMe solid state drive

• NVidia GeForce GPU with at least 8 gigabytes of GDDR6 RAM

Software:

• You must have Python installed (How to install Python in Windows 11).

• You can use Anaconda if you want (How to install Anaconda in Windows 11).

• You must have Git Installed (How to install Git in Windows 11).

• You need an account at HuggingFace (it’s a free account)

Check your Python version to make sure it’s up to snuff:

And make sure Git is installed:

And you’re ready to go.

Step 2: Install Stable Diffusion Web UI

Create a folder somewhere where you want the software to live. Go to that folder:

cd /your/project/directory

(for me it’s C:\Users\jerem\Projects)

Then clone the repository:

git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git stable-diffusion-demo

You should see the folder you just created:

stable-diffusion-demo

Now we need to go into the models folder:

cd stable-diffusion-demo\models\Stable-diffusion

It should look like this:

This is where we’ll put the Stable Diffusion models when we download them.

Step 3: Download the Model from Hugging Face

Next, we need a stable diffusion model, and we can get one from Hugging Face.

Let’s try the v1-5-pruned-emaonly.ckpt model. Download it to the stable-diffusion-demo/models/Stable-diffusion folder:

It might take a while to download (4GB at the time of this article).

Ok, now.. you’re ready to run the web app!

Step 4: Run the Stable Diffusion Web UI

At your command prompt, make sure you’re in the folder you created in step 2.

cd stable-diffusion-demo

Then run webui-user.bat

The first time you do this, it will install everything needed, so it may take a few minutes.

Once it’s completed, your command prompt will look something like this:

And the web server will be up and running.

Step 5: The Web Interface

Load up the following URL in your web browser:

http://127.0.0.1:7860/

It may load up automatically in the browser as well. But you’ll see a full web interface you can use to generate images:

Awesome! Let’s try it out!

The sampling method is the first thing you might notice in the generation tab. There are a LOT of them:

I suggest spending some time adjusting and playing with this. But for now, we’ll use DPM++ 2M Karras that’s selected as default.

Here are some settings to pay attention to:

• Sampling steps - This will repeatedly try to improve the image as it generates. Low values will be low quality, but fast. High values will be higher quality and slower to generate.

• Width and height - These will control the size of the generated image. Like above, larger images will look better and take longer.

• CFG Scale - This will change how “random” the result is. A higher value will attempt to take the prompt as literally as possible. Lower values will produce more creative results.

• Seed - This value determines the output of the random number generator. You can use it as a key. If you use the same prompt with the same seed, you’ll get the same image. You can create many variations from the same “key”.

So today, I will leave everything at the default settings. The only thing I will do is create a seed to progressively improve the same image as we go.

And I’ll add in a prompt to make something silly.

‘a photo of an anthropomorphic frog riding a skateboard in Times Square`

It took about a minute to generate this image. (Laptop with RTX 3060)

And it’s pretty cool! It’s impressive, considering it’s being run on my local machine. Let’s improve this image!

Step 6: Improving Images

Here’s the actual image I produced:

Let’s mess with the settings to see what we can improve. Let’s change the Sampling steps. This is how often it goes through the image and tries to improve it. The default setting is 20. Let’s set it to the maximum number of 150. This will take more than a minute to produce now.

I will leave the prompt and the seed the same and click “Generate” again.

I’ll warn you: it can work the GPU when you do this.

Here is the result after 150 sampling steps:

So it’s certainly different, but not in a significant way. We don’t want to scale up our generating time by 10x for this small change. I’ll change it back to 20 and change CFG Scale to 5. This will make the model more “creative”.

Here are the settings:

And here is the result:

Ok, that’s too creative. But you can see the changes that occur when you adjust it. You can also use different sampling methods as well:

DPM++ SDE Karras

This model’s output is kind of neat because it shows the frog skateboarding better.

Euler

DPM++ 3M SDE

When attempting to draw things in cartoon, especially anthropomorphic models, it can come out very bizarre.

But that’s all there is to it!

Conclusion

In this tutorial, we:

• Installed the Stable Diffusion Web UI

• Downloaded a model

• Generated AI images

• Modified the output

All from our local machine! Here are the benefits and downsides of this method compared to something like Midjourney:

Pros:

• It’s free!

• Generate as many images as you like

• Runs locally and is not dependent on an internet connection

Cons:

• Nowhere near the level of quality as Midjourney and others

• You need a good machine to run this

• It may take longer to generate images

So there you have it! Now, you can generate images on your machine and show your creations to the world. We are barely getting started with the possibilities available from this model. We’ll explore it more in the coming weeks.

If you have any questions, feel free to reach out!

– Jeremy

Questions? Comments? Yell at me!

If you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!

“I’ll just write a quick Python script for this” - me, a bunch of times

One of the things Python does well is abstracting complexity. One example of that is the Python function. A function is a reusable set of instructions to perform a task. Functions aren’t unique to Python; they work mostly the same as in other languages.

If you want to know how to write and call a function in Python, here’s a step-by-step guide.

The Anatomy of a Python Function

Before you can call a function, you have to write a function. Thankfully, that’s easy. Let’s look at the main components of a function.

def function_name(parameters):
    # Your code goes here
    return

The keyword ‘def’ refers to a function definition followed by your chosen function name and parentheses enclosing optional parameters. Parameters are anything you want to put into the function.

The action happens in the function body (Where it says your code goes here). This is where we put statements that make the function do work.

The return keyword allows you to send data out of the function. Note: You don’t always need to return a value. It’s optional.

So the main parts are

• definition (def keyword)

• function name

• parameters

• body (what the function does)

• return value

All of these, put together, form a function.

Calling a Python Function

Once we’ve defined a function, calling it is as straightforward as writing the function’s name followed by parentheses. If our function requires parameters, we place these inside the parentheses. These are optional.

Let’s build a simple function to display Hello World whenever we call it.

def hello_world():
    print("Hello, World!")

Even though there are no parameters or a return value, this is a function in Python. The “output” of the function is printing Hello World.

We can call this function with this line of code:

hello_world()

And this will output “Hello, World!” to your console whenever we call it.

In fact, if we call it five times:

hello_world()
hello_world()
hello_world()
hello_world()
hello_world()

It will display the same thing five times.

Congratulations, you’ve just written your first function in Python.

The Power of Function Parameters in Python

Parameters are pieces of data we pass into the function. The work of the function depends on what we pass into it. Parameters enable us to make our Python functions dynamic and reusable. We can define a function that takes parameters, allowing us to pass different arguments each time we call the function.

def greet(name):
    print("Hello, " + name + "!")

greet("Jeremy")
greet("Susie")
greet("Jim")

Here, the greet() function takes one parameter, ‘name’. When we call the function, we can pass any name we wish to greet.

Dealing with Multiple Parameters

Python functions can accept multiple parameters, allowing us to add dynamic inputs to our function calls.

def greet(name, city):
    print("Hello, " + name + " from " + city + "!")

greet("Jeremy", "Gaston")
greet("Susie", "Forest Grove")
greet("Jim", "Cornelius")

Now greet() takes two parameters, ‘name’ and ‘city’.

And it’s that easy. Congrats, you can now pass data into a function in Python.

Leveraging Default Parameters in Python Functions

Sometimes, you want to set a value for a parameter as a default. This allows the function to be called even if no data was passed. Rather than throwing an error, it will populate the value with anything you specify.

def greet(name="User"):
    print("Hello, " + name + "!")

greet()
greet("Alice")

Here, ‘greet()’ function has a default parameter ‘name’ set to ‘User’. If no argument is passed, the function greets ‘User’. If we provide a name, it greets that name instead.

It’s a good way to set defaults.

Python Return Statement

The ‘return’ statement exits a function and returns a value. With it, we can store the output of a function in a variable for future use.

def square(number):
    return number * number

result = square(5)
print(result)

In this case, square() function returns the square of the input number. The output can be stored in a variable and used later.

The return keyword is used to push values out of the function to use in your program.

Functions are awesome!

Python functions are a powerful tool in a programmer’s arsenal. They encapsulate code blocks for specific tasks, enhancing the readability and maintainability of the code. Understanding how to call a function in Python, employ parameters, and leverage the ‘return’ statement is fundamental to proficient Python programming.

Remember, practice is key! The more you use this, the more second nature it will be for you.

The Versatility of Variable Arguments in Python

Python introduces an interesting feature in functions: variable-length arguments. Sometimes we don’t know how many arguments will be passed to a function. Python’s variable arguments (*args and **kwargs) solve this problem.

def add_numbers(*args):
    return sum(args)

print(add_numbers(3, 5, 7, 9))

In the example, add_numbers() uses *args to accept any number of parameters. The function then sums up all the numbers and returns the total.

In-Depth with Python Keyword Arguments

Python functions also allow keyword arguments, which enable us to identify arguments by name. This can be extremely handy when a function has many parameters, and it improves the readability of our code.

def describe_pet(pet_name, animal_type='dog'):
    print("I have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name + ".")

describe_pet(pet_name='Willie')

In this scenario, ‘describe_pet()’ is called with the ‘pet_name’ keyword argument. The function also includes a default argument, ‘animal_type’, set to ‘dog’.

Grasping Anonymous Functions in Python: Lambda

Python’s ‘lambda’ function is a small, anonymous function defined with the ‘lambda’ keyword, rather than ‘def’. Lambda functions can accept any number of arguments but only have one expression.

multiply = lambda x, y: x * y

print(multiply(5, 4))

In the code above, a lambda function is defined to multiply two numbers, and it’s called with two arguments: 5 and 4. The function returns the result of the multiplication.

Conclusion

Congratulations, you now know how to work with functions in Python. We have covered:

• The main parts of a function

• Calling a Python function

• Using function parameters

• Using multiple parameters

• Creating default parameters

• Returning data with the return statement

• Using variable parameters

• Leveraging lambda functions

Functions in Python provide a way of organizing and reusing code to create cleaner programming solutions.

As a next step, we recommend you delve deeper into advanced Python function topics such as recursive functions, decorators, and generator functions. I’ll be adding more content like this to this blog very soon.

Bookmark this blog and come back for more cool Python tutorials.

Questions? Comments? Yell at me!

What is Blurring?

First off, let's understand what blurring is. Blurring is a process where we reduce the sharpness of an image by blending the colors of neighboring pixels. Basically, we smooth out the image, which can be useful for reducing noise, improving the overall look, or creating artistic effects.

How Does Blurring Work?

To blur an image, we need to apply a filter, which is simply a small matrix of numbers called a kernel. Don't worry if you don't know what a matrix is. Think of it as a grid of numbers. The kernel moves across the image, and for each pixel, it calculates the weighted average of the neighboring pixels' colors using the kernel values.

There are different types of kernels, and today we'll explore two common ones: the Gaussian blur and the Median blur.

Let's Write Some Code!

Before we start coding, make sure you have Python installed, and OpenCV set up. I prefer to use Python virtual environments for my projects, and it's easy to setup.

python -m venv opencvdemo

Here I am naming my environment opencvdemo but you can name it whatever you like.

Then, activate OpenCV:

In Linux or Mac:

source opencvdemo/bin/activate

In Windows:

.\opencvdemo\Scripts\activate

You'll need to install OpenCV. You can do that by using pip:

pip install opencv-python

Now, let's create a Python file and import the necessary libraries.

I named my script blurring.py.

import cv2
import numpy as np

Loading the Image

We'll begin by loading an image from your computer. Replace 'sampleimage.png' with the actual path to your image. (It can also be .jpg if you like).

image = cv2.imread('sampleimage.png')

Here's the sample I'm using. Feel free to use it yourself. Download it here

I generated it with Dall-E, so I don't own it.

Gaussian Blur

Let's start with the Gaussian blur. This kernel uses the Gaussian function, a bell-shaped curve that spreads the blur evenly around the pixel, making it look more natural.

To apply the Gaussian blur, we'll use OpenCV's GaussianBlur() function, which takes three arguments:

• The input image.

• The kernel size (width and height). They must be odd numbers.

• The standard deviation (0 means it will be calculated automatically).

gaussian_blur_image = cv2.GaussianBlur(image, (11, 11), 0)

Now, let's display the original image and the blurred one side by side:

cv2.imshow('Original Image', image)
cv2.imshow('Gaussian Blurred Image', gaussian_blur_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

And it looks like this:

Awesome, right? Just a few lines of code, and you can blur images.

Median Blur

Now let's do a Median blur. This kernel takes the median value (the middle value in a sorted list) of the neighboring pixels' colors, which reduces noise while preserving edges.

We'll use OpenCV's medianBlur() function to apply the Median blur, which takes two arguments: the input image and the kernel size (an odd number).

median_blur_image = cv2.medianBlur(image, 11)

And once again, let's display the original and blurred images:

cv2.imshow('Original Image', image)
cv2.imshow('Median Blurred Image', median_blur_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Let's run it!

This is a different kind of blur you may want to use.

It's pretty easy stuff.

Saving Your Images

We know how to display these images on the screen, but that's only part of it. What if you want to save them? It's easy with this one line of code:

cv2.imwrite("output.png", median_blur_image)

Of course, you can change output.png to whatever you want.

We used the cv2.imread() function to read the image, then performed some modifications to it, and use cv.imwrite() to write it to a new image. Chances are, you'll want to use this later.

Summary

In this tutorial, we learned about

• Blurring - what it is and how it works

• Loading images with OpenCV

• Gaussian blurs

• Median blurs

• Saving image after modification

Go ahead and experiment with this code. Change the kernel sizes and standard deviations to see how they affect blurring.

Remember, practice makes perfect.

You've unlocked a powerful skill in computer vision, and this is just the beginning! Often you'll want to apply a blur or other modifications before performing operations on an image, so now you know how.

There's much more to explore, like edge detection, object recognition, and even facial recognition. I'll be covering all these in future tutorials. The possibilities are endless.

Questions? Comments? Yell at me!

If you're into Computer Vision and other cool AI tech, you should subscribe to my AI Architect Newsletter to keep up with the latest stuff!