I almost forgot! I had a workshop at Skepticon


Oh, yeah, I did a workshop last Friday titled “Bad Evolution”. It was fun! Not quite as I anticipated, though.

It was a workshop. As I understand it, a workshop should involve audience participation, not just lecturing at them, and that’s what I prepared for. I had an exercise prepared, and I came with 50 handouts, just in case a lot of people showed up.

About 120 people showed up. Whoops. I might suggest that, in the future, Skepticon have some kind of workshop registration that allows us to set limits on the audience size, because that was too many, and it was kind of chaotic. Chaotic fun, rather than chaotic evil, so I guess it was OK, but it was still a little overwhelming.

Also, it was in a room with rows of chairs lined up, all facing straight ahead, which is also not conducive to workshopping. At least that was easily disrupted, and I had everyone destroying the tidy arrangement of the room.

Anyway, what we did is fairly simple. I talked for a bit, giving an overview of good strategies for handling discussions with creationists. I gave them this list of suggestions:

  1. Don’t be afraid to say “I don’t know.” Honesty is always a good idea.
  2. Go meta if you’re asked a difficult question. Do they know the answer? Why are they asking you? Is it a sincere question?
  3. If you have an answer, don’t let them dodge it. Follow up. Pursue a line of argument.
  4. Focus. It’s better to skip an opportunity for a good jab in order to build a strong story.
  5. Ask questions of them. You are not a passive oracle at their bidding.
  6. Question their assumptions. Be prepared to have your assumptions questioned.
  7. Demand sources. Science is built on the shoulders of giants, they must be acknowledged.
  8. Patience pays off. You’re not engaged to go in for a kill, you’re having a conversation.
  9. You will not convince the creationist, or “win”. Resign yourself to that.
  10. Keep your perspective and a sense of humor. These people are ridiculous.

I walked them through a couple of simple examples (“If evolution is true, why are there still monkeys?”), and then handed out a long list of much more difficult, more subtle creationist claims, and had one person in the group pretend to be a creationist, present one claim, and then let the others try to rebut them. The main point was to both cultivate a little empathy for the creationist argument, stupid as it might be, and to show that even someone on the side of science might be stymied fairly easily.

For example, here’s one question from my list (which was taken from a collection of bad arguments from the mindless pen of David Buckna):

Microsoft programmers utilized complex codes to create the Windows 95 software. The genetic code, which is more sophisticated, controls the physical processes of life and is accompanied by elaborate transmission and duplication systems. How does evolution, using natural processes and chance, solve the problem of complex information sequencing without intelligence?

The average person would have difficulty responding to that. I think it’s important for us to not take for granted that the answers are always obvious…even when I might find anyone question easy to answer.

Go ahead, try to answer it in the comments, but note that “You’re stupid” and “Citations to the peer-reviewed literature or GTFO” are not on my list of recommended strategies.

