DEV Community: Jeremy Morgan

SQL to Cypher - 10 Queries You Already Know

Jeremy Morgan — Wed, 05 Aug 2026 15:38:25 +0000

The query every backend developer has needed and nobody enjoys writing

In March 2016, npm removed an 11-line package called left-pad. Within minutes, builds began failing across the JavaScript ecosystem. It broke thousands of projects, including tools like Babel. Many developers didn't choose left-pad directly; it was hidden in their dependencies and went unnoticed until it vanished.

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)              // (1)
WHERE p.license = 'MIT'        // (2)
RETURN p.name, p.description   // (3)

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:

You know this in SQL	You write this in Cypher	Translation difficulty
`FROM table alias`	`MATCH (alias:Label)`	Automatic
`WHERE`	`WHERE` (or inline `{prop: value}`)	Automatic
`SELECT`	`RETURN` (at the end)	Automatic
`ORDER BY` / `LIMIT` / `DISTINCT`	Same keywords	Automatic
`JOIN ... ON`	A relationship in the pattern: `-[:REL]->`	Shape change
A type/discriminator column	A relationship type	Modeling shift
`GROUP BY`	Implicit: plain terms next to aggregates	Shape change
`HAVING`	`WITH ... WHERE`	Shape change
`LEFT JOIN`	`OPTIONAL MATCH`	Automatic
`EXISTS (subquery)`	`EXISTS { pattern }`	Shape change
Self-join on an association table	The V-walk: `(a)<-[:R]-(x)-[:R]->(b)`	Modeling shift
Recursive CTE	`-[:REL*]->`, direction by arrow	Different capability

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:

Cypher Fundamentals - Learn Cypher in 1 hour

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

Intermediate Cypher Queries

Note: These courses are 100% and are offered to Neo4j users to help you get the most out of the product.

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.

Six Degrees of Ayrton Senna: Learn Neo4j by Connecting 75 Years of Formula 1

Jeremy Morgan — Thu, 23 Jul 2026 17:25:40 +0000

One of my favorite things about F1 racing is the data behind it. F1 cars are the most complex and advanced in any racing series. They collect huge amounts of telemetry data. The tracks also gather data during events, and race engineers analyze it week after week. They study everything from weather, tire temperatures to corner exit speeds. Data drives the sport forward in a major way.

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:

Load Driver and Constructor nodes.
Connect them with DROVE_FOR relationships (one per driver, per team, per season).
Derive a brand-new TEAMMATE_OF relationship between any two drivers who share a team and season.
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:

Neo4j Fundamentals — the property graph model, cemented, with exercises.
Cypher Fundamentals — everything we hand-waved past today, done properly.
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.

I attended POST/CON 2025. Here are my thoughts

Jeremy Morgan — Mon, 16 Jun 2025 16:54:10 +0000

I just returned from POST/CON 25, and I'm left with one big impression: Postman gets it.

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

Running DeepSeek R1 Locally on a Raspberry Pi

Jeremy Morgan — Sat, 15 Feb 2025 00:09:53 +0000

DeepSeek R1 shook the Generative AI world, and everyone even remotely interested in AI rushed to try it out. It is a great model, IMO. As you may know, I love to run models locally, and since this is an open-source model, of course, I had to try it out. It works great on my Mac Studio and 4090 machines.

But can it run on this? A silly little Raspberry Pi?

I received a few emails and private messages asking about this and had to try it out. In this tutorial, we'll walk through how to run DeepSeek R1 models on a Raspberry Pi 5 and evaluate their performance. Whether you want to get into running LLMs locally or build some edge AI stuff, this could be a fun tutorial to try out.

Here it is in video form if you prefer that:

So let's get started. Here's what you need:

Prerequisites

Hardware:

Raspberry Pi 5 (8GB or 16GB RAM recommended).
MicroSD card with Raspberry Pi OS (64-bit) installed.
Stable power supply and internet connection.

Software:

Basic familiarity with Raspberry Pi OS and terminal commands.
Docker (optional, for containerized applications).

Here's the machine I tried it with:

Step 1: Configure Your Raspberry Pi

Enable Remote Desktop (Optional)

To simplify GUI interactions, enable Remote Desktop:

sudo apt-get install xrdp -y
sudo systemctl start xrdp
sudo systemctl enable xrdp

Set the Pi to auto-login to the desktop GUI.

Type in

sudo raspi-config

And select 1 System Options

Then select S5 Boot/Auto Login

and choose B3 Desktop (Desktop GUI, requiring user to login)

Now, if you want, you can log into the desktop remotely using RDP and access a desktop.

