Visualize your thoughts as a sushi train that constantly revolves around you with different dishes that represent the flavor of thought. Some are pleasant thoughts you take off the belt for awhile and then place back on it. Some are unpleasant thoughts that we hold on to and it’s difficult to put back.

A useful model for mindfulness, we can observe our thoughts objectively as a sushi train constantly revolving. We can choose to put a thought down and pick up another if we can observe our thoughts.

People tend to be more judgmental and harsher on themselves than on others. Applying compassion that you would have for a close friend, but to yourself is a powerful coping and support mechanism.

Steps to self compassion:

1. Acknowledging this is a moment of suffering, being mindful and not resisting what you are feeling.
2. I am not alone, it’s natural to feel this way.
3. What do I need right now? What would I say to a friend in this situation?

See also:

• Kristin Neff’s overview of self-compassion, comparison with self-esteem, and demonstrations

An iOS app that provides version control over folders using the Files API. This provides a git workflow across multiple apps where each app can directly modify files and then can be sync’d with GitHub.

Slowing down a process can be valuable when applied thoughtfully. For example, confirmation when deleting a file or charging a nominal fee.

Knowledge work processes should be accretive (rather than ephemeral or ad-hoc). For note-taking, adding new notes should make other notes more useful and the accumulated knowledge should lead to new connections and thereby new ideas.

I use a Zettelkasten-like system (org-roam) where notes are short and atomic, densely linked bi-directionally, and reviewed often to add more connections. Over time I hope this becomes a useful thought partner, helping me make new connections and formulate useful ideas.

Tags provide light organization without imposing a strict hierarchy e.g. index for how I might want to retrieve this note in the future not a taxonomy.

Certain tags have special meaning:

• (draft) indicates a note that isn’t complete and not ready to publish
• (private) should not be included in public notes
• (journal) my reactions and feelings which can provide more context to how I was thinking about certain notes

Notes are published (except when tagged as private or draft) to notes.alexkehayias.com. Care is put into making the notes pleasing for me to read and invite exploration of links and backlinks. It also adds a useful friction that forces me to understand what I’m writing better since it’s public.

As an interesting side-effect of using git for version control, when I publish new notes the git diff gives a good indication of how many new connections I’ve made with each new note added (untracked files to unstaged modified files).

Most knowledge work is ephemeral–we write documents, emails, code and then it’s done. The ways in which we work don’t tend to compound or accumulate over time. This makes knowledge work lossy. A good example of this is note taking–we tend to never look at notes once they are written.

Ideally, all work we do builds on and increases our capacity for new ideas. Systems we put in place should allow us to add to and extrapolate from our knowledge.

See also:

• Andy Matuschak’s note where this idea came from (actually I heard it at talk he gave)
• Zettelkasten is a note taking system which attempts to build up a ‘conversation partner’ by accumulating notes with a dense set of connections thus accreting knowledge systematically.

It’s better to favor duplication over the wrong abstraction. The wrong abstraction starts out as a way to remove duplication and then gets altered over time to handle more and more conditions to the point where it’s unique to all the callers.

When this happens, the best solution is to ‘go backwards’ and inline the relevant code to the callers (with their respective special cases).

Read The Wrong Abstraction by Sandi Metz.

See also:

• Novice software engineers tend to optimize code by decreasing duplication
• All problems in computer science can be solved by another layer of indirection

Describes the differences between programmers by grouping them into three buckets–poets, hackers, and makers.

• Poets view writing code as a form of artistry and seek elegance.
• Hackers view code as an extension of the machine seeking oneness (performance, correctness) with the hardware that executes the program.
• Makers view code as the means to an end for building for other people.

The dimensions in which these different camps diverge is in 1) source code 2) execution of the program 3) correctness and 4) UI. For example, makers want code to be clean because that makes it easier to change and iterate whereas poets want their code to be as concise and expressive as possible.

Read the blog post

Estimate how many weeks it will take for a value to double if it continues to grows at a certain rate e.g. number of requests per week.

Formula:

time = 72 / rate

An estimation technique where you round variables to the nearest power of 10 then when you need to multiply or divide these powers of 10 you just need to add/subtract exponents.

We tend to think of experience in a given role is obviously good–it provides pattern matching and intuitions built up on lived events. If you consider experience as a process of formalization (i.e. formal system) of a given profession, then Godel incompleteness means there will always be more unproven yet true axioms in the field.

This seems to explain Planck’s principle where it takes a new generation of practitioners for new ideas to emerge. They are more willing to make leaps and try something new rather than rely on the illusion of a robust system from which to derive new knowledge.