Comments

  1. aziraphale says

    My quick answer to Buckna would be that there is an expanding field of work, genetic algorithms, which shows precisely how chance variation plus selection can produce useful complex information.

  2. Nullifidian says

    How detailed do you want our answers? Is saying, “Go read Darwin’s ‘On the Origin of Species'” good enough? Or poking fun at Paley?

  3. davidnangle says

    The biggest opening I can see is, “… using natural processes and chance…”

    Life doesn’t “use” processes, it results FROM processes. Chance is almost erased from consideration due to the necessary long-term progression of biochemical interactions. It isn’t “chance” when hydrogen and oxygen combine to form water.

  4. Rich Woods says

    Who says that evolution solves the problem of complex information sequencing? It sometimes doesn’t, just like Windows 95 sometimes didn’t. Where’s the omniscient intelligence in that?

  5. anat says

    Yeah, regarding that ‘sophistication’ – I remember explaining how the genetic code worked to my brother, who was studying computer engineering at the time. His response was that it was a pretty stupid way to do things, so much room for error.

  6. kevinalexander says

    Chance is only involved in alterations in the code. If by chance the alteration is harmful then that’s the end of the line for that iteration of the code. There are still other living examples of copies of the ‘code’ that keep life alive and their chance alterations were helpful or at least not fatally harmful. Every living thing on earth is the successful result of an unbroken line of iterations from the first simple ‘code’. The ones whose luck ran out are in the fossil record.

  7. Matt says

    That actually is a fairly difficult question to answer in a satisfying way in the short period of time allotted during a debate. Allusions to the spontaneous formation of complex molecules from simpler precursors aren’t very satisfying because there’s not an obvious link between that and the vast information store in DNA. And we don’t really have a perfect idea of how the genetic code evolved: we can see evidence THAT it evolved and make informed speculations about how, but I’m not sure how satisfying that is to a skeptical audience either. Another problem is Orgel’s second rule: “evolution is cleverer than you are”, so attempts to show how it is imperfect or inefficient often seem to succumb to a sort of evolution of the gaps, where imperfect seeming parts of the evolutionary framework turn out to have good reasons for being the way they are. I confess that, not being an expert, I wouldn’t have a good answer to this question: it’s just the right combination of vague false analogy and using evolution’s own strengths against it.

  8. John Harshman says

    First you would have to establish a little clarity. He isn’t actually talking about the genetic code, which is ridiculously simple: 64 codons, 20 amino acids + stop. I think he’s talking about the entire process of control of development and metabolism. And yes, that is complicated, and it extends way beyond the genome. Or perhaps he doesn’t quite know what he’s talking about. I don’t know what “complex information sequencing” is either.

  9. alkisvonidas says

    I would point out that the genetic code is a very different kind of code than (imperative) computer code. Imperative computer programs have very little tolerance for modifications; one misplaced instruction and the whole thing is dead in the water. The genetic code is highly modular; it is a bit like those group stories, where each person involved can add their own little twist, and the others keep working on the story as it progresses. Genetic code is well suited for exploring the available information landscape.

    Of course, this doesn’t answer the very important question of WHY the genetic code is so modular in the first place. One good reason are the mechanisms of sexual reproduction: genes are “reshuffled” regularly, so they have to be able to function semi-independently. And what about asexual lifeforms? Well, bacteria have been utilizing a form of gene-exchange similar to sex since very early in the history of life, and it is possible that independent genes (“replicators”) merged to create the first cellular life.

    Feel free to poke holes in my hopelessly simplistic narrative :-D

  10. Usernames! (╯°□°)╯︵ ʎuʎbosıɯ says

    Easy: Windows 95 was designed with a specific set of purposes: to act as an intermediary between applications and hardware, standardizing all the interfaces.

    64 codons, 20 amino acids + stop
    — John Harshman (#11)

    Yeah, no comparison to the C language, along with assembler, which is what Windows 95 kernel was written in.

    If an application wants to display text or graphics on the user’s screen, it calls a specific Windows 95 program interface with the correct parameters and Windows takes care of actually displaying the information on the user’s screen. There are similar functions for accessing the user’s hard drive, sound card, network, keyboard, etc.

    DNA (genetic code) on the other hand, was designed with no such purpose, because it wasn’t designed. What happened was accidents (random mutation) with successful (for increased organism reproduction) or neutral changes were more likely.

    A flawed, but illustrative argument:

    Grab a sufficiently-large size box of pennies and flip them all. Throw out all the ones that came up tails. Flip the remainder. Repeat for 15 generations. The coins that are left were not “designed” to come up heads. Their random orientation was advantageous to making it to the next generation (tails = death), that’s all.

  11. alkisvonidas says

    @kevinalexander

    The ones whose luck ran out are in the fossil record.

    Actually, some of the most successful life forms that ever lived are in the fossil record. I very much doubt anything seriously maladapted would live long enough to leave an imprint in the Dust of Ages. We really don’t see the dropouts of the evolutionary race.

  12. lee101 says

    Related to genetic algorithms is genetic programming, which starts with very simple snippets of programming code and applies processes analogous to those in evolution to combine those snippets to produce computer programs which can do very complex things, often things that have never been done before, and that would take human programmers years to accomplish. The main contribution of a GP trainer is a “fitness function”, but in the case of living things, that function is built-in: natural selection, sexual selection etc.

    I would say that computer science is not a good source to draw on for arguments against evolution. The evolution paradigm has been far too useful in computer science.

  13. cvoinescu says

    I am sure by “code” they mean what’s encoded in DNA and the machinery that works with it, not the relatively boring correspondence between codons and amino acids. The question is unclear — specifically, “information sequencing” is ambiguous — but it could be a form of “how does the amount of information in DNA increase over many generations?” — but it may well be “development and/or physiology need certain things to happen in a specific order; how is that done?”.

    Both are fascinating questions, quite different but surprisingly related. My understanding is that the answer to the first one comes from genetic material duplication (for instance, through copying errors), which gives redundancy and frees one copy to diverge; most of the time, it diverges into junk, but every so often it ends up doing something useful. One needs to emphasize that this is possible because there aren’t simply “many” generations — the number is so large as to be staggeringly incomprehensible.

    The second question brings up chemical gradients and Hox genes and others I’m less familiar with, as well as regulatory elements, cascades, feedback loops, and so on. I may not be prepared to give a lot of detail on the spot, but I can stress that many of the mechanisms are well understood in quite some detail.

    The connection between the two readings of the question is that these mechanisms themselves have been duplicated many times, with some of the copies re-purposed for new goals.

  14. felicis says

    “Microsoft programmers utilized complex codes to create the Windows 95 software. The genetic code, which is more sophisticated, controls the physical processes of life and is accompanied by elaborate transmission and duplication systems. How does evolution, using natural processes and chance, solve the problem of complex information sequencing without intelligence?”

    Short answer – by taking nearly a billion times as long, and utilizing the variation that comes with random processes with an enormous number of attempts to get something that works just well enough.

    Longer answer – how much time do you have, and in how much detail do you want the answer? We still don’t know *all* of the details, but we do have a fairly good idea of a lot of it, as well as some plausible explanations for what we are missing (good enough to know where to look and how to check if we’re wrong). But without knowing what you are looking for, I am trying to meet a standard you haven’t stated – allowing you to move the goalposts after any answer I give.

  15. stevewatson says

    I’d be tempted to reply to the Buckna-bot:
    “That’s a load of word salad tossed together by an ignoramus who’s trying to sound knowledgeable about computers, and until you can ask a coherent question, I’ve no obligation to waste time on you. And BTW I’m a software engineer with a better-than-average understanding of mol-bio, so I do know what I’m talking about when I dismiss it as word salad.”

    And walk away.
    (Yeah, I know: I’m supposed to try to parse out and reply to the underlying question, but…damn.)

  16. says

    Stop trying to compare a human designed coded system with a random/selected patten recognition system.

    One is comparing Windows version 10 with something like living organism with a version number such as 100,000,000,000,000 or more is you go back to random chemical reactions in some primordial soup.

  17. grahamjones says

    Prokaryotes.

    Prokaryotes did all the hard lifting. Prokaryotes wrote the operating system of life. Eukaryotes are apps. Prokaryotes did it by making a million million million million million mistakes. Windows 95 programmers made fewer mistakes, because they were intelligent.

    (I agree with cvoinescu at #17 that “genetic code” in the question does not refer to codons and amino acids, and “sequencing” means something like “programming”.)

  18. lee101 says

    Slightly less relevant, but still interesting to consider that Windows95 is itself a by-product of human evolution, mediated through the human brains that were very much part of that process. Not quite so direct or consistent a product of the extended phenotype as a beaver’s dam, but still a product.

  19. Zmidponk says

    Well, I think I’m a fairly average person, so here goes:

    In a sense, Windows 95 is an example of directed evolution – it evolved from Windows 3.1, which evolved from Windows 3.0, which evolved from Windows 2.1, which evolved from Windows 2.0, which evolved from Windows 1.0, which wasn’t really an operating system, but an extension to MS-DOS, and MS-DOS has it’s own train of evolutions from earlier versions, and the first version imitated the CP/M operating system from the mid 70s in several ways, so could be said to have evolved from that in turn. CP/M would be considered today as a very clunky, difficult to use thing that is almost unrecognisable as an operating system to modern eyes, yet is relatively simple from a coding perspective (the first version ran in 3.5 kilobytes of memory). Windows 95, in comparison, was a relatively smooth, easy to use program that resembled the operating systems we use now, 20 years later, in many ways, but is much more complex in terms of coding, requiring 4 megabytes of memory, over 1000 times what CP/M needed, but didn’t really perform well on hardware with less than 8 megabytes of memory, over 2000 times what CP/M required. This process of evolving one into the other took 22 years (CP/M was written in 1973, Windows 95, as the name suggests, was released in 1995). Evolution manages the same sort of feat in an undirected manner by simply taking a hell of a lot longer to do it.

  20. Kilian Hekhuis says

    For one, that first sentence shows a remarkable lack of knowledge of programming. Microsoft programmers didn’t use “complex codes”, they used C, a fairly simple programming language…

  21. cvoinescu says

    Zmidponk @24:
    I think you muddy the waters by using “evolution” in the general sense, because the process Windows went through was fundamentally different from biological evolution. Sure, codebases and core concepts are reused, so there is a succession of ancestors; there’s even some randomness (e.g. in the finding of bugs), but there’s never a population of operating systems, and the direction of change from one version to the next is hopefully well under the control of the company at the large scale, and under that of the programmers in the detail. Windows is no more the product of evolution than Paley’s watch is.

    Kilian Hekhuis @25:
    Speaking of “codes” is as telling as the confusion between genome and genetic code.

  22. rpjohnston says

    1. “The genetic code is more sophisticated” is a baseless assertion. They are two fundamentally different algorithms and cannot be comapred on a single metric (which you also have not defined in any way, by the way).

    2. There are quite a few ways that the genetic code is manipulated by natural factors. One of the simplest and most familiar is natural selection; normal physics creates changes in the code during development, and mutations that are helpful or neutral in helping the code survive get passed on. The mutation rate is high enough to create a few new genes each generation, but low enough that any particular gene is unlikely to be changed at any given iteration. Of course, there’s FAR more to it than this; it encompasses multiple disciplines and several levels of university classes to get a through but base understanding, which I obviously can’t give to you on the spot. If you’re honestly interested in finding out more, I can point you toward resources; or simply looking up evolution and wikipedia can give you a cursory understanding the most major points. If you only asked as a “gotcha” and don’t care about the information, then I have answered your question as thoroughly as needed to pass your goalposts.

  23. Zmidponk says

    cvoinescu @26:

    I think you muddy the waters by using “evolution” in the general sense, because the process Windows went through was fundamentally different from biological evolution.

    Well, I would say it’s actually Buckna that muddies the waters by making the comparison in the first place, and, yes, the two processes are fundamentally different. My post was an attempt to ignore that, as it basically means the question is fundamentally flawed to make it more or less unanswerable, and answer it – and I’m still coming to the conclusion that there is actually an answer that is correct that fails to disprove biological evolution.

    Sure, codebases and core concepts are reused, so there is a succession of ancestors; there’s even some randomness (e.g. in the finding of bugs), but there’s never a population of operating systems, and the direction of change from one version to the next is hopefully well under the control of the company at the large scale, and under that of the programmers in the detail. Windows is no more the product of evolution than Paley’s watch is.

    It is arguably directed evolution – the developers take a look at the current version, decide what they want in the next version and alter the code to make that happen. Each subsequent version is based on the previous one, so the code evolves from version to version, and there is no ‘population of operating systems’ required.

  24. cvoinescu says

    Zmidponk @29:
    Of course the waters are terribly muddy to begin with. No argument here.

    It is arguably directed evolution – the developers take a look at the current version, decide what they want in the next version and alter the code to make that happen.

    I’m sorry, that is true, but I disagree that it’s at all useful. That’s the same approach I take when redecorating the house, or doing any number of activities, including eating. I can easily evolve a plate of food into an empty plate. It’s an incremental process.

    Okay, no, perhaps that’s not fair. But bringing up the evolution of software does not do more to shed light on the biological process of the same name. You would not bring it up in a discussion with a creationist, except perhaps to contrast it with biology.

  25. Zmidponk says

    cvoinescu @30:

    I’m sorry, that is true, but I disagree that it’s at all useful.

    Outside of this question, yes, it’s entirely useless. However, the subtext to this question is more or less ‘Windows 95 is a very complex bit of coding, so is the genetic code. Windows 95 didn’t evolve, so the genetic code couldn’t have either.’ I’m showing Windows 95 actually DID evolve – it just did it through directed evolution, by a succession of programmers and developers, from much simpler code.

    Okay, no, perhaps that’s not fair. But bringing up the evolution of software does not do more to shed light on the biological process of the same name.

    Mainly because I’m not trying to.

  26. 2-D Man says

    I’ll take a crack at it. I’m neither familiar with software engineering nor biology. At least, not beyond the most basic level. So I’m taking a tack that I haven’t seen in this thread so far.

    By using the word “sophisticated”, it seems like you’re pointing at Windows 95 and saying, “That is complex, therefore it was designed.” and then pointing at a human and saying, “That is more complex, therefore it was also designed.” The trouble with this argument is twofold: 1) complexity is a slippery concept at best (more on that if we have time [ie another comment, if anyone’s interested]) and 2) complexity does not imply design.

    I want to focus on the second one because it’s more straightforward. This whole argument is a long descendant of William Paley’s argument of a watch on a beach. He also concluded that the watch was designed because it was complex. But you would never do this.

    Think of how you would even notice that the pocket watch was there: because it is shiny, unlike the sand around it. Go pick it up, and you’ll notice that it is smooth, unlike the rocks, Examine the materials, they’re remarkably pure. Notice a pattern? All of these are things that contrast the watch with its surroundings.

    And there’s the rub: if you want to show that anything is designed, the best way to do that is to show that it doesn’t match the things around it.

  27. prae says

    I’m a software developer, and I was thinking about this “ZOMFG DNA IS CODE!!1” thing quite recently. The most obvious thing is: There isn’t anything resembling a Turing machine in there. It’s a good thing that DNA isn’t code, too: a program is quite easy to break, delete one byte and it probably won’t even start, or start behaving wildly different. You won’t end up with a slightly different program, like you would end up with a slightly different protein which might even still work if you damage a gene.

  28. Matt says

    @prae There are analogies to branch instructions and loops and storage and manipulation of data structures in DNA. And insertion-deletion systems apparently have considerable computation power. Also, there are many bytes that can be deleted from a typical program without causing the program to malfunction noticeably or at all. For instance, the bytes that describe pixel brightness on a CRT display. In addition DNA molecules, like computer programs, are embedded in an apparatus/environment that is constantly checking for and repairing errors. Anytime you transfer or copy a computer program, there is a robust error checking and correction apparatus working behind the scenes. And there are many places on the genome where a single nucleotide polymorphism (that is a mutation in a single letter of the DNA code) can cause woeful effects, e.g. cystic fibrosis, sickle-cell anemia, a few cancers, etc.

  29. cvoinescu says

    Zmidponk @31:
    Okay, I see where you’re going with that, and it’s fine; it’s just that I’d rather focus on the part you gloss over in the last sentence of your original post:

    Evolution manages the same sort of feat in an undirected manner by simply taking a hell of a lot longer to do it.

  30. prae says

    Well sure, a mistake in a string or image stored in the software won’t make it crash, but in a place where actual logic happens? For example, you erase an opcode, and the processor interprets what used to be the register on which to run the operation as an opcode, and keeps interpreting everything past it wrong, too.

    I wouldn’t compare file integrity verification to dna integrity verification either. The way I understood it, DNA can only be repaired when no information was actually lost, if it only occured on one side of the helix, or if the bases are still present but malformed, or if the strand has been cut. To do it the computer way, you would need some sort of a “checksum calculase”, which would run along the DNA strand and create a shorter sequence based on it, then copy the strand, then do the same on the copy, and then use some sort of a “comparase” to compare them, and if they don’t, throw the copy away and try again. It would also help to keep backup copies of chromosomes, and I mean real backups, not just being polyploid.

    Mh that article might be interesting, but I’m not going to pay them 50€ oO. The question here is: does nature actually use these insertion-deletion systems for any kind of calculation or are they just possible? A system which are able to edit DNA, depending on the DNA, at least sounds like it could be turing-complete.

  31. Owlmirror says

    A while back, Paul W. wrote an interesting comment suggesting that DNA transcription/translation was like a production system computer; a computer in a broader sense of the term:

    To use a string of CS buzzwords, the particular kind of computer that the basic gene activation and transcription mechanisms implement is parallel, asynchronous, forward-chaining production system.

    What that means is that the program is mostly just a set of rules that say what do in response to what.

    A typical (non-structural) gene is just an if-then rule (a “production”) like

    IF A and B and not C THEN C and D and E

    The program variables A, B, C… are implemented as concentrations of chemicals in the nucleoplasm. (More precisely, they’re represented by the relevant binding sites on the molecules of those chemicals.)

    This is not an IF-THEN statement like in a serial program on your PC. It doesn’t get executed because the previous statement was executed and it’s the next one, and it does not implement flow of control. (There are no GOTOs in this machine language. There is no sequential stream of control to tell where to go.)

    A rule in a production system is less like a statement in a serial program than it is like a an axiom in logic. The above rule (sorta) says that if A and B are true, and C is not, then the rule can “fire” and “produce” something that says C and D and E and put it in the working memory of the computer, to affect which other rules can “fire.”

    In biological terms, one rule is represented by one gene, and the preconditions on the “left hand side” of the rule are represented by promoter and repressor binding sites–places that molecules with appropriate sites can dock to enable or disable the gene from being transcribed.

    When the rule fires, i.e., the gene transcribed it produces a molecule (transcription factor) with binding sites that implement C and D and E.

    It’s very different from a serial, sequential von Neumann machine, but it’s a well-understood kind of computer. It’s certainly well-understood that if you implement one in hardware (as opposed to simulating it in software), it is definitely a computer. It’s way more than it needs to be to be just “a computer,” and is a pretty interesting, flexible kind of computer.

    (there’s more before and after, but I think that gives the sense of the core idea)