Mark Tomczak @mtomczak@qoto.org

There is something shabby-luxurious about traveling by Amtrak along the Eastern US that is incredibly endearing to me. Just the whole vibe of "Yes, we know it looks nothing like the brochure, but damnit we're trying."

And given the option of flying somewhere or taking the train somewhere, if the difference in travel time is a matter of a few hours, I'll take the train every time. Planes are too distracting, and the tray table is way too small. Besides, 50/50 odds that for the price of a coach plane ticket, I get an entire roomette to myself.

I get so much code written on a train.

#riptwitter

The list of things that have gone wrong at Twitter is, well, extensive. But the simplest one happened at the very start, was exacerbated by Musk's subsequent communication, and was extremely, IMHO, predictable.

So, let's talk about the difference between startups and established tech companies.

I worked at a startup as my first job out of college. Put five years in. It was an amazing experience and I was truly fortunate to have it; I was thrown into the deep end, learned things about software architecture that would serve me well throughout my whole career, and wouldn't trade it for anything.

I also:

* broke off a date with my future wife because I was the only one of three team members who could make a demo work for the next day. We pulled an all-nighter.

* became well-familiar with the biker gang that pulled up to the bar across the street from our office every Saturday night; could set my clock by them arriving. Did often, on account of all the seven-day weeks.

* got the sickest I'd ever been, out three weeks. Week two, my CEO calls and checks to see if there's any duty I could take on because we had no other hands to do it. I wrote some user-facing documentation. Three months later, someone caught all the obvious typos and asked "What idiot wrote this?" I dead-panned that I think I missed some issues on account of all the vivid hallucinations.

* had a conversation with my doctor about the indigestion that was waking me up at night. He suggested I relieve stress. I responded "I work at a startup, so what are the options that don't require a career change?"

And eventually, I left because I was ready to stop living like that.

