BAML seems really cool, in particular "structured action parsing" promises a clever way to always get structured output from any LLM. However, at this time in the LLM hype cycle, it feels too important to have direct access to model APIs without too much abstraction. What I want is structured action parsing, but with Zod types. Apart from avoiding the lock-in to the rest of the BAML ecosystem (prompt templates etc.), it gives me the flexibility to dynamically generate schemas to pass to the LLM (yes, I use this today). This doesn't feel too hard to accomplish given the details around how structured action parsing is implemented. Plus, the code is open source, under Apache 2.0, so this feels even more doable!

The Subway Therapy wall has made me think: what if you had a virtual sticky space that was localized to your subway stop, maybe even your train. Perhaps you could use it to post stickies, but also converse with a random stranger on the train (over some bluetooth mechanism). Bring the joy of serendipitous discovery to the real world.

My favorite hangout over the last few months has quickly become the cooking hangout - a group of people gather around in tiny New York apartments with their tiny New York kitchens where, inevitably, theres only space for one person to cook and the rest of us (some more than others) provide entertainment.

A fun variation on this that I want to try is to have each person bring in 3-5 ingredients (blind) and construct a 3 course meal from the resulting hodgepodge of items.

Getting large amounts of high-quality data for robot datasets is notoriously hard. What if a company formed around it with a very long horizon (5-10+ years) and did the following:

• Build a VR game so good and realistic that it makes VR really take off (or just wait for enough time for VR/ AR to get good enough and take off).
• This game has a sims like component that is you doing things around the house. You could imagine this being really cool with a vision pro like AR interface, but that feels like it’d have much worse privacy concerns.
• The data collected in this game is tailor made for training robot policies across a wide variety of settings

Are you tired of seeing a feature flag definition in code, and having no idea what branch is actually being taken in prod? Now you have to shudders context switch to a browser, go to LaunchDarkly, and figure out what this fucking flag is set to. Never again. With the “Magic String LSP” (MSLSp for short) your LSP pulls strings from a wide array of sources, defines a presentation layer for all of them, and shows them on hover. So the next time you see:

const importantBranchThatShouldNotBeTaken = LaunchDarkly.getFlagValue('myFlagThatsBeenRolledOutFor18Years')

or

terraform_module {
    env_variable = important_tf_output_from_a_stack_far_far_away.output
}

you won’t have to context switch again.

Update: OpenCtx does this! Or at least, it has a generic abstraction layer that you can do this with. It is open source, but why didn’t they just hook into LSPs?

Traces have a perpetual problem of being unbelievably useful but extremely expensive because of how many of them can be generated. What if instead of solving this problem by sampling fewer, more interesting traces, you worked on improving the data representation of traces?

In particular, traces today are generic JSON blobs in OpenTelemetry. What if you thought of trace data as a denormalized store where one part is your source code at a particular version, and your traces are short, compact binary formats that point to specific parts of that source code. My intuition is that you could store a much larger number of traces, and perhaps have more efficient queries across them as well. This mainly works if you just want timing information, and don’t care as much about what arguments were passed in. In that case you could store a span with just a few bytes in the following way:

• 2 bytes for the code location - this gives you 65336 places that you can trace in code.
• 4 bytes for timing information - specifically the time it took to run that portion of the trace.
• 4 bytes for a global trace ID, 2 bytes for a trace counter.

With just 12 bytes, you can get a full description of what happened, in what order, and how long it took without storing and processing blobs of JSON all over the place. This could also make tail sampling these traces easier since you can hold more of them in memory.

The Power Broker is one of the greatest books I’ve ever read. This experience is only accentuated by living in New York City and feeling the impact of that one man’s obsession with power many decades later. There should be an interactive app that walks through some of the more incredulous pieces of his history through a curated tour around the city. Some notable visits could be:

• Worlds Fair
• Lincoln Center
• UN building/ Stuytown and Peter cooper village
• The Cross-Bronx Expressway, East Tremont and Crotona
• Jones Beach
• The highways of Long Island that curve around the robber barrons estates
• Nelson Rockefeller and the Rock
• Empire State Building and Al Smith
• Tamanny Hall
• Central Park Zoo
• Delacorte Theater and Shakespeare in the park
• Riverside highway and the Columbia Boat situation
• Randall’s island and the Triborough
• BQE entrance and how highways destroy a neighborhood
• Manhattantown and the creation of slumlords

I really want to get a Work In Progress/ On Air neon sign outside my room, but I hate the fact that the sign is visible even when I’m not working. What I really want is a sign that becomes completely invisible when I’m not working. Maybe this is possible with mirrors, some mechanical magic, or some material magic?