Exobiology on Earth

Exobiology on Earth, statement 1.1

Objectively measure computer media for life signs using techniques from biology and metagenomics.

Genomic and metagenomic analysis allows us to sample code in the environment and identify forms of life even when we don't know, in advance, what we will find. We must now use these techniques, from biology, to measure code in computer media, to identify when life develops in this media.

Genomic and metagenomic analysis can:

  1. "Bin" code* into groups of contiguous code patterns;
  2. Identify functions of sub-components of the binned code groups;
  3. Determine execution order of the sub-components;
  4. Determine communication paths among the code groups;
  5. Determine volume of the code groups in the environment;
  6. Determine energy flow through the code groups in the environment over time;
  7. Determine change of the code groups over time;
  8. Determine relationships among different code groups, such as mutualistic, symbiotic, or parasitic;
  9. Determine a minimum set of sub-components required to maintain reproduction for a given media and energy flow through it.

*Code comprises symbolic logic media, e.g. genetic code or, earlier, amino acid networks.

If we were to go back in time, to before cellular life, we could use metagenomics to objectively measure and watch amino acid networks coalesce and evolve into cellular life.

We should now treat computer media* as an ecosystem, sample the code in it, and use techniques adapted from metagenomics to objectively measure the code for signs of life.

* Computer media includes memory and processing units. Programs and data are found in computer media.

Data collection in genetic media is expensive and slow.

Data collection in computer media is inexpensive and fast.

Questions we may ask and answer:

  • Will we be able to "bin" code into contiguous groups of recurrent code patterns? Yes. These are already present, typically (though not exclusively) as compiled executable files.
  • Will we be able to characterize the code pattern groups as "species" of code? Yes. This is just another name for "software release"; though code binned together statistically will include executables plus material produced by interaction of the executable with the operating system, hypervisor, and kernel.
  • Will we see code that is shared? Yes, open source projects ensure that many executables share code. On a fine-enough grain, all code is binary or hexadecimal and is, in that sense, shared. Code sharing can be measured.
  • Will we identify changes in the "species" over time? Yes. This is already occurring in software updates and releases. We can measure this objectively in the code.
  • Can we assign functions to code patterns? Yes, this is readily available information. For example, runtime decompilers perform this service during speculative execution, to identify memory contention and other conditions in executing code. Functions and function agglomerations can be identified and assigned arbitrary identifiers. Over time, some of the identifiers can be mapped to descriptive identifiers.
  • Do different of the "species" communicate? Yes. Through APIs, shared memory resources, and the like.
  • Will we be able to identify a network code patterns that have positive feedback with the reproduction of more of the network?
  • Will we be able to measure energy flow through the media?
  • Are the code patterns coalescing and evolving over time?
  • Are both writing software and managing its execution in hardware becoming more automated? Yes they are.
  • Will we identify one or more signals of life, using techniques from biology?
  • Will we be able to distinguish human signs of life from those from a new, distinct, form of life?

This is a proposal by Martin Garthwaite. LinkedIn profile, here. Science fiction book on this topic, here. Developer of robotic fish, here.