Author Archive for Jason MorrisonPage 2 of 3

Cell signaling, computer architecture, functional programming, and AI blackboards

While thinking about synthetic biology, I find it useful to identify analogues of biological systems in a discipline I am already familiar with, computer science. This helps me better understand the new concept and can also raise questions about the new system that already have discussions around them in the CS world. Of course, the fidelity of such metaphors is not 100%, so I have to take care to ground such discourses with actual biology, but it’s been great for brainstorming so far.

Here are a few such metaphors.

Computer Architecture

One challenge in building composable biological systems for effective abstraction hierarchies is cell signaling crosstalk. One issue at play is a possible shortage of signal carriers; if you need ten different processes to occur at the same time and to act orthogonally, you will need ten signal carriers. Much as CPUs have a finite number of registers and data buses have finite width, there are only so many standardized signal carriers that standardized parts currently accept. Certainly, more carriers could be designed, but there may be ways around this. In computer architecture, the register shortage can be addressed by temporarily saving register data into memory, and the bus issue can be addressed with a stateful multiplexing approach. Perhaps stateful biological systems such as the repressilator or a push-on push-off switch have something to offer here.

Functional Programming

The other, more subtle, crosstalk issue is that of unintended side effects. When considering engineered biological devices, there may be side effects outside of the well-characterized and intended inputs and outputs, so the abstractions leak – figuratively and literally. These issues are also present in highly parallel computing environments when a shared resource such as a location in memory is operated upon by many processes. One must take care to ensure that the processes cooperate to ensure that they do not tread upon one another. There are many paradigms for approaching concurrent software, and it is becoming increasingly apparent that a system of threads, locks, and mutexes quickly gets difficult, if not impossible, to keep track of. Interesting discussions of other approaches:

A key element in many of these approaches to concurrency is a lack of shared state and, by association, lack of side effects. Since intracellular signaling systems are inherently parallel, two operations may only be reliably executed in tandem if they have minimal-to-no side effects (or, more realistically, minimal, orthogonal, well-characterized effects). My point here is not to imply that there is a concurrent programming paradigm that can be transferred to synthetic biology to solve the side effect issue. I mean to illustrate that, as we engineer larger systems, it will be crucial to minimize unknown side effects of synthetic biology constructs with high-quality characterization.

I realize that I am first suggesting stateful systems, immediately followed by a call for referential transparency (the property of being without formal side effects), often conflated with statelessness. It’s important to remember that, taken as an abstract concept, referentially transparent (side-effect free) operations can maintain internal state, so long as that state does not leak out of the operation, be it a computation or intracellular signalling pathway.

Also, something on my TODO list is to check out cell-free systems, and consider their applicability to the crosstalk issue:

AI Blackboards

Lastly, it also occurred to me that intracellular signaling systems are similar to the artificial intelligence blackboard architecture and, as such, it could be useful as a thought model. I’ve not pursues this idea very much, although it appears that some folks have made the same connection in the context of modeling: Modelling intracellular signalling networks using behaviour-based systems and the blackboard architecture.

Installing redland-1.0.7 from source on Ubuntu 7.10

The Ubuntu packages for the Redland RDF libraries seem to have an issue, at least for the Ruby bindings (see Ruby objects to cyclic dependency about the “cyclic include detected” issue), so I installed it from source.

In case I need to do this again (or someone else does), here are the steps I took for installing Redland on Ubuntu 7.10:

1. Get the GNU MP Bignum library:
sudo apt-get install libgmp3-dev

2. Make or go to a scratch directory
cd ~
mkdir redland
cd redland

3. Get redland 1.0.7 and unpack
wget http://download.librdf .org/source/redland-1.0.7.tar.gz
tar xvfz redland-1.0.7.tar.gz
cd redland-1.0.7

4. Build raptor first
cd raptor
./configure && make && make check && sudo make install
cd ..

4. Then build rasqal

NOTE: If you get “Can’t locate XML/DOM.pm in @INC ” during make check, then:
sudo apt-get install libxml-dom-perl

cd rasqal
./configure && make && make check && sudo make install
cd ..

5. Build redland
# We are back in the main redland-1.0.7 directory
./configure && make && make check && sudo make install

