I find this hard to say…

I’m an audiophile, I think that vinyl is better than CDs.

I think that B&W photography is better than Color photograpy.

But, I do believe that everything is a fractal.

Taken to the extreme, this means that everything is digital.

Digital-ness is only a function of sampling frequency - our limitation on what we can enumerate.

Imagine a measuring stick (a ruler). We can sub-divide each division into two more divisions. If we assign “1” to one tick mark and “2” to another tick mark, what do we call the tick-mark between “1” and “2? What about the tick marks between “1” and that one? How far down does this go?

Likewise, in software, we can sub-divide problems until what we have is “good enough” to solve the problem-at-hand.

What is Compile Time?

Lately, we have realized that Compile Time can be subsidivided into Type Checking and Implemenation. At the moment, that is “good enough”.

In the end, everything is interpreted. A CPU is just a bunch of electronic circuits that interprets the opcodes (sequentially) that we stick in memory.

Compile Time is really just an optimization - the effort to interpret fewer opcodes less often.

Type checking is just software.

Type checking is an interpreter.

We’re getting better at type-checking.

We’re sub-dividing the problem we call “Compile Time”.

When are we going to stop?

Probably never.

It is folly to think that there is but one language to rule them all.

It is wrong to think that something is absolute1.

We should reflect this non-absoluteness in our software and programming languages.

It is folly to denote variables as we denote them today.

Variables should be hierarchical.

Software should be hierarchical.

Calling functions by-name2 should not be allowed.

See Also

References
Table of Contents

everything is a fractal -> everything is digital
it is just a question of sampling rate

quatum physics

speed of light

  1. I quit Core Physics soon after some hippy tried to tell me about tachyons, i.e. that there are things that exceed the speed of light. ↩

  2. Absolute name. Currently we think of functions as points in a global namespace. Function names, variable names, type names, etc. should be relative not absolute. Namespaces should be hierarchical. We should refer to objects like we refer to UNIX directories - hierarchically. I think that Java started to creep this notion in, but it didn’t go all the way. Relative names should be the rule in our programming languages. Local variables and parameters are relative (relative to the containing function). Inheritance doesn’t work well because it allows relative boundaries to be crossed (I favor composition, not inheritance). ↩