Thinking about Biology and C.S.

I really should tag these entries in the first paragraph by type — so those only interested in some could skip reading the others.  This is philosophical, and tangentially related to Comp. Sci. theory (my own, of course).

I’ve read for a long time now the musings of Steve Talbot at NetFuture.  (I’ve already referenced that writing previously), starting back when the focus was more The Future Does Not Compute — an interview on that topic introduced me to this website.

Today I learned an interesting word.  One would ask why, if I consider myself having any philosophical training at all, I haven’t heard of it before: entelechy — the “vital force” in Aristotelian philosophy.

But even if the latest article did not reference AI (and thus all software engineering), I’d make the connection myself — something vital is lost.  By the way, this is an angle of attack against Kurzweil different that other, more pragmatic and, perhaps, “easier” disagreements.

I’m going to urge you to read that article, at least most of it, before getting to the last paragraph, and the following will make more sense if you understand the gist of what he’s saying, also.

On a personal/theoretical/odd tangent: this captures somewhat my notion that a teleporter would not work, not for any physical/practical reason, but that life is something more than chemical/molecular — though I do wonder about preserving quantum states — more than that, it is “motion.”  Say nothing about the spiritual aspects of life, which cannot be “transported” via matter-to-energy-to-matter conversion, the mere fact of a precise, exactly duplicate model of a living organism is not enough to re-produce the same entity — it’s gesture cannot be so easily captured.

So the application to software engineering is this: static analysis is never enough — the dynamics of the system must be considered, and considered well.  Not very earth-shattering, I know.  Common sense, even.  It may be obvious, but any experienced programmer is “automatically” doing a “run-time” analysis when s/he is trying to debug a problem — at the meanest level, you have a finger, or pen, moving along the code (probably with some scratch notes about various states), but when were you taught this?  If ever.  (More experienced developers have some advanced technique beyond pen and paper, but it boils down to the same thing, no?)  Rather, if you were taught any kind of analysis at all, it was quite static.  Or am I alone in that?


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: