Skip to content. | Skip to navigation

Personal tools

Sections
You are here: Home

 

Evolvix: accurate modeling made easier


Evolvix is the first general-purpose programming language that is being designed by biologists for biologists.
This means one thing for us as language designers.
Simplify.

A lot. Then find ways to do more with less. Rework to make things easier. It even cuts coding time, like the relevant books say.
When you think you can't improve, write a small sample of code, and ask a few potential users to interpret it for you and explain why.
You will probably be surprised. And if you care about creating a user-friendly language, this is likely to send you back to the drawing board.
With good, justifiable reasons. This is not about fuzzy perfectionism or trying to please everybody. This is about hard-nosed values.
Like accuracy, correctness, functionality, performance, expressivity, security, efficiency, maintainability, stability, provenance.
Or about reducing how the hidden costs of poor software design waste the time of our lives, and a fortune on top.

Biology is the ultimate science of complexity.
It's diversity is so staggering, that one can ask, how much of it we will ever comprehend.
Wherever the limits, this is certain: We have more than enough to do with biology's inherent complexity.
We do not need the complications added by unnecessarily complex software.

 

How do we know?
Most of us are biologists. We would love to understand more of the biology we study.
Experiments are a great way of answering many questions. That is, once we've analyzed the new data.
Which usually requires more than a pocket calculator these days. Still, many are impossible to decide by experiment.
 They could be addressed by simulations. That is, if these were not so hard to put together. "Use the right language for the right task."
That is what professional programmers often say. The hard-core programmers among us know from painful experience, how very true that is.
Trivial tasks in the "right" language, can become impossibly hard, error prone, and time consuming in the "wrong" one.
Only which general-purpose programming language was made for biology? Many of us thought, some of us should know.
But some of us didn't, and so started some years ago to ask anybody who looked like they might know. Still nothing.
We found special-purpose languages. We found dedicated code libraries for certain areas in biology.
We did not find a general-purpose programming language made for biology.
We are the Evolvix Thinkers, and we will change that.

 

Currently this website is transitioning.
Its old mode is still useful (all about the Evolvix prototype that we built; it works well for what it does).
Its new mode has not yet fully arrived (all about how to facilitate the process below that improves the design of Evolvix).
Please bear with us in the mean time.



Flipped Programming Language Design

 

 To make the Evolvix model description language and modeling platform really user-friendly,
we specifically developed a new approach for this purpose: the


Flipped Programming Language Design Approach
,
also abbreviated as the
DesignFlip.

The DesignFlip refers to a comparison with
more traditional approaches to programming language design.
All good language designers have use-cases, ask users, and review their work.
Here is a cartoon of the different perspectives:

 

A brief overview of the unconventional approach to designing the general-purpose programming capabilities of Evolvix.

 

  Evolvix is shaped as collaboratively as reasonable by all Evolvix Thinkers.
To avoid an overly complex mess of contradictions between different styles and more,
There is an important design rule for efficiently working with the 'flipped design' approach. It's the

 One Brain Rule
It exists for ensuring overall ultimate simplicity for the language design and the decisions necessary to get there.
It states that one human being must be able to understand everything about syntax and semantics that are destined for
stability in the core language and its core libraries. What doesn't fit a single brain is usually too complex for a general language.
To keep decision paths short and architectural work efficient, this one brain must belong to the language architect who is ultimately
responsible for all decisions that may constrain future design choices. It's the language architect's responsibility to act as if long-term
backwards compatibility is meant forever and must never be broken. That one person's brain must experience language designs as
the best possible trade-offs between the various needs and wishes of different types of users and the various mandates for
maximal elegance in overall design, maximal consistency in syntax and semantics as assessed by diverse expert in
repeated rounds of rigorous reviews, maximal flexibility, maximal security, maximal user-friendliness, as well as
minimally many rules and exceptions, overall reducing inessential complexity as much as possible. Ultimately,
it is the language architects responsibility to give those future potential users a voice, who do not have one,
and would never dream of affecting the design of a programming language, but would really
benefit from such a language, if they could use one.

By now you will have guessed it.

Evolvix is not your typical programming language, and this is not your typical programming language website.
The aim to enable general-purpose programming does not mean that you can make assumptions.
Biology is different. In fact (almost) everything in biology is different from (almost) everything else.
As a rule of thumb, if you can think it, it probably exists somewhere in biology, if only as a
rare special case. And if it exists, then simulating it efficiently will eventually become a
goal for Evolvix. This is a tall order, we know. It requires handling an extraordinarily
broad diversity of types and exceptionally many exceptions. Therefore, we cannot
make many assumptions either during development. Whenever we tried, most
shortcuts we hoped for turned into box-canyons we had to return from.
Life is too short for this. Therefore, we changed the approach.
 Evolvix has a name capturing what it's software development approach stands for: enable evolution.
