[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: lynx-dev Concerning the use of abort in the source of lynx

From: Michael Sokolov
Subject: Re: lynx-dev Concerning the use of abort in the source of lynx
Date: Sun, 4 Jun 00 19:57:47 CDT

pAb-032871 <address@hidden> wrote:

> About the genetic decoder you're building; a lot of genetecists
> refer to DNA as a biological data structure, but don't *really*
> treat it like one, do they?  Great stuff.

Those who specifically work with DNA (not just biologists in general) do
understand that it's data, but not being computer scientists, they can't make
real use of this knowledge. You really need to live and breathe computing and
information sciences to solve this problem. Biologists obviously don't. Now
this is *not* a disrespect to them. Their work is essential for handling the
actual chemical processes and physical means of observing and affecting them.
However, in addition to that a good computer scientist has to do the computer
science part.

And speaking of which, the DNA program isn't just data, it is a *program*,
i.e., executable code, or microcode to be more precise. The ribosoma, the cell
organelle that processes the DNA strand, executes it almost exactly the way a
classical von Neumann fetch-execute processor executes instructions. A deeper
analysis shows that the closest familiar equivalent of the ribosoma is the
microsequencer unit of a processor, which executes microcode from the control

As any logic design textbook would show, any sequential circuit (i.e., any
circuit whose output and subsequent behavior depends on the sequence of all
prior inputs) can be viewed as a finite state machine (FSM), which is most
directly modeled as a register holding the state, the next state function, and
the output function. A computer CPU is also a sequential circuit generally
speaking. Of course, if viewed directly as a sequential circuit, it would
explode astronomically and such a view is possible only in very abstract
theory. The simplest (in terms of least internal state) computer CPU I know of
is the basic PDP-11, which has 8 16-bit general purpose registers (including
the program counter and stack pointer) and a 16-bit processor status word.
These registers constitute all of its internal state. But if you do the math,
it's 2^144 (about 10^43) states, that's almost Avogadro's number squared!
Therefore, viewing a computer CPU directly as an FSM is possible only in very
abstract theory. In reality, CPUs have a lot of registers and internal data
paths and are quite complex internally. But as the same logic design textbooks
would show, in order for a circuit to exhibit sequential behavior, there has to
be an FSM in it somewhere, even if not directly. And CPUs are FSMs, just not
directly. They have registers that hold the macrostate, but the only a small
part of the CPU is directly implemented as a sequential circuit, and that is
the microsequencer. The macro operations performed by the CPU and its macro
state internally break down into microinstructions and microstates, which are
simple enough to be implemented directly as a sequential circuit.

Exactly the same holds for the DNA program. The ribosoma that directly
processes it is the microsequencer, and the two-bit codes in the amino acid
residues are the inputs to its FSM. The myriad of state transitions in this FSM
then logically form into macroscopic operations that eventually create us.
These can then be described by higher-level FSMs, which is what I'll be doing
to regenerate damaged tissues.

Michael Sokolov         Harhan Engineering Laboratory
Public Service Agent    International Free Computing Task Force
                        International Engineering and Science Task Force
                        615 N GOOD LATIMER EXPY STE #4
                        DALLAS TX 75204-5852 USA

Phone: +1-214-824-7693 (Harhan Eng Lab office)
E-mail: address@hidden (ARPA TCP/SMTP) (UUCP coming soon)

; To UNSUBSCRIBE: Send "unsubscribe lynx-dev" to address@hidden

reply via email to

[Prev in Thread] Current Thread [Next in Thread]