Robin Sloan on platforms and the web:

And I suppose I think a standard for art is that it doesn’t just play a game, but invents one. On an internet crowded with creators eager to obey each platform’s demands, follow their Best Practices (which harden into mandatory genres: quick-setting concrete), there is, I believe, an incandescence to stubborn specificity.

... There’s one platform for which none of this is true, and that’s the web platform, because it offers the grain of a medium — book, movie, album — rather than the seduction of a casino.

Astute and eloquent as always.

Blogs and websites certainly have their own ecology and cookie-cutter shapes you can fit neatly into. And yet, at the same time, they don't. It's that fine control, the distance from metrics and algorithm juicing, the conductor with their back turned to the audience — all of this makes the act of web craft much more fulfilling in the end.

3D artist End Vertex released a video on For-Profit (Creative) Software last month. The whole video is worth your time if you've ever touched programs like Flash, ZBrush, or anything Adobe.

The style of the video itself is fascinating. It moves seamlessly between history of the web, SaaS pricing model critique, and full blown CG animated art piece. You have the sense of being in a conversation with the way the tone shifts between presentational and intentionally meandering.

There are a few takeaways:

This will be familiar to software folks: Avoid coupling with outside vendors. Favor Open Source where possible and decouple the implementation details enough to make migration less painful.

That's one thing for a codebase to handle. It's another for an individual artist to take into account, especially when industry standard software is an expected requirement for finding employment. Paying for software is good and we should do that. Being expected to pay enterprise level price points for individual accounts, though?

The salient message is to support Open Source projects and communities.

We live in a bonkers time. In the 90s, Bryce 3D would have run for $299. Photoshop for $895. Yet, today, you have terrific Open Source alternatives available for free thanks to the work of talented devs, volunteers, patrons, and advocates.

Every paid product that you are using is bolstered by numerous Open Source projects. Everything from ffmpeg to SQLite. Chances are that an app you are using is just a thin layer of custom logic on top of an iceberg of OSS. If you are using a computer to read this, you have benefited from the Open Source community.

So it's worth giving back when you can.

The first thought that comes to mind would be to do so through a pull request. That's great if you have the time! Many of us are busy, though. Contributing needs to be in the same lane as our own work for this to be sustainable.

It doesn't take being a developer to contribute, though. Docs need writing. Tutorials need creating. Projects need advocates and proud supporters. If you are a user of the software, you can proudly bang the drum and/or write guides for newcomers as End Vertex recommends.

And, of course, you can donate. Plenty of options abound, my personal favorites: KDE, Blender, and Internet Archive.

I love seeing this on a corporate level. Chad Whitacre spoke on Syntax about his time stewarding large donations towards Open Source projects. It's often times not a large some of money for the company donating, but makes a large difference for the maintainers receiving it.

There's no shortage of criticism around big tech. Even so, there are people and technologies that are looking to give. Help out when you can!

The bird out of the box!

I'm launching an app today!!

Go learn more here, where you'll find download links for iOS and Android!

Listen on Youtube

Didn't think I could pick that fast!!

Thanks to Let's Talk About Math Rock for the tabs and curated licks.

Been eating lots of these guys!

Listen on Youtube

"A new chapter to add, to a life of restarts."

Thanks to Let's Talk About Math Rock for the tabs and curated licks.

🌺🐝

Some folks are discouraged when readers barely spend any time with their full body of work.

Each individual message or piece, in my mind, isn't that important, though. It's the culmination and the practice that matters.

What I love when I see someone who writes regularly is that they are taking time to live more deeply.

That's a big benefit of writing in the first place. But it doesn't stop after a piece is done.

Consider what it takes to publish something, even in today's near instantaneous environment:

• Having an experience
• Forming a response
• Considering how to communicate that experience
• Editing (either a re-read or several rounds of massaging...or not!)
• Optionally, audience considerations (tailoring to a niche, or generalizing for a broad audience)
• Putting the work through the banal parts of your publishing platform.

This all takes much more time than it does to read the thing. At multiple points, there's an opportunity to relish in an idea or experience. Depth happens naturally, then.

As much as I would love to, I don't get to the bottom of every person's full archive. But the main influence has already had its impact — a spark has been lit by another flame shining brightly.

Listen on Youtube

Wild lick from the tune!

Thanks to Let's Talk About Math Rock for the tabs and curated licks.

A farewell to Dallas House. 👋

Andrew Bird wins the award for coolest person who has a Substack Newsletter.

Here he is writing in accompaniment to The Andrew Bird Jazz Trio – Live at the Green Mill:

For the last 20 years, I’ve tried to play my violin like a tenor sax. Instead of choppy articulation, I go for a fluid phrase that a lung full of air could create. The pressure of the bow on the string is like forcing air through the reed, pushing that threshold between a full tone and noise. Lester Young is my guy, as are Coleman Hawkins, Ben Webster, and Don Byas. I favored the 5-string violin while recording Sunday Morning Put-On, as it got me closer to that tenor sax sound. The low C string has the richness of a tenor, and you have to move more air to get it going, sometimes producing that skronk that is too strident on the higher strings.

Funnily enough, when I play sax, I often times have the sound of a violin in my head. Joshua Bell played on repeat for me as I studied phrasing and buoyancy.

This isn't uncommon. No matter the instrument, I've talked to musicians who have moments of trying to imitate another in their tone and timbre for certain moods. Euphoniums imitating a cellist, clarinetists imitating flutes, a sax section imitating electric guitar, etc.

It seems like Andrew Bird and I were both aiming for the same fluidity and warmth of sound, just with different reference points. Maybe there's a mystical instrument in the middle of the two, yet to be invented, that has the best of both.

I came across the need for the JS Proxy class today!

I'll borrow MDN's example to show how it works:

const target = {
  message1: "hello",
  message2: "everyone",
};

const handler = {
  get(target, prop, receiver) {
    return "world";
  },
};

const proxy = new Proxy(target, handler);

console.log(proxy.message1); // world
console.log(proxy.message2); // world

A few cool ways that you can use this:

1. Extend the functionality of a class instance's methods.
2. Adding an extra level of validation for your arguments.
3. Serving as an intermediary between your application code and package.

In our case, we needed to make calls to a specific client safely by handling errors in a specific way. I'll show an abstract of how it was handled below:

import {RedisClientType} from "redis";
import {callSafely} from "#utils/callWithTimeout";

export class RedisClientWrapper {
    private redisClient: RedisClientType;

    constructor(redisClient: RedisClientType) {
        this.redisClient = redisClient;

        return new Proxy(this, {
            get: (target, prop) => {
                const originalMethod = target.redisClient[prop as keyof RedisClientType];
                if (typeof originalMethod === "function") {
                    return (...args: any[]) =>
                        callSafely(
                            () => (originalMethod as Function).apply(target.redisClient, args),
                        );
                }
                return originalMethod;
            },
        });
    }
}

Here, I'm using the Proxy as the return from my class definition. The get method is an object-level get, not an individual method. So, anytime an instance of RedisClientWrapper uses a function or tries to access a property, it will go through the get method I've defined.

Once called, we'll check to see if the attribute is a function, and if so, call that function safely. Otherwise, we'll return the original value from the redisClient.

Then, to use it, we just wrap up our client with RedisClientWrapper:

const wrappedClient = new RedisClientWrapper(newClient);

wrappedClient.get(key) // Key retrieved safely!

Great tune!

Thanks to Let's Talk About Math Rock for the tabs and curated licks.