Figure 1. Life & Software Parallels

As we discussed in our previous blog post, Biology Becomes Programming, an important missing link to world-shaping innovations in biotechnology is a simple interface for designing life forms. With L++ we are bridging this gap by creating the first programming language for describing life forms in an efficient and intuitive manner. In Bacterial Chemotaxis Part 1, we briefly demonstrated the capabilities of L++ with our design of bacterial chemotaxis. In today’s post, let’s delve a little bit deeper into how to use L++ to design life forms using our straightforward biological syntax.  

The parallels between biological programming and machine code programming continue to be apparent as you look at the development process. Similarly to how C++ provides basic syntax which can be compiled into machine language which describes a program, L++ syntax can be compiled into DNA which describes an organism or biosystem. In simplified terms, a biosystem including an organism can be treated as a system of various molecules (e.g., proteins and metabolites), their concentrations, and their interactions with other molecules over space and time. The concentration of each molecule species can vary over time, amounting to an analog signal. 

A computer programmer working on developing a new program will first and foremost need to have a basic understanding of what they want their program to do. Likewise a life programmer using L++ will need to identify the various structures and behaviors of their desired life form before they begin writing code. This initial process of determining the structures and functions you want to model is an integral part of the design process, and provides the necessary framework for biologists to intuitively specify biological systems. With this framework in mind, biologists can begin writing L++ code using basic biological syntax such as that seen below. 

 reaction R(A -> B, k=9, krev=12);
 A = 4;

Code 1. Basic Chemical Reaction

Chemical reactions are a crucial part of any biosystem or biological process. Within all living cells there are many biochemical reactions taking place at all times. No programming language for life would be complete without a way of describing these chemical reactions, and with L++ the process is simple. Keeping with our goal of creating a very intuitive language, declaring a reaction and a molecule can be done with a simple format.*

For example, in Code 1 you can see a reaction declared where molecule A is converted to molecule B. Further parameters of forward and reverse rate constants are described with k and krev, respectively. The initial concentration of A is specified to be 4 a.u. (arbitrary unit). L++ supports data analysis, and using our visualization platform, a biosystem described in L++ can be simulated and the resulting data can be visualized in a number of ways with an easy click of a button. Below you can see a plot of quantity of molecules versus time using the code from Code 1 to generate the plot.  

Figure 2. Simulation result of Code 1. Molecules A and B start at the specified initial concentration. As reaction proceeds over 0.5 seconds, molecule A is converted to molecule B until they reach equilibrium as obtained from the forward and reverse rate constants. 

Let’s look at a more complicated example with an oscillating reaction. Pay close attention to how one can precisely control molecular quantities in time using square brackets [] (Code 2). We support absolute time (default unit being seconds).

 reaction R1(In -> S1, k=8);
 reaction R2(S1 -> S2, k=1);
 reaction R3(S2 -> Out, k=5);
 reaction R4(S2 -> R2, Ks=1, nH=2.5);
 In[:] = 1, Out[:] = 0;
 S1 = 1.5; S2 = 1;

Code 2. Oscillation. Notice that below the reaction declarations, the various concentrations of the inputs and outputs are described by time. The square brackets [] indicate the time of the reaction. They can contain one number representing the start time or two numbers indicating the start and end time. If a colon is used without any numbers in the brackets, the full time of the reaction will be applied. So in the above code, [0] denotes the initial concentration of the molecules, while [:] indicates constant concentration throughout the reaction. 

From the above set of reactions, more complex systems behavior emerges, such as oscillation. Take a look at Figure 3 below to see the plot of these reactions.

Figure 3. Simulation result of Code 2. The concentrations are as described in Code 2 with In and Out remaining constant and S1 and S2 beginning at 1.5 and 10 arbitrary units respectively. The oscillating reaction occurs as described by the rate constants.  

At every step in the development process, we are ensuring that L++ can truly function as a complete biology programming language. This includes comprehensive support for chemical names. Users can input any chemical name and the L++ code will compile correctly for that chemical. Additionally, all units can be used with SI units being the standard units by default. Spatial information and absolute time are also supported in the default units of meters and seconds respectively.  

 A = 500nM;
 E(0, 0.1, 0) = 1;
 glucose G = 2nM;
 G(0, 0.12, 0)[5ms] = 100nmol;
 G2 = G(0, 0.1, 0)[10.345];

