Converts code into generated music on-the-fly. There’s a sub-genre of electronic music that uses programming tools at live shows where the musician grows the program by writing and reinterpreting code as the audience watches and listens.

Examples:

• Overtone uses Clojure and SuperCollider for live coding music

Plain text is the lingua franca for storing information that is simultaneously readable and writeable by computers and humans. It can even be converted to physical form and encoded back to digital form with no loss. Plain text file formats are unlikely to go away.

Plain text ceases to be portable when the grammar needed to parse the content is unstable. This is true in both spoken languages and computer interpretation. For example, markdown is stored in plain text, but can’t always be reliably interpreted for formatting because there are variations in the grammar.

See also:

• EBNF grammars could make plain text storage more universal

A blog post is the synthesis of multiple ideas communicated to an audience where as writing a note is the act of collecting an idea written for yourself. This makes it substantially easier to do and why most people take notes, but don’t write blog posts.

See also:

• note blogging
• notes clarify understanding

A blog of working notes that others can read and follow along with to learn about interesting ideas and things you are coming across. I find it easier to keep up due to my note taking practice especially compared to writing full-length blog posts or tweets. It would be interesting to follow along notes of other people to learn about new things.

This site is an example of note blogging that also supports RSS so people can follow along.

Besides the usefulness of building a Zettelkasten for myself, publishing notes is a friend catcher. Interesting people reach out to me to discuss my notes or the process of publishing them.

A company can use time horizons as a competitive advantage by being willing to wait longer for returns on investment than competitors. The set of ideas possible with a longer time horizon is inclusive of the set of ideas in shorter time horizon, but also includes more ideas that are not available in the shorter. Assuming some of those ideas are fruitful, there is a fundamental advantage to having a longer time horizon than the competition.

This is an argument for keeping companies private for longer so they don’t need to operate in lockstep with the market’s quarterly earnings reports.

See also:

• Heirlooms foster long term thinking. While written about shared resources, this also applies to hypothetical companies aiming to operate for a long time.

A model of computation where there is exactly one state at a time of a fixed number states. The current state can be changed by transitioning to another. Using state machines has the benefit of 1) being easy to reason about what the program does e.g. security audit and 2) making obvious what a valid state is so the programmer doesn’t accidentally put into a ‘bad’ state i.e. reduce bugs.

Example applications:

• Modeling authentication flows using a deterministic state machine to prove it can not be exploited
• Modeling a user interface that has several modes to prevent bugs where a user gets stuck in an unrecoverable state

The following example uses rustlang’s type system to model a finite state machine where transitions can be passed additional typed arguments:

pub struct StateMachine<T> {
    pub state: T
}

pub struct StateMachineWithArgs<T> {
    pub state: T,
}

pub trait TransitionFrom<T, R> {
    fn transition_from(state: T, args: R) -> Self;
}

pub trait State {
    type Args;
    fn new(args: Self::Args) -> Self;
}

impl<T> StateMachineWithArgs<T> where T: State {
    pub fn new(state: T) -> Self {
        StateMachineWithArgs { state }
    }
}

struct StateOne;
impl State for StateOne {
    type Args = ();

    fn new(args: Self::Args) -> Self {
        Self {}
    }
}

struct StateTwo;
impl State for StateTwo {
    type Args = ();

    fn new(args: Self::Args) -> Self {
        Self {}
    }
}

struct StateThree;
impl State for StateThree {
    type Args = ();

    fn new(args: Self::Args) -> Self {
        Self {}
    }
}

// Implement state transitions by implementing the TransitionFrom trait.
// Doing this enforces only known transitions at compile time i.e.
// you get a compile time error that two states can't be transitioned to

impl TransitionFrom<StateMachineWithArgs<StateOne>, ()> for StateMachineWithArgs<StateTwo> {
    fn transition_from(state: StateMachineWithArgs<StateOne>, args: ()) -> StateMachineWithArgs<StateTwo> {
        StateMachineWithArgs::new(StateTwo::new(args))
    }
}

