Skip to content


August 22 2023

New season of Hearthstone! Goodbye, next forty-eight hours.

New season of Hearthstone! Goodbye, next forty-eight hours. I'll be captive to this relentless obsession. Alongside Baldur's Gate 3, of course.

This patch, it sucks from the get-go. Bannana Slammas for life, I suppose.

broken combo
only broken enough for fourth place i suppose

The billboards up in Soho stir something within me. Something McLuhan might've coined, about the package being more valuable more than the item inside. The ads on NYC's billboards, uncountable as they are, most fade from memory like a worn-out jazz record. But their very existence on the giant sized wall, catching the eye of the odd twenty-somethings, mid-pilgrimage to their temple of Equinox, that broadcasts its own message. Sure, I could plaster an ad on some wall in a silent town but that lacks the jazz, the hum and pulse of the viewer's gaze, which makes all the difference in selling the song. Plenty artists wallow unseen, only a handful get to wallow under the spotlight.

Leaders need this one thing more than anything else: good sense. It's the same when it comes to your body, your thoughts, your work life. Be your own arbiter of good judgement.

Photos...they've been the game for me on Instagram lately, kind of like a guilty pleasure I suppose. Don't know why.

It's ludicrous when you think about how I'm using Instagram, disregarding entirely how they mapped out the service. Truly not giving a flying fuckkk. It's like a Finstagram, but taken to the logical conclusion of really only using Instagram for a glorified photo storage service. Picture it: me following no one, completely ignoring ads on the feed the company worked so hard on to build! A strange way to play, right?

But in its way, it's transformative. Instagram morphs into something else, a simple yet miraculous platform for my photos, a sanctuary. It's effortless to stick in my favorite tunes too, lending a voice to every image. And the filters? Oh, the filters. An array of options with a single, easy tap. Quite something, isn't it?

Oddly enough, I found myself the central character in some LLM tutorial – an instructional piece about using these LLMs for cold outreach on LinkedIn, of all things. Seeing this offered some clarity, unsheathing the mystery of the spam deluge that keeps finding me. Particularly from the VCs, the constant hum in the background. Leave me alone dammit!

