Skip to main content

another late night and building with genes...

I was so excited about finally finishing the last of my testing I decided to stay up to go over the todo list I showed before, and make sure that every task was addressed in code. As I mentioned in a previous post, often the actual implementation will deviate from the task items on the todo list which are written on the fly as I am thinking about what needs to be done to address a given problem. I discovered a few items from the list that were obsoleted since I found more efficient ways of doing them in the actual code, always a good thing to find that you don't have as much work to do as you first thought. After I finished checking all the items off, I proceeded to perform one of the coolest parts of software design to me, if only because it is some what mysterious (it being a type of programming I have yet to do) and that is , build software. I've been using a application distribution builder I found after a few well placed google queries called Advanced Installer, this program was selected because it allowed me to do precisely what I wanted to do without inundating me with features that I didn't want. The Interface is pretty well designed and allows selection of build options of varying complexity for the developers needs. I got to thinking about the evolution of the software design process. We start with code, the IDE serving as our canvas , upon it we paint our vision of the world in the form of our classes. We define how those classes interact with the system (network, file, UI) and how they interact with other classes , I've commented before on the similarities of software engineering to biology but it bares repeating , especially when you think about what the build process does.

The compiled code of the individual classes in my package structure are collected and bound to the target system platform for installation. My framework is written primarily in java , so the options for execution platform include pretty much any platform desired thanks to the ubiquity of the jvm runtime environment. The similarity between a cell of a given type and a package of classes is striking, both have a core set of instructions from which the behavior of the cell through its membrane is exhibited. In the cell , these instructions are the genes but in the application distribution they are simply the class files. In biology , molecular biologists are figuring out that several ideas that had long been believed to be true were simply wrong. The first to fall was the idea of 1:1 correspondence between genes and proteins. This mantra went on for years on the belief that the answer to protein synthesis had to be simple, well that was quite an arrogant and wrong idea. The use of the base nucleotides ensures that just the number of ways in which the molecules could combine to stable structures is far far beyond the number of grains of sand on Earth or on any other rocky body in the solar system. Proteins fold to define how they interact in the system , their folding is directly constrained by the cellular chemistry in their formative environments...so literally having the right substances available during the transcription and protein synthesis phases can modify the protein created. Genes encode for a complex set of polypeptides which can include more than one protein. Another idea that was thrown out is the idea that non coding regions in the DNA were labeled as "junk" , it turns out these regions play critical signaling and timing roles in the expression of enzymes and proteins. Just as sheet music filled with notes without timing spacing could never allow a pianist to make a rendering faithful to the composers design, so to does it seem that DNA genes (specified by the active promoter regions called CPG islands) have their expression modulated by the important interstitial "junk".

It turns out cells have adapted evolutionarily in some ways to produce different variants of a protein by expressing a single gene, ...worse(or better depending on your pov) it seems some proteins require a dance be played between multiple genes to express the proper variant. The complexities are legion. In recent years the power of the type agnostic stem cells which can differentiate into any required cell type has provided a direct analog to concepts in OO programming. When we look at the analogs in OO design , had we been so bold we might have predicted the biological truths that have been recently discovered. This is because in OO , the classes that we design that provide for instance creation of objects in memory in most OO languages have similar complex relationships. In java for example we have interfaces (signature without implementation), we have abstract base classes (abstract signatures and concrete implementations) , we have concrete classes (concrete implementations only) and by using multiple interfaces we can simulate multiple inheritance. The abilities mirror very closely what we have discovered about the biological analog in genes.

One might wonder why create such tools as interfaces and abstract base classes, the answer is that they can significantly save the developer on coding time by reducing redundancy and promoting code reuse when employed properly. If a particular function can be called by multiple objects or classes that needed it without having to duplicate the function in code in those different classes...the energy expenditure of the developer is less since he does less code, but more importantly the computer in loading the instructions associated with the running application , loads fewer bytes, and each byte takes time to load and costs processor and memory resources as well. Ultimately the design of methods to allow facile prototyping of classes by using interfaces to define their structures and force implementations in inheriting classes, or to use ABC's to perform a mix of abstract signature creation and concrete method implementation (my preferred tool) in a programming language are ones which bottom line , conserve energy.

