Posts on Jonathan Peacher

Tracking Monster Damage With Xs and Slashes

Tue, 01 Jul 2025 00:00:00 +0000

Mike Shea (Sly Flourish) on the Lazy RPG Talk Show:

Turns out subtracting is hard [when tracking monster damage]…so instead of subtracting damage from its monsters hit points, I would just track the damage up…when the damage it took crosses over its hit points, then it’s time to die…so what I started doing was just using X’s and slashes.

This is a great suggestion! I’ve just been using standard tally marks, but I could definitely see how this streamlines things. Going to have to try it out at my next game.

TLDR: Use / for 5 damage and X for 10 damage. Cross a / with \ to make an X. Use standard tallies for remainders. When you cross out 5 tallies, create a new / and disregard those tallies.

Reply via email

Going to try link blogging

Fri, 13 Jun 2025 00:00:00 +0000

Matt Birchler: Why I Love Link Blogging

The web allows us to create content that is connected with the rest of the web. Everything we do, especially us writers, is kicked off by something someone else said, and we should embrace that. Make your blog a part of a conversation, not an island that feels like you’re just doing this all on your own. None of us are, and we should be proud of that.

Simon Willison: My approach to running a link blog

The purpose of my link blog: it’s an ongoing log of things I’ve found—effectively a combination of public bookmarks and my own thoughts and commentary on why those things are interesting.

In a previous article I proposed two categories of content that are low stakes and high value: things I learned and descriptions of my projects. I realize now that link blogging deserves to be included a third category of low stakes, high value writing. We could think of that category as things I’ve found.

I want to post more on this site, but I consistently struggle to find the time and the attention span to write up a good post. So I’m going to try link blogging, something two of my favorite, and most prolific, bloggers, Matt Birchler and Simon Willison, do on a regular basis.

I’m still going to try to write some more long-form posts when inspiration strikes, but I’m hoping that these lower-stakes posts will help me build up a regular posting habit. Plus, I think they serve as a good reference for things I’ve found and thought were interesting.

Reply via email

PyTexas 2025

Tue, 15 Apr 2025 00:00:00 +0000

Day 1

Keynote: Mariatta

❤️

Reducing the “Oops Factor”: Pipelines for Securing your Python Development Lifecycle on a budget

More projects are having security issues, especially now with AI and vibe coding.
A “swish cheese” approach to securing your codebase, most of which can be integrated into your CI pipeline.
- Secret Detection: gitleaks
- Dependency Scanning: pip-audit
- SAST (Static Analytis Security Testing): bandit
- DAST (Dynamic Analysis Security Testing): Dastardly / Tenable
- YOU

The Pythonic Ideal in The Age of Generative AI

AI ← LLM ← Coding Assistant
An experienced engineer is defined by their experiences, not by the duration of their role.
Pros/Cons of using a coding assistants:

Coding assistant	Beginners	Experienced
Write code fast	Con	Pro (for boilerplate)
Write code beyond skill level	Pro/Con	Pro/Con
Explain code	Pro	Pro
Find bugs	Pro/Con	Pro/Con
Hallucinate	Con	Con
Vibe coding	Con	Con
Viable pair programmer	-	Pro
Ethical issues	-	Con

If you are a beginner, write code first, then use AI to explore when stuck, but make sure to understand the generated code.
If you are experienced, let AI write the boring stuff (boilerplate, consistent code, etc.), and level up by prompting for code beyond your comfort zone (ask for options).
If you are a teacher, use AI from the start. Ask it to suggest alternatives to existing code.
Will AI replace you? Maybe. It will if you refuse to evolve with it.
Is pythonic code dead? Maybe. But be kind to future developers (including yourself).
Takeaways:
- LLMs are just fancy autocomplete
- If we over-rely on AI when first learning, we run the risk of not gaining the experience needed to grow.
- AI is a tool, nothing more.
Advice:
- Don’t panic
- Learn your craft
- Embrace AI
- Teach the next generation
- Keep it pythonic

Generators: The Unsung Hero of Async Programming

The GeneratorExit exception can be to cleanup generators.
You can send data back into a generator using .send(x) and x = yield y.

Demystifying AI Agents with Python Code

What are AI agents?

“agent = llm + memory + planning + tools + while loop” – Tweet

You can give the ChatGPT API memory by including the previous messages in subsequent API requests.
You can tell the ChatGPT API to use tools (functions), to do things like searching the web, that returns structured data.
- You can use .signature() to generate the function specs for these tools.
Tools like crewAI abstract all this away.

Python Untethered: Building Robust Embedded Systems

What are embedded systems?

“…[an] embedded system is a device that contains a computer that the average person would not consider being a computer.” – Reddit

Lighting Talks

pip install interrogate for docstring coverage.

Day 2

Keynote: Jay Miller

Contributing to open source and community are similar.
- You have an idea and want to share it with others.
- When you give away your ideas, they only tend to get better.
“Creating a new open source package (and community) is like adopting a puppy.” - Pamela Fox
Let people know what help you need, and vice versa.
Autocorrect “LGTM” to “Looks good to me, thank you!” and don’t say “just x”.
There is always more that you could have done, but if you are doing something, it is helpful.
Respect everyone’s capacity.
Ambition + Inspration = Scope Creep

Building a Test Framework From Scratch (Or Not)!

What is a testing framework? A programming structure for coding automated test cases, executing them as a suite, and reporting their results.
Just use pytest.

Place-making and Productivity: Build Maintainable Broad-scale Tools With a Small Team

pain = n_teams * size_team * n_tools * n_migrations * (1 + r_turnover)

Verbs, Not Nouns: Writing Documentation Users Want to Read

Two types: Reference / Tutorial
Reference (Nowns): Comprehensive, focuses on the product, quick retrieval
- e.g. man pages, api reference, code coments, readme files.
Tutorial (Verbs): Not comprehensive, focus on the user, and read beginning to end
- e.g. tutorials, how-tos, walkthroughs, use cases
Outline your doc first:
- What do you want user to do?
- Ask the users, if you can
- Write down everything
- Define discrete steps
- Prioritize the use cases
Advice
- Look for the verbs
- Focus on what the users want to do
- Move the verbs up front

Lighting Talks

LLMs are like APIs. You make a request, and they return data, but with “moods”.
Micromentor with SLQAR: Show up, listen, question, act, recharge.
How to say thanks to Python People:
- Level 0: Actually say thanks
- Level 1: Say thanks in public
- Level 2: Show your support
- Level 3: Contribute/volunteer
- Level 4: Contribute money
- Level 5: Nominate them for awards
Be kind to your screen sharing partner. Just share the window or tab.
“Make friends, not connections” - Kojo

Reply via email

Alamo Drafthouse 2024

Fri, 17 Jan 2025 00:00:00 +0000

Wow, only 11 movies this year at the Alamo Drafthouse! Turns out having your first child heavily reduces the time you have to go see movies 😫 This will probably be my last Alamo Drafthouse post since we canceled our Season Pass…for now.

Mean Girls (2024)
The Zone of Interest
Anatomy of a Fall
Drive-Away Dolls
Dune: Part Two
Immaculate
Civil War
Kingdom of the Planet of the Apes
Babes
Inside Out 2
Bad Boy: Ride or Die

Here are the previous two years if you’re curious. Till next time Alamo 🍿

Reply via email

DjangoCon US 2024

Fri, 27 Sep 2024 00:00:00 +0000

I wasn’t able to attend in person this year or take too many notes due to work, but I was able to enjoy a few great talks in between things! Here’s to next year! 🤞🏼

Day 1

Choosing Wisely: SPA vs. HTMX for Your Next Web Project

Three options: Static HTML, Progressive Enhancements, SPA
- ← more server data, short user sessions
- → more client data, long user sessions
Static HTML is fast and simple, but not very interactive.
SPAs are interactive, but expensive and complicated.
PEs provide the best of both worlds.

Error Culture

[Error culture] accepts error notifications and ignores them, encouraging a reactive firefighting culture, instead of a proactive culture of problem-solving.

Are you in error culture?
- Is your deleted items filled with lots of emails from no-reply style email addresses that you didn’t even read…you just deleted them?
- Do you have a rule that just deletes emails?
- Do you get alerts and have no idea why or what to do about them?
- Are people rewarded for waiting until problems they knew about are big enough to alert everyone about and then resolve them?

Don’t take down a fence unless you know why it was put up. – Chesterson’s Fence

Ask yourself these questions when managing alerts:
- Is the alert important?
- Is the alert actionable?
- Who is the alert for?
Venn Diagram:
- !Actionable + Important + Right People = Confusion
- Actionable + !Important + Right People = Time Waste
- Actionable + Important + !Right People = Frustration
- Actionable + Important + Right People = Best Case

Product 101 for Techies and Tech Teams

What your PM really wants:
- A team that is interested in the strategy
- Genuine interest in solving problems
- Empathy with end users
PM responsibilities
- Empower their team with strategic insights
- Translate strategy into proposed actionables
Team responsibilities
- Take interest in the strategy
- Pay attention to details and quality
- Care for the user experience, from start to finish
Becoming a product-minded engineer
- Be interested in the business and its user base
- Stay curious
- Provide relevant input
- Be an ally to your PM

Passkeys: Your password-free future

django-allauth now supports passkeys!

The magical incatation! 🪄

# The main setup.
MFA_SUPPORTED_TYPES = ["webauthn"]
MFA_PASSKEY_LOGIN_ENABLED = True
MFA_WEBAUTHN_ALLOW_INSECURE_ORIGIN = True
MFA_PASSKEY_SIGNUP_ENABLED = True
# Allow email recovery.
ACCOUNT_EMAIL_REQUIRED = True
ACCOUNT_EMAIL_VERIFICATION = "mandatory"
ACCOUNT_EMAIL_VERIFICATION_BY_CODE_ENABLED = True
# Allow creation without username.
ACCOUNT_AUTHENTICATION_METHOD = "email"
ACCOUNT_USERNAME_REQUIRED = False

The art of (not) redirecting

Your URLs are a mirror to the soul of your code.

Naming is hard, so:
- Design as best as you can.
- Break as little as possible.
- Avoid 404s at all costs.

Status codes that will help!

302_FOUND
301_MOVED_PERMANENTLY
307_TEMPORARY_REDIRECT
308_PERMANENT_REDIRECT

The art of not redirecting (or how to design URLs):
- Readable: People will read them, some will even type them by memory.
  - ❌ /u/d/1/c/~q/page
  - ✔️ /user/profile
- Predictable: People should be able to guess-navigate your site by rewriting URLs.
  - ✔️ /user/profile/
  - ✔️ /user/settings/
  - ✔️ /user/security/
- Concise: Straight to the point, no redundancy.
  - ❌ /user/user-settings/security-settings
  - ✔️ /user/settings/security
- Complete: Every part must lead to somewhere, or at least redirect to somewhere else.
  - ✔️ /user/settings/security
  - ✔️ /user/settings
  - ✔️ /user
- Consistent: Single language, single style.
  - ❌ /current_user/Seguridad/multi-factorAuth
  - ✔️ /current-user/security/multi-factor-auth
- Beautiful: Well at least not ugly.
The art of redirecting (or how to avoid 404s at all costs):
- django.contrib.redirects, but that only works for static routes.
- For dynamic routes, they first used a middleware that mapped their old namespace to a new namespace.
- This only works for a single mapping, but what if you want to change them again? They implemented path(..., old=[...]).

❤️ Django: the web framework that changed my life

Day 2

Keynote: How To Be A Developer and Other Lies We Tell Ourselves

To be a better developer is to be a better person to others.

Lightning Talks

Django Commons!
Twelve rules for job applications and interviews by Daniele Procida

❤️ Finding 2.0

The hesitation to call your project 2.0 is a lot like imposter syndrome.
How to find your 2.0:
- Intention. Intention to find your 2.0.
- Assessment. Where is your starting point.
- Vision. What is your destination.
- Acceptance. Prepare for breaking changes.
- Plan. Plan each version with a release date!
When to start?

Now is better than never – The Zen of Python

Change is coming. Change is inevitable. The question isn’t if we are going to change, but how. Because we’re either going to change by design or by disaster – Annie Leonard

Don’t wait for disaster, 2.0 is not sacred.

You got that nice tech salary, now what?

