I’d say by and large, playing this game has helped. It didn’t knock down my productivity too much. Also, I really think Zygarde is a Digimon. I believe this so strongly that I made a silly little graphic to explain.

I’m a biased Pokémon stan and really loved Scarlet & Violet (SV) despite the performance issues. Legends Arceus (PLA) was really fun, but felt a little hollow. Hisui had this sense of scale, but the design was just so plain and repetitive. ZA suffers from that a little bit as well, with little variation between buildings and streets. It’s often hard to orient yourself to your location. It’s a little disappointing given that the game takes place in a single city, and it would make a lot of sense to see some variation. PLA had different weather and topography that served it well. You don’t really feel this in ZA until you go to the sewers a little over halfway through the game.

On a more positive note, the graphical fidelity and performance are great on my OG Switch. The battle transitions are seamless, and the moves look great. There really doesn’t feel like much of a difference between the overworld and battles. I do miss the transition into battles that PLA had, but it fit the game’s vibe. The real-time combat is fantastic.

The new mega evolutions are absurd and fun like they’ve always been.

I wasn’t too invested in the story, which was an issue I had with the original Kalos region offerings. This region really seems like vibes first story second. I’m curious about how a return to Unova will feel. Those games were my favorites. How can you not think Haxorus is the coolest Pokémon ever?

I’ve still got a little way to go as far as beating it. I completed the wild zones, but not all the research requests. I think I might actually have to interact with another person to do a bunch of trade evolutions. First-world problem meets GameFreak removing a feature (think link cable evolution item in PLA) between releases.

This game improves on both Scarlet & Violet and Legends: Arceus, refining their core innovations. GameFreak has faced more scrutiny and fan criticism (mostly deserved) because of how these games look and the little change between them. I’ve come to terms with the slow pace of progress between releases. That’s definitely not the ideal way to review stuff, but between Pokémon games and Marvel Cinematic Universe movies, I’m less critical than most. They bring me joy and don’t insult my intelligence. Anyway, I think if you’ve ever enjoyed a Pokémon game, you’ll like this one. If you’re over 10, this won’t tip the scales in my opinion.

Maybe I’ll start reviewing things and posting them here. I should probably finish whichever of Brilliant Diamond or Shining Pearl I own.

Playing Pokémon Legends ZA was originally published in Desert Thunder on Medium, where people are continuing the conversation by highlighting and responding to this story.

I have also learned Rust is a harder language to pick up than Dart, and in order to really learn Rust, I have to slow down and use the resources available to me. The way I learned Go was by doing things I’d usually do in Python with a small go script. My approach these days is to “read the manual” and then get started. This has been helpful for understanding concepts around Rust’s ownership system (you can read my notes here). Over time I’m going through each chapter of the Rust book (print or online) and taking detailed notes for my digital garden. Hopefully they can help you review the material if its hard to grasp or remember. All of that aside, my point is that Rust requires that I slow down a little bit and build smaller projects while continuing to build features for my main projects. I’m working on a small CLI using the clap package. It’s like being a junior engineer again. I would power through tasks during the day and in the evenings try to get a deeper understanding of what was asked of me.

I find Dart to be way easier. Rust is interesting but I’m not having fun quite yet. This is likely due to Dart’s familiarity and flexibility. It shares a lot with languages used commonly in application development, like ES5 JavaScript and Java.

Plus the developer experience for Flutter is fantastic. I really appreciate the hot reload and ability to easily test my application on both platforms. Sure, you can quickly whip up features in a web app, but there’s something magical about seeing an app hot reload on your phone or in an iOS simulator. I’ve been using the material widgets for Soulbloom, and they take a lot of the overhead out of the process of writing client side code.

Learning React was similar for me. I started learning modern web development in earnest after I felt that I had a firm grasp of JavaScript. State machine patterns were brand new and difficult to wrap my head around. “UI as a function of state¹” is the key pattern that was being discussed and taught as the ecosystem moved away from lifecycle methods into hooks.

Designing an application and mapping out the state is challenging. Elm’s usage of messages² to describe the way an action (sort of like redux action types³) mutates state is great for building mental models. Iced uses the Elm architecture, which has been great for conceptualizing and writing my application. The limiting factor remains my knowledge of Rust.

