Jones interpreter challenge?
Johnicholas
I am an OrganicBuilder newbie, and I haven't studied all of the
(awesome) solutions that are out there.
However, it seems like even the very awesomest (e.g. calcyman's
replicator) treat the string to be replicated as arbitrary payload
data, in contrast to real biology (and some CA self-replicators) that
do what they do by interpreting a data string.
Do you think that an interpreter (or ribosome) challenge based on
Hartmann, Jones, and Simonsen's "Programming in Biomolecular
Computation" would be feasible?
Johnicholas
Bertrand Dechoux
I haven't read yet the paper so I can give you a clear answer now but
could you provide more information?
It seems like there is a 'prototype'. Do you know more about it?
Regards
Bertrand Dechoux
Johnicholas
of things).
An interpreter is a program that obeys passive data.
So if we consider a strand of RNA to be passive data (ignoring the
fact that it can fold up into a protein-like catalyst for now),
then a ribosome that moves along that strand of RNA (together with a
supporting bath providing ATP and tRNA) and builds a protein
as specified by the RNA is a form of interpreter.
The usual pattern in computer programs is that the data is written in
a higher-level language (e.g. Python or Ruby)
and the interpreter is written in a lower-level language (e.g. C).
Self-hosting or metacircular interpreters are a bit harder to justify,
but they're very useful.
To some extent, the long-term viability of Lisp is due to its firm-yet-
abstract definition in terms of a metacircular interpreter.
A self-hosting interpreter helps when porting a language from one
underlying implementation to another,
they can be augmented to build debuggers,
in combination with partial evaluation they can smooth the way for
writing compilers.
"Jones-optimal" is a particularly desirable criterion for a self-
interpreter/partial-evaluator combination.
Anyway, Jones and his co-authors wrote a programming language for
"blobs", including a self-hosting interpreter.
Their blobs are something like Organic Builder's atoms, though they
didn't confine themselves to pairwise reactions.
The interpreter has a focus point, and on one side of the focus point
is a tree-shaped polymer, the program to run.
On the other side of the focus point, there is another tree-shaped
polymer, the data the program is manipulating.
I think if it were ported from Jones et al's formalism to Organic
Builder,
it would be like a universal computer constructor such as TJ Hutton
and Calcyman have built.
Johnicholas
Tim Hutton
Here's the PDF:
http://cs2bio10.di.unito.it/proceedings/paper_2.pdf
It's a great idea. I'm surprised the paper doesn't cite typogenetics
because that's pretty much what Hofstadter was talking about.
Dittrich's 2001 review of artificial chemistries gives a good overview
of similar systems:
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.7.7326
If we wanted to implement this challenge idea in Organic Builder we
would have to make some changes because there's currently no way for
the user to change the type of an atom, or to manually assemble a
molecule. But it might not be too hard. Organic Buider is open source.
In my 2007 paper I convert a gene-sequence into an enzyme which can
then act on other gene-strings. With a set of enzymes a sequence of
actions could be performed.
http://www.sq3.org.uk/papers/cells2007.pdf
If we allowed the users to program the genome of those cells then we
might make challenges around that system. This would also be a lot of
fun.
--
Tim Hutton - http://www.sq3.org.uk - http://profiles.google.com/tim.hutton/