I’ve been watching the Beyond Belief 2006 conference on the relationship between Science and religion. While I didn’t agree with all of the views expressed I did learn many things.

• That when you ask someone to give up their religion, you’re asking far more than just giving up particular beliefs. In many cases you’re also asking, through implication, the abandonment of membership in a cohesive community, admission of being incorrect, possible alienation of close family or friends (both on social and ideological grounds), and a disruption to habitual lifestyle. For many, whose religious beliefs are more entrenched, you’re asking them to conceive of the world in a fundamentally different way; a way that, from their current viewpoint, is completely barren of meaning and purpose.
• That the world at large, and the scientific community by extension, has only just now gotten to the point where critical discourse on/about belief systems is not only possible but also tolerated. Only now are we becoming willing to fess up to the fact that sometimes what some other person believes has actual (possibly negative) effects on everone; that it’s not only the crazy religious fanatic that’ll suffer for his own foolishness, but that, if spread, those beliefs can hurt other individuals, and society as a whole.
• That scientists, because they are human, don’t really know what they want, and aren’t always successful at picking a strategy to obtain it. Sam Harris wants a world where social checks on destructive radicalism exist so that we can avoid fearing each other, yet he believes that religious moderation is perniciously bad because it’s not enough of a check, and its underlying scripture actually endorses some forms of violent extremeism. Dawkins wishes for everybody to live in a completely rational world, yet unfortunately expresses his views in a vitriolic manner. Both want to get rid of religion, yet their verbiage put it on the defensive, feeding the current meme that religion and science are in some sort of cosmic battle, thus undermining what they hope to achieve.
• Of the few that were in defense of religion, I really liked the account of Abraham arguing with God (who apparently is not always right), and the anecdote of the atheist that was told by his devoutly Jewish father that “The only sin would be to pretend.”
• I noticed that, of those mounting the attack on dogma, there was a refusal to wait for scientific studies in the areas of belief/scripture and it’s affects on behavior, group dynamics, and socio-economic systems. That waiting for this evidence is immoral because we should be devoting our resources to improving the human condition, rather than measuring it, as any time taken to measure is time taken from improvement (which compounds exponentially). So those attacking dogma most viciously, were themselves most dogmatic.
• That currently, more than half of society believes that the Earth is approximately 6,000 years old and that Evolution doesn’t happen. In a technological society, these beliefs are unsustainable. In order to continues scientific advancement, we need intellectual cooperation, the explicit acceptance of empirical findings and the rationale/explanations for those findings.
• Science has, thus far, remained largely silent on the issues of morality and ethics. This has resulted in the social tolerance of irrational, though dangerous, beliefs, on the one hand; and the polemical misuse of scientific findings on the other (social Darwinism, Eugenics, and other social engineering efforts) We have do develop in this area, so that we can, if not derive, at least suggest, “ought from is”.

Well, I actually agree with all the speakers viewpoints, and I think it’s important for scientists to do the following:

• Choose, as a goal:
  1. Stamping out all vestige of religion.
  2. Castrating existing religions so that they they have less chance of becoming destructively violent.
  3. Replacing religion with a form of moderate secular humanism
• Then choose a strategy that will effectively achieve that goal.
1. Propagate and popularize evidence that religion leads to destructive behavior.
2. Work with religious leaders to emphasize those parts of scripture that stress living in harmony with ones neighbors. Help to create systems of arbitration such that doctrine can be revised in the face of new empirical evidence.
3. (my favorite) Create an anthology of parables honoring important figures of Science (Newton and the Apple, Fleming and penicillin, etc…) Preach that these achievements are within the realm of everyday mortals, and not the exclusive domain of privileged genius. Use the work of folklorists, anthropologists, and social/group psychologists to create literature engineered to provide everything that religion currently provides: personal meaning, purpose, morality, community, social cohesion, anecdotal tales useful as memetic analogies and cultural themes spreadable as children’s bedtime stories. Replace religion with a belief in science, and do so in a scientific, purposeful, fashion.
• Work to promote the chosen strategy for the chosen reasons, and perform this work on the individual level.
• Stop the rhetoric about a war between science and religion.

Religion probably has the biggest problem with science, not because of a whittiling away of the “God of the Gaps” but rather, because the relentless progress that science makes is not only exponential because of feed-back mechanisms and therefore disruptive to the status-quo, but because it creates gods. No longer are gods the exclusive domain of historical fictions, Not when we can perform miracles. I can make light at the flip of a switch, travel through the air like a bird, command mysterious machines to do my bidding with cryptographic incantations (yes, I like the console). Medical technicians can make some of the deaf hear, will be able to let some of the blind see. Nuclear technicians have turned lead into gold (at extreme expense). We’ve put men on the moon. Yes, we are gods. And it’s time we started assuming responsibility for self-created power. Exposing religion for the non-acceptance of self-criticism is only the beginning. As science enables us to achieve godhood status we must develop a corresponding morality, for we can no longer afford subscription to the dictums expounded in history books.

