Current Articles | RSS Feed RSS Feed

4 Things Life Can Do that Engineers Can’t

Posted by Andy Singleton on Mon, Oct 01, 2007 @ 10:53 AM
Digg digg it | Reddit reddit | del.icio.us del.icio.us | StumbleUpon StumbleUpon 
In the future we will understand how evolution works and we will see into the structure of life. This will be the basis for a powerful, or at least dangerous, new engineering capabilities.

We are making inevitable progress towards this understanding. However, right now, we can’t see it. When we have this understanding, I think it will come in the form of basic principles that apply to any dynamic system, biological or not. These principles will explain the party tricks listed below, and more.

Here are four things life can do that engineers can’t:

1) Make something big by starting with something small and expanding each part

That is a great way to start a business.

Growth is, I think, the most dramatic difference between living and nonliving engineering. Life always builds this way. At least in the realm of material objects, engineers never build this way. Imagine going into a car dealership, getting a tiny car with tiny little metal parts, and somehow expanding it later. It’s hard to imagine how that would work. On the other hand, I have seen enough science fiction movies to know that if something swells up, extrudes appendages, and starts chasing you, it must be alive.

2) Grow all of the differentiated parts of an organism, starting from a single cell, using only local cell-to-cell signaling.


3) Make 100,000 proteins from 30,000 genes

The human genome project found about 30,000 genes. We suspect (but do not know) that there are more than 100,000 proteins in a human body. Each set of genetic instructions can be used in multiple ways “alternative splicing” to make a protein machine. Our feeble human brains may never understand how this encoding works, but I think we will figure out why so much overlap is used.

Imagine if you made a machine where each little piece knows where it should be and what it should become, and where this knowledge changes synchronously over time. Hmmm…

4) Make a brain with 100 billion neurons using 10,000 or so genes

The brain is very complicated, with specific organs, intricately connected, and very subtle and specific instincts that are hardwired in. It controls thousands of types of motion and detects innumerable patterns. What organ helps us learn to talk? What about Chomsky’s universal grammar? We keep discovering new wiring. Heard about the experiment that showed men will spend more money after they look at pictures of pretty girls? If you look through the psychology literature you find thousands of these built-in behaviors. And they all come from a small number of genes. It seems that the genes start the brain off, and then it picks up structural information from its environment as it goes, in some very deterministic way.

There is hope. If we understood 1 and 3, we could probably figure out 2. The answer to 4 is probably the same as the answer to 2.

I’m going to make some guesses about the principles behind trick number one – making something big by starting with something small and expanding each part. I think that a key principle of a device that grows is that it is cellular. Each part is composed of a number of cells, and it can expand by increasing the number of cells per part. Furthermore, I would guess that a second principle is that the cells are substitutable – they can be replaced by other similar cells and the part will still be useful.

These are certainly characteristics of the plants and animals that we know. I think they are general principles because they also apply to something else that grows by expanding its parts – an organization of people. The organization grows by increasing the number of people (cells) in each function, and it survives turnover.

Principles like these can be applied to build software and systems that have smooth upgrade paths. Maybe someday we will buy baby cars, too. I hope they don’t bite.

COMMENTS

Actually, engineers CAN do this using L-Systems - a concept that's been around for a long time. The short version is you define a term rewrite system, and then start with a term and then iteratively rewrite it. Kinda the opposite of language parsing. There's lots of different sorts of l-system, but they all work in a similar way. You have a grammar, such as this: T$ -> T B B$ -> T B B$ -> L B -> L L -> [X L] [Y L] [Z L] L -> T B You add an interpretation onto this - traditionally based on a concept like a turtle from logo, but it doesn't have to be that. * $ means the token is at the end of the string * T can mean "trunk" * B can mean "bud" * L can mean leaf * [ means remember position * ] means return to last remembered position. Also counts as an end of string. * X means rotate by a given angle in space * Y means rotate by another given angle in space * Z means rotate by yet another given angle in space This can then be "run" to allow the growth of a tree. You can have deterministic growth or stochastic. In the above I've weight the two "B" terms as 50:50, and the two "L" terms as 50:50. You also have a start token - in this case T. The term rewrite then looks like this (assume our random number generator flips between possibilities. T$ T B$ T T B$ T T L$ T T [X L][Y L][Z L]$ T T [X T B][Y [X L] [Y L] [Z L]][Z T B]$ T T [X T T B][Y [X T B] [Y T T [X T L][Y [X L] [Y L] [Z L]][Z T T B]$ As you can see (hopefully) this grows quite quickly into an interesting shape *and* matches what you do actually see in nature - cell division & specialisation. Consider the information you need here: * The data for the grammar - in this case we have 9 tokens, you need an end of match & end of rewrite marking meaning 11 tokens. That means those tokens fit inside 4 bits each, with 49 tokens needed in total - making 200 bits. I'm guessing that you can probably do better. * ie T$:T B|B$:T B|B$:L|B:L|L:[X:L]:[Y:L][Z L]|L:T:B| However what can you generate? You can generate as big a plant from this as you like. Indeed as you can see it grows exponentially really quickly. (Often approx inline with the fibonacci sequence) I did this for my third year project at Uni, and it was fascinating then, and the idea of growing systems, especially software fascinated me. I don't think we're there yet, but Kamaelia (my pet project) is influenced by this (among many other things), and we're getting closer to being able to do some of these things. Though nowhere near as elegantly as biology as yet. Incidentally, if this seems complex, consider this: Logo is a language written for children, and they like it. L-Systems are simply a minor extension to the ideas in Logo. (The L in L-systems stands for Lindenmeyer - the fact that Logo is a turtle language which matches well with this is a happy coincidence!)

posted @ Thursday, October 11, 2007 11:28 AM by Michael Sparks


Gah, all the blank lines and spacing have been deleted. :-(

posted @ Thursday, October 11, 2007 11:29 AM by MichaelSparks


Post Comment
Name
 *
Email
 *
Website (optional)
Comment
 *

Allowed tags: <a> link, <b> bold, <i> italics

Receive email when someone replies.

Blog Navigator

Navigate By : 
[Article Index]

Subscribe by Email

Your email:

About This Blog

Accelerating Software Development with Agile, open-source style processes, distributed teams, on-demand teams, new product launches, Web 2.0 strategies, startups.  Author Andy Singleton builds new products fast.

About Us

Assembla offers services for building software with agile, distributed teams.