You got that nice tech salary, now what?
- Set financial goals
- Determine savings needs (nesteggly.com)
- Determine current expenses (last 3-6 months) (ynab.com)
  - Determine fixed, adjustable, and unexpected expenses.
  - Be aware of “Hedonic Treadmill”: A permanent increase in expenses for a temporary increase in pleasure.
    - Example: buying better coffee and not being able to go back
- Define a monthly budget
- Check-in every 3-6 months
- Max out your tax-advantaged accounts
- Index funds
- Term life insurance
- Check out /r/personalfinance/wiki
But where do we put our money to grow?!
- Not your savings account (but do have 3-6 months of expenses there!)
- Use any employer match.
- Max out tax-advantaged accounts
  - Roth/Traditional IRA
  - 401k
- Purchase low-cost, broad market, index funds.
  - 50% US stocks
  - 30% International stocks
  - 20% Bonds
  - Stocks = Higher reward, riskier
  - Bonds = Lower reward, less risky
  - Index funds track a collection of stocks index funds that outperform managed funds.

How to design and implement extensible software with plugins

Day 3

❤️ Keynote: The Fellowship of the Pony

❤️ Hidden gems of Django 5.x

❤️ A Brief History of Django

Django User Model: Past, Present, and Future

“We should push the user model back to being Django’s responsibility and address that leak.” – Carlton Gibson

Universal Concerns
- User Contract
- Separation of authentication from authorization
- Forms
django-allauth solves many of these problems.
My Current Approach
1. Custom user model
2. User profile model on ‘User’
3. Use ‘django-allauth’ 3rd party package
- Custom user model (empty) + django-allauth = my preference

API Maybe: Bootstrapping a Web Application circa 2024

Lean into Django.

Django has always been the framework for perfectionists with deadlines. When those deadlines are financial, all the more so. Django is the perfect web framework for our post-zero percent interest rate world.

Locality of Behavior is a starting point not a destination

[Locality of behavior] is a tool, not an end in itself.

Tools to achieve locality of behavior:

Reply via email

What caught my eye at WWDC 2024

Thu, 13 Jun 2024 00:00:00 +0000

Well that was probably the most interesting WWDC in a while. Not saying it was great or perfect, but definitely a turning point. That intro was amazing though! Here’s what caught my eye along with my gut reaction:

iOS

Custom home screen icon placement - Wow, finally.
Custom home screen icon tints - Hmm, not quite right.
Ability to lock apps - Nice, but also sherlocks this as a paid app feature.
Ability to hide apps - Sus stuff aside, hiding utility apps is a win.
iMessage RCS support - Finally.
iMessage rich text - Oh cool.
iMessage emoji tapbacks - Finally. Yes. Perfect.
iMessage scheduled texts - Finally. Yes. Perfect.
iMessage over satelite - Oh cool.
Airpods shake/nod for accept/decline - Oh cool. That won’t misfire at all…

watchOS

Live activities - Oh cool. Also cool that it reuses dynamic island activities.
Vitals app - Oh cool, hopefully useful.

iPadOS

SharePlay drawing - Oh cool. I need this on iOS!
SharePlay control - Oh cool. I need this on iOS!
Calculator app - Wow, finally.
Math notes with calculations, variables, and graphs - Oh wow, yes! Amazing! Wish I had this in college.
Smart script for cleaning hand writing, pasting, and spell checking - Oh wow, yes! My hand writing is miserable.

macOS

iPhone Mirroring - Oh wow, love it, now add this to SharePlay!
iPhone Notifications - Oh wow, yes! I’ve wanted this before!
Tile snapping - Wow, finally.
Passwords App - Wow, finally.
- I don’t think this sherlocks existing password managers. I think the main win here is that this is going to get more people to actually use a password manger who would never before. I’m not switching anytime soon, but this is still a big win and step forward for online security generally.

visionOS

Widescreen mac mirroring - Nice, I’m sure others will love this.

tvOS

InSight - Eh, cool I guess.

Apple Intelligence

AI == Apple Intelligence - Haha, of course they find a way to steal AI!
Website summaries - Nice!
Priority notification - Oh cool, this is going to be useful!
Writing tools - Cool, but this does mean more content will be generated.
Image editing - Love it!
Image generations - Cool tech…bad ethics. Also creepy.
Context aware and conversational Siri with more integrated actions - YES! Gold star! What Siri was meant to be! Can’t wait! ⭐️
Privacy cloud compute - Good!
Genmoji - Haha, I love this!
Audio transcribing Oh cool!
ChatGPT - 🤮

Reply via email

Cloudy with a chance of totality

Fri, 24 May 2024 00:00:00 +0000

After watching the first lightning talk at DjangoCon US last year, I was inspired to see and photograph the next eclipse¹, and wouldn’t you know it, my house was just outside the path of totality, so I had to see it. Plus I was recently gifted some hand-me-down camera lenses and one of them happened to be 250mm. Just enough to get some good pictures!

Fast forward to the day of the eclipse. I had all my gear ready and when I checked the weather for the day…cloudy with a chance of ~~totality~~ rain. I didn’t let that stop me, however, and I was hopeful that the clouds would part. So I drove to my viewing spot in the path of totality and set up shop.

As predicted, it was very cloudy, and I struggled to find the right settings for the camera, but was able to dial it in just enough when the sun poked through the clouds. As the time drew near…and then past…I was worried I wasn’t going to see anything, but a few minutes later the clouds parted just enough for me to get some, I think, amazing amateur shots! It was really fun watching the moon make its way across the sun.

My dreams were short-lived however as, right before totality, the clouds returned, blocking out the money shot! I was incredibly disappointed, but at least I was able to enjoy the eerie feeling of day turning to night.

Ah well, I guess I will just have to try again in 2045!

1/20s, f/28/5, ISO , 250mm, Canon Canon EOS Rebel T6s

1/30s, f/28/5, ISO , 250mm, Canon Canon EOS Rebel T6s

1/15s, f/28/5, ISO , 250mm, Canon Canon EOS Rebel T6s

13/10s, f/28/5, ISO , 250mm, Canon Canon EOS Rebel T6s

1/623s, f/12/5, ISO , 8/5mm, Apple iPhone 12

April 8, 2024 ↩︎

Reply via email

PyTexas 2024

Sun, 21 Apr 2024 00:00:00 +0000

Day 1

Keynote: The Design of Everyday APIs

The Design of Everyday Things - Don Norman
Good API design is intuitive, flexible, and simple.
Intuitive:
- Use domain nomenclature
- Clumsy naming hints at clumsy abstractions
- Provide symmetry
Flexible:
- Provide sane defaults
- Minimize repetition
- Be predictable and precise
- Let users be lazy
Simple:
- Provide composable functions
- Leverage language idioms
- Provide convenience

Provide a good README:

# README
## Installation
## Get Started
## Learn More

Python Code vs Pythonic Code

Experts “recognize”, beginners “reason”
Python Power Moves
- Decorators
- Comprehensions
- Generators
- Slicing
Why is python hard?
- Python code != Pythonic code
- Python code != <any other language’s concepts>
- Python is (too) easy
- What memory
- Python needs lots of testing
- All about those libraries…

ContainerCraft: Mastering Efficient Integration Testing

https://testcontainers.com/

Anarchy to Order - Organizing Assorted Data with Python and LLMs

Links in a graph are not enough, we need to label those links to create a knowledge graph.
Graph databases (like Neo4j) does this!
- No FKs, very flexible, label relationships

Lessons Learned Maintaining Open-Source Python Projects

What is a maintainer? They keep projects operational and in an appropriate condition.
What is not a maintainer? Someone who adds new features or fixes issues…that would be a contributor.
What does a maintainer do?
- Ensures package and information about it is discoverable.
- Ensures consumption and contribution is familiar.
- Sets ground rules (hint: CODE_OF_CONDUCT.md).
- Triages incoming bug reports (hint: use templates).
- Grooms and rejects incoming feature requests (hint: think of long-term good rather than short term gain).
- Reviews pull request (hint: require tests, changelogs, ruff code reformatting, and commit squashing when needed).
- Cuts releases with a changelog (hint: think small and often. have version and deprecation policies).
- Thanks contributors.
- Ensures the projects architecture remains consistent.
- Lets other people help (hint: CONTRIBUTING.md).
- Ensure CI remains green and fast (hint: don’t forget to rebuild docs, add pull request warning).
- Fosters community (hint: issue tracker, slack/discord, social, stack overflow).
- Mentors and convert good contributors to co-maintainers.
- Ensures they can keep doing it (hint: priorities mental and physical health, it’s okay to step away)
Why be a maintainer?
- Looks good on your CV.
- Gives opportunities to meet people.
- Mentoring experience.
How to be a maintainer?
- Pick something you use actively use on a semi-regular basis.
- Read the docs in detail.
- Practice by trying to solve an issue and reach out to the current maintainer.
- Know communication is deceptively hard, we all have different communication styles.
  - Be polite and patient, and give people the benefit of doubt.

Working with Audio in Python

Very cool lesson on how digital audio works.
Pedalboard provides useful abstractions around audio files.
Always process audio files as a stream to handle any size of input.
Use numpy for faster operations.

Rest Easy with Jupyrest

Jupyrest turns jupyter notebooks into json APIs.

Iterate, Iterate, Iterate!

more-itertools 😍

Voice Computing with Python in Jupyter Notebooks

You can write faster (and avoid RSI) by using your voice instead of typing.
You can be even faster by defining text replacement commands (e.g. “insert code block”).

Lightning Talks

You can make LLMs smarter by feeding it new data in the system prompt.
Recurse Center: Social Rules
- No well-actually’s
- No feigned surprise
- No backseat driving
- No subtle -isms
How to give a talk:
1. Be Engaging
2. Be Loud
3. Be Big (60pt font)
4. Be Prepared
5. Be Considerate
Tips for giving a good talk:
- Tell a story
- Find your signposts (break points)
- Practice
- The energy you give is energy you get
- expect (and prepare for) the unexpected

Day 2

Keynote: Thriving with Python

How do we succeed in a polyglot world? Choose the best language for the job.
How do we avoid the pitfalls?
- Avoid chasing speed. All languages have tradeoffs.
- Avoid swooning at shiny. All languages will eventually bloat.
- Avoid hype and FOMO. Pretend it’s the news.

20 GOTO 10: How to Make Scrolling ASCII Art

There will always be new forms of art.

What is Scroll Art?
- ASCII art
- Terminal/console output of monospace text
- Previously printed text scrolls up (and only up)
- You can’t erase the text you’ve printed
- You can’t move the cursor to arbitrary XY coordinates
Why?
- Easy to understand. Input is text, output is text.
- Any computer can run them.
- Easily accessible. Can us any language.
- Easy way to start learning/teaching code.

System Design on Easy Mode

Durable execution is a higher level of abstraction for writing functions that are guaranteed to complete running.
How? https://temporal.io/

Building Efficient Containers for Python Applications

Docker + Python is initially straightforward, but tricky to optimize.
Why should I care?
- Slower build times lead to decreased productivity and ability to fail fast.
- Larger image sizes lead to more storage requirements and longer download times.
How do we measure efficiency?
- Image size
- Build time (no cache)
- Rebuild (no change)
- Rebuild time (with code change)
- Rebuild time (with dependency change)
Possible Optimizations:
- Layer Ordering: Order matters. Ex. install deps before copying code.
- Pin deps & Disable pip cache: Deps have deps, pin those too. You don’t need pip to cache inside an image.
- Smaller Base Image: Removes build tools saving storage. Install only needed tools, install, and then remove tools.
- Combining Layers: Chaining commands on same RUN can save on storage.
- Multi-stage Build: Using builder stage to create venv to use in runner stage saves space from discarded builder stage.
- Cache mount: Saving pip cache on your machine saves redownloads.
Other best practices:
- Always use a Python-specific .dockerignore file
- Separate Dev and Prod dependencies
- Use the latest Debian/Ubuntu/Redhat distribution to base from
- Try to avoid specifying the Python patch version in the base image
- Use CPU specific vs GPU specific image

Always Use Sets

Always use sets because they…
- clearly communicate expectations
- prevents unexpected drift in behavior
- allow us to write algorithms based on discrete math
- add clarity to the code through set operations
- are faster than lists or tuples - even when 10 items are changed
- worthwhile even if you have to sort or combine later
Except…
- when you are running out of memory
- when you have a dict that is equally idiomatic

Oh the (Methods) You Can (Make): By Dunder Seuss