Note: on my Raspberry Pi I could not get any browsers to run properly. They would not display in a readable form, I'll be looking it and trying to fix that at some point.

Your browser may also look like this:

Step 2: Install Ollama

Ollama is a tool for running LLMs locally. Since Raspberry Pi uses ARM64 architecture, download the Ollama Linux ARM64 build:

curl -fsSL https://ollama.com/install.sh | sh

Verify the installation:

ollama --version

Note that it will say

WARNING: No NVIDIA/AMD GPU detected. Ollama will run in CPU-only mode.

This is because the Raspberry Pi's GPU is not CUDA compatible. However, we can see how it runs on just the CPU.

Step 3: Run DeepSeek R1 Models

Test the 1.5B Parameter Model

Let's start with the smallest model available to try it out. That would be the deepseek-r1 1.5b model model, which has 1.5 billion parameters.

ollama run deepseek-r1:1.5b

Example Prompt:


>>> Tell me a funny joke about Python.

Performance Notes:

Speed: ~6.12 tokens/second.
RAM Usage: ~3GB.
CPU: Consistently maxed at 99%.

So that's not too bad. It's not great, but it might be useful for prototyping and experimenting. You could use this for many tasks as long as it isn't real-time chat or something immediately interactive.

Let's try a bigger model. We know it will be slower, but I want to see if it's possible.

Test the 7B Parameter Model (Optional)

For this test, we'll try the deepseek-r1 7B parameter model. This one is considerably bigger and is a pretty decent model for many projects.

ollama run deepseek-r1:7b

Performance Notes:

Speed: ~1.43 tokens/second (extremely slow).
RAM Usage: ~6GB (requires 8GB+ Pi).

This one is really slow and barely usable. But it's still impressive that you can run a 7B parameter model on a Raspberry Pi, in my opinion. There's not much use for it, but it's possible.

Step 4: Deploy a Dockerized Chat Application

Let's try running a dockerized chat application. This is an application I built for a previous YouTube video. It's a VueJS application that uses the DeepSeek R1 models.

The source code is available here.

Here's how to run it on a Pi:

Clone the Demo App (replace with your own project):

git clone https://github.com/JeremyMorgan/DeepSeek-Chat-Demo
cd deepseek-chat-demo

Build and Run with Docker:

docker compose up

Access the app at http://localhost:5173 and test prompts.

Hey! It runs! Awesome. The responsiveness isn't too bad, it's a little slow but usable.

Step 5: Experiment with a Raspberry Pi Cluster (Extra Bonus Round!)

I decided to drop this on my Raspberry Cluster just to try it out. While this doesn't improve speed (LLMs run on single nodes), it's a fun experiment for distributed workloads.

These Raspberry Pis are all 8GB models instead of the 16GB. Here's how you can set it up:

Set Up Kubernetes using micorok8s or similar tools.
Deploy the App by creating via a YAML manifest (deepseek-deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: deepseek-deployment
  labels:
    app: deepseek
spec:
  replicas: 4
  selector:
    matchLabels:
      app: deepseek
  template:
    metadata:
      labels:
        app: deepseek
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchLabels:
                  app: deepseek
              topologyKey: "kubernetes.io/hostname"
      containers:
        - name: deepseek
          image: jeremymorgan/deepseek-1-5b-chat-demo:ARM64
          ports:
            - containerPort: 11435
              hostPort: 11435

Create a service (deepseek-service.yaml):

apiVersion: v1
kind: Service
metadata:
  name: deepseek-service
spec:
  type: NodePort
  selector:
    app: deepseek
  ports:
    - name: http
      protocol: TCP
      port: 80           # service port (cluster-internal)
      targetPort: 80     # container port
      nodePort: 30080    # external port on every node
    - name: chat
      protocol: TCP
      port: 11436        # service port (cluster-internal)
      targetPort: 11436  # container port
      nodePort: 31144    # external port on every node

The responses remain slow, as clustering doesn't parallelize model inference. However, the performance difference between 8GB and 16GB is not noticeable with the 1.5B parameter model.

You can grab the Docker image from here and check it out:

https://hub.docker.com/r/jeremymorgan/deepseek-1-5b-chat-demo/

Key Takeaways

So here's what you'll learn while deploying DeepSeek models to the Raspberry Pi 5.

Feasibility:
- The 1.5B model runs acceptably on an 8-16GB Raspberry Pi 5 for lightweight tasks.
- The 7B model will run, but is impractical due to speed (1.43 tokens/sec).
Use Cases:
- Educational experiments.
- Prototyping edge AI applications.
Optimization Tips:
- Use quantized models (e.g., 4-bit GGUF) for better performance.
- Avoid GUI overhead by running Ollama headless.

Conclusion

While DeepSeek R1 won't replace cloud-based LLMs on a Raspberry Pi, it's a fun way to explore AI on budget hardware. Consider upgrading to a Jetson Nano or used GPU server for better performance.

It's a fun experiment!

Final Results:

Model Size	Tokens/sec	RAM Usage	Usability
1.5B	~6.12	3GB	Basic Q&A
7B	~1.43	6GB	Not recommended

Try it yourself and see how it goes, if you have any comments or questions Yell at me!!

Review: The New NVIDIA Jetson Orin Nano

Jeremy Morgan — Tue, 24 Dec 2024 00:57:02 +0000

Hello, friends! If you're a reader of my nerdy articles you've probably heard about NVIDIA's Jetson. It's a great platform for prototyping apps and putting AI at the edge.

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:

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)
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:

