QuoteOriginally posted by: katastrofaQuoteOriginally posted by: Traden4AlphaQuoteOriginally posted by: CuchulainnQuoteOriginally posted by: Traden4AlphaThe taxonomic/Darwinian approach to defining inheritance structures is the clearly superior approach on both logical and empirical grounds. From a maintenance perspective, the Darwinian approach encompasses the ultimate in long-term maintainability (with hundreds of millions of years of use and millions of successful subclass-generation events to prove it ). Organisms of any kind can readily spawn new subclasses of other kinds of related organisms. DNA is the ultimate in reusable and overloaded code.Maybe the core flaw that causes people to build fragile or incorrect class-subclass trees is that they focus too much on superficial external characteristics such as "can it fly" not realizing that flight may be accomplished in many internal ways (e.g., different configurations of bone, muscle, body mass distribution, and metabolism). It's the internal similarities (e.g., DNA patterns) more so than the external similarities that lead to robust inheritance diagrams.I don't agree. Darwin believed in predeterminism and DNA is hard-coded.So, I think you are referring to parametric polymorphism. Nothing wrong with that, its just not very flexible.Not sure what Darwin's thoughts on predeterminism have to do with how orinthologists classify birds based on evolutionary inheritance.DNA is far less hard coded than C++ code. The copy process for DNA is far more error prone than the copy process for C++ files. And almost all creatures get 50% of the DNA from each parent so the system is far more flexible than most code libraries.Not really. Programs too live in some environment and are vulnerable to assaults coming from there. For example (something everybody knows, but phrased as a response to this convo), in the past there were the popular buffer overflow attacks on the stack, which is now better protected, but the heap safety leaves much to be desired, e.g. redirecting pointers to virtual tables [*] is a relatively simple hack, which makes web applications so vulnerable (another argument for Cuchulainn to advocate using templates... even if they are less convenient and, if aimed at absolute safety, prone to different sort of "mutations", such as programmer errors). Finally, if one's really determined, they can try to overwrite the code area.* https://cseweb.ucsd.edu/~lerner/papers/ ... dfExellent
points. There's certainly an interesting overlap between biological and software viruses. In both cases, a foreign code chunk gains access to the system and converts it for replication and distribution of the virus.But programs have it easy. DNA copy error rates are on the order o 10^7 times worse than bit error rates in computers but the system is robust enough that it: a) does not matter than often; b) generally get culled if it does. Several hundred million years of virus evolution have created beasties that criminals could only dream about (e.g., the human hepatitis B virus is only about 1,200 -1,500 bytes in size). The average human is carrying around about 100,000 copies of various kinds of virus DNA amounting to about 5-8% of the human genome.