As I continue to build and learn, I want to express more gratitude towards Blake Watson. He has a phenomenal post about finishing side projects. You should give it a read if you struggle to finish your projects.

1: https://docs.flutter.dev/app-architecture/concepts#ui-is-a-function-of-immutable-state
2: https://guide.elm-lang.org/architecture/
3: https://redux.js.org/tutorials/fundamentals/part-2-concepts-data-flow#actions

Please Clap was originally published in Desert Thunder on Medium, where people are continuing the conversation by highlighting and responding to this story.

Building a Start Page

Here is a snippet from the main script for the page/app:

So here I use JSDoc types because I didn’t feel like dealing with TypeScript today. The point of Alpine is to make interactivity simple, and all I was building was a web page with a few columns of links (I was inspired by this¹) and a pleasing color scheme². I took this hardcoded array of links and rendered them using the x-for directive. An easy way to iterate.

The slightly more challenging aspect of interactivity for me was using the $store magic. Basically I wanted the sidebar visibility to be available globally and spent a long time figuring out why I couldn’t get it to work. It was because you define the initial value of that particular slice with a value, not a function. This, and the dark mode toggle with a little bit of animation are so common in web apps nowadays and its nice that you can just whip it up with a few lines of code.

The sidebar is polished with a few directives added to the markup:

The defaults were enough for my purposes. The documentation wisely provides some tailwind specific³ examples. My favorite thing about tailwind is the LSP. Autocomplete with icon sets is a godsend. Especially with Remix Icon. You can quickly leverage variants of an icon. Here’s how I do hover states with some icons:

Though more often than not, I want colors to change when an icon is in a button so it’ll look like this:

If not for the LSP, I’d likely have these saved as snippets. I had a lot of fun
just playing around with markup today.

Home Cooked Software

This was all inspired by a rabbit hole that Blake sent me on[⁴]. I didn’t know
what a home cooked app was but I like the sentiment. Cooking is a true labor of love and I hope I can provide more joy and show love to people with my work. I’m staring at monospaced fonts all day, may as well bring some warmth to someone’s soul instead of my eye sockets.

Local first software⁵, written extensively about by Martin Kleppman (author of Designing Data Intensive Applications), had a talk⁶ at their Berlin conference last year about Home Cooked Software and the concept
of a barefoot engineers. The central purpose of the talk was to describe the tech savvy programming adjacent person’s new power with tools like v0, ChatGPT, and TLDraw. You probably know a person who doesn’t code but
builds the coolest spreadsheets and probably sells notion templates on gumroad. Sometimes they do learn to code but maybe they don’t have to in order to make cool stuff.

This doesn’t really pertain to me. I’m not an amazing engineer. I just do it
for the love of the game⁷ and can’t use AI autocomplete or AI generated code without getting upset. Robin Sloan’s notes are more in line with how I’d approach this. The key here is really knowing your users. In his notes, one of them is his mother. As I’ve worked on my company’s projects, the best feedback I’ve gotten is from my friends who I know would use my stuff. I’d like for my relationship with users and my community to be a little like that mixed with a cult following (the John Green kind). I feel a lot of joy knowing when someone finds value in my work and it’s a high I chase quite relentlessly.

Thanks for reading.

1: <https://afinestart.me/> by Blake Watson who I discovered googling about some of Alpine’s directives.
2: <https://rosepinetheme.com/> Rosé Pine is one of my favorite colorschemes
3: <https://alpinejs.dev/directives/transition>
4: <https://blakewatson.com/journal/alpinejs-for-home-cooked-apps/>
5: <https://localfirstweb.dev/> For my money, this is *real* serverless work.
There’s an entire company that recreated Postgres in WASM. How cool is that?
6: <https://maggieappleton.com/home-cooked-software> Maggie Appleton (who runs the Digital Garden awesome) on Github.
7: Okay not exactly true. I love programming but I would like to contribute
to an organization and collaborate with a team again. Email me if you’re hiring or want to collaborate!

Need More Time was originally published in Desert Thunder on Medium, where people are continuing the conversation by highlighting and responding to this story.