Compact and Lightweight: Perfect for edge AI projects where space is a premium.
Impressive Performance: At $250, you’re getting serious bang for your buck.
Quiet Operation: Even under load, it’s quiet—a big plus for home projects.
User-Friendly OS: Jetpack is intuitive and packed with features.

What Needs Improvement:

Limits on Larger Models: It’s not a deal-breaker, but don’t expect it to handle anything beyond 7 billion parameters comfortably.
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!)

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

Video version of this tutorial:

How to Make a Retro 2D JavaScript Game Part 3

Jeremy Morgan — Thu, 19 Dec 2024 19:39:26 +0000

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:

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.

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.

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.

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.

Next Steps

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:

Source Code
Playable Version

How to Make a Retro 2D JavaScript Game Part 2

Jeremy Morgan — Thu, 19 Dec 2024 19:36:10 +0000

Let’s make this game interactive! We’ll add a player, movement controls, and falling items.

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

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, here it is:

Source Code
Playable Version

How to Make a Retro 2D JavaScript Game Part 1

Jeremy Morgan — Thu, 19 Dec 2024 19:34:38 +0000

Welcome, aspiring game developers! 🚀 In this beginner-friendly guide, we’ll build a simple, retro-themed "Catch the Items" game using Phaser 3, a powerful JavaScript game development framework. This series of tutorials is designed for absolute beginners, so don’t worry if you’re new to coding or Phaser—you’re in good hands.

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

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:

Create a project folder:
- Make a new folder on your computer, e.g., catch-game.
- Inside the folder, create a file named index.html.
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>

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.

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

Source Code
Playable Version

Get Started with Python

Jeremy Morgan — Mon, 16 Dec 2024 18:39:36 +0000

Hey there, fellow geeks and future coders! Welcome to Part 1 of our series, "Learn Python"! If you've ever wanted to learn Python but felt overwhelmed by where to start, you’re in the right place. We’re going to break it down in easy, bite-sized chunks, walking you through each concept step by step. So grab your coffee (or your favorite beverage), and let’s dive in!

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:

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.

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!

AI New Hotness for December 13th, 2024

Jeremy Morgan — Sat, 14 Dec 2024 05:22:53 +0000

Welcome to this week's edition of the AI New Hotness Newsletter, where we talk about new and exciting stuff to happen in the world of Generative AI, particularly for software developers. It’s a fast moving, wacky world for sure.

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!

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.

Python Basic Syntax and Indentation: The Complete Beginner's Guide

Jeremy Morgan — Thu, 12 Dec 2024 00:21:51 +0000

When you're first learning to program, Python stands out for a special reason: it's designed to be read almost like English. Unlike other programming languages that use lots of symbols and brackets, Python relies on simple, clean formatting that makes your code look like a well-organized document.

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

Python uses indentation to understand code structure
Always use 4 spaces for each level of indentation
Be consistent with your indentation throughout your code
Simpler, flatter code structure is usually better than deeply nested code
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!

Understanding Python Syntax and Variables

Jeremy Morgan — Tue, 03 Dec 2024 18:57:44 +0000

Hey there, Python enthusiasts! If you’re diving into the world of Python or brushing up your skills, mastering Python’s syntax and variables is a fantastic place to start. Python is known for its simplicity and readability, making it a top choice for developers of all levels. In this guide, we’ll unravel the basics of Python syntax and variables with plenty of practical examples and best practices. So, grab a coffee (or your favorite beverage) and let’s dive in!

Why Python Syntax and Variables Matter

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)

Indentation Errors: Stick to spaces or tabs (not both), and use four spaces per level.
Scope Issues: Know the difference between local and global variables.
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.

Questions? Leave them in the comments here!