To optimize code, reduce state, coupling, complexity, and code, in that order. Reducing state makes the program easier to reason about (e.g. pure functions are easy to test). Be willing to add more coupling if that means less state, more complex if it decreases coupling, and duplication if it makes code less complex. See also:
Stone fish traps in use over the last 40,000 years located in the Barwon River that some believe are the earliest human construction in the world. It’s an example of a man made system that has endured for thousands of years and is still in use today—a model for how one might approach building new systems. See also:
A quote from George Lucas about how Star Wars was about he Vietnam War and the backdrop of Nixon’s run for a second term. Democracies don’t get overthrown so muc as given away to dictators. This feels relevant today to the Republican party sycophants that enable a mentally ill and incompetent President as he runs for re-election.
A metaphor for how we respond to negative emotions such as anxiety, anger, sadness. When the struggle switch is on, one emotion leads to another in a cycle. For example, feeling anxious then worrying that your anxiety is going to get worse is essentially being anxious about anxiety. When the struggle switch is off, we observe the negative feeling using mindfulness and taking action on what we can control. This helps disengage from the negative emotions and avoid the struggle. See also:
The idea that life originated on another planet and was transported to Earth. It’s difficult to prove or disprove in a similar way to the Silurian hypothesis, evidence is difficult to obtain—artifacts from civilizations don’t last that long, evidence of life is not visible on any likely originating planet within our solar system. See also:
An activity or action one can do regularly that draws people to you because you are providing something of value. For example, a blog with content about helping you negotiate salary at a tech company or a podcast that draws people from your industry. This gives you something shared to talk about with strangers and build relationships which opens up new possibilities.
This note does not have a description yet.
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:
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:
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:
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:
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: The following example uses rustlang’s type system to model a finite state machine where transitions can be passed additional typed arguments: In
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, ());
}
}
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:
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:
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). See also:
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:
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:
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:
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.