Very charming story time summary of the many…many dunder methods! ❤️

Sanely Working With Legacy Code

What is legacy code?
- Code without documentation.
- Code without tests.
- Code with poorly written test that is hard to change.
- Code which you are not familiar with and often not your idea.
- Valuable code which you are not comfortable changing.
The Plan
- Begin with understanding the code we want to improve
- Check that our understanding of the code matches what is expected
- Add tests
- Make changes
- Communicate our changes to the code effective to others on our team

Lightning Talks

flet.dev, multi-platform apps
Use watchfiles to auto run dev commands on save (e.g. linting, testing, etc.)
Game Jam == Hackathon for games

Reply via email

Trying out the Vision Pro

Tue, 06 Feb 2024 00:00:00 +0000

Being the Apple nerd that I am, when I found out there was going to be demos of the Vision Pro, I had to sign up! It’s not everyday you get to try out a new Apple product.

Here are some of my first impressions:

Display. I was a little disappointed with the display. Don’t get me wrong, it’s a really good display, but I was really hoping Apple would have come out swinging with something orders of magnitude better than the competition. I found the display too dim and pixelated, slow at times, and contained too much vignetting around the edges. I think the only thing that saved the display for me were the prescription eye inserts.

Controls. The eye-hand controls are by far the defining feature of the Vision Pro. It was incredibly intuitive and eerily accurate. It honestly felt like it was reading my mind, and I quickly started zooming around the UI. I did get a few false positives here and there, but I think I’ll blame my fidgety hands for that. One thing I didn’t like too much however, was that it really made me think about what my eyes were doing, and I could already feel the strain in the short time that I used it. Only thing I forgot to try was the virtual keyboard…eh, it was probably bad anyway.

3D Content. I was shown some of the 3D photos and videos you can create, and too be honest they just felt like blurry lenticular cards and were not all that interesting. 3D movies were fun to see again, and the 3D environments you can place yourself in were a bit more intriguing, but it was Apple’s “Immersive Videos” where things really started to shine. They were absolutely amazing, and it nearly brought a tear to my eye because I really felt like I was there…I left wanting more.

Comfort. Generally speaking, it was comfortable, but wow was it heavy. I felt the pressure mostly along my nose and cheek bones, and I could feel it well after the session had ended, not to mention the prominent red mark around my face. I know Apple really wants everyone to use that “solo knit band”, but I would probably never use it in favor of the “dual loop band”.

So, am I going to buy the Vision Pro? No! It is way too expensive, not to mention the accessories, but if I had a few thousand dollars lying around, sure I’d buy one. I do think it’s an amazing product, and the start of an exciting journey, but I could never justify it in its current state. Besides, we all know what the end game is here 🤓

Reply via email

Get a virtual library card

Fri, 02 Feb 2024 00:00:00 +0000

At my sister’s insistence, I finally got my first virtual library card as an adult, and I can honestly say I will probably never buy a book, ebook, or audiobook again! Unless, of course, I want to display a book on my shelf…

I was originally concerned the virtual experience and catalog would not be satisfactory, but with apps like Libby that is not an issue. Nearly everything I wanted was available as an ebook or audiobook, and the best part, you can send the ebooks to your Kindle!

I’ve had it for about a month or two now, and in that time I’ve gotten through around 10 books, way more than I normally would. I think this is for two reasons:

Cost
Motivation

Cost. Books can be expensive, especially if I wanted to do the book-audiobook combo, which caused me to pass up books I wasn’t absolutely sure I would read. With a library card, they are effectively free¹, so borrow away!

Motivation. When I bought a book, I had effectively forever to read it, which translates to…I’m never going to read it. With a library card, I had a return date. This deadline forced me to actually read the book before it goes away.

Overall, I think getting a virtual library card has been a huge success. If I had to give one con, it’s that if you, like me, enjoy reading and listening to books at the same time, it can be hard sometimes to borrow the ebook and audiobook at the same time if there are different wait times. Luckily, you can defer items to get them to line up better.

Happy borrowing!

Or at least close to free depending on your area. ↩︎

Reply via email

Store tupperware with their lids on

Wed, 24 Jan 2024 00:00:00 +0000

Decluttering at the Speed of Life by Dana K. White

Store food storage containers with their lids on…I put lids on containers as I take them out of the dish-washer (or off the dish drainer when I hand wash) and stick them in the cabinet. They don’t nest, so no finagling is required. When I need a container, I grab it. All of it. No searching for a matching lid.

Finally got around to listening to this book that was recommended by Jeff Triplett on Mastodon. This tupperware quote is my favorite, and most impactful! My wife and I have only been doing this for about a week and it’s already paying dividends.

This is the way.

Reply via email

Alamo Drafthouse 2023

Sun, 31 Dec 2023 00:00:00 +0000

55 movies this year…nearly double last year!

M3GAN
Mulholland Dr. (2001)
Skinamarink 🫣
Broker
Infinity Pool Uncut
Everything Everywhere All at Once (2022)
Knock at the Cabin
Ant-Man and the Wasp: Quantumania
Cocaine Bear
Scream VI
Dungeon & Dragons: Honor Among Thieves 🎲
The Super Mario Bros. Movie
Beau is Afraid
Suzume (Subtitled)
Renfield
Evil Dead Rise
Guardians of the Galaxy Vol. 3
Mother! (2017)
The Boogeyman
Transformers: Rise of the Beasts
Past Lives
The Flash
Spider-Man: Across the Spider-Verse
Asteroid City
Flux Gourmet (2022)
Joy Ride
No Hard Feelings
Insidious: The Red Door
Oppenheimer
Talk To Me
Barbie
Haunted Mansion (2023)
Teenage Mutant Ninja Turtles: Mutant Mayhem
Strays
Oldboy (2003)
Bottoms
A Haunting in Venice
The Nun II
Eyes Wide Shut (1999)
Saw X
Strange Way of Life (2023) + The Human Voice (2020)
The Creator
The Exorcist: Believer
When Evil Lurks
Cat Person
The Exorcist (1973)
Killers of the Flower Moon
Priscilla
The Hunger Games: The Ballad of Songbirds & Snakes
Saltburn
Elf (2003)
Napoleon (70mm)
Poor Things
Wonka
The Boy and the Heron (Dubbed)

Reply via email

Generating social share images with Hugo

Sun, 31 Dec 2023 00:00:00 +0000

Aaro Luomanen, Generating OpenGraph images with Hugo

Have you ever shared a link somewhere and wondered where those little preview images of websites come from? Well if you didn’t know, they are called OpenGraph tags…I managed to generate some sweet og:images using Hugo’s image manipulation tools.

I’ve been wanting to setup social share images for a while, but I figured it would be too complicated or time consuming to manage, so I never got around to it. That is, until I found Aaro’s blog post! Turns out it is super simple to have Hugo (what this site is built on) generate OpenGraph images for you!

Here is what you’d see if you shared this post on social media. It’s simple, but I like it. Thinking I might add tags to this in the future.

Thanks Aaro!

Reply via email

YouTube RSS

Mon, 18 Dec 2023 00:00:00 +0000

About 6 month ago I discovered that every channel and playlist on YouTube has an RSS feed, and since then I’ve been slowly “re-subscribing” to all my favorite channels. It really has been an amazing way to experience YouTube without all the algorithmic noise.

Just add the following feeds with your desired channel or playlist to your favorite RSS reader! You should be able to find channel IDs in its about section.

www.youtube.com/feeds/videos.xml?channel_id=<ID>
www.youtube.com/feeds/videos.xml?playlist_id=<ID>

Reply via email

How does this still work

Mon, 27 Nov 2023 00:00:00 +0000

Currently listening to Life in Code by Ellen Ullman, and I’m reminded how brittle our digital world is and wonder how it hasn’t fallen apart yet 🙃

“We build our computers the way we build our cities—over time, without a plan, on top of ruins.”

“Code and forget, code and forget: programming as a collective exercise in incremental forgetting.”

Reply via email

DjangoCon US 2023

Thu, 26 Oct 2023 00:00:00 +0000

Day 1

Orientation and Welcome

“I am going to say some words here I don’t fully understand” – @lacey

Contributing to Django or how I learned to stop worrying and just try to fix an ORM Bug

Your Web Framework Needs You! – Carlton Gibson
Ticket Strategy: Something old and straightforward
Steps:
1. Replicate the bug
2. Read some docs
3. Write some code
4. Test the code
5. Write down (publicly) what you learned

HTML-ivating your Django web app’s experience with HTMX, AlpineJS, and streaming HTML

SPA’s are popular because they can provide dynamic user experiences with no reloading. This comes at the cost of larger file sizes making pages take longer to load, and higher complexity making the codebase harder to maintain.

We can achieve the same dynamic experiences with tools like HTMX and AlpineJS, while also reducing load times and complexity.

✅ These tools provide the features an elevated user experiences (normally via SPAs):

(HTMX) Remove whole-page refreshes for every interaction
(HTMX) Use small payloads from the server to update the interface
(AlpineJS) Update HTML as a result of changes in data
(AlpineJS) Empower rich on-page interactions
(HTMX/AlpineJS) Be fast

✅ These tools provide faster pages loads by literally being small:

Around 30KB

✅ These tools provide easy to maintain HTML attributes control behavior:

Locality
Remove your JS build system
Write mostly Python and HTML
Easier maintenance
Faster iteration cycles

Lightning Talks - Day 1

April 8, 2024 Total Solar Eclipse
- Last in the continental US until 2044/2045
- By glasses/filters early (ISO 12312-2 certified)
Django Stickers! 🦄

Using database triggers to reliably track model history

django-pghistory tracks changes to your Django models using Postgres triggers, providing:

Reliable history tracking everywhere with no changes to your application code.

Structured history models that mirror the fields of your models.

Grouping of history with additional context attached, such as the logged-in user.

import pghistory
@pghistory.track()
class TrackedModel(models.Model):
int_field = models.IntegerField()
text_field = models.TextField()

Beyond the Basics of Migrations

DON’T reinvent the wheel: if Django’s autogenerated migrations work, use that
DO rename custom migration files for clarity
DO always use the reverse parameter when using RunPython or RunSQL
DO make sure your coworkers know if you customized a migration so they can review it properly
DON’T use migrations for repeat actions
Efficiency matters on large tables (especially with CI/CD)

Custom Model Managers and QuerySets: Graduating from Django Beginner to ORM Master

What are Managers? An interface through which database query operations are provided to Django models.
- Model methods = row level operations
- Manager methods = table level operations

How do you define Managers?

objects = CustomManager() # basic usage
objects = CustomQuerySet.as_manager() # bread and butter usage
objects = Custommanager.from_queryset(CustomerQuerySet()) # advanced usage

Manager or QuerySet?
- QuerySets = Chainable, Filters, Annotations/Aggregations, Reading
- Manager = Not Chainable, Creating, Updating, Deleting

Why use custom Managers?
- Readability
- Encapsulation
- Testing!!!
- Built-in service layer
- Gateway to learning the ORM
Common Patterns
- .for_CONTEXT(ctx)
  - Manager or QuerySet
  - Filter based on some context
  - Ex: .for_user(user)
- .is_CONDITION(cond?) .not_CONDITION(cond?) .exclude_CONDITION(cond?)
  - Manager or QuerySet
  - Filter based on some condition
  - Ex: .is_leasable() .is_leased_for_year(year)
- .create_MODEL() .create_MODEL_for_CONTEXT(ctx)
  - Manager
  - Create a model with side effects
  - Ex: .create_user_for_club(club)
- .within_RANGE()
  - Manager or QuerySet
  - Filter based on numerical/date range
  - Ex: .within_start_date(days)
- .greater_than_VALUE() .less_than_VALUE()
  - Manager or QuerySet
  - Filter based on numerical/date value
  - Ex: greater_than_days(days)
- .set_FIELD() .toggle_FIELD()
  - Manager or QuerySet
  - Update a field across entire QuerySet
  - Ex: .set_active() .toggle_status()
- .with_ANNOTATION()
  - Manager or QuerySet
  - Add additional info not available on Model
  - Ex: .with_adjusted_income()

Passkeys on Django

See django-passkeys.

Building Powerful APIs with Django, Django Rest Framework, and OpenAPI