Here's the thing: there is *so much* of the software dev ecosystem where you don't *live* like that. You live like that because you're working on something you're willing to sacrifice yourself for it (I'm not talking about being passionate about the work---you can be passionate and have a work-life balance---I'm talking actual sacrifice; things you won't get back) or you are expecting a *huge* payout relative to the invested effort. If those ingredients aren't there? You don't take that gig. And companies that aren't willing to offer that payout or the kind of we-are-here-to-change-the-world opportunity don't get those employees.

Twitter was once such a startup. It's not anymore. It went public. Once a company goes public, it's no longer a startup; it's a place people who want a reliable paycheck and a reasonable work-life balance go to work. At Google, we were counseled to have a "startup mentality" by leadership, and people certainly tried to give it their all, but... You just don't work like you're at a startup at a 100,000-person company. You can't. The buy-in isn't there. It does you no good to pull seven-day weeks when the database team you're relying upon works five-day weeks, holds all the credentials to modify the DB, and just won't answer their email on a Saturday. What's the point then? Go home, love your spouse, work on your house, hike in the park, touch grass.

Musk tried something I don't think I've seen before: he tried taking a company that "won the game," as it were, and *roll it back to a startup.* He took a place people had a stable job making a product people use and tried to make it a place where the future was uncertain again. And then he confirmed that, yes, he *was* expecting those employees to work seven-day weeks to realize a vision... A vision he didn't even enunciate.

Twitter was a place steady hands were working to maintain a mature product for a reliable paycheck. A mass exodus is entirely expected. I don't know why *he* didn't expect it.

(... `"withheld_in_countries": ["DE", "FR"]`)

I'll miss a few things about Twitter.

Mostly the fact that with a little sleuthing, you could find on every account which ones Twitter believed were Nazis or Nazi-adjacent. Because for German legal compliance reasons, they had to filter those accounts for German users, so there was a little metadata you could fetch via the API that told you if a given tweet or entire account was Germany-noncompliant.

#frc

Control system theory is frustrating because the nomenclature is all over the map.

Sometimes you get a formula where the inventors named the important tuning parameters, which you need to understand to make the formula work, "B" and "Zeta."

And then you get the *coolest* names for relatively mundane concepts, like "control authority." "Control authority" sounds like what an anime character uses to control their magic servant, not the idea that you can't force a motor to do more if it's already doing as much as it can.

When you get into #TypeScript and realize JavaScript classes are so... Weak.

https://youtu.be/I2ExecDUcZs?t=4422

#MatrixAlgebra

Okay, so I figured this part out: a matrix multiplied by its transposition is a covariance matrix. By which I mean: the higher the value in a given (row, col), the more data in those axes were correlated.

https://en.wikipedia.org/wiki/Covariance_matrix

To simplify, consider a 3x3 matrix `A` and multiply `A` by `transpose(A)`.

What each cell of the result is telling you is how likely it is that when you change the value on the row axis, the value on the column axis changes the same way. So the diagonal will always be large, because data on an axis will always correlate with itself (i.e. when you change the value of `x`, the value of `x` changes in *exactly* the same way, `x*x = x^2`), but cell 0,2, for example, tells you how much changing x causes z to change the same way (if it's the same value as cell 0,0, then the points lie on a diagonal in the xz-plane: changing `x` causes the exact same change in `z`).

I still need to cogitate a bit on why the eigenvector with the largest eigenvalue of this matrix is the axis along which the data has the highest variance in the original coordinate space.

Hey lazymastodon, I have a linear algebra question.

So I've been thinking a bit about principle component analysis as of late. The way to find the vector of most variance in a multidimensional dataset is to put every datapoint in a column matrix, multiply that matrix by its transpose, and find the eigenvectors of the resulting square matrix.

Here's my question: I don't have a good intuition for what "multiply the matrix by its transpose" is doing. That compares every point to every other point by multiplying the same-dimension components together and summing the result across dimensions, but like... Why does that result in an interesting matrix instead of a pile of noise?

Election day in the US.

It's indicative I think of the modern nature of social interaction that I meet more of my geographic neighbors working the polls than I do any other day of the year.

They're all fine and lovely people, but we spend our lives living next to each other and commuting to thousands of different places to spend most of our waking time.

Oop, looks like I've been out of the C++ game for long enough that I forgot some fundamentals. ;)

CoderPad does support `unique_ptr`; you have to `#include <memory>` to pull it in because C++'s std lib is carved up into a bunch of smaller headers.

It's been awhile!

Anyone familiar with the CoderPad environment:

Is there anything special one must do to access `std::unique_ptr`? I'd expect that to be available but it seems to be missing from their C++ environment.

Hypothetically speaking, I can see no obvious reason copyright law cannot be extended to exclude from "fair use" the injection of images into a machine learning engine without consent of the copyright owner of the image.

This will need to be done carefully, because if the goal is to throw a wrench into Stable Diffusion and its siblings, that wrench can easily ping-pong into e.g. banning Google from creating ContentID fingerprints to protect artists from copyright abuse. Some specific dimensions to pin down:

- what is a machine learning engine?

- what does it mean to train one on an artist's work?

- what does 'consent' look like? How explicit must it be?

Implementation will be messy but it's always messy; this is copyright, there's no other kind of implementation of copyright. "...other nations have thought that these monopolies produce more embarrassment than advantage to society" (Thomas Jefferson). But it may be a good idea if we have no alternative that protects the livelihoods of artists in a world where everyone is now a mediocre visual artist.

... And, of course, US copyright law has no bearing on China's law. Nor Russia. Nor dozens of other countries. So we would have to be prepared for our entertainment industries paying top-dollar for human labor competing on the international stage with a sea of mediocre artists that cost electrons and little else.

When you want to update a LaTeX document with some information provided on the command line.

https://blog.fixermark.com/posts/2022/latex-content-from-command-line/

General #GraphQL thought:

I fear the possibility GraphQL is a trap. I think, in principle, it's a good idea. In practice, I'm concerned that pretending one can offer a pretty flat access to the underlying data in a backend store ignores some irreducible complexity in the question of data storage and retrieval.

How easy is it, in general, to build a GraphQL query that is expensive to answer because it skips all the indexes the backing database supports? I don't know; I've only worked with one or two GraphQL APIs. But one advantage to REST and RPC is that since you have to be intentional about creating new procedures or new resources, you have to be intentional about creating indexes.

Can modern DB engines compute those indexes based on usage patterns or is it still a very manual process?