No matter how it's explained, I still can't wrap my brain around how evolution produces complex systems. How do systems with interdependent processes and parts get produced by a process that seems to proceed stepwise?
You're a programmer, right? A lot of people on here are.
You know how when starting something completely from scratch, there is so much foundational work to do, making frameworks, helper libraries, classes, etc. You have to do all that stuff before your program can do much (assuming no third party libraries).
Well, once your code base (or just your knowledge of existing libraries) is advanced enough, you can more easily combine pieces of it with relatively small changes to the code. You can mix and match parts and the result will be something very complex that may be based on person-years worth of work while only taking a few minutes to assemble.
Pieces of code can be removed from the final product with a one line change. While the code still exists in the final product, it isn't referenced anywhere.
These are a couple of analogies that help me think about it. They don't explain everything, but it should be enough to make clear that just because evolution works by "stepwise" changes that doesn't mean one step can't create huge differences.
Complex organs have developed from simpler organs in a series of small incremental improvements, while the organ all the way have been fully functional.
Think of it like iterative developing a program by adding or modifying one line at a time, while still keeping the program runnable. You can start from a simple program and develop it into a complex program with this method, although it will be a very tedious and inefficient process compared to if you were allowed to rewrite multiple lines in one go. But evolution works in small increments.
If you add to your analogy that you have no knowledge of the existing codebase, and you have no idea what you're adding or modifying, then you understand my difficulty grasping the concept. Thanks for the reply though!
Essentially you start with a random program and iterate on it using an evolutionary model. The point of these algorithms is precisely that an understanding and knowledge of the code base is not required. All that's necessary is some way of measuring the program's fitness for a task.
Right, but if you had _billions_ of years, you could still write an amazing program, even if you have no knowledge of the codebase and no idea what you're modifying.
Well, my point was that it is not just time, but also the massive parallelism. Both combined is just such a phenominally mind-bogglingly large amount of exploration.
Complex systems can originate from simple environments. If you're mathematically inclined, I invite you to read Wolfram's book "A New Kind of Science", it does a great job of showing processes like this, for example with cellular automata. The key take-away is that complexity isn't necessarily the product of an even more complex birthing mechanism, but that complexity can and does frequently arise from simplicity, a notion most programmers should be familiar with as well.
> How do systems with interdependent processes and parts get produced by a process that seems to proceed stepwise?
Slowly, and in very small steps. Not every step produces a "useful" change, either: most mutations are fatal, the rest is by and large neutral.
The initial biosphere was relatively simple, but after hundreds of millions of years, the system has grown huge and complex.
You can visualize evolution by imagining a search space, being explored by a myriad of different configurations (of organisms or machines). Configurations that survive, survive. The others are filtered out. Surviving configurations get to explore more of that search space and the process repeats. Over time, this leads to some pretty neat architectural advances (but any biochemist will agree there's a lot of horrible, unfixable spaghetti code in there as well).
We only get the impression of very high complexity and lots of interdependent processes because we look at a very mature ecosystem. Things would be easier to grasp if we were restricted to looking at very early microbes. The principles are the same, though.
When you are backed into a corner, you accept whatever is left to explain the complexity at hand. Then you pretend that you understand it. Collect enough these "understandings" of complex stuff and you will be able make analogies between them or even offer "little secrets" for the uninitiated.