Status codes
- 1xx: Informational —> in progress
- 2xx: Successful —> done
- 3xx: Redirection —> naahh, ain’t nobody got time for that.
- 4xx: Client error —> its definitely you, not me
- 5xx: Server error —> okay, its me not you
API first approach
- Separation of concerns
- Flexibility and scalability
- Collaboration and parallel development
- Clear and consistent interfaces
- Documentation and contract-driven development
- Future-proofing
- Integration and Third-party support
Cache all the things!

Hosting and DevOps for Django

Goals
1. (Hosting) Setup is resilient to individual server failures
2. (Hosting) Resources can be scaled in response to load
3. (Deployment) Code can be tested before being deployed to production
4. (Deployment) Deployments are automated
5. (Data/Secrets) Data and secrets are secured and backed-up
6. (Monitoring) Errors are easy to notice and diagnose
Hosting
- What are the options?
  - ~~Bare servers (EC2)~~
  - Platform as a Service (EB)
  - Managed Container Service (ECS)
  - Kubernetes (EKS)
- Why these three?
  - These technologies work one level up from servers/containers
  - The unit of work is an instance of an application
  - Dead servers can be automatically replaced
  - Resources can be scaled manually or automatically
- Which one to pick?
  - Platform as a Service is a sensible default and a great starting place
  - Managed Container Services make sense if you have many services or heavy non-web workloads
  - Kubernetes is for multi-cloud or on-prem deployment. Kubernetes can run all your infrastructure, but then you must reinvent a lot of things (esp. load balancers, databases, and block storage)
- What about inbound traffic?
  - Load Balancers (ALB)
    - Allow multiple application servers without single point of failure
    - Allows autoscaling servers (on CPU usage or custom metric)
    - Protects from some kinds of DDOS (adding Nginx/Apache can help)
    - Can share one load balancer between multiple environments
    - Bonus: handles HTTPS and HTTP redirects
- What about static files?
  - Okay: unicorn + whitenoise
  - Better: Reverse Proxy (Apache or Nginx)
  - Best: CDN (CloudFront or CloudFlair)
- What about background tasks?
  - AWS Elastic Beanstalk Workers (weak at on-demand)
  - AWS Lambda + SOS (15-minute limit)
  - Celery (complex setup)
Deployment
- Steps
  1. Create new running copy of application (code, dependencies, static assets)
  2. Do peripheral infrastructure changes (migrate, hard part) See Django Migrations: Pitfalls and Solutions
  3. Put new running copy of application into rotation
  4. Remove old running copies
- Environments
  - Dev Code & Fake Data: Local & Staging
  - Dev Code & Real Data: Prod-Copy
  - Prod Code & Fake Data: Demo/Training
  - Prod Code & Real Data: Production
- Use infrastructure-as-code: Terraform
- CI/CD: GitHub Actions
- System Updates: Covered by PaaS. Don’t forget Docker.
Data/Secrets
- Managed Databases
  - Database and OS version upgrades
  - Automated backups and managed backup restoration
  - Storage autoscaling
  - Encryption at rest
  - Managed read replicas and failover for prod. Environments (“multi-az”)
    - Reduces data loss from 24 hours, to seconds
- Static Files (S3)
  - Turn on encryption at rest
  - Turn on versioning
  - Use django-storages
- Secrets
  - Use a secrets manager
  - Use django-environ
Monitoring
- Sentry (error monitoring)
- UptimeRobot (uptime monitoring tool)
- DataDog (profiling tool plus error monitoring)
- NewRelic (profiling tool)
- CloudWatch (AWS-native infrastructure monitoring tool)

✨ Modern editing experience for your Django models with Wagtail 🐦

A typical Wagtail project would have your user-facing website structure be defined by the tree structure of the Page model. However, if you have an existing Django project with your own defined Django views, and you don’t want to use Wagtail’s Page model, you can still get plenty of benefits from Wagtail [by integrating the various model mixins into your existing models]!

Day 2

Postgres Performance: From Slow to Pro

Use database cache (shared buffer)
- Check cache hit ratio (you want ~98%) to know if you need to increase this
Upgrading versions can increase speed
PGTune is a good tool for recommended settings!
Performance tips
1. Stop run away queries, set a statement timeout
2. Set up pg_stat_statements and know your slowest queries. If they’re important, fix them
3. Add indexes (but not too many) for your longest running and/or your most frequent queries
4. Check your cache hit ratio
5. Tune memory or add memory as needed
  - make sure your connections have enough memory
  - make sure you have enough connections, look at pgbouncer

Empathetic testing: Developing with compassion and humility

Write tests with a focus on refactorability, outcomes, and uses…rather than defending implementation choices
- Does this test enable, or prevent future changes?
Seek alternatives to patch/mock (Ex: pip install responses freezegun)
This is an “act of kindness” for future developers and creates an enjoyable work experience

Lightning Talks - Day 2

BUILDING THINGS WHEN YOU HAVE A CLUTTERED MIND
1. CONCENTRATION, EVEN IN AN “IDEAL” ENVIRONMENT
  - It might be entirely different for you. Experiment.
  - Self-help & productivity bloggers do not have all the answers for what works for YOU
2. I AM NOT ACCOMPLISHING ENOUGH - OTHERS ARE *AHEAD* OF ME IN LIFE
  - You are more than your level of productivity
  - Life is not a race with a specified timeline
3. SHAME ABOUT HALF-FINISHED OR ABANDONED PROJECTS
  - Forgive yourself
  - Life isn’t about the # of things you can accomplish
  - You are more than your level of productivity
  - Not every project needs to be finished
  - The journey and experience are valuable
  - And, you can almost always go back to that idea or project in the future…
  - Take notes. If you don’t write it down, it is not real.

Don’t Buy the “A.I.” Hype

“These models do not hallucinate. They make stuff up because a programmer using a random generation function decided they should…By saying they hallucinate, we are removing the responsibility of the programmer and the model trainer to be ethical.”

“[In] the most recent version of ChatGPT, in the release notes, one of the bullet points was: Less likely to make up facts…You cannot make up a fact. A fact is the truth. A fact is. You do not make up a fact. That sentence is an impossibility and shows the irresponsibility going on right now that they actually let that get out in the release notes.”

There’s More to Open Source than Code

Non-code contributions: Any contributions that don’t involve code!
- Documentation
- Blogging
- Trying stuff out
- Issue triage
- Code reviews
- Answering/Asking questions
- Volunteering at events
- Localizing
- Organizing events
- Hosting/facilitating hackathons
- Creating assets
- Giving talks
- Video content
- Social media
- Content curation
- Moderation
- Mentorship
Why?
- Getting out of the comfort zone
- Helping a project thrive
- Improving onboarding
- Meeting people
As a code contributor, what can I do to facilitate these?
- Establish a safe, inclusive, effective community
- Tag issues
- Advocate for the community
- Include non-code contributions in CONTRIBUTORS.md

Managing Content with Django

Wagtail
- Feature rich: media management, workflow tools, polished user experience, commenting, search
- All encompassing experience. Most objects can be edited in Wagtail.
- Page-focused
- Growing community, lots of momentum
- Some batteries are hard to remove
django CMS
- Minimalist approach, plugins recommended. “Django Admin + an editor”
- Component-first, easy to make new ones (called “plugins”)
- Heavy on frontend editing
- Smaller community, slower momentum
- Great multilingual support
Conclusions
- Wagtail is all encompassing, getting better about gaps with Django
- Wagtail has the better UX most of the time
- Wagtail is simpler, which is a pro/con
- django CMS is great at being a small piece of a larger puzzle
- django CMS puts more emphasis on content type and structure
- django CMS frontend editing is slick for quick changes

An approach to lightweight tenancy management using Django Rest Framework

Single Tenant: When each tenant has it’s own application/db.
Multitenant: When each tenant shares a single application/db.
- drf-nested-routers to nest resources under each tenant.
- drf-access-policy to provide role based permissions.
- You can create a TenantAwareManger to protect against leaking data on custom queries.

What Django Deployment is Really About

Four main concerns
- Static Files
  - manage.py runserver handled this during development, but…
  - Once you deploy, the production web server needs to handle this (django is too slow).
  - Once you’ve set STATIC_ROOT, you have to run manage.py collectstatic.
  - What about Whitenoise?
    - Middleware that intercepts and skips slow django request for static files.
    - Great when you can’t directly configure your web server.
    - Excels when serving from a CDN (handles headers).
- Database
  - Your local and production database setups will most likely be different.
  - Generally, if you’re using a cloud provider, you’ll be connecting to a remote, managed, database.
- WSGI Server
  - The thing that actually runs your Django code.
  - manage.py runserver handled this during development, but…
  - In production, you need to pick a production WSGI Server (gunicorn/uwsgi).
- Web Server
  - Apache/nginx
  - VPS: Manual
  - PaaS: Managed
Bonus:
- Run manage.py check --deploy
- Check out django-simple-deploy
- Check out django-production

Introduction to GitHub Actions: Understanding Key Terms and Building Your First GitHub Action

You configure a GitHub Actions workflow to be triggered when an event occurs that then runs a series of jobs on a runner that include one or more steps that call a script(s) or action

Day 3

Keynote: Testing Modern Web Apps Like a Champion

Follow up to PyTexas Keynote - “Full-Stack Python”
Testing challenges: Tests are slow, brittle, flaky, don’t make sense, don’t make money, require changing context.
Modern testing goals
1. Focus on building fast feedback loops rather than certain types of tests.
2. Make test development as fast and painless as possible.
3. Choose test tooling that naturally complements dev workflows.
Writing good tests (Arrange-Act-Assert Pattern)
1. Arrange things in the system
2. Act on the target behavior
3. Assert expected outcomes
pytest

Web test automation tool comparison

Selenium	Cypress	Playwright
Popular among testers	Popular among developers	So hot right now
C#, Java, JavaScript, Ruby, Python	JavaScript only	C#, Java, JavaScript, Python
All major full browsers	Chrome, Edge, Firefox, Electron	Chromium+, Firefox, WebKit
WebDriver protocol	In-browser lavaScript	Debug protocols
Just a tool - requires a framework	Full, modern framework	Full. modern framework
Can be slow/flaky if waiting is poor	Visual execution but can be slow	Typically the fastest execution
Open source, standards, & gov	Open source from Cypress	Open source from Microsoft

TLDR
1. Write unit tests to catch problem directly in the code.
2. Write component tests if you have a component library.
3. Write API tests to grind through variations.
4. Write UI tests to cover user-centric behaviors.
5. Do performance and load testing to make sure the app works well.
6. Run tests continuously as part of standard development workflows.

Django migrations, friend or foe? Optimize your Django migrations for faster testing

Once you’ve built up many migration, creating your test database will start slowing down.
You can use --keepdb when running tests to preserve the test database between runs, but this can be hard to take advantage of in CI/CD.
You could use squashmigrations, but turns out the database building performance is more or less the same.
The best solution (for local and ci/cd) is to completely rebuild your migrations.

Inside Out: My Journey of Understanding Inclusion

Unconscious bias
- Ex: The arborist was shocked that a woman mows my lawn
- Ex: The clerk assumed I’m not operating the jigsaw
- Sometimes concepts are locked down in our minds (Some since upbringing!)
- An individual is honestly unaware of a prejudice
- It’s a twofold effort: to notice it, and then to shape it
- Source of bias can be stereotypes, preconceived notions, past experiences, or even gut instinct
  - Appearance (age, [dis]abilities, gender, race, body size, etc)
  - Data (title, education, language, name, religion, etc)
  - Opinion (attribution, confirmation, conformity, contrast)
- We can reflect on our own unconscious biases to improve the Django community as a whole
Double bind
- Conflicting expectations or stereotypes
- Challenging to meet both career advancement and likability criteria
- Women sometimes have to choose between being liked but not respected, or being respected but not liked
- Double bind paradoxes
  - Maintaining distance yet being approachable
  - Advocating for oneself yet serving others
  - Authoritative yet participative
  - Demanding yet caring
Culture aspects
- What is normal in your culture, may not be in others
- We can further explore how cultural factors influences:
  - being a good person
  - being a good communicator
- Book: The Culture Map
  - Communication context
    - Some cultures use high-context (indirect, contextual)
    - Some cultures use low-context (direct, explicit)
    - What’s desired in one style can be seen as negative in the other
      - High context could be seen as not trustworthy or lier
      - Low context could be seen as condescending or patronizing
    - Implicit does not (usually) work across cultures
    - Perhaps is better to err on the side of verbose
      - Less room for misinterpretation
      - Less effort to parse from the recipient
    - Also important to make explicit why we are being explicit!
  - Being Convincing
    - A.K.A Persuasive, in a good way!
    - Some cultures use principle-first (Why, deductive reasoning)
    - Some cultures use application-first (How, inductive reasoning)
    - We can find a balance, and provide both
    - Use TLDRs