What happened in November? Nothing major. I had interviewed with quite a few places and gotten to later rounds of the interview process but found myself getting rejected over and over and I think I just snapped. It didn’t help that my situation didn’t change and with the approaching holidays, the job market would likely slow down. I started to feel desperate and all I could think to do was try to accept my situation. I’m an engineer. Acceptance is not an innate skill I have. Everything is a problem to be solved. So I went to good old Google, which is actually just me usually searching for “best books on whatever reddit.” This led me to mental health and mindfulness subreddit posts about acceptance and surrender and eventually grabbing a copy of Michael A. Singer’s book.

I can’t express how helpful his story has been for my psyche. He has had such a unique set of life experiences, all book-ended by challenging situations in which he chose to accept his circumstances, surrender, and go with the flow. He made it through writing a thesis and a lawsuit successfully! It seemed like magic. All he said was to surrender to the experience and let yourself experience the feelings that come up. He demonstrates something Tara Brach mentions in Radical Acceptance too. Acceptance isn’t about doing nothing. You still take action, but the context surrounding it is what changes².

The experience that Singer describes of himself surrendering before writing is one my dad experienced when he first came to the states. Both of these nerds surrendered and allowed their minds to digest and synthesize information. You never know what you’ll find, and you can’t force your mind to operate the way you want it too with conscious will. This is the approach to writing these posts and my code that I feel I must take. When I am able to surrender I’m able to produce more work. Whether or not is useful or of any quality remains to be seen³. While powering through iced, I started writing a book in the repo. It felt like an idea that came out of nowhere but it feels right. The library is cool but it’s documentation is famously⁴ lacking, so why not just make something myself?

Thanks for reading.

[1]: I’ll have to post my notes about the book on my digital garden.
[2]: This seems like a central theme of the FX adaptation of Shogun. I should give the book a read. The show comes with the highest recommendation from me.
[3]: Does it even matter? I mean, have you seen some of these HR and ATS tools? If that seems petty, it is.
[4]: I want to add that I mean no disrespect to the developer. Iced is incredible and its important to focus on what you feel is right. The library is good and he’s honest about the docs so what more can you ask for?

This was originally posted on my website.

Slowing Down was originally published in Desert Thunder on Medium, where people are continuing the conversation by highlighting and responding to this story.

Source Code

Check out the async python demo repo here to play around with tasks, queues, httpx, and the MLB stats API.

Overview

Asynchronous programming is the process of writing code that includes events that occur independently of the main flow of the program. So a process will begin, but the interpreter will continue to execute the next steps of the program. This allows us to do multiple things at the same time. In contrast, synchronous code is executed sequentially, or a single step at a time. Each statement is executed and the computation completed before moving on to the next. It is often easy to think of the functions that are being executed like an algebraic function, in which each operation/computation occurs in a predictable order. In other words, if we imagine each operation as a task, they are performed one at a time, with one finishing completely before another the next. If they’re always performed in the same order, the implementation of later tasks can assume that previous tasks finished error-free.

Multi-Threaded Model

Another model for task execution, is the multi-threaded model. each task is performed in a separate thread of control, managed by the operating system kernel. On systems with multiple processors or multiple cores, run truly concurrently. This is commonly referred to as preemptive multitasking.1

Cooperative Multitasking & GIL

In the async model, tasks execution order is interleaved with one another in a single thread. This is simpler than the threaded case because the programmer always knows that when one task is executing, another task is not. It is called cooperative multitasking. We’ll discuss the implications of that later. For now, know that this makes an async thread subject to the Global Interpreter Lock (GIL). This is a mutex that ensures that there are no race conditions2 . The work around for that to create multiple threads is a multithreading library.

Asynchronous programming is relevant for processes/tasks dependent on computer resources outside the CPU. For example, HTTP resources require accessing the network and opening and closing files require disk access. Synchronous statements calls are called blocking (blocking calls), because they must be executed before the next statement runs.3

Demo

Here are some simple examples that ostensibly do the same things. We create a queue (remember, FIFO — first in first out), that contains tasks (simple operations), and then we iterate through the queue and execute the tasks. I’ve wrapped these in a simple click CLI. See the README in the associated repo for instructions on installation.

