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.

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 virus that passes from animals to humans. Examples include: SARS, Swine Flu, and COVID-19.

A pattern for traversing a tree of heterogeneous objects. Decoupling the algorithm for traversing the tree and the code operating on the objects leads to a much cleaner (and easily extensible) code.

Example usages include traversing an AST, the AST does not need to be changed to accomodate new code that is operating on it e.g. linters.

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.

Intertwines documentation and source code which emphasizes the need for code to not only be understood by the compiler, but also by future engineers trying to reason about your code.

Introduced by Donald Knuth in his book Literate Programming written in 1984 and implemented in the CWEB tool.

Literate programming with org-mode

Here’s an example of weaving the execution of code into this document which exports both the code block and output:

import random
print random.randrange(0, 100)

54

To tangle this code such that it exports to a source code file we can add the following heading to the source block tangle: hello_world :exports none which will export the code block to a file hello_world.py.

Read more about literate programming in org-mode using org-babel