Language challenges
- Language [in]flexibility
  - It’s easy (at least possible!) to speak neutrally in English
  - It’s not in other languages, like in Spanish, French, Hindi, or Arabic
  - Ex: In Spanish, everyone is supposed to use the masculine form to describe a group of people, but in reality the masculine form is used to describe doctors, engineers, managers, etc., while the feminine form is used to describe nurses, secretaries, teachers, etc.
  - Aspirational conditioning starting from childhood
- Inclusive naming in tech
  - Gender (“man-in-the-middle”)
  - Disabilities (“crippled”)
  - Neurodiversities (“dumb”, “crazy”, “sanity-check”)
  - Groups that historically have suffered oppression (“master”, “slave”)
  - Denoting negative connotations (“whitelist”, “blacklist”)
  - Violent (“abort”, “kill”)
  - Check your code/project/docs if you can!
- Inclusive context
  - “Next spring”/“summer” applies to only half of the world!
  - Abbreviations/acronyms are used for the sake of brevity or practicality but could impact new contributors
    - CRUD, MTI, DDL, DTL, DDT, etc.
    - Useful, but spell it out the first time it’s introduced.
Allies
- Supportive Advocate: Actively supports marginalized groups and role models for inclusive policies/practices
- Empathetic: Understands diverse experiences and challenges, and listens without judgment
- Confronts Bias: Challenges discrimination using their privilege and influence, and amplify underrepresented voices
- Self-Educates: Learns about diversity and inclusion and continuously improves as an ally
- Not self-appointed: Recognized as such by the minorities
Conclusions
- Varied Factors: it’s a balancing act, but it’s worth the effort
- No Magic Formula: no guaranteed recipe or procedure exists
- Acknowledge Challenges: the first step toward resolution
- Reflect and Act: introspect as individuals and as a group
- Pursue Equity: evaluate opportunities for change and improve
- Provide support: allies are key in the process of change

Lightning Talks - Day 3

Starting a business in 5 minutes
- You will fail, but some things will succeed…this is called “finding your niche”
- It will be expensive, so keep it simple
- Wait to hire your first employee…until you have 3x their salary
- Everything is people, and people needs systems
- If you build it, they will not come…get your first customer before launching
- You can do it!
Strategies for a long running side projects
- Doc…you…men…tay..shun……Documentation!
- Tests…what the code should and should not do.
- Issues…write up your features as issues.
  - The Perfect Commit
- Code comments
How to get into dev mentorship
- The only true measure of success is the number of people you have helped times the effect of that help.
- People in a position of privilege can open doors and make opportunities
Humility: An unexpected treatment for imposter syndrome
- Humility provides honest self-awareness and evaluation to contradict doubts.
- Humility encourages others around you.
- Humility is a discipline for everyone.

Best Practices for Making a Wagtail Site as Accessible as Possible

Accessibility is practice of ensuring our web content is able to be consumed by the widest possible spectrum of people.
This is a legal responsibility for many…and a moral responsibility for all.
Wagtail has two main accessibility initiatives:
- Accessibility of Wagtail itself
- Accessibility of sites it produces (this talk)
Wagtail comes with an accessibility checks that allows editors to identity and correct accessibility issues themselves.
What is still up to developers
- Semantic markup in templates
- Configuring Wagtail’s accessibility checker
  - Default is to only show errors that an editor can address
  - Configure to show all errors to superusers
- Enforcing proper heading hierarchy
  - You could override blocks to validate
- Promoting good alt text
  - Wagtail doesn’t have alt-text on the image model because alt text should be contextual
  - You can create a custom block that ties an image to alt text
- Using ARIA labels, where appropriate
- Helping editors help themselves
  - Use help_text
  - Create a HelpPanel

One database table, one model, many behaviours: Proxy model

Proxy models allows you to create a new model based on an existing model without creating a new database table, can be used to modify the behavior of the original model.

Back to the Future of Hypermedia in Django

REST: Representational State Transfer
HATEOAS: Hypermedia as the Engine of Application State
- The server controls everything, the client just displays the result.
- Better for accessibility and sustainability.
Not HATEOAS: JSON as the Engine of Application State
- Great for complex interdependencies and/or offline apps, but overkill for general CRUD apps.
Common patterns and resources

Django’s accessibility track record

96.3% of the top 1,000,000 homepages have basic accessibility issues
~95% of a sample of 25,000 Django homepages have basic accessibility issues
Accessibility Insights Extension

Panel Discussion: Who put me in charge? Moving beyond day-to-day coding in Django

“What’s important for you as a managers who is managing devs is to understand what they’re working on” – Julia

“I don’t know if it’s as much a skill [switching from contributor to manager] as it is like being genuinely interested in the people that work for you” – Elizabeth

“Sometimes…I can sort of see a pothole coming, you know, either a technical pothole or maybe a political one or maybe a legal one or a financial one, and say ok, there’s a pothole coming up” – Charles

“Your input is not just being able to directly say ‘ok this project might be a problem.’ It’s when you get other people to the point where they can see the project may be a problem.” – Charles

“You do lose a little bit of political sway [returning to an individual contributor].” – Andrew

“A good technical leader breaks a plan down to 3 month chunks.” – Andrew

“How do you identify some of those initial signals that you’re ready to take that step to [becoming a manager]?” – Jay

“It’s similar to the question: when are you ready to have children?” – Charles

“Being really good at documentation has always benefitted me in my career and particularly in management.” – Elizabeth

Reply via email

Evening things

Thu, 19 Oct 2023 00:00:00 +0000

One feature that has been missing from my favorite todo app, Things 3, has been the ability to automatically move tasks to the Evening section when they appear on the Today page. With the power of shortcuts, we can fix this!

Click here to download the shortcut.
Create an automation to run the shortcut everyday.

The way it works is you mark tasks you want to appear in Evening with a tag called “Evening” (you can change that to whatever you want) and, voilà, everyday the automation will move todays tasks tagged with “Evening” into the Evening section!

231020: Just realized that setting the automation to run whenever you open Things 3 also works great!

Reply via email

Copy anything

Thu, 28 Sep 2023 00:00:00 +0000

I don’t know about you, but I often find myself wanting to copy some text that isn’t copyable! This usually occurs if the text in question is part of an application’s UI, for example. To solve this, I created a handy shortcut that allows you to select an area of your screen and extract any text in that area to your clipboard ✨

You can integrate this into your workflow by assigning the shortcut to a keyboard shortcut. I used Command + Shift + 7 to bring it next to the existing keyboard shortcuts for taking screenshots.

Reply via email

Italy

Wed, 20 Sep 2023 00:00:00 +0000

If there’s one thing I learned, it’s that the history of Italy is layered … just like lasagna 🍝

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1000s, f/8/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/800s, f/8/5, ISO , 30mm, Sony ZV-E10

1/500s, f/8/5, ISO , 30mm, Sony ZV-E10

1/2000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/800s, f/7/5, ISO , 30mm, Sony ZV-E10

1/50s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1600s, f/7/5, ISO , 30mm, Sony ZV-E10

1/50s, f/8/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/3200s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/500s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/640s, f/7/5, ISO , 30mm, Sony ZV-E10

1/60s, f/16, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/800s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/320s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1600s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/800s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1250s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/800s, f/7/5, ISO , 30mm, Sony ZV-E10

1/250s, f/8/5, ISO , 30mm, Sony ZV-E10

1/800s, f/8/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/800s, f/7/5, ISO , 30mm, Sony ZV-E10

1/200s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1600s, f/7/5, ISO , 30mm, Sony ZV-E10

1/2500s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/2500s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/640s, f/7/5, ISO , 30mm, Sony ZV-E10

1/800s, f/7/5, ISO , 30mm, Sony ZV-E10

1/3200s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/800s, f/7/5, ISO , 30mm, Sony ZV-E10

1/2000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/3200s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1600s, f/7/5, ISO , 30mm, Sony ZV-E10

1/500s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/640s, f/7/5, ISO , 30mm, Sony ZV-E10

1/400s, f/7/5, ISO , 30mm, Sony ZV-E10

1/320s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/800s, f/7/5, ISO , 30mm, Sony ZV-E10

1/400s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/640s, f/7/5, ISO , 30mm, Sony ZV-E10

1/3200s, f/7/5, ISO , 30mm, Sony ZV-E10

1/2000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/500s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

1/2500s, f/7/5, ISO , 30mm, Sony ZV-E10

1/500s, f/5, ISO , 30mm, Sony ZV-E10

1/640s, f/5, ISO , 30mm, Sony ZV-E10

1/500s, f/5, ISO , 30mm, Sony ZV-E10

1/2500s, f/7/5, ISO , 30mm, Sony ZV-E10

1/3200s, f/7/5, ISO , 30mm, Sony ZV-E10

1/1250s, f/7/5, ISO , 30mm, Sony ZV-E10

1/4000s, f/7/5, ISO , 30mm, Sony ZV-E10

Reply via email

Why My Dockerfile ARG Was Missing

Tue, 13 Jun 2023 00:00:00 +0000

I was doing some cleanup in a Dockerfile today when I noticed one of the packages was not on the correct version. It was on the latest version despite the fact there was an ARG pinning it…or so I thought. After some sleuthing, I found this helpful Stack Overflow post that explained and pointed me in the right direction.

Turns out…

“An ARG declared before a FROM…can’t be used in any instruction after a FROM.”

So the reason my package was installing the latest version was because the ARG didn’t exist! Conveniently, it also didn’t error, which is why it went unnoticed 🙃

The solution? Move the ARG down one line after the FROM.

# Bad
ARG VERSION=1.2.3
FROM ...
# Good
FROM ...
ARG VERSION=1.2.3

Reply via email

PyTexas 2023

Sun, 02 Apr 2023 00:00:00 +0000

Day 1

Keynote: Walking the Line

Amazing keynote, and I will definitely watch it again when it’s uploaded to YouTube!

Make small, incremental, and easy to understand changes.
Test often and fail quickly.
Orient yourself by checking an expected failure.

A Tale of Two Typings

Legacy code is simply code without ~~tests~~ types.
Define your types, don’t just inline them.

Trust Fall: Hidden Gems in MLFlow that Improve Model Credibility

The talk focused on machine learning, but I think this can still apply outside of that.

Build trust through documentation and reproducibility.

Exploring Socio-technical Security Concerns in Critical Open-source Python Repositories

Catalyst: Someone intentionally introduced bad code into Linux for a research paper.
Pull requests power open source contributions.
FOSS needs to be careful what gets merged in.

A BuildEngineer in a buildless lang

Improve development by reducing stylistic diffs and increasing semantic diffs.

Recursion for Beginners: A Beginner’s Guide to Recursion

All recursive solutions have an iterative solution.
Unless you are dealing with trees, avoid recursion.

Improving code without losing your mind

https://blog.alexewerlof.com/p/tech-debt-day/
We tend to focus on getting features out the door.
Like an artist, programmers should improve – refactor – their art.
Set aside time to improve – refactor – your code.
Make code understandable and obvious.

Lightning Talks

Make code obvious. Otherwise, make it familiar. Otherwise, make it well-documented. Start by making it obvious!
For demos/testing, you can pip install packages directly inside of the Python Interpreter!

>>> import pip
>>> pip.main(["install", "django"])

Day 2

Keynote: Full-Stack Python

Python is the ~~second~~ best language for [doing] everything [together].
Simple is better than complex.
Python transforms us from programmers into problem solvers.
Aside from HTML/CSS, the entire stack can be built with Python!
HTMX 😍

Unlocking the Power of Health Data: An Introduction to FHIR and Python

Healthcare coordination is a mess, with no interoperability.
Enter the Electronic Health Record, but it had low adoption because it was only a syntactic protocol.
Enter HL7FHIR which was syntactic, semantic, and even had an API scheme.

Having fun with application design

Empathize – Curiosity about your users.
Define – Understand a problem.
Ideate – Creativity in idea generation.
Prototype – Build the right thing.
Test your assumptions.

How to Build and Ship More Secure Python Apps with Sigstore