In the sync function, we create a queue and run a blocking worker function that processes tasks from the queue. We do this by using the standard library threading module and queue module, where each task is a simple pause using time.sleep(1) to simulate a blocking operation. This demonstrates how a blocking worker running in a single thread processes tasks sequentially.

In the async function, we create an asyncio queue and run a non-blocking worker function that processes tasks from the queue. In this case, we have two workers running concurrently, processing tasks from the queue. We're using a single-threaded event loop to run the workers concurrently. This demonstrates how non-blocking workers can run concurrently in a single thread while using the asyncio module. asyncio's sleep function is used to simulate the time it may take to complete an operation like I/O-bound tasks or network requests. This is referred to as cooperative multitasking4, where the event loop continues execution while the task waits for whatever resource it needs. Another example of this is done via python generators, which use yield (the task yields control to the loop).

HTTP Requests

HTTPx is a library that gives us both an async and synchronous interface. This can provide us with a good way to demonstrate the differences between two ways to write concurrent code when the tasks are not CPU-bound. Usually you’ll see simple synchronous requests in python code executed by the requests package. The key differences in the synchronous case are the extensibility of the httpx Client object, and support for http/2. In the demo application (see cli/http.py), you can compare the time to synchronously fetch the JSON data for all 30 MLB teams versus running the tasks concurrently using the AsyncClient class from httpx.

HTTP/1.1 vs HTTP/2

The differences between http/1.1 and http/2, which come down to four major points: content prioritization, multiplexing, server push, and header compression5. Multiplexing does a lot to enhance the efficiency for developers, as it is a feature allow for a single tcp connection to be maintained between the server and client, where the client opens up multiple streams to fetch data. Server push lets the server send data to the client after sending a message detailing what content is coming. Header compression compresses redundant http header information using HPACK. When multiple requests are made, the small decreases in packet size can add up to decrease latency. Content prioritization on the other hand has more to do with web pages, as it allows the client to choose which content is loaded first (between static files like CSS or JavaScript).

Which Concurrency Model Wins?

A common myth is that async python code is faster than synchronous due to concurrency. As mentioned previously, this is cooperative multitasking in a single thread. Because it is cooperative, threads don’t have CPU distributed evenly, as execution has to be relinquished by the task itself instead of interrupted by a governor like the operating system kernel. Cal Peterson demonstrates this when benchmarking synchronous and asynchronous servers6 He notes that async servers don’t need as many workers because they can use a single CPU. It’s the latency caused by the yielding of a task that slows them down. He notes that throughput is determined by the amount of python replaced by native code.

Further Reading

1. Async Python from Hackernoon (link)

2. 500 Lines or Less: A Web Crawler with Asyncio Coroutines (link)

3. Structured Concurrency, used by an alternative to asyncio, Trio. The pattern here is called the “nursery pattern,” in which threads have clear entry and exit points and are encapsulated in constructs called nurseries. These ensure that the execution of the thread has completed before the process exits.

Images of code from carbon.

1 Fonseca, R. (2012). Async Programming [Class handout]. Brown University, CSCI 1680.

2 “The Python GIL (Global Interpreter Lock) • Python Land Tutorial.” _Python Land_, 18 Dec. 2021, https://python.land/python-concurrency/the-python-gil.

3 Grinberg, Miguel. Sync vs. Async Python: What Is the Difference? https://blog.miguelgrinberg.com/post/sync-vs-async-python-what-is-the-difference. Accessed 24 Nov. 2024.

4 “Cooperative Multitasking.” Wikipedia, 31 Jan. 2024. Wikipedia, https://en.wikipedia.org/w/index.php?title=Cooperative_multitasking&oldid=1201426758.

5 “HTTP/2 vs. HTTP/1.1.” Cloudflare.com, 2015, www.cloudflare.com/learning/performance/http2-vs-http1.1/.

6 “Async Python Is Not Faster.” Calpaterson.Com, 11 June 2020, https://calpaterson.com/async-python-is-not-faster.html.

7 Design and Internals — Trio 0.27.0+dev Documentation. https://trio.readthedocs.io/en/latest/design.html#cancel-points-and-schedule-points. Accessed 24 Nov. 2024.

Asynchronous Python was originally published in Desert Thunder on Medium, where people are continuing the conversation by highlighting and responding to this story.