2026.

I am teaching my teenage daughter programming, because I want her to have a
world model of the digital realm. There is immense utility on the boundary
between the digital and physical world, for example the program of a pacemaker,
where programs affect the world.

Since toddlers we can model the physical world, we can guess when things fall
where they would go, we know we can pull with a rope, but can't push with a
rope. We know how to abuse the world, as Archimedes said: "Give to me a fulcrum
on which to plant my lever, and I will move the world".

You know that certain things are possible or impossible, like your couch
levitating is impossible, but maglev trains are possible. It takes great deal of
effort to know if something is truly impossible, and a toddler will be utterly
confused if they see a maglev train.

The digital world has its laws of physics as well, those laws are stranger, and
we are not prepared, there is no toddler that can guess what would happen with a
program before it observes its effect, and even then it will often be wrong.

Lets investigate the todo list app:

-----------------------
 [x] Buy eggs.     [-]
 [ ] Gym           [-]
 [ ] Lunch with Ed [-]
 [+] ___
 
 Status:
 Done: 1 Pending: 2
-----------------------

It has a list of items and a status bar. The user clicks on an item, and it gets
marked as done, they click on the [+] and a new item gets added, they click on
[-] and item gets removed.

What laws govern this program? How many items can you add? How long can the item
name be? How fast can you click? Can you open it from multiple devices? Can you
share your list?

So how can you build a world model for this world of information and structure,
a model that will allow you to predict what would happen before it happens. Is
it even possible? To get at least to the level of "my couch can't levitate, but
certain things can levitate"

Yes it is, and that is why I am teaching my daughter programming.

What are good questions to ask about this world? The equivalent of: why do
things fall?

A good question is "where are the items", as in, where do they exist? Or the
words "eggs" or "Gym", or the fact if they are marked done or not.

Here we can question the humans' relationship with symbols. What makes you think
of an `egg`, how come 'e' 'g' 'g' is as good as 🥚? A deeper question is, where
does abstract information exist? The letter 'e' that I just put in your brain,
where is it?

In the computers we have made, abstract information exist in a very peculiar
combination of electrical loops that we can probe when reading and enable or
disable when writing. 

We can encode information either by storing its pattern, or storing a program
that when executed generates its pattern. For example we can store the pattern 1
2 3 4 5 6 7 8 9 10 ..., or the code that generates this pattern `x + 1`, they
are functionally equivalent, as in if i run our program and give it 19473 as a
number, it will give me 19474, if look in our giant table of numbers in location
19473, there I will find 19474.

Because of the physical properties of our computers, there are times where
storing the pattern is better, and times where executing the program is
better. An important note, is that the program is also just a pattern, and we
store it in the same place as the other data. Our computers can pretty much do 3
things, add numbers, read and write memory at certain location. The programs are
just numbers that the computer decodes and executes one of those operations, and
of course since the programs are just numbers at certain memory locations they
can modify themselves.

So what does that mean for our list of items? The fact that information is
stored in a grid of tiny electric loops? And we can read and write at any
location?

There are many ways to do this, but fundamentally it gets reduced to only
two. Either we need to store all the locations of the items in a sequence, where
we either need to terminate somehow to know when the list is done, or we need to
store its length somewhere and we know when we are done. Or we can store the
location of the first item and when we go there inside it we can store the
location of the next item and so on, until the last item stores 0 as next
location and we know it is done.

There are laws that govern those two ways, like for example if we store all the
locations together, how do we add another item? We need to add it to the end,
but we don't know what is stored after us, so we need to find some free memory
and copy our sequence there and add the new location to the end. Or if we want
to remove an item, we need to copy the sequence before it and move all items one
to the left.

If we store the chain of item to item, then to add we don't need to copy, but we
need to walk the chain to reach the last element and then link it to the new
element. To delete from the middle we again just have to find the element that
points to the one we want to delete and make it skip to the one after.

We can add many optimizations and tricks to make it easier to add or remove from
the middle, or the end, and so on, but those are just details.

There are practical laws of digital computers with addressible memory. And
knowing how to program them allow you to build a world model and predict what is
possible and impossible. You might think what I am talking about is simply an
'algorithm', well there are many ways to store and edit a todo list, there
certainly are some that I don't understand, and can't even imagine. But, what I
mean is that addressible memory and a computer that executes instructions from
it one at a time, enforce certain practical laws. 

For example the fact that we can not store both the item and its location in one
go. First we need to find a free location, then we can decide, do we store the
location or first we put the item in that location? They of course have
different implications if the computer crashes mid-store, we could either have
an orphan item, or we can have a corrupt list.

But we must choose.

A good analogy is natural units in physics, where the speed of light, Planck's
constant and Boltzmann's constant are set to 1, in those units, time and length
have units of 1/energy, force is energy squared, mass, energy, momentum are all
in units of energy. Velocity is dimensionless, it is just a fraction of the
speed of light. Everything stems from this.

In the addressible memory fetch-execute computers you have arrays, pointers and
order of execution.

---

In the end, all types and symbols are erased, only loops and locations remain.