You wouldn’t pickup and chew gum (FOSS) from a wall would you? Would you!?
Attacks on FOSS are increasing, and Sigstore hopes to fix this.
ttl.sh, an anonymous and ephemeral Docker image registry.

HoloViz: Visualization and Interactive Dashboards in Python

HoloViz, a framework for developing data visualization dashboards.

Put your Pants on and lint all your Python code!

Pants, a fast, scalable, user-friendly build and developer workflow.
Ruff, an extremely fast Python linter.

Using Python for Digital Investigations

Digital Investigations (open-source research), research that uses info that is publicly available.
Research sources include public geospatial, media, user-generated, and archive data.
Open-source research and software have similar names, different histories, and both use Python as their language of choice.

Lightning Talks

Schools, when compared to industry, focus on code instead of other import aspects like tests, documentation, and collaboration.
Book Recommendations
- Being Geek: The Software Developer’s Career Handbook
- A Philosophy of Software Design
- Think Like a Programmer: An Introduction to Creative Problem Solving
Single click to select by character, double click to select by word, triple click to select by line!

Reply via email

Multiple Monitors on Apple Silicon

Mon, 30 Jan 2023 00:00:00 +0000

If you are reading this, you probably just discovered that your second monitor isn’t working when you connect it to your M1/M2 Mac. Surprise, those chips have only one video output and thus can only support one external monitor! Bummer…

To get around this, and move on with your life, you can use DisplayLink to output extra monitors via USB! Normally, connecting to an external monitor looks something like this:

flowchart LR Machine -- video --> Monitor

With DisplayLink, that video signal gets compressed and outputted via USB. This data is then decompressed by a DisplayLink adaptor and outputted to the monitor as a video signal. That looks something like this:

flowchart LR Machine -- video --> DLS[DL Software] -- compressed --> DLA[DL Adaptor] -- video --> Monitor

From my experience using it so far, it works pretty well! I have noticed some minor latency and flickering issues, but that is a small price to pay, I think, for gaining a second monitor.

So TLDR, to get a second monitor on M1/M2 Mac, you have to:

Install DisplayLink.
Buy a DisplayLink adaptor that is compatible with your monitor specs.
Plug and Display!

Reply via email

Alamo Drafthouse 2022

Wed, 04 Jan 2023 00:00:00 +0000

Puss in Boots: The Last Wish
Black Panther: Wakanda Forever
The Whale
Avatar: The Way of Water
Bones and All
Violent Night
The Menu
Triangle of Sadness
Black Adam
Ticket to Paradise
Amsterdam
Pearl
Howl’s Moving Castle
Barbarian
The Invitation
Three Sound Years of Longing
Beast
Bodies Bodies Bodies
Bullet Train
Nope
Thor: Love and Thunder
The Black Phone
Star Trek: The Genesis Trilogy
Everything Everywhere All At Once
Jurassic World Dominion
Elvis
Lightyear
Crimes of the Future
Men
Doctor Strange: In the Multiverse of Madness
Sonic 2

Reply via email

DjangoCon US 2022

Wed, 19 Oct 2022 00:00:00 +0000

Day 1

The Django Admin Is Your Oyster: Let’s Extend Its Functionality

Don’t make it easy for attackers to find your admin page…don’t use /admin.
Override ModelAdmin.get_search_results to speed up searching.
Remember to use prefetch_related and select_related to reduce DB queries.
Add optional checkboxes to change forms to kickoff extra functions when saved.
- You can also dynamically set help text for better UX.

You can use multiple databases in a single admin.

# Migrate
$ python manage.py --database=sandbox
# settings.py
DATABASES = {
'default': {...},
'sandbox': {...}
}
# utils.py
class SandboxAdminModel(admin.ModelAdmin):
using = 'sandbox'
def save_model(self, request, obj, form, change):
obj.save(using=self.using)
def delete_model(self, request, obj):
obj.delete(using=self.using)
def get_queryset(self, request):
return super().get_queryset(request).using(self.using)
# admin.py
@admin.register(MySandboxModel)
class MySandboxModelAdmin(SandboxModelAdmin):
...

Extend change_form.html to add help text for the whole model, not just fields.

# change_form.html
{% extends "admin/change_form.html" %}
{% block form_top %}
{{ original.admin_help_text }}
{% endblock %}
# models.py
class MyModel(models.Model):
admin_help_text = "..."

Create custom actions for bulk changes.

# admin.py
def increase_msrp_by_8_perc(modeladmin, request, queryset):
...
@admin.register(Car)
class CarAdmin(admin.ModelAdmin):
actions = [increase_msrp_by_8_perc]

Documenting Django Code in 2022

https://diataxis.fr: A framework for authoring technical documentation.

You Don’t Need Containers to Run Django in Production

When should you use containers? When you have…
- Thousands of programmers.
- Millions of users.
- Billions in valuation.
There is a lot of FOMO around containers. For example, reproducibility is a big selling point for containers, but generally, this benefit is rarely taken advantage of.
Some downsides of using containers are added complexity and cost.
What do we want in production?
- Secure environment.
- Protection against malicious users.
- Don’t want to wake up in the middle of the night.
- Seamless code updates.
Web Server (WSGI vs ASGI):
- WSGI is 20 years old…and it shows.
  - Limited concurrency.
  - Graphic: Showed that as clients scale with gunicorn, response time gets worse. The graph represented a BEST case scenario.
- ASGI is 5 years old…and it shows.
  - Unlimited concurrency (ignoring memory).
  - Graphic: Showed that as clients scale with uvicorn, response time gets worse. The graph represented a WORST case scenario.
Reverse Proxy (nginx):
- Can help limit concurrency as needed.
- nginx can handle 20 million RPM on a 8 core VM.
- Caddy is a new/easier alternative, but nginx is tried and tested.
Process Monitor (SystemD)
Deployment (Git Deploy Config)
Bonus Tip: Use software that offers LTS.

Herding your database queries: diagnosing, improving and guarding performance of DB interactions in your Django apps

Blog Post
Tools like django-debug-toolbar and django-silk are great for diagnosing rogue queries, but there can be cases where these tools are not going to help directly (e.g. with a js frontend).
To solve this, they rolled their own custom middleware to analyze queries per request and output the result to the terminal.
```
Received request GET /library/books/, status 200, db_query_count=29, db_query_time_ms=136.421, duration_ms=192.56
```
After you optimize your queries, you can protect yourself from regression with unit tests by taking advantage of django_assert_max_num_queries.
You can also use coverage context to check new endpoints that are created and don’t have unit tests.

The Django Jigsaw Puzzle: Aligning All the Pieces

(other) MVC == MVT (django)
- Model == Model
- View == Template
- Controller == View
The Django Admin is great, but if your admin.py is growing past 20 lines, you might be relying on it too much.
django-extensions: One of the things it does is auto import models in the django shell.
Don’t use /admin!

 WSGI Server
┌────────────────────────────────────────────────┐
│ Middlware │
│ ┌────────────────────────────────────────────┐ │
│ │ Django app │ │
HTTP request │ │ ┌────────────────────────────────────────┐ │ │
─────────────► ┌──────────┐ ──► │ │ │ ┌────────┐ ┌─────┐ ┌──────┐ │ │ │ ┌─────────┐
Browser │Web Server│ │ │ │ │URL conf│ ──► │ │ ─── │Models│ ───┼─┼─┼── │Databases│
◄───────────── └──────────┘ ◄── │ │ │ └────────┘ │ │ └──────┘ │ │ │ └─────────┘
HTTP response ▲ │ │ │ │Views│ │ │ │
│ │ │ │ │ │ ┌─────────┐ │ │ │
▼ │ │ │ │ │ ─── │Templates│ │ │ │
┌──────┐ │ │ │ └─────┘ └─────────┘ │ │ │
│ File │ │ │ └────────────────────────────────────────┘ │ │
│System│ │ └────────────────────────────────────────────┘ │
└──────┘ └────────────────────────────────────────────────┘

Nurturing a “Legacy” Codebase

What is a “legacy” codebase?
- Code with, potentially forgotten, history.
- Code that follow outdated conventions.
- Usually still running in production.
Should you evolve or rebuild? Ask yourself…
- Does the code meet current requirements?
- Are there frequent or sever production issues?
- How healthy are the dependencies?
Lets say you choose “evolve,” what should you do?
- Automated tests with good coverage.
- Upgrade/Replace outdated dependencies.
- Use a linter and/or black for code formatting.
- Use pre-commit for cross-team consistency.
- Make sure current devs understand the story of the code.
- Help future devs by writing detailed commit messages along with an issue tracker.
- Document!
- Build a culture of leaving clues for the future!

Day 2

Keeping track of architectural-ish decisions in a sustainable way

The Problem
- Is there a problem? Image a new coworker asks why a particular decision was made, but no one knows. We lose relevant information of the decision making process (e.g. context and alternatives considered).
- Why is this a problem? We cannot reliably reflect on our decisions, onboard new people, or evolve.
- What’s causing this? Perhaps our tools are not specifically designed to capture changes, nor why they changed.
Architectural Decisions: The thing we need to capture.
- Architectural Decisions (AD): A software design choice…that is architecturally significant. It’s an AD if you need to ask:
  - Should we meet to discuss this?
  - What framework should we use?
  - Could we use [shiny-new-thing] for this?
- Architecturally Significant Requirement (ASR): A requirement that has a measurable effect.
Architectural Decision Record (ADR) [also]: The tool we can use to capture.
- What is an ADR? A short, practical to fill, text file describing a specific AD. Like a journal entry to future developers.
- Who is it for? Primarily for developers and technology staff.
- What’s in it?:
  - Context: Why did this need to happen? What need to be considered?
  - Options: What were the options? What were the pros/cons of each?
  - Consequences: What will happen as a result?
  - Status: Has the decision been implemented or superseded?
- Where does it live? Close to code (benefits from peer reviewing and discoverability), wiki, or something else.
Takeaways:
- Leads teams to consensus.
- Prevents knowledge hoarding.
- Gets new maintainers up to speed.
- Not one person with critical knowledge.
- Shows maintainers if a change they’d like to do has been considered previously.
- Can be used as justification to stakeholders.

Django Migrations: Pitfalls and Solutions

Migrations and Branches
- Rewinding migrations only works if the relevant migration files are in the codebase, regardless of applied migrations.
- This can cause problems when switching branches with divergent migrations. Solutions:
  - Reverse migrations before switching branches.
  - Restore a backup from before you ran either branch’s migrations.
  - Use backward compatible migrations.
- A similar problem occurs when trying to merge two branches with divergent migrations. Solution:
  - python manage.py makemigration -merge
Reversible Migrations
- Migrations are not time travel…database backups are!
- Common rewind errors include, using RunPython with no reverse function, removing a constraint if data has been added that violates that constraint, or deleting a field that is non-null and has no default.
- You can improve reversibility by backing up your database, set fields as nullable for some time before deleting them, and using a reverse function with RunPython (or at least use noop).
Backwards Compatible Migrations
- The Deployment Race Condition: When, during deployment, the codebase and database will be out of sync! This can cause errors on your site if a request comes in while they are out of sync.
- Assuming you are adding to the database more often than removing, you can reduce the frequency of this issue by migrating the database first, then deploying your new code.
- For all other cases, you should try to create backwards compatible migration, i.e. migrations that once applied still work with you old code before that it gets updated.
- Some migrations trivially backwards compatible:
  - Ops with no DB schema change (RunPython, changing choices, squashing migrations, etc.)
  - Adding a nullable field.
  - Adding a model.
  - Removing/Relaxing a constraint.
  - Adding a constraint that all existing data/code already meets.
  - Removing a model that isn’t referenced.
- Others, are not. For those, we want to try and get those to “look” like the above list.
  - You can make some migration noops by using legacy database names.
    - To rename a field, set db_column to the old name, and django will not update the database.
    - To rename a model, set db_table to old name, and django will not update the database.
    - You can even move models between apps an avoid schema changes by using db_table and SperateDatabaseAndState.
  - You can decompose some migrations into two deploys.
    - Adding a constraint: First deploy code that satisfies constraint, then deploy migration to update data.
    - Removing a model: First deploy code that remove all references, then deploy migration to remove the model.
    - Remove a field: First deploy code that deprecates the field using django-deprecate-fields and remove all code references, then deploy migration to remove the field.
  - For all other, more complicated, cases, use scheduled downtime (maintenance mode).
    - Split/Merge fields/models.
    - Change field types.
    - Do “true” field/model renames.
    - Compress multiple releases into one.