Code 3. L++ directly supports chemical names and units. One can access and control the quantity of any objects in time and 3D space, using square and round brackets, respectively. Going through each line of code in the above example, the first line describes the concentration of molecule A as 500 nM. The second line indicates 1 molecule of E at a specific spatial position with coordinates (x=0, y=0.1, z=0). Line 3 indicates that there is 2 nM of glucose, which was named G. In line 4 we have the concentration of glucose described with both spatial and time data, so at 5 milliseconds into the reaction the glucose concentration at position (0, 0.12, 0) will be 100nmol. The last line shows that G2 accesses the concentration of G at 10.345 seconds into the reaction at position (0, 0.1, 0).  

As you can see, the syntax is all very straightforward. In addition to our intuitive biological syntax, L++ also contains traditional programming syntax support for conditions, loops, functions, and namespaces.

 organism E
 {
   membrane M
     {
       protein P;
     }
 }

 for (i = 0; i < 10; i++)
 {
    E(rand(0, 10cm), rand(0, 10cm), 0) = 1;
 }

 E.M.P = 10nmol;

Code 4. Traditional programming syntax supported in L++ enhances coding efficiency and code writability. For example, code may be organized with hierarchical structure and meaningful identifiers, and common functions such as the random function can be used as well to indicate the quantity of E at a random x position between 0 and 10cm, a random y position between 0 and 10 cm, and a z position of 0. A for loop is used to efficiently place a total of 10 E’s at different random spots. Finally, 10 nmol of protein P at the membrane of E was instantiated.

To quickly recap, L++ contains comprehensive biological syntax support as well as traditional syntax support. Data analysis is also supported such as statistical analysis, plots, and schematics. There is much more support L++ offers in order to create a truly efficient and complete programming language for life.  

In describing a biosystem, it is useful to be able to describe behavior at each different level in order to efficiently design life. L++ allows for multi-level resolution for description of molecule, cell, tissue, organ, and organism levels. We also recognize the importance of being able to model analog signals arising in biosystems, and L++ supports numerous mathematical models for analog signals. It is not only data analysis and signal construction support integrated within L++, but also compilation and execution support for translating code into simulations including high-quality 2D and 3D visualizations.  

With these features, L++ can be used to describe biosystems with much greater efficiency than other competing languages. Thus, L++ will be the first practical language for building high-level biosystems including organisms.

Figure 4. L++ for instructing robots to schedule and carry out experiments.

A very exciting implementation of L++ is support for instructing robots to schedule and carry out experiments. With this industry-shaking innovation, robots will be able to carry out a scheduled set of actions according to the L++ code. Experimental protocols including all inputs such as necessary reagents, equipment, etc. are paired with an available robot, and they can carry out tasks that are reported to a monitoring system with the capability of correcting for errors as well as recognizing when a protocol is complete and allowing the robots to return to a queue awaiting their next assigned protocol. This will greatly expedite the biological research process empowering researchers to test hypotheses much more efficiently. It is not just the field of biology that will be impacted by the creation of L++, our comprehensive language for life will also be a useful tool for medical practitioners.  

Figure 5. L++ for searching for diagnoses, treatments, and outcomes through L++ databases

L++ can be used as a helpful tool in diagnosing, treating, and predicting treatment outcomes for various conditions. Using intuitive medical L++ syntax, medical providers can describe a diagnosis, treatment, or treatment outcome and query through L++ databases to obtain similar cases. For example, a patient might come in with a cough, a doctor can then describe the patient’s symptoms and query them in a database to view diagnoses commonly associated with a cough and any other relevant symptoms. Additionally they can view various treatments for the diagnosis as well as treatment outcomes for each treatment. With L++, doctors will have a potent, new diagnostic and treatment tool that will serve to facilitate and advance medicine.  

Thank you for joining us for our discussion about L++. We are very excited to share our novel approach for designing life, we will discuss more about L++ and the industry-shaking innovations it will bring in future blog posts. If you are interested in reading more, please visit our website or stay connected with us on social media! 

---

*Declaring a reaction can be done using the format:
reaction <identifier-name> (<chemical equation>, <parameters>){<higher resolution description>};

Declaring a concentration of a molecule can be done using the format: 
<molecule type> <identifier-name>(<space>)[<time>] = <quantity>; * (default unit:M)(default unit:s)