impl TransitionFrom<StateMachineWithArgs<StateTwo>, ()> for StateMachineWithArgs<StateThree> {
    fn transition_from(state: StateMachineWithArgs<StateTwo>, args: ()) -> StateMachineWithArgs<StateThree> {
        StateMachineWithArgs::new(StateThree::new(args))
    }
}

mod test_state_machine {
    use super::*;

    #[test]
    fn it_works() {
        // Initialize the state machine starting with the first state
        let state_one = StateMachineWithArgs::new(StateOne::new(()));

        // Transition to the next state
        let state_two = StateMachineWithArgs::<StateTwo>::transition_from(state_one, ());

        // This won't compile because it's not a valid transition!
        StateMachineWithArgs::<StateThree>::transition_from(state_one, ());
    }
}

In python with typing:

import typing as t
from functools import singledispatch
from dataclasses import dataclass


@dataclass
class State1():
    check_me: bool

class State2():
    pass

class State3():
    pass

class State4():
    pass

State = t.Union[
    State1,
    State2,
    State3,
    State4,
]

@singledispatch
def transition(state: State) -> t.Optional[State]:
    pass

@transition.register
def state1_to_state2(state: State1) -> t.Optional[t.Union[State2, State3]]:
    if state.check_me:
        return State2()
    return State3()

@transition.register
def state2_to_state3(state: State2) -> t.Optional[State3]:
    return State3()

@transition.register
def state3_to_state4(state: State3) -> t.Optional[State4]:
    return State4()

# Run the state machine to completion

transition(transition(transition(State1(check_me=True))))
transition(transition(State1(check_me=False)))

Leaving notes in a way that takes advantage of our innate relationship with space and context. For example: leaving a post-it note on the door for the next time you head out to remind yourself to buy something you need. This spatial context relationship can be applied to our digital lives as well. Notes that live alongside emails are a much better cue than remembering to check your note-taking app for todos related to the person you are talking to or the email thread.

See also:

• Hyperfine village organizes ideas spatially
• Our digital lives are siloed

80% of the effects come from 20% of the causes. This distribution seems to repeat in many problem spaces where there is an imbalance between the inputs and outputs.

Most elements of our digital lives (e.g. apps) only exist within themselves and seldom work together. Because workflows are more useful than point solutions that leaves users with the burden of getting things to work together, humans are the interop layer.

For example, a hypothetical product like a spatial note-taking app would require that participation across email, browsers, and even the operating system. However, this is extremely unlikely to be done well because interoperability is stunted due to lack of monetary incentives for cooperation between apps.

See also:

• Hyperfine village organizes ideas spatially

An algorithm used for constraining elements in a UI such as adjusting layout based on the screen size. It is designed to handle linear equality and inequality efficiently (e.g. show window to the left of the other and gracefully degrading if there isn’t space).

Read the paper

See also:

• tui-rs uses Cassowary for laying out text-based user interfaces in the terminal
• GraphPlan - another kind of constraint solver that uses both a novel data representation of the problem domain and a solver

When building products you are always learning new things about the user, the market, and their problems. Sometimes this happens intentionally (e.g. doing user research) and sometimes it happens unintentionally (e.g. adding a feature that suddenly takes off in usage). Ideally these facts are made explicit and is accretive over time so that new facts leads to better understanding over time which leads to more successful products. This also requires flexibility and updating ones model as new information is uncovered.

This is similar to the ideas from lean startup where the goal is to efficiently validate critical assumptions by building the minimum required to learn from users.

Facts don’t necessarily need to be provable to be valuable, just correct (a G-statement). Gödel Incompleteness For Startups argues that the unprovable yet true facts are the most scarce and therefore most valuable.

A single number to measure the productivity of a knowledge worker could be the number of new notes added per day. This idea comes from Andy Matuschak based on a foundation that knowledge work should be accretive and each note being an atomic idea that contributes to the overall pool of knowledge one can access.

A kind of fuel for nuclear reactors composed of a ‘sand’ of coated fuel pellets. This allows the fuel to expand and contract, but the fission products (e.g. gasses) stay contained. The fuel has a negative temperature reactivity coefficient which halts the fission reaction if the fuel reaches a certain temperature. This self regulation makes it much safer compared to conventional reactors.