Random post logic – all credit goes to the original creator: milkythemes!

    function loadScript(url, callback) {
    const head = document.head;
    const script = document.createElement('script');
    script.type = 'text/javascript';
    script.src = url;
    script.onreadystatechange = callback;
    script.onload = callback;

function luckyPost() {
    let ghostVersion = typeof version == 'undefined' ? 'v3.0' : version;
    let apiKey =
        typeof key == 'undefined' ?
            console.error('Ghost integration API key is missing. Please refer to documentation at') : key;

    const pageUrl = `${window.location.protocol}//${window.location.hostname}`;

    const api = new GhostContentAPI({
        url: pageUrl,
        key: apiKey,
        version: ghostVersion

    const postUrl = [];

    const randomBtn = document.getElementsByClassName("btn-random");
    const stringHostUrl = `[href="${pageUrl}/#rdm-post/"]`
    const randomPost = document.querySelector(stringHostUrl);
    const randomPostSelector = document.querySelectorAll('[href=""]');

    for (let i = 0; i < randomPostSelector.length; i++) {
        randomPostSelector[i].text = `Loading...`

        .browse({ limit: 250 })
        .then((posts) => {
            posts.forEach((post) => {
        .then(() => {
        const randomPostSelector = document.querySelectorAll('[href=""]');
        for (let i = 0; i < randomPostSelector.length; i++) {
            randomPostSelector[i].text = `Open Random Post!`
            randomPostSelector[i].href = `${pageUrl}/${randomUrl(postUrl)}`
        }).catch(() => {
    		const randomPostSelector = document.querySelectorAll('[href=""]');
            for (let i = 0; i < randomPostSelector.length; i++) {
                randomPostSelector[i].text = `OOPS!`
                randomPostSelector[i].href = ``

    // The randomUrl function is used to grab a random array from the list 
    function randomUrl(postUrl) {
        return postUrl[Math.floor(Math.random() * postUrl.length)];

loadScript('', luckyPost);

Tier 7 exists.


Blue Lock got dark!

big carbon copy!

Hey, the kid's scored a page on Wikipedia!

Atrioc - Wikipedia

Sticky Header for Ubud! (Put this in the code injection header)

        position: sticky;
        z-index: 1;
        top: 0;
        background: var(--background-primary);

August 21 2023

Instabrams are back baby! Thanks to Alfred, Obsidian, Ghost, and GPT that is!

I found out today that, oddly enough, my dislike for food—and smells, as an offshoot—liberates my ears. I can fill them with all kinds of sounds, just like I fill my mind with all sorts of books. And who knows, this might make my understanding richer, deeper. After all, tastes and sounds, they both bring in similar complexities, don't they? What's the science behind this, I wonder?

Planning with time blocks using the Time Block Planner is something else, I tell you. Just staring at how my hours roll out in reality, versus where I believe in my mind that they're going.

It really makes me treasure those fresh hours each morning when I draft the plan. But, damn it, they do race by like comets while I'm knee-deep in living them. Sure makes one thing clear though - there's still quite a road ahead of me to align my time better with the stuff that sits front-row in my priorities.

Today, I cranked out a couple scripts that just might fan the flame back into my inconsistent habit of creating Instabrams. Knocked up one heck of a pipeline for DALL-E, taking chunky texts, wringing them dry into neat, crisp summaries, and morphing them into fetching cover art.

Then there's the second script. What does it do? Well, simple: it chews up shorthand blurb, like the one you're picking through now, and spits it back out in the flavor of a certain author close to my heart, our man Murakami himself. Now, you can sneak a peek at both these scripts down below and take in the art piece a notch above.

Both scripts neatly tuck away the outputs onto my clipboard. Handy for the lazybones that like me, can use ‘em just about anywhere across the machine. Embrace sloth!

i wrote two scripts today that should hopefully harken the return of instabrams. i created a dall-e pipeline that takes text, summarizes it and turns into a cover art.
in addition i wrote a script that rewrites shorthand like you are reading now into the style of one of my favorite authors, haurki muarkami. you can see both of the scripts below, and the art for this peice in the image above.
importantly, both copy results to clipboard for usage anywhere across my machine. let's go laziness!

Really would be nowhere without these amazing tools that devs have built (Ghost, Obsidian, GPT). I merely build the ligaments that connect the very solid bones.

GitHub rang the bell for the 700th star on chat gpt md today. It's been awhile since any updates were added, and I can't help but feel a twinge of regret. But the open source world - well, it can be a free ride for some folks, especially amongst the Obsidian folks. It's like being a chef with everyone sampling your soup, but no one foots the bill.

there was an enormous disconnect between how we think open source works and what is actually happening on the ground today. There is a long, and growing, tail of projects that don’t fit the typical model of collaboration. Such projects include Bootstrap, a popular design framework used by an estimated 20% of all websites, where three developers have authored over 73% of commits. Another example is Godot, a software framework for making games, where two developers respond to more than 120 issues opened on their project per week.† -- Working in Public: The Making and Maintenance of Open Source Software

Create a Ghost Cover Image with DallE

import dotenv from "dotenv";

import OpenAI from "openai";
import clipboard from "clipboardy";
import fs from "fs";
import fetch from "node-fetch";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function summarizeClipboard() {
  const text = clipboard.readSync();
  // console.log(`Summarizing: ${text}`);
  const completion = await{
    messages: [
        role: "system",
          "Summarize the following into a theme and create an art prompt from the feel of the text aesthetically along the lines of: 'an abstract of [some unique lesser known art style from history] version of {x}' where x is the feel of the text aesthetically. Just return the art prompt, say nothing else." +
    model: "gpt-4",

  // console.log(`Summary: ${completion.choices[0].message.content}`);

  return completion.choices[0].message.content;

async function saveImgFromUrl(url) {
  const response = await fetch(url);
  const buffer = await response.buffer();
  const filename = `./dalle-images/${}.jpg`;
  fs.writeFile(filename, buffer, () => console.log("finished downloading!"));

  return filename;

async function appendToLog(logItem) {
  const log = JSON.parse(fs.readFileSync("./log.json"));
  fs.writeFileSync("./log.json", JSON.stringify(log, null, 2));

async function main() {
  let prompt = await summarizeClipboard();
  prompt = prompt.replace("Art Prompt: ", "").trim();
  const image = await openai.images.generate({ prompt: prompt });
  const imageUrl =[0].url;

  const imgFilename = await saveImgFromUrl(imageUrl);

  const log = {
    query: clipboard.readSync(),
    prompt: prompt,
    imageUrl: imageUrl,
    imgFilename: imgFilename,

  await appendToLog(log);

  // save prompt to clipboard
  console.log("./dalle-images/" + imgFilename.replace("./dalle-images/", ""));

Rewrite Chicken Scratch as Murakami

import dotenv from "dotenv";

import OpenAI from "openai";
import clipboard from "clipboardy";
import fs from "fs";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function rewriteClipboard() {
  const text = clipboard.readSync();
  // console.log(`Rewriting: ${text}`);
  const completion = await{
    messages: [
        role: "system",
          "Rewrite the following in the style of Haruki Murakami, using short, punchy, easy to read, simple words that flow. Almost as if spoken cadence. Text:\n" +
    model: "gpt-4",

  // console.log(`Rewrite: ${completion.choices[0].message.content}`);

  return completion.choices[0].message.content;

async function appendToLog(logItem) {
  const log = JSON.parse(fs.readFileSync("./log.json"));
  fs.writeFileSync("./log.json", JSON.stringify(log, null, 2));

async function main() {
  let prompt = await rewriteClipboard();
  prompt = prompt.replace("Rewrite: ", "").trim();

  const log = {
    query: clipboard.readSync(),
    prompt: prompt,

  await appendToLog(log);

  // save prompt to clipboard
  console.log("Prompt saved to clipboard");

Images From the Script

These have wriggled under my skin, becoming my favorites of the day. You can make buckets of them without breaking much of a sweat. Keep your eyes on the blog – there's more visual feast on the way!
DALL·E 2023-08-21 15.55.18 - Art Prompt_ Create a Tonalist and Symbolist fusion manifesto of an enchanting wilderness filled with mystic animals and towering trees embodying the p.png
DALL·E 2023-08-21 15.21.35 - Create an abstract version of the Cubism style that portrays the challenges of financial burdens and health care costs.png·E-2023-08-21-15.13.12---Create-an-abstract-watercolor-version-of-the-constant-struggle-between-the-expansion-and-collapse-of-the-mind.-Use-vibrant-colors-and-fluid-brushstrok.png
DALL·E 2023-08-21 15.13.12 - Create an abstract watercolor version of the constant struggle between the expansion and collapse of the mind. Use vibrant colors and fluid brushstrok.png

Half a decade past, this is where I lived.

I snapped this photo, and soon after found myself in a nearby bar, nursing a drink and ruminating on the past five years. I had some predictions right - walking away from full-time software engineering to chase dreams of startups and artistry. But there were surprises too - who could've predicted a pandemic, or AI taking great leaps ahead?

I pondered over the goals I set for myself in 2018 - many still unmet, many still echoing around my head. Is that a good thing or a bad thing? Not sure. But one thing I've learnt is this: success is a recipe. It calls for dogged effort, an accreting outlet for said effort (think: investment returns), a dash of lady luck, and being at the right place just when it's the right time. Voila, dreams come true and they'll call it fate.

Like Ging said to Gon, "I can't get there quite yet, but I'm relishing the ride."

"Five years ahead?" I reckon I'll be there, right at the threshold of that old, worn out door of mine.

Oddly enough, it seems as if my eyes on the photo on the right been brushed with a dash of guyliner. Can't make heads or tails of that, honestly. is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.

Problem Set Theory

let's learn about these here subsets!

Now that we have a grasp on what problems are from What is a Problem (202306222324) and aren’t from What Isn't a Problem (202306212318) we can launch into the discussion about how computers solve problems. From our definition of problem, we see that solutions are in reality state transitions. When a problem is present, an entity will expend energy to solve that problem by transitioning to a state where that problem isn’t.

Computers, in that they calculate really, really fast, and have access to immense amounts of data are phenomenal at certain types of state transitions being that they have a lot of available states to visit and they can visit these states nearly instantaneously compared to the time the human brain can transition and trial states.

So, it follows that computers help solve problems for entities through automation. The total problem set (all problems that the total collection of entities suffer from) is filled with problems in what we can call the repeatable set. These problems can be solved for in the same way, over and over. An example would be a simple math formula: a 20% tip for example. You are aware that you need to append 20% to the bill, but you don’t have the patience (speed) or the space on your receipt left over (memory) to compute tip. Later in the book we will discuss how exactly computers do this, and how they have gotten inevitably better at conducting this type of work.

The interaction between a human and a computer then is the relationship of making problem solving more efficient. To the point it can be translated into machine code. To solve a problem a computer completes a machine computable problem. As time has gone on and more foundational problems have been solved in the space of computing, the applicable space of potential problems that can be converted into patterns has also grown, much like using the base to put an art gallery or a movie theater or a cafe. What goes in the space matters little if the ground itself is stable.

This means more people have been able to participate in this communication layer. But not by much! According to the Global Developer Population & Demographic, 2019, only 1/3 of 1% of the global population codes. For example, there were fewer people who were actively able to manage the space between machine code translation to assembly and those who were subject matter experts in auxiliary fields such as construction to animal husbandry. This barrier to entry, financial and mental, is largely responsible for few technical people owning much of the tech landscape in judgment and in absentia. By building general computers and general software, engineers and programmers are able to claim an entire swath of abstract land and choose/enforce how people build anything on top of their architecture.

Problem and Pattern Matching Space

Let’s envision an imaginary set of all possible problems, and call it P. Within this set of problems exists a subset called of the repeatable problems above that we can call R. Repeatable problems can be solved over and over with different inputs and are a direct mapping from input to output. On the other side of the set of P, we have non-repeatable but still computable problems, N. These problems are bespoke and have elements of non computability through judgement and pattern matching in the transition from problem to solution. Once a bespoke problem is understood, it can be automated, but that automation is a single purpose tool that can not be abstracted further. Finally, we have problems that are both non repeatable and non computable in set NN. These problems do not have any state transitions that can be automated, and there is no plausible path that we can see leveraging computability either. Our goal is to understand how many problems exist within each subset. As a general rule:

  • problems in R can easily be converted to code
  • problems in N can likely be converted to machine code with the help of probability matrices like neural networks
  • problems in NN can not be converted into computer code, which has a side effect of meaning that in general they are not reliably solvable in the first place. There is a lattice of randomness involved with this level, sometimes the entire graph shifts and a problem state your on straight up blips into or out of existence.
problem space.png

Problems in R

Like the example above, problems in set R are not yet solved, but feel readily solvable using the same tactic.
This distinction is is important. This implies that the problem has a stable solution that moves it to the correct state.

Imagine you step into an imaginary hotel, and the bellhop asks you to follow him. You pick up your bags as he leads you to the elevator. He presses the 10 button, and the elevator begins to ascend. Around floor 5, the evaluator grinds to a halt. You glance nervously at the bellhop but he calmly says there is nothing to worry about as he deftly opens the elevator switchboard and flips wires 2 and 3 in the control panel. The elevator continues to move as if nothing has occurred and your bellhop asks you how your flight was.

In this case, we had a very real problem. We were on floor 5, and desired to be on floor 10. The elevator hit some bug in its code that required a manual override from the bellhop to continue its work. Once the bellhop flipped the wires, the elevator resumed as normal. The lack of emotion on the bellhop’s face implies to us that this is a common state of affairs, and that this elevator is no stranger to this particular malfunction.

Engineered solutions that work are solutions in the R space. How can we make it so the power button turns on/off the computer while the X button applies an X to the screen? We engineer a repeatable solution. If you removed all of the stickers from your keys, each button is functionally the same. We write software that gives them unique, dependable meaning.

Problems in R can be thought of as breadth first search perfected. Instead of grasping for straws and searching randomly, or even relying off gritty heuristics, repeatable problems work every time (or close enough to 100% that it may as well be 100% and errors can be successfully corrected against).

Problems in N

Whereas R was the perfect transition from a state with an existing problem to another state where a problem isn’t, problems in N involve judgement calls.

Let’s return to our imaginary elevator in the imaginary hotel. As the elevator ascends it gets stuck, but the hotel has hired a new bellhop who is unfamiliar with the trick. You glance nervously at him, and he looks back to you also slightly nervous, and chucked “I’m sure it’s fine!” He tries pressing a few buttons, nothing happens. He tries pressing buttons like a piano chord, and the light briefly goes out. Together, you and he open the panel behind the buttons and notice a tangle of wires that seem to have a mind of their own as they are magnetically switching leads. You both realize that one of these sets will be what you need but you aren’t sure which permutations will cause the elevator to move, and which will leave you stuck in place. Eventually after fiddling for a while you find a working configuration, and the elevator continues to quietly ascend. Unfortunately for our new hire bellhop, this exact problem will happen again when he takes the next guest up.

The solution to this problem can’t be automated the way the problem in R were, but we can use patterns and heuristics to narrow our search space. The solution is still engineered in the sense that certain states get us what we desire, the issue Is that the path from problem to solution state dynamically changes, preventing any serious attempt at automation.

Thanks to transformers and LLMs, we are now reaching problem translation where problems can look like very noisy patterns and computers will still be able to match them and solve against them. This allows us to solve problems in this set to great acuity, along with having the flexibility of handling new problems without having to modify any of the underlying code base.

Problems in NN

Finally, we come to problems in the third set, NN. NN is both not computable and not repetitive. Even with an arbitrarily large amount of available compute and sufficient memory, problems in this set cannot be solved with the programming techniques of reliability, and can not be solved with the pattern matching and heuristics of the N set.
The problems in this set have solutions, but the solutions are unreachable by the current scope of technology we have.

Let’s imagine we have tasked all the computers in the world to team up and solve the elevator problem in our imaginary hotel. This includes every cell phone, every smart thermostat up to an including supercomputers at research institutions and server farms at Amazon, Google, etc. The computers run nearly infinite simulations of the combination of passenger weight plus the wiring of the elevator panel. The computers unit test every single possible state that the elevator should (or could) possibly be in. The machine learning models run epochs upon epochs of generations to understand the elevator, and to create a giant matrix that in theory should be able to fix the elevator >95% of the time.
In addition, we recruit all humans with different backgrounds to spend an entire year of humanity focused on this singular problem, with the aim of coming up with novel and creative potential solutions to the buggy elevator. The physicists naturally go after the set of electrons running through the wires. The lawyers research the patents that the elevator was built under, and what jurisdiction has ownership. The dentists examine the teeth of the bellhop, running X-Rays to see if the bellhop has any potential cavities. Schoolchildren go into the elevator and press buttons at random, trying to come up with a funny combo.
Despite all the angles of effort, the problem seems unsolvable. And then suddenly, one day as if by magic, the elevator fixes itself. That’s frustrating! What does this mean?

Problems in the NN set can only be solved by the other nodes outside of the problem set moving the state into the solution. You may call this fate, coincidence, or just plain dumb luck. When creativity and computation cannot force state manipulation despite energy expenditure, sometimes the graph itself needs to change shape.

Multiple Set Problems

Problems can exist within multiple sets at once. Some NN problems have sub problems in R and subproblems in NN. Subproblems will be discussed later, but problems can well have multiple routes, some of which are completely closed off by a subproblem in NN!
multipe soln ex.png is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.

Issue 15: Houston, We Have a State Transition

Yes Houston, I tried jiggling the knob, that was the first thing I tried!

This content is for Members


Already have an account? Log in

Why a Computer is a Universal Tool

why is a computer a universal tool?

From The List (202306232002), we discussed a series of increasing layers of complex problems that could be solved by imaginary an imaginary simple computer without any other technologies being added in a vacuum. But of course in the real world, that is not the case. In the 2020’s computers are in everything.
We defined a universal tool in The Universal Tool (202306202156) as being able to:

  1. recruit raw materials to its cause, generating single purpose tools inside of itself
  2. reshape its current architecture to perform new roles with the same building blocks (improving the same tools); attuning to problems better over time as we learn more about the problem
  3. bend the world around it to create more instances of itself
  4. solve new problems leveraging creativity and imagination

Recruit Raw Materials

There was a brief time in the early digital computation era (the 1950s) when everyone thought special chips would be placed into different items, but it turned out to be much more plausible and efficient to let a general purpose computer control any number of remote specific client computers — client computers as small as thermostats to giant cloud clusters of servers. The boundary between client and server began to fade over time. Computers can now decide with onboard logic to vacuum a room, to stop a car while parallel parking, or turn on sprinklers in the middle of a drought. Computers as a tool command raw materials at their discretion, and in addition can recruit inert raw materials and combine them based on context. This conditional “creativity” is a foundation of early work in AI, though researches realized early on that there is not nearly enough time or space in the world to implement everything in expert systems leveraging rule based mechanisms (but we’ll discuss this later).

Attuning to Problems

As time marches onward, problems tend to change shape. For example — some problems are inherently seasonal. We only worry about blizzards in winter, not July. This entails that some tools are only useful when the correct context is available, e.g. a snow plow in December.

Computers, and specifically programs, thanks to their abstraction, can re attune to a problem at any time. You probably know these as feature updates and bug fixes. This inherent flexibility means that the same program can evolve to match the problem as it evolves and grows. Interestingly enough, because it is so cheap to create new features and append them to the same code base, we actually get a new problem of feature creep where some vestigial features of programs are no longer useful but stick around because of the Chesterton’s fence parable, which states that changes should not be made until the current state of affairs is understood.

Create More Instances of Itself

A universal tool, being a universal tool, should have no issue in creating more copies of itself. This process need not to create a direct clone, but the successor should have the same core universal abilities of its parent at a minimum.

A human parent is well aware that their child, while being a product of their DNA, is not them. In addition, the parent raises their child leveraging a combination of genetics and environment to hopefully one day create a functioning member of society that then themselves can create a new child at the pace of one or two generations and so on.

Computers (the physical objects) have no direct way of replication (This statement isn’t even entirely true on the face of it as modern computer hardware fabrication centers are more run by computers than people! Especially since modern CPU chips are tuned on the nanometer level so there is no room for human error).
However, this does not mean that computers can not be heavily leveraged to make better computers, and in fact, this must be the case as every next generation computer was built on predecessor software and hardware and improved upon by using state of the art tech.

Speaking of software: software is a different story. To understand why this is the case, we need to understand the concept of Turing completeness. Simply put, for an imperative language to be considered Turing complete it must:

  1. have conditional repetition and jumping (for loop and if/else statements)
  2. be able to write and read to some form of storage

Later, we will be examining the proliferation of programming languages from the root of machine language. But for now, all we need to understand is that a Turing complete language can encapsulate a smaller also Turing Complete language, which can encapsulate another Turing complete language, and so on. Most modern programming languages (the ones you’ve heard of!) are Turing complete. An interesting side tool component from Turing completeness is Turing equivalence, meaning if you have computers P and Q, if they are Turing equivalent you can simulate them interchangeably.

This is not a copy. A copy implies that one is functionally the other, or more accurately, the copy is able to do all the things the original can do and nothing more or nothing less. A Turing equivalence between computers mean that in addition to being functionally equivalent, either Turing machine could have created each other and have Turing machines the same size, greater or smaller, with the same functionalities.

Solve New Problems

The thesis and purpose of this book is to explore the expanding space of problem solving through the tool of computation so there wouldn’t be much of a book to speak of without this being the case, but let’s dive into this claim.

A universal tool, as specified in The Universal Tool should be able to modify its physical attributes to address new problems with the same architecture. In other words, there should be no prevention of the universal tool to adapting to a new problem.

When we needed our hammer to also be a flashlight, we are not leveraging the same architecture from the hammer itself. We are adding an external LED bulb, battery and button. A computer can modify it’s same architecture in unique and novel ways to fit to brand new problem territories. Within the total space of computation is both all solved problems with computers and unsolved problems.

In fact, there is only two (or maybe three if you’re generous) other object in the known universe that can also fit the four requirements above. Care to guess what they are?

The Other Universal Tools

The brain is the other universal tool. The brain is able to do all of the items listed above (and more!). A brain can easily recruit raw materials to its cause, and then leverage those raw tools to create more advanced tools that then themselves go on to create more advanced tools. Thanks to the scientific method, the human brain is able to use science to get closer and closer to the reality of a thing. Sexual reproduction is the brains means (well DNA’s really) way of creating new copies of itself. Finally, the human brain is able to leverage creative leaps to jump from one solution space to another, and is not limited to the visible problem space, as a counterfactual engine (though that is a topic for another day).

DNA is the second universal tool. Language is the third universal tool. I’ll let you deduce why these are the case given the requirements of a universal tool.

You may have noticed that universal tools can create brand new universal tools on top of them. The reasons for this are discussed in depth in David Deutch’s amazing The Beginning of Infinity but for the purposes of this book, realize that within universes are smaller universes that in and of themselves can create universes and so on. is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.

What Is a Problem

wait, so what *is* a problem exactly?

Context Matters

First and foremost, problems are context dependent. Context matters with problems. Desire matters. When a thirty eight year old nurse decides to go on vacation, it is because he hypothesizes that a vacation will change the state of stress that he is in to a less stress inducing, more favorable one.

To his dismay, he might find when on some sandy shore in Costa Rica, that he can’t really give up work with a physical location change as his problem resides somewhere else in his mind. He must try another hypothesis, another potential solution.

There are multiple state changes one can take to maneuver to a solution, we can call these potential solution states.

A Solution in a Problem in a Solution

Secondly, to be considered a problem it also may be a solution. Let’s continue to examine the example above. Even though the nurse is using the vacation to escape the stress of the state of his work, he has burdened himself with a different problem for his credit card. This means that a solution can be a problem, and a problem can also be a solution.

A vivid example of this is opiate abuse. Something that for many starts out as a solution to an acute problem (the pain of a broken leg, for example) over time becomes an even greater problem itself (addiction) that requires a whole new host of solutions.

Self Imposed Limitations

Finally, to be considered a problem, an entity must be willing to expend energy to change it. Like a lion risking its life hunting a wildebeest, or me taking the effort to write this, a self-imposed cost must be entailed to change state.

The rain is not a problem, being caught in it is. Therefore, we expend extra energy (running or holding up an umbrella for an extended period of time) to change the unfavorable state to a more favorable one.

In more specific terms, to address a problem an entity needs some type of motivation either intrinsic or extrinsic to respond to a situation. To get the reward from the food, one must seek it out and chase it, or spend months growing it.


The oldest and by far most vast and root problem we living beings deal with on a daily is entropy. Why? Entropy is the natural consequence of the goings on of the universe. Have you been hungry today? Your cells actively convert food and oxygen into energy to be expelled. This process costs energy causing the tank to constantly need to be refilled. The lengths that living creatures go to to prevent the effects of entropy are fascinating. From developing cold blood to relax on rocks in the sun in reptiles to developing face creams and polar plunges in humans, we all have an active role in preventing or reversing the effects that entropy causes.

Aging itself, is a process that is built around accumulating damage to cells over a long period of time. Entropy – every time you breathe, every time your cells convert ATP – is literally making you older.

In (What Isn't a Problem) 202306212318, we determined that a problem needs to have one or greater potential solution states to be considered a problem. Does that mean enropy, a byproduct of the Second Law of Thermodynamics and therefore having no solution states to escape it (without breaking the laws of the universe) is not a problem?


Entropy, as in entropy itself is not a problem. You and I as living beings have a problem with our relationship to entropy, how it wreaks havoc to our bodies and minds. That is where the creativity of face creams comes in, and why there are so many types of face creams that all attempt to solve the same problem!

In Sum

So a problem:
1. can be a solution to another problem (but does not have to be)
2. has one or more states to try that will potentially be favorable
3. a entity is actively willing to expend energy and motivation to address the problem is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.

What Isn't A Problem

its not what a problem is, its what it isnt

A Desire and a Means

To understand what a problem is, we must discuss what problems are not.

Problems in and of themselves only exist when a entity desires to change something in their environment. Un-living entities affected only by the laws of physics do not suffer problems. Problems only exist within the context of entities that exert counter force against the pressure of the laws of physics (or leverage the laws of physics sometimes too).

In Oxford, a problem is defined as:

a matter or situation regarded as unwelcome or harmful and needing to be dealt with and overcome

While I agree that problems in and of themselves are generally “unwelcome”, I think a more apt description of a problem is the desire from an entity to be in a different state/change the state of the world around them. If you have a bucket of messy clothes in a heap after drying them, that is not the preferred state you desire to leave them in. So you hang them up or put them in a dresser. The clothes themselves are still the same fabric, you still have the same number of socks (assuming the dryer didn’t eat a few of them). A problem can really only exist if there is someone (or something) that desires for the state to be different than it is.

When water is held back by a dam, it attempts to move further downhill because a much stronger force (gravity) compels it to. The dam serves both as prevention for the water moving downhill and as a new object that the body of water interacts with changing the state that the body of water exists in. At no point does the dam or the water feel slighted or perturbed by the other parties inclination. In fact, if both were teleported into the vacuum of space, their relationship would be very different because the force of gravity would be driven to zero. Instead of holding the water back, any water molecules that come into contact with the dam will be struck away with extra velocity.

Zero Solutions

Something with zero solutions is also not a problem. Since a problem entails a state change being possible, if one is stuck with zero potential states to jump to, it ceases being a problem. This claim necessarily includes creativity, as there are some things in the universe (like the speed of light for example) which cannot be overcome, despite any creativity applied directly to the issue (at least with our current understanding of special relativity). Creativity is in and of itself a universal tool as we defined in 202306202156 (The Universal Tool), but even a universal tool is subject to the laws of the universe by virtue of being a physical object. This means that anything outside of the realm of physical and mental creativity cannot be a problem that an entity can solve.

So a problem isn’t:
1. a problem is not possible for non-living or more specifically, non-desiring objects in the universe. There must be a concerted effort on the part of the desirer to change the state of the problem to a more favorable position or state.
2. a problem does not have zero solutions after creativity is involved, I.e. there must be a state to jump to from the state you are currently in. If there are zero jumps available, it is not a problem. is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.

The Clash of One Way Clocks


Why do we write in one direction? Why do we speak in one direction? Are these byproducts of physical reality, a biological coping mechanism, or some form of societal decision to keep our minds and actions orderly? ^ftmvri

The great work of linguists in the 20th century taught us that language has an inherent computation to it.[1]

This raises an interesting set of questions about the computation of language: is audio itself linear (random universe noises)? Or is only language linear? Is perception due to how creatures experience time? If time followed different rules, would our command of language?

Tongue Twisters

Tongue Twisters[2] are a toy example of separate linear systems causing chaos in parallel.[3] The eye reads the tongue twister on the page (peter piper picked…), the brain shapes the lips and tongue to make the required shapes, and the ears listen to the sounds the mouth is producing (what am i saying?).

Each step requires a discrete amount of time. There is time required for sound waves to travel from your vocal chords and back into your ear feedback loop. There is time required to think a thought and activate the required neurons. There is time required for the eye to read characters and decipher them with the occipital complex and the fusiform gyrus.

The "distance" between the physical mouth shapes is longer than it takes for the brain to send the command to form the next syllable.

A tongue twister is a fun (and safe) way to have all of these different timers run into each other at high speed and crash.

So it would seem we're not just dealing with one linear perceiver, in fact, we're dealing with multiple, all of which operate at different speeds.[4]

Prediction and Bets

This raises a more impactful question than if Peter Piper did in fact pick those peppers. If our ability to predict has a "speed limit", and if it only predicts in one direction -- how can we be "sure" of anything? Are guesses and predictions simply the act of examining an external "line"[5] and using previous experience to determine where it might head?

In reality this line never goes backwards but may at any moment twist or turn.[6] How can we be sure that the line will move as we hope this time? How can we know that this time won't be different?[7]

In addition, we add the complication of multiple lines of reasoning happening concurrently. If one clock of reasoning is far behind another, do we get thread locked in the boxes of our own minds?

Do habits[8] simply mean that we have seen something before multiple times and expect a similar outcome? Is there any way to trust another person without past credential signaling on their part?[9]

Wouldn't you rather invest with a billionaire than a librarian at your local library?[10] But what if the billionaire made all their money from thievery and the line that reveals this fact lags behind another 5 years after you met the billionaire? Would that disqualify them as a business partner five years ago?

Is pattern matching a panacea for truth?

I'll leave you with this:

Turing also went further, showing that there were certain things that even the most powerful machine could not compute. In particular, he pointed out, no computer could predict its own behavior. Say you feed the machine a tape and come back to find that it’s been chugging along for twenty-four hours. Say it’s been chugging along for a week, or a year, or even ten years: read, write, left, right. There’s still an infinite supply of tape remaining, but is this thing ever going to write down, say, a O? Is it ever going to finish? There’s no way to tell, Turing showed, not in general. The “halting problem,” as it’s known, is hopeless. (Location 1269)

  1. for more on this, refer to the work of Noam Chomsky grammars

  2. 202301091332

  3. trying to time share multiple processes at once 202212212348

  4. 202301130109

  5. or multiple!!

  6. ^8750ma

  7. ^mynde0

  8. things that one can do subconsciously

  9. how does our prediction of their success in life change if they went to Harvard or have competed in the Olympics?

  10. 202301081728