Failed Migrations
- If your migrations fail, be aware that:
  - You should abort your deployment.
  - Each migration is atomic, but the group of them are not.
  - If your migrations are not backwards compatible, your users will be getting errors (unless you are in maintenance mode).
  - If your migrations are not backwards compatible, your database will be in an incompatible state, and you can’t use manage.py shell.
- To fix this:
  - Avoid this to begin with by testing against production data!
  - Correct data with manage.py shell, assuming your migrations were backwards compatible.
  - Push the broken migration onto the server (because you should have aborted the deployment), and reverse them (assuming they were reversible).
  - Restore database to a backup.
  - manage.py dbshell

Django Through the Years

Not much to say about this, other than it was a very fun history lesson! ❤️

Just enough ops for developers

My main takeaway here was the following fastapi analogy:

CPU = Cook
Process = Cashier
Request = Customer

Your First Deployment Shouldn’t Be So Hard!

Django is great, until you get to deployment, at which point there are a billion different ways to do it. This can be a barrier to entry for new developers and for experienced developers who need to prototype rapidly…enter django-simple-deploy.

Prerequisites:

A simple Django project.
Use requirements.txt, Poetry, or Pipenv.
Use Git.
Have the target platform’s CLI installed with an active account.

$ pip install django-simple-deploy
# Add simple deploy to INSTALLED APPS.
$ manage.py simple_deploy --platform fly_io --automate-all
# Profit!

Day 3

Async Django: The practical guide you’ve been awaiting for.

Async is exciting, but be aware that using async will make your application more complex.

import asyncio: Python’s implementation of an async runtime that Django uses.

import asyncio
async def foo():
...
await bar()
async def main():
tasks = [asyncio.create_task(foo()) for range(5)]
# Important! Wait for all tasks to complete.
await asyncio.gather(*tasks)
asyncio.run(main())

Can you use this for background tasks?
- Kind off…if it fails, there is no built-in statuses, retires, or error handling.
- It depends…on how you are running Django (WSGI or ASGI). With WSGI, hitting an async view spins up an event loop, but will disappear when then view exits (like the example above).

Aggregate Views (what you did before GraphQL):

import httpx
import asyncio
async def aggregate_view(): # pseudo code
async with httpx.AsyncClient() as client:
response_a, response_b = asyncio.gather(
client.get(view_a_url),
client.get(view_b_url),
)
return JsonResponse({
'response_a': response_a.json(),
'response_b': response_b.json(),
})

Chat App (four ways):
- Polling (HTMX): Simple, but doesn’t scale, isn’t responsive, and can lead to self DDOS.
- Long Polling (HTMX + Channels): Responsiveness, but creates a lot connections.
- Server-Sent Events (HTMX + Channels): Better, keeps the connection open.
- WebSockets (HTMX + Channels): Also keeps the connection open, but allows two-way communication.

Why large Django projects need a data (prefetching) layer

“DRY isn’t helpful if you need to be careful.”
Django REST Framework loves DRY, but has high change amplification as a side effect.
Change Amplification: The expected number of places in the codebase that needs to be modified during an atomic change to the software.

An example of this in DRF is needing to prefetch in serializers.

class MovieSerializer(ModelSerializer):
# data that requires prefetching
# You have to remeber to prefetch for each view using MovieSerializer.
class MovieListView(ListAPIView):
queryset = Movie.objects.prefetch_related("directors")
serializer_class = MovieSerializer
class MovieDetailView(ListAPIView):
queryset = Movie.objects.prefetch_related("directors")
serializer_class = MovieSerializer

You could do one of two things to combat this:
1. Use non-DRF serializers that are very explicit about prefetching.
- django-virtual-models.
1. Or keep DRF, but:
- Warn about missing prefetches for each serializer.
- Automatically run necessary prefetches.
- Automatically prevent unnecessary ones.
- Keep serializer nesting support.
- Keep SerializerMethodField support.
TLDR: Use tools to be explicit about the data you expect from the DB. Otherwise you’ll suffer from performance regressions and your read logic will break frequently.

A pythonic full-text search

PostgreSQL added full text search in 2008.
Django added full text search in 2016.
Paolo has a great article outlining the various search features.

Home on the range with Django - getting comfortable with ranges and range fields

Ranges are everywhere!
Support for ranges was added for PostgreSQL Django in 2015.
The typical approach is to us “start” and “stop” fields, but that gets complicated fast.
- The DB doesn’t know these two fields are related.
- You have to manually add bounding/validation/constraint logic.
- Queries can get weird/complicated.
Ranges fix all this!
- 1 field that stores lower, upper, and boundary information.
- Automatically validates/constrains values.
- Easy/Intuitive queries.
Ranges (Math):
- Ranges = Intervals, Inclusive = Closed, Exclusive = Open
- (exclusive, exclusive) - (1, 3) - 2
- [inclusive, exclusive) - [1, 3) - 1, 2 The default for Django ranges!
- (exclusive, inclusive] - (1, 3] - 2, 3
- [inclusive, inclusive] - [1, 3] - 1, 2, 3
There are lots of very useful query filters!
- __overlap, __contains, __adjacent_to, __fully_lt/gt, etc.
Django supports a number of different value types via pysycopg2.extra.
- You can also create custom types! Example: IP ranges!
Pitfalls
- Limited Django Admin support.
- You have to use Cast when using F().
- You have to use Lower and Upper database functions to access values.
Resources
- psycopg2.extras
- django-range-merge
- django-generate-series

Reply via email

Quick Hugo Deploy with GitHub Actions

Thu, 18 Aug 2022 00:00:00 +0000

Once you have your Hugo project setup, all you need to do is push the following GitHub Action to deploy!

name: Build
on:
push:
branches: [main]
workflow_dispatch:
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
with:
submodules: true
fetch-depth: 0
- uses: peaceiris/actions-hugo@v2
- run: hugo --minify
- uses: JamesIves/github-pages-deploy-action@v4
with:
branch: gh-pages
folder: public

.github/workflows/build.yml

This action does three things each time you push to main:

Pulls your repository, including all submodules.
Builds your site with the Hugo CLI.
Deploys the build to GitHub Pages via the gh-pages branch.

That’s it. After a few moments, your site should now be live at:

https://<username>.github.io/<repository>/

If you want a custom domain for this site, you can configure a custom domain with GitHub Pages.

Reply via email

How to Be a Lazy Dungeon Master

Wed, 03 Aug 2022 00:00:00 +0000

The Lazy Dungeon Master’s Checklist

The steps it takes to prepare a typical game session can be boiled down into a simple checklist:

Review the characters
Create a strong start
Outline potential scenes
Define secrets and clues
Develop fantastic locations
Outline important NPCs
Choose relevant monsters
Select magic item rewards

Review the characters

The first thing you need to do is write down the names, backgrounds, motivations, and desires of the characters. Use these notes to prime your brain and tie the characters to the rest of your game.

Create a strong start

Set the stage by asking yourself, what’s happening, what’s the point, and where’s the action? We are looking for an event, hook, and closest action in one, maybe two, sentences. When in doubt, start with combat.

Outline potential scenes

Write down a short list of scenes that might occur in your game. Only write down as much as you need to prime your brain. These scenes are not in any specific order and may not even occur.

Define secrets and clues

Write down ten secrets and clues the characters might discover during your game. These secrets and clues bring your campaign to life and reveal small pieces of the story or history of the world. They should be abstract enough to allow you to improvise their discovery during the game.

Develop fantastic locations

Develop one or two locations that the characters might discover for every hour of play you expect to have. These locations need to have an evocative name, three fantastic aspects, and be described using age and size. It is also a good idea to tie some of these locations to the backgrounds of the characters.

Outline important NPCs

Prepare a few NPCs that the characters might discover and will drive the game session and the adventure. Improvise others during the game. NPC outlines should be brief and include a name, connection to the adventure, and a character archetype.

Choose relevant monsters

Make a list of monsters the characters might encounter that make sense for the story, situation, and location of your game. Don’t tie these monsters to any specific location or situation. Instead, improvise encounters based on the story and situation during the game. For boss fights, remember to account for character capabilities without negating those capabilities.

Select magic item rewards

Players love magic items! Regularly ask the players what kinds of items they’d like to discover. Use that information to make a list of magic items that the characters might discover during your game. When it fits the story, drop an item into the game. You can also drop in random magic items for some variability. You can tie magic items to the story by connecting them to quests, secrets, or clues.

adventure.md

The Lazy Dungeon Master’s Checklist should easily fit on a single page. Here is a markdown template for your next session!

Roll for initiative!

## The Strong Start
Description of your strong start.
## Potential Scenes
- Description of your scene.
-
## Secrets and Clues
- Description of a secret or clue.
-
-
-
-
-
-
-
-
-
## Fantastic Locations
**Location**: aspect, aspect, aspect
**Location**: aspect, aspect, aspect
**Location**: aspect, aspect, aspect
## NPCs
**Name.** Description/Connection. *Character* from *X*.
**Name.** Description/Connection. *Character* from *X*.
**Name.** Description/Connection. *Character* from *X*.
## Monsters
- Name
-
## Magic Items
- Name/Description
-

Reply via email

Python Version Manager 101 (pyenv)

Mon, 28 Feb 2022 00:00:00 +0000

When you boot up a new machine, it will usually come preinstalled with a version of Python. You can verify this by running the following:

# This shows the version installed.
$ python -V
Python 2.7.18
# This shows the location of the installation.
$ which python
/usr/bin/python

That’s great, but do not use “System Python.” It came with your operating system because it is a dependency that should not be tampered with. Doing so could harm your system or the very least, cause you a lot of grief down the road.

You could work around this by manually installing other versions of Python, but that is hard to manage and can get messy fast, especially if you have multiple projects depending on different versions of Python.

Instead of dealing with all that, you might want to invest of few minutes setting up a Python Version Manager, in this case, pyenv, that will let you easily switch between multiple versions of Python.

If that sounds good to you, continue reading to learn how to install and use pyenv.

Installation

I’m not going to get super specific on the installation of pyenv because it depends on the machine you are working with. These instructions are what got me set up on my specific machine (M1 Mac using Zsh), so your mileage may vary. Here are the official instructions if these don’t work for you.

homebrew, the missing package manager for macOS.
pyenv, the python version manager.
pyenv-virtualenv, a virtualenv plugin for pyenv.

Dependencies

Before you can install pyenv, you need to install all its dependencies.

# Install Xcode Command Line Tools
xcode-select --install
# Install Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
echo 'export PATH=/opt/homebrew/bin:$PATH' >> ~/.zshrc
# Install Python build dependencies
brew install openssl readline sqlite3 xz zlib

Install `pyenv`

Now we can install pyenv using brew and configure your terminal to let pyenv dictate which version of Python you are using.

# Install pyenv
brew install pyenv pyenv-virtualenv
# Configure shell environment
echo 'eval "$(pyenv init --path)"' >> ~/.zshrc
echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.zshrc
echo 'if which pyenv-virtualenv-init > /dev/null; then eval "$(pyenv virtualenv-init -)"; fi' >> ~/.zprofile

You know you’ve set everything up correctly if you see the following:

# You've installed pyenv!
$ pyenv --version
pyenv 2.2.4
# pyenv put itself between your system and terminal!
# Notice that the installation path is different now.
$ which python
/Users/<user>/.pyenv/shims/python

Usage

With pyenv installed, we can do some powerful stuff!

Install pretty much whatever version of Python we want.
Create virtualenvs that act like separate Python installations.
Set the global, local, and shell versions of Python we want to use.

How It Works

By default, pyenv will use “System Python,” which as I mentioned we shouldn’t use, so we need to install other versions. When you install a new version of Python using pyenv, it stores them in its root directory (~/.pyenv).

After we install the versions of Python we want, we need to tell pyenv where and when we want to use each version by using the global, local, and shell commands.

When we use the global command, we are setting the global Python version. pyenv records this information in this file ~/.pyenv/version.
When we use the local command, we are setting the local application-specific Python version. This will apply to all its subdirectories as well! pyenv records this information by creating a file in the current directory called .python-version.
When we use the shell command, we are setting the shell-specific Python version. pyenv records this information by setting the $PYENV_VERSION environment variable.