Oh yeah, and Happy Holidays.

This is a highly speculative idea.

Lately, I’ve been dreaming of a system where inheritance would be extremely general. None of this hierarchical nonsense. I’m looking for something with more flexibility. I’m looking for dynamic binding, done as late as possible, along a directed graph. I’d like to allow for the possibility of cycles in this graph, which’ll probably throw a wrench in the works. We already have mechanisms for detecting cycles, and by marrying these with a yet-to-be-defined cannonical method resolution order that preserves the local preference ordering and monotonicity even in the face of cycles.

Even more outlandish is a recursive definition for a class, that is, a class that inherits itself. I have no idea where this might be useful, for I have not yet inundated myself with the dark literature surrounding mind-warping meta-programming. I also do not know how this might affect typing systems and substitutability.

Hopefully soon, I’ll be able to resolve some of these important issues, but for now I unleash the idea that inheritance and method resolution can be implement via a walk along a directed graph, possibly cyclic. At any rate, I’m gonna have to start teaching myself graph theory.

Ok, so we’ve seen that concurrency and inheritance don’t really mix that well. In fact, they don’t really mix at all. GoF say that we should prefer composition to inheritance. But I’ll be taking the extreme approach and asking “Can Inheritance solve problems that Composition cannot?”

I’m suggesting that we probably want to give up inheritance when we make the move to lightweight independent processes. Inheritance (and practically all it’s attributes) can be simulated using process composition.

• Interface Inheritance

Supposing that we wish to flesh-out a concrete implementation of an abstract interface, we have only to code up a process that responds to the correct messages. Unfortunately, if we forgo inheritance we also lose strict compiler checking, and are forced to check the completeness of implementation using debuggers or Unit Tests. We are still allowed to implement partial functionality, or to make a whole chain of abstract interfaces in this way. But the loss of compiler checking has important ramifications and drastically affects program architecture. But the generic methodology is to have the subprocess intercept all messages, and then send only the ones it can’t deal with onto the parent. Things get complicated when multiple inheritance occurs. Python’s duck typing has an interesting means of method resolution.

• Type Inheritance

Using the Liskov Substitution Principle as our model, we wish to be able to substitute a process (or entire process network) and have it behave according to the rules for a particular type. Normally this is done through the language’s type system in a rather simplistic manner (by looking the types up in a derivation tree). Type inheritance implies interface inheritance (otherwise we might try to call a method that doesn’t exist or send a message that can’t be received). Completeness of implementation can be achieved either by forcing the compiler to do type checking on the message, or to invoke an arbitrary rule: such as simply discarding messages that are not understood (with or without warnings/error messages).

We see that these are tightly-coupled concepts, for generality we’d like for a process understands all the messages a particular type can receive to be allowed to masquerade as an instance of that type, even though it might not be derived as such in the formal type system. Furthermore, we’d like the compiler to inform us of this possibility during the coding stage. But given that the most useful thing about a Concurrency Oriented Language is the ability to change the interconnection of the processes at runtime. This weakens the introspective abilities of the compiler, for it will no longer be able to report on the full list of messages accepted by a process because that happens much later, at runtime. In fact, we also might have to give up the entire notion of type if a process can be sent as a message to another process (and who wouldn’t want to do that?), because if we can’t type-check our processes, and they can be used as a message, then we can’t type check our messages either.

So, ultimately, what we want from the compiler is provable correctness, and what we want from the language is an easy means of code reuse. While we can always implement the calling and precedence rules ourselves when conjuring a network of processes, including delegation for multiple inheritance. This is a pain, and subject to programmer error.

I think our best bet is to provide run-time tools that will perform this of introspection. Erlang has been quite good in this respect. The real questions now become:

1. What are the common process structures (as opposed to data structures)?
2. Can we reasonably extend the type checking to include directed graphs with loops?
3. What are the new design patterns for processes? and how are these different from object design patterns?
4. How do we debug a concurrent system?
5. Do we have to implement the inheritance explicitly ourselves everytime? or are there linguistic constructs that will help?

Next time I’ll move focus onto a thought I had about type systems following arbitrary directed graphs. I mean, not everything in the world is best modeled as a hierarchical tree.