They conserve the use of energy of the coding agent (you and me the programmers) and they conserve energy of the executing computer. (in terms of compute time and required execution memory) In biology , the same goal is at the heart of the designs , except it bubbles up from the intrinsic rules of physical chemistry that determine how biomolecules will prefer to combine or orient based on their shape. (bond structure) The search for conservation of energy is what allows proteins to fold into the shapes they have when a given sequence of nucleotides is combined in a conducive intra cellular environment. The same law guides the use of multiple genes to express multiple protein variants..if you can use 3 genes to synthesize 30 critical protein variants it is far more energy efficient than having 30 genes doing one each. The evolutionary likelihood of such genes arising and then being selected for beneficial use is vanishingly small than the chance of existing genes being co opted , existing chemistry conditions promoting the synthesis of variations of protein structure that have usefulness in the organism. In biology, the guiding hand was time and strict abeyance to the rules of chemistry that define molecular affinities, in computer engineering the guiding hand is a lazy programmer , who wants to do as much (of whatever functionality) with as little as he can and do it in the memory space provided with the processing speeds available...it only makes sense that the two goals , one blind the other directed would end up serving the same god...

conserve energy

The similarities continue on in the build process, where a cell with its complement of expressed genes determine how it behaves (muscle, skin, bone...etc.) in a deployed application, the class hierarchy determines how a family of classes may behave based on their common pun- DNA the base classes from which they may be inherited. In the running application instances of these classes are invoked, replicated, collected and destroyed and perform the same tasks for other objects. Improper management of these tasks can lead to the accrual of junk in the running memory, enough junk leads to memory overflow and application "death". Similarly, in living beings cellular junk, the remnants of aberrant protein processes not properly degraded by the organism can build and reduce the efficiency of cellular processes. Over time this junk build up is believed to be a cause of many diseases in particular it is suspected as a major cause of the aging disease which also leads to death. Scientists are rapidly making advances in being able to reduce intra cellular cell junk to ensure the transcription and synthesis stages are kept error free throughout the organisms life time. In software engineering we have it a bit easier, when our applications begin to act sluggishly we know if we analyze the object invocation patterns we can determine the causes of the junk and remove or prevent them using a profiler. If only we had a profiler for biological organisms...the day when this is so may not be that far off.

Links:

conservation of energy rules all...

Story on junk dna not being junk

Descriptive animation from transcription to protein synthesis

Protein biosynthesis

Software Profilers

one gene one polypeptide

intracelluar junk may be a cause of death

Comments

Anonymous said…
This comment has been removed by a blog administrator.

Popular posts from this blog

Highly targeted Cpg vaccine immunotherapy for a range of cancer

Significance?


This will surely go down as a seminal advance in cancer therapy. It reads like magic:

So this new approach looks for the specific proteins that are associated with a given tumors resistance to attack by the body's T cells, it then adjusts those T cells to be hyper sensitive to the specific oncogenic proteins targeted. These cells become essentially The Terminator​ T cells in the specific tumor AND have the multiplied effect of traveling along the immune pathway of spreading that the cancer many have metastasized. This is huge squared because it means you can essentially use targeting one tumor to identify and eliminate distal tumors that you many not even realize exist.

This allows the therapy for treating cancer to, for the first time; end the "wack a mole" problem that has frustrated traditional shot gun methods of treatment involving radiation and chemotherapy ...which by their nature unfortunately damage parts of the body that are not cancer laden but …

Engineers versus Programmers

I have found as more non formally trained people enter the coding space, the quality of code that results varies in an interesting way.

The formalities of learning to code in a structured course at University involve often strong focus on "correctness" and efficiency in the form of big O representations for the algorithms created.

Much less focus tends to be placed on what I'll call practical programming, which is the type of code that engineers (note I didn't use "programmers" on purpose) must learn to write.

Programmers are what Universities create, students that can take a defined development environment and within in write an algorithm for computing some sequence or traversing a tree or encoding and decoding a string. Efficiency and invariant rules are guiding development missions. Execution time for creating the solution is often a week or more depending on the professor and their style of teaching code and giving out problems. This type of coding is devo…

AgilEntity Architecture: Action Oriented Workflow

Permissions, fine grained versus management headache
The usual method for determining which users can perform a given function on a given object in a managed system, employs providing those Users with specific access rights via the use of permissions. Often these permissions are also able to be granted to collections called Groups, to which Users are added. The combination of Permissions and Groups provides the ability to provide as atomic a dissemination of rights across the User space as possible. However, this granularity comes at the price of reduced efficiency for managing the created permissions and more importantly the Groups that collect Users designated to perform sets of actions. Essentially the Groups serve as access control lists in many systems, which for the variable and often changing environment of business applications means a need to constantly update the ACL’s (groups) in order to add or remove individuals based on their ability to perform certain actions. Also, the…