So how does `pyenv` decide which version to use?

As we move between directories pyenv searches for the files and environment variable we set above and processes them in the following order:

$PYENV_VERSION. This version will be used if set.
.python-version. This version will be used if this file exists.
~/.pyenv/version. This version will be used if this file exists.
If none of these exist, it will use “System Python”.

What about virtualenvs?

Working with virtualenvs is extremely simple. All we have to do is use the virtualenv command and specify the version of Python we want to use. pyenv then creates the virtualenv it’s root directory which we can use with the global, local, and shell commands, just like the full Python installations!

And if you configured your shell correctly, you don’t even have to run any activate or deactivate commands, pyenv will handle that when you enter and leave directories.

Command Overview

Now that you have a basic understanding of how pyenv works, here is an overview of its available commands.

`install`

Install a Python version using python-build. pyenv builds each installation from source, so it could be a few seconds for this command to complete.

$ pyenv install 3.10.2

`uninstall`

Uninstall a specific Python version.

$ pyenv uninstall 3.10.2

`versions`

List all Python versions available to pyenv.

$ pyenv versions
system
* 3.10.2 (set by /Users/<user>/.pyenv/version)

Notice that there is a * indicating what is the active version of Python and it tells you how pyenv decided to use that version.

`global`

Set or show the global Python version.

$ pyenv global
system
$ pyenv global 3.10.2
$ pyenv global
3.10.2
$ python -V
Python 3.10.2

This will update the /Users/<user>/.pyenv/version file.

`local`

Set or show the local application-specific Python version.

$ pyenv local
pyenv: no local version configured for this directory
$ pyenv local 3.10.2
$ pyenv local
3.10.2
$ python -V
Python 3.10.2

This will create or update the .python-version file in the current directory.

`shell`

Set or show the shell-specific Python version.

$ pyenv shell
pyenv: no shell-specific version configured
$ pyenv shell 3.10.2
$ pyenv shell
3.10.2
$ python -V
Python 3.10.2

This will set the $PYENV_VERSION environment variable.

`virtualenv`

Creates a Python virtualenv in the pyenv root directory.

$ pyenv virtualenv [version] <name>

If no version number is given, the current active version will be used. You can name the virtualenv whatever you want, but it is best practice to name it the same as the relevant project.

`virtualenv-delete`

Uninstall a specific Python virtualenv.

$ pyenv virtualenv-delete <name>

`virtualenvs`

List all Python virtualenvs.

$ pyenv virtualenv project
$ pyenv virtualenvs
3.10.2/envs/project (created from /Users/<user>/.pyenv/versions/3.10.2)
project (created from /Users/<user>/.pyenv/versions/3.10.2)

You will see two entries per virutalenv (pyenv versions does the same thing). In this example, 3.10.2/envs/project is the actual virtualenv and project is a shorthand simlink to that folder.

Once a vitualenv is created, we can use it along with the global, local, and shell commands!

$ pyenv local project
$ pyenv local
project

Conclusion

I hope by reading this post you see how useful having a version manager like pyenv can be and were able to get up and running quickly. I know I sure have!

If you have any feedback, click the button below. I’d love to hear from you!

Reply via email

Immune Part 1: Meet Your Immune System

Wed, 23 Feb 2022 00:00:00 +0000

If you’d like to read the whole thing yourself and support the author, you can buy the book (not affiliated): https://sites.prh.com/immune

What is the Immune System?

3.5 billion years ago, cells figured out how to gather resources by leeching off of other cells. 541 million years ago, multicellular life formed and developed systems to defend against intruders. While we can’t directly analyze ancient immune systems, we can study it via the tree of life. The farther separated two creatures are on the tree and still share the same trait, the older the trait must generally be.

Modern animals are the height of the immune system development which at its core is a tool to distinguish the other from the self. While distinguishing the other from the self is the core, it is not the goal. Its overall goal is to achieve homeostasis, what we call health.

Ultimately the battle to stay healthy is futile and will be lost in the end, but our immune system fights to keep us going a little bit longer. Our immune system can also go wrong and be corrupted. When tricked, it can help spread diseases, protect cancer cells, cause allergies, and even get confused and deceive the body itself is the enemy. When too enthusiastic, it can cause unpleasant systems while it’s doing its job and can even cause death.

What Is There to Defend?

Immune cells are tasked with protecting the ~40 trillion cells in your body. Most threats are stopped by the skin, but intruders can still enter via your mucus membranes: windpipe, lungs, eyelids, mouth, nose, stomach, intestines, reproductive traces, and bladder.

What Are Your Cells?

Cells are the smallest units of life that we can clearly identify. Generally, something is alive if it separates itself from the universe around it, has a metabolism (intakes outside resources and expels inside garbage), responds to stimuli, grows, and can make more of itself. Cells are not conscious, have free will, or feelings. They are essentially biological robots. Cells have various “organs” inside them called organelles. These organs are surrounded by millions of molecules. Half of which are water molecules and other half consists of 1k-10k different kinds of proteins.

Proteins are the most fundamental organic building blocks and can be used for basically everything, from sending signals, constructing simple wall/structures to complex micromachines. Proteins are made from chains of amino acids (organic building blocks that come in 20 different varieties). A typical protein has 50-2000 amino acids (30k is largest known). There are billions of billions of possible proteins, but only 1-million to 1-billion useful ones. Your cells know which proteins to make thanks to the instructions on your DNA.

About 1% of your DNA is made up of building manuals for proteins. The rest is responsible for regulating which proteins are built when and how and how many of them at which time. Instructions on DNA are converted into proteins in a two-step process: 1. Special proteins read DNA and covers it into messenger molecules call mRNA (the language DNA uses to communicate orders). 2. The mRNA is then taken from the nucleus to the proteus production center called the ribosome. Here, mRNA is read and translated into amino acids that are put together in the order they arrived.

In the world of proteins, shape is everything. Their shapes determine what they can and can’t do. A proteins shape is determined by the amino acids it has and their sequence. As a protein is built, the chain folds together into a specific shape. Proteins work by interacting with each other in very complex ways. They move and interact by wiggling really fast. Because of their scale they behave very different compared to a human scale and can in theory move up to 5m/s if they were not surrounded by other molecules. This motion is called Brownian motion and is why water is so important for cells and leads to biological pathways.

Biological pathways is a fancy word to describe a series of interactions between individual things that lead to a change in a cell. A proteins specific shape enable them to fit together or interact with other proteins in specific ways. Sequences of these interactions, called pathways, cause cells to do things. An individual cell is pretty dump, but many cells working are pretty smart. The phenomenon occurs in many places in nature and is called emergence. It is the observation that the whole has properties and abilities that the parts do not have.

The Empires and Kingdoms of the Immune System

Your Immune System consists of two major realms: Innate and Adaptive Immunity.

Your Innate Immune System is ready to fight after birth, and can identify if an enemy is not self, but other. It does the down-and-dirty hand-to-hand combat, but it also determines what broad category your enemies fall in and how dangerous they are. And finally it has the power to activate your second line of defense:

Your Adaptive Immune System, which needs a few years before it is ready to deploy efficiently. It is specific and can draw from an incredibly large library to fight every possible individual enemy that nature can throw at it, with powerful super weapons. But while it is powerful, one of its most important jobs is to make the Innate Immune System even stronger.

Reply via email

What Am I?

Tue, 22 Feb 2022 00:00:00 +0000

I am someone who generally writes code using web-based technologies. What am I? This question has bugged me for years and I think I’ve finally come to a conclusion.

If you like spoilers, look at my home page or the conclusion below. If not, here is my breakdown. Keep in mind that there exists many more titles than I mention below, but I am just trying to focus on my field. This is also just based on what I’ve been exposed to and I am happy to be proven wrong.

So what am I? Let’s start at the beginning…

Programmer/Coder

I am 100% a programmer and a coder. Those two words essentially mean the same thing. I write programs with code.

While I think all other titles fall under this category, I do not consider it a job title. It’s just too generic to represent an occupation.

Software Engineer vs. Software Developer

Going a level deeper, we find Software Engineers and Software Developers. As far as I can tell, both of these mean the same thing, and the word “Software” is optional. These titles represent anyone who designs and creates systems to solve problems.

So I am a [Software] Engineer/Developer?

Web vs. Mobile vs. Desktop

Well, we can go another layer deeper and specialize in web, mobile, or desktop applications which produces these lovely titles:

Web [Software] Engineer/Developer
Mobile [Software] Engineer/Developer
Desktop [Software] Engineer/Developer

They all do the same thing, just in their respective specialization.

So am I any of these? Well yes, I primarily specialize in the web, but with tools like React Native, Expo, and Electron, those lines are beginning to blur.

Full-Stack vs. Backend vs. Frontend

Unfortunately, we can go yet another layer deeper and specialize in the frontend, backend, or even both layers of an application, thus producing even more titles:

Full-Stack [Web/Software] Engineer/Developer
Backend [Web/Software] Engineer/Developer
Frontend/UI [Web/Software] Engineer/Developer

These terms primarily get used in web environments (which is why I wrote “Web/Software”), but they could also apply to mobile and desktop.

This one is easy for me. I work across the entire stack, so I must be a Full-Stack [Web/Software] Engineer/Developer?

Okay, so what am I?

I am someone who designs and creates systems to solve problems on the web across both the frontend and backend. And thanks to cross-platform technologies, it has never been easier for me to take my web development skills and port them over to mobile and desktop environments. Based on this description, the best titles for me are:

Engineer
Developer
Software Engineer
Software Developer

All these titles encompass what I currently do and where my capabilities lie. I work across the stack, primarily in web environments, but depending on the technologies I could port those skills over to mobile and desktop. That said, I could see some ambiguity if I just used Engineer or Developer. So we are down to two:

Software Engineer
Software Developer

At this point, it just comes down to personal preference, so just because it sounds cooler…

I am a Software Engineer!

Here is a title breakdown:

- Programmer/Coder
+ [Software] Engineer/Developer
- Web [Software] Engineer/Developer
+ Full-Stack [Web/Software] Engineer/Developer
+ Backend [Web/Software] Engineer/Developer
+ Frontend/UI [Web/Software] Engineer/Developer
- Mobile [Software] Engineer/Developer
- Desktop [Software] Engineer/Developer

New Computer Who Dis?

Mon, 21 Feb 2022 00:00:00 +0000

Install

Command Line Tools

xcode-select --install

Oh My Zsh

sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Homebrew

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

pyenv
node (need to consider a package manager)

Applications

Reply via email

SWR 101 - React Hooks for Data Fetching

Fri, 10 Sep 2021 00:00:00 +0000

SWR is a fast, lightweight, and reusable data fetching package for React that uses the stale-while-revalidate caching strategy. By using this package, you can simplify and enhance your project’s data fetching logic.

Normally, data is fetched in a top level component using useEffect and passed down to its children using props. Additionally, logic must be added to handle errors and revalidation. This can lead to complicated and messy codebases, especially when data is needed throughout a large component tree. Enter, SWR.

npm install swr

import useSWR from 'swr';
const fetcher = (url) => fetch(url).then((r) => r.json());
function App() {
return (
<div>
<Welcome />
<Avatar />
</div>
);
}
function Welcome() {
const { data, error } = useSWR('/api/user', fetcher);
if (error) return <div>error</div>;
if (!data) return <div>loading</div>;
return <div>Welcome {data.name}!</div>;
}
function Avatar() {
const { data, error } = useSWR('/api/user', fetcher);
if (error) return <div>error</div>;
if (!data) return <div>loading</div>;
return <img src={data.avatar} alt={data.name} />;
}

In the example above, the useSWR(key, fetcher, options) hook returns data from cache (initially undefined), then sends a fetch request using fetcher (a custom fetch function that can use any library you want), and finally updates data and the cache from the response.

The amazing thing here is that data is independent of the component tree (parents don’t need to know anything or pass props) and because useSWR uses a key to fetch data, it avoids duplicate requests by sharing the cached data across all components (only 1 request is made). Not to mention that it handles errors and revalidation out of the box!

We can even make reusable hooks to make common fetch requests even easier to perform!

function useUser() {
const { data, error } = useSWR(`/api/user/`, fetcher);
return {
user: data,
isLoading: !error && !data,
isError: error,
};
}

SWR is a powerful package that simplifies and streamlines your data fetching logic. I’ve only touched on the core aspects of the package. For further reading, check out the links below.