Software has always evolved, is evolving, and will keep evolving at great speed. So we better get used
to software evolution and organize our systems accordingly to avoid the equivalent of mass-extinctions
whenever a new (incompatible) must-have product is introduced. Here mass-extinction is not only referring
to unnecessarily early abandonment of perfectly usable systems because the new product has features.
Mass-extinction is also referring to the dependencies that become obsolete. The new software that
requires you to buy a new PC not only kills your (working) old PC and your scanner that refuses
to speak to your new PC. A much more hidden part of these mass-extinctions affects valuable
information in your brain: all the carefully trained neurons that manage for you the compiled
details of how to use "your computer", they have now also become obsolete and their
information will eventually die. Luckily, the neurons in your brain don't have to die;
you can re-train them to learn something new. However, that takes time, and you
might want to use your time for better things than constantly re-programming
your neurons to keep up with the latest Silicon Valley hype.
What does this have to do with Evolvix?
It's all about the biology!
Evolvix is being architected a very specific purpose.
It might be useful for a million other things and we might even help you with
some of them. After all, Evolvix is on its way to become a genuine general-purpose programming
language. Chances are that solving your problem may prepare Evolvix for solving some biological problem that we
haven't yet thought about. enabling  However, that should never obscure the fact that Evolvix serves a very special purpose:
Evolvix aims to enable researchers to build on the results of other researchers
work in mechanistic Evolutionary Systems Biology (EvoSysBio) in ways that are long-term stable.


These very specific requirements have made it necessary to pioneer an entirely new methodology for developing Evolvix. That is why we flipped the design process. That is why we place such an extra-ordinary emphasis on asking potential future users of a programming language, what they might want to see in that language and how they might interpret its syntax if they saw it today. Authors of texts for a broad audience know, it takes much effort to find words to communicate clearly. In the context of programing languages, "clear" - more than anything - means "unambiguous" for compilers (that's the computer science part) and humans (that's what we have come to call "debugging code2brain interfaces").
Our approach is possibly unique, as a scientific reviewer stated. While other language designers also ask for input from users, the Evolvix DesignFlip takes 'asking users' to a whole new level. We design Evolvix with potential future users. This is essential for refining Evolvix tools to the high quality standard required for its long-term tasks in the context of the EvoSysBio research it is meant to support. Else we will never get to simulate those cancer cells in mice. What we need is:
  • Long-term backwards compatibility, so we never have to break any user's code
  • User-friendly syntax that provides an ease-of-use for experimental biologists unheard of so far
  • Integrated data management that is so reliable that experimental biologists will want to use Evolvix to store their data anywhere
  • Built-in capabilities for simplifying the many coding challenges that are unique to biology and have been ignored by other languages so far
  • Learn from existing real-world, open-source, general-purpose programming languages and from relevant research in computer science, etc. No need to reinvent the wheel.

 

Where do we go from here?


We have built a prototype that helped us to get a better grasp of what Evolvix really needs to accomplish its broader mission briefly described above. You can download it and it has some useful functionality (see below).
However, the main thrust of our work has been directed towards architecting the design for a much more stable and general version of Evolvix.
We are in the process of transitioning our internal systems to prepare for rolling out capabilities we have been refining for
allowing us to process feedback from larger audiences. Until then we will mostly use our current, more interactive approach.
We have conducted most of our usability and expert review work so far during interactive discussions in the Loewe Lab at the Wisconsin Institute for Discovery at the University of Wisconsin-Madison. There is much more to be said about how this works. If you are really interested in contributing, please have a look at our paper on "debugging code2brain interfaces", send us your CV and let us know how you think you might be able to contribute. Be specific. If you are an expert in any area, and happen to be interested, feel free to . Maybe we are looking for exactly your expertise at that moment. Sometimes your expertise would be very helpful at a later point. Please be persistent and patient. We are in the process of building a network of reviewers, who are willing to support our language development with expertise in many diverse areas. If there are other ways in which you may wish to support the development of Evolvix, .

Evolvix Initial Prototype


The initial prototype of Evolvix that we developed makes it easy to efficiently record time series from simulations. For example, the following two time series plots are produced by the same Evolvix model, but simulated by two different modeling methods. The two plots represent a predator-prey model that predicts how many predators and prey organisms will exist at any point in the future. Simulations are based on rates of birth and death of predators and prey and their interactions.
The plot on the left was produced by a method assuming that half an organism is alive (as done in deterministic ordinary differential equations).
The plot on the right is from a method that assumes in-divisible 'individual' organisms (as done in stochastic simulation algorithms that treat half an organism as dead, thus making random effects unavoidable).

Oscillating systems are frequent in biology, from molecular circadian clocks to predator-prey systems. This time series is computed as if the system was deterministic, ignoring all possible sources of variability.Oscillations in stochastic systems can deviate substantially from what would be expected in an equivalent deterministic system

 

Evolvix greatly simplifies switching between these two methods of simulation for any given model.

More on what Evolvix is     |     What can Evolvix do for you?     |    Evolvix vision

 

 

Sponsor Logo - National Science Foundation