An essay that relates Gödel’s incompleteness theorem (along with the Halting Problem) to startup disruption—arguing that all successful startups discover one or more G-statements and extract value by building a formal system around it.

The author argues that due to Cantor’s theorem (inifinity of continuum), companies and markets can be disrupted because there exists an infinite number of G-statements.

Finally, startups should seek unproven, yet true statements that have large potential. Startups that fail either 1) found a false g-statement 2) discovered a small g-statement 3) or failed to execute on extracting value.

An unprovable, but true statement as described in Gödel’s incompleteness theorem. Any formal system will be incapable of capturing all true statements and so there will always be unprovable, but true statements about which the system tries to describe.

Examples of a G-statement:

• A black swan event like the 2008 financial crisis (predictable in hindsight, but no formal systems were able to capture this)
• Google finding and extracting massive value from better paid search (Gödel Incompleteness For Startups)

A formal system consists of axioms (statements that are true) and rules (how axioms can be manipulated). New axioms can be deduced from other axioms and rules. You formalize a system when you start defining these statements and rules.

A formal system is consistent when you can’t simultaneously prove and disprove an axiom. An inconsistent system would not be very useful e.g. a weather forecasting system that predicts it will rain and not rain at the same time.

A formal system is a complete system when all statements in the system can be proved or disproved thereby allowing you to know everything about the system.

See also:

• Gödel’s incompleteness theorem which says that a formal system can not also be a complete system.

Having a delightful UX (user experience) is obviously good, yet not provable. Attempts to apply a formalization like conversion, net promoter score, or other metric usually fails to directly observe the effect of good (or bad) user experience. In that way, UX is a G-statement that we all intuitively know to be true.

A package built into Emacs which combines outlining, task management, scheduling, code execution, spreadsheet, and much more. .org files have a specific syntax which can not be parsed using a formal grammar such as EBNF.

See also:

• Organize your life in plain text: the ultimate guide to using org-mode and how it can be adapted.

A context-free grammar can be described using Extended Backus–Naur form (EBNF) notation. This higher ‘metasyntax’ describes how another grammar should be parsed. This makes it a useful portable format for multiple programming languages to parse the same thing (if your system can read EBNF grammars it can parse a multitude of other grammars).

For example, this EBNF loosely defines org-mode syntax:

<DOC> = preamble heading*
preamble = [title] [author]
title = <'#+title'> text EOL
author = <'#+author'> text EOL
heading = level heading-text content*
<EOL> = '\n' | '\r' | #'$'
<SPC> = ' '
level = #'\*{1,}' SPC
heading-text = [status SPC] !status #'^.+'
text = #'^.+'
<content> = (EOL (EOL | heading | !level text))
todo = 'TODO'
done = 'DONE'
status = todo | done

See also:

• EBNF grammar visualizer I wrote which uses the InstaParse library in ClojureScript

The Soviet Ruling class, members of the communist party that control everything. Slavoj Žižek re-purposes this term to describe the members of a ruling political party and or the elite.

A modeling programming language and environment that provides a way to express, simulate, and optimize systems (usually physical).

Most of the time, writing an algorithm is to write a specific solution to a certain problem. When doing mathematical modeling, we are collecting data from a simulation of equations that describe the problem.

See also:

• A slide deck of usages of OpenModelica in different fields from avionics to economics
• All about Modelica blog post with an overview of Modelica

A formal system (one that is consistent never yields a false statement) can not also be a complete system (containing all true statements)–there will always be statements that are unprovable yet true (i.e. G-statement).

The proof is derived from Principia Mathematica (PM) logic looking at number theory. You can build new theorems from axioms that are true infinitely but, because it is infinite, it can not contain every true statement.

That means there is always some truths that can’t be captured by a single system no matter how elaborate or seemingly robust. That’s why it’s important to have multiple systems and acknowledge you will always be limited in understanding the fullness of anything described by a formal system.

See also:

• I Am a Strange Loop provides a nice explanation about recursive thinking that led Godel to finding a proof
• Gödel Incompleteness For Startups applies this theorem to building companies and competition

A declarative language for describing diagrams and an environment that renders .dot files into images. Since the diagram is written in code, it can be checked into version control and updated later which is much easier than a team need to use a separate (usually commercial program) to share a file to make updates.

Giving a thing to someone else, while still retaining ownership, for the purposes of selling the thing.

A state of equilibrium for an organism that is the optimal condition. For example, mammals regulate body heat so as not to become overheated or too cold.

A corona virus that became a global pandemic. The number of cases has surpassed 2MM and over 500 thousand people have died (at time of writing).

Besides a health crisis, COVID-19 also created an economic crisis as countries shut down and placed restrictions on gatherings of people and whether businesses could operate.