Pybites

We're curious, how do you use AI when you code?

6 days ago | [YT] | 5

Pybites

What makes up the 2026 Python stack?

Why are uv, ruff, FastAPI, Typer, and SQLModel widely adopted by developers that want to have an ergonomic and performant toolset?

What methodologies do we use in our teaching to help developers consistently write clean and robust code?

Join our LIVE event later today where we'll show you this and more!

pybitescoaching.com/live/

1 week ago (edited) | [YT] | 6

Pybites

New Poll!

What is the biggest bottleneck in your Python journey right now?

2 weeks ago | [YT] | 4

Pybites

Ever stared at a screen bleeding with <<<<<<< HEAD markers and questioned your career choices? 😅

We just did. Bob and I effectively broke our own app (Pybites Books) last weekend because I got complacent and had been coding in a vacuum.

If you want to avoid spending your weekend untangling a broken repo, you need these 3 non-negotiable git habits:

1️⃣ Use Issue Trackers: Stop coding in isolation. Break generic ideas into granular tickets and communicate well.

2️⃣ Check Stale PRs: Pulling main isn't enough. Check for open PRs before you branch, or you're guaranteeing a conflict.

3️⃣ Master Bailout Commands: Know how to use git stash and git cherry-pick to surgically extract your work when things go sideways.

We break down our exact git disaster, why it happened, and how we saved the app in our latest episode.

Watch us confess our engineering sins here 👇

What’s your worst git horror story? Let us know in the comments.

2 weeks ago | [YT] | 3

Pybites

In Python, `==` checks value equality.
`is` checks object identity.

It's important to distinguish between the two when comparing objects in Python.

For example:

```python
>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> c = a
>>> a == b # True (Same content)
>>> a == c # True (Same content)
>>> a is c # True (Same object in memory)
>>> a is b # False (Different objects)
```

A handy way to affirm this is to use the `id()` built-in function to look at the unique id of the object.

For example:

```python
>>> id(a), id(b), id(c)
(140611808855040, 140611819909632, 140611808855040)
```

Notice how a and c share the same ID, but b—despite having identical data—is a distinct object.

Keep in mind that for small integers you might get unexpected results:

```python
>>> a = [5, 200, 256, 257, 300, 500]
>>> b = [5, 200, 256, 257, 300, 500]
>>> for i, j in zip(a, b):
... print(i, j, i is j)
...

5 5 True
200 200 True
256 256 True
257 257 False
300 300 False
500 500 False
```

This behavior is an implementation detail of CPython (integer caching from -5 to 256) and can vary depending on context (REPL vs script, optimizations, constant folding).

Takeaway: never rely on identity when comparing numbers or strings.

So:
• Use `==` for comparing values.
• Use `is` for identity checks (e.g. `x is None`).

---
Have you ever been bitten by using `is` instead of `==`? 💡

2 weeks ago | [YT] | 9

Pybites

Ever had a Python script run lightning-fast on your local machine, only to crawl once it hits production? 🐌

In episode 215, Bob sits down with Arthur Pastel, creator of CodSpeed, to talk about stopping silent performance regressions before they merge.

We dive into:
⚡ Why standard benchmarking in the cloud is basically lying to you (and how to fix it).
⚡ How to treat performance checks exactly like your code coverage.
⚡ Why the rise of AI-generated code makes performance guardrails absolutely critical.

If you want to stop guessing about your code's performance and start automating it, you need to hear this one.

2 weeks ago | [YT] | 4

Pybites

One thing we love about Python 🐍 is that you can go deep into OOP, but also functional programming. 💡

It just depends your needs (and mood? 😄)

A good example of the latter (and aptly named) is the functools module. 😍

For example, need a function with some arguments pre-filled?

As an analogy, think of speed dial on your phone. You don't type the full number every time — you save it once with a short name.

`functools.partial` does the same for functions. You can "freeze" some arguments in, get a new simpler function out.

One line instead of writing a wrapper function.

Combine this with `map` (example below) and we get beautifully concise + functional code (and thinking) 🚀

Take a moment to think where `partial` (or another functools construct) would simplify your code?

We're all ears ... 💬👇

4 weeks ago (edited) | [YT] | 12

Pybites

Be honest: When ChatGPT, Copilot, Gemini, Claude, etc generates a chunk of code that looks correct, what is your immediate next step?
---

We're talking about "Vibe Coding" vs. "Skills Erosion" this week. It's easy to feel productive when the AI writes the code, but are we trading speed for understanding?

Curious to see where the community stands on this. Vote below! 👇

4 weeks ago | [YT] | 4

Pybites

We're really proud that our podcast highlights people from all walks of life. It isn't just about interviewing and chatting with the titans in our space.

There's so much to learn from people who are just starting out on their journey as well.


This was a great chat with Asif. It goes to show that everyone has the ability to build valuable things regardless of where they are in their career!

4 weeks ago | [YT] | 2

Pybites

Properties are a clean way to encapsulate logic in classes.

In Django, they help you avoid scattering state checks across views and templates (and pushing business rules into the presentation layer).

Just decorate a method with `@property` and you can treat it like a calculated attribute.

I did this in a Django model the other day. Result: DRY-er, more self-documenting code, and a single source of truth. Example 👇

Usage:
• Templates: `{% if content.can_submit_for_review %}`
• Views: `if content.is_published: ...`

Rule of thumb: keep properties lightweight. If it does a query, prefer a method so it’s obvious it’s not “free”.

Where do you draw the line between `@property` and a method in your code, and what are your favorite use cases?

4 weeks ago | [YT] | 17