See also:

• Nuclear micro-reactors

Smaller self-contained nuclear reactors that can be manufactured and shipped. Multiple micro-reactors can be combined for higher energy needs. It is believed to be safer because it can be manufactured and shipped (along with self-regulating Tri-structural isotropic particle fuel (TRISO) fuel) rather than custom built on-site as nuclear reactors are today. They use helium gas to cool the reactor which is also safer in case of excess heat and more efficient for generating electricity.

See also:

• Modular Micro-Reactors – The Future of Nuclear Energy?

Nuclear reactors are often regulated by water to control excess heat. However, micro-reactors are cooled using Helium gas. This has the advantage of eliminating the possibility of phase changes like water turning into gas which generates pressure. It is also more efficient for generating electricity since water does not need to be moved around the reactor.

Focusing on continuously improving p99.9 latency (long tail latency) not only improves overall latency, it necessitates more reliable systems, better user experience, and enables more enterprise sales who tend to want contractual obligations around p50 latency.

Read Everything you know about latency is wrong.

See also:

• Consumers buy products, enterprises buy platforms
• Engineering management

Telcos and cloud providers that require a high degree of uptime and reliability aim to have less than 1% of incidents caused by code or configuration changes. In reality this is closer to 10%, but the goal makes clear the kinds of systems and infrastructure required.

A study performed in 2008 by UC San Diego found that American households consumed ~3.6 Zettabytes of information in a year. Between 1980 and 2008, the annual growth rate of information consumption is 5.4 percent.

Statistics from UC San Diego.

In the early stage of a startup, companies have limited resources and a wide range of things that need to get done. Founders often wear ‘multiple hats’ to build and run the company. This follows to early employees—even with a stated job role, out of necessity they will need to go beyond it. This appeals to generalists (those who can do multiple kinds of things reasonably well) and is highly valued because the startup needs to do a wide range of things with limited resources.

Contrast that to a startup that is further along (> 1000 employees) and the needs change. Organization and administrative functions are required to coordinate many people working towards a shared set of goals. This puts pressure to hire the right person for a specific role where roles are defined to help administrators make sense of their workforce. Needs become more specific, and specialists are valued more because 1) they fit the definition of what’s needed more clearly 2) deeper expertise is required to solve more specific problems immediately.

When interviewing candidates about their experiences and challenges they have encountered, you learn a lot about their employer, how they work, and the real story behind some decisions if you listen closely.

See also:

• Engineering management

The practice of being mindful about consciousness so that one can be more present and not have their mental states dictated by things out of their control. It takes deliberate effort to build the skill of recognizing the thoughts that appear and controlling our attention at will.

In the new normal brought on by COVID-19, typical activities that we rely on to recover and recharge are not available anymore due to the economic shutdown. For example, socializing with friends at a restaurant or going to the gym.

In addition, some of those previous activities that might have been restorative actually detract from overall well-being. For example, going for a leisurely walk outside raises your anxiety every time you pass someone on the street and are reminded of the virus or protecting your vulnerable household.

A way of modeling an external API provider as a compute resource for executing an agent program. Instead of making a request and getting a response (as in the usual HTTP API pattern) you submit a program that executes in the provider’s environment. This could allow users of an API to simplify their access patterns, benefit from data locality, and have stronger guarantees for execution than hosting their own infrastructure.

For example, instead of making a read request to get some data then make a write based on that data and wait for an async webhook, the requestor could submit a program that does all of that executes within the providers contained environment.

See also:

• How we should build APIs tomorrow that talks about some of the problems with the current RESTful approach

In video game programming it can be tempting to replicate a client server model similar to how websites work. This is generally a mistake because game state tends to be highly co-mingled between state and graphics. Attempting to cleanly separate the ‘backend’ game logic with ‘frontend’ visuals results in awkward boundaries between the two, which are still coupled, but in a way that requires more complicated code to manage (e.g. a message bus, event sourcing) and are probably less performant (e.g. passing json messages within a 33ms frame budget).