6. Get and build redland-bindings
cd ..
wget http://download.librdf.org/source/redland-bindings-1.0.7.1.tar.gz
tar xvfz redland-bindings-1.0.7.1.tar.gz
cd redland-bindings-1.0.7.1
./configure && make && make check && sudo make install

7. Build the language-specific bindings you would like
cd ruby
make && make check && sudo make install
cd ..

Bio eye for the CS guy (or gal!)

Lately, as a result of my fascination with Synthetic Biology, I have been reading biology and bioinformatics references voraciously. More on Synthetic Biology to come, but I encourage you to read up on it. It suffices to say that it greatly appeals to me, coming from a Computer Science and engineering background. When you throw “refactoring” and “bacteriophage” into the same paper title, or mention languages and grammars for programming DNA, you’ve got my attention.

To my surprise, I have found several resources that introduce biological concepts to readers with just such a background. In the interest of sharing this information over primping and editing this in Mephisto admin, here’s a work-in-progress of said list.

Some Ruby code that is maybe imaginary

I have partially or fully read, and recommend:

For the last entry, especially note chapters 1, “Molecular Biology for Computer Scientists,” and 2, “The Computational Linguistics of Biological Sequences .”

This last one is not related to programming, but is an amazing introduction to cellular biology that I would highly recommend for its fantastic illustrations and readable prose, whether you are familiar with the material or not:

Sardines

Sardines is an experiment in organizing a tiered, distributed wiki that is motivated by Open Science.

Imagine research that takes place in a lab and is recorded and documented on an electronic platform such as a blog or wiki. It’s reasonable to conceive that the researcher may want to keep a closer hold on their findings for a short time in order to polish and confirm, before releasing it into the open.

This being said, it would be nice if the data, before being released publicly, were available within the entire research lab or institution. It’d also be great if the publication process seemed relatively seamless and that the interfaces for local private edits and global public edits be similar. To cap it all off, people “downstream” (i.e. in the lab) should automatically get updates when changes are made available “upstream.”

Example

Distributed document versioning

In this example, there is one public server and two private servers; labs Alpha and Beta each have a private instance of the server running so that they are assured of privacy. Lab Alpha has published version 3 of its research, although they have an internal copy which is more recently updated. The published version is available on the public server and is made known to Lab Beta’s server. Lab Beta has private research which it has not yet released.

Notes

It may very well be the case that this idea constitutes “too much software,” and a simple published-state property on a central wiki would suffice.

Multitouch: FTIR

In my last term at RIT, I took a course titled Innovation and Invention with Dr. Jon Schull. It was rather experimental, with a breakneck pace and minimal organization that was both highly productive and rewarding. It has continued to flourish, and has significant overlap with the new Collaboratorium at RIT.

As part of this course, I worked on a multitouch display (see my project log for the multitouch table). Matthew Kampschmidt and I gave a talk that introduces multitouch technology and applications, as well as the fundamentals behind FTIR (Frustrated Total Internal Reflection).

Rockit: A Parser Generator for Ruby

I gave a talk in January 2007 for my Language Processors and Compiler Construction course at RIT on Rockit, a parser generator library for Ruby. I touched on versions 0.3.8 and 0.7.2, which are GLR and PEG driven, respectively.

Ruby Type Inference and Code Completion for RDT

I gave a talk at RubyConf 2006, detailing my project for the Google Summer of Code 2006. I worked on type inference for the purpose of code completion in the Ruby Development Tools Eclipse plugin with Chris Williams as my mentor. Chris has gone on to work with Aptana on RadRails.

You can read the archives of my project blog.

Introduction to Rails 1.13

I gave a talk at our second Rochester on Rails meetup in January 2006 that is an entry-level introduction to Rails (circa 1.13) . It covers the history, reasons you may use it in a project, and basic architecture of Rails.

Introduction to Ruby

I gave a talk at our second Rochester on Rails meetup in January 2006 that gives a brief and basic introduction to the syntax of Ruby 1.8, along with a few nice language features.

About Me

Hey, what’s up. I’m Jason. I love code, science, and building cool stuff.

Some awesome stuff:

I go to:

Some stuff I did before:

Elsewhere on the internet:

You can get in touch with me at jason dot p dot morrison at gmail.