There is not cure for any virus yet, except inoculating you (giving
you a vaccine) in advance, before you got infected.
When researchers are developing vaccines today they are analyzing
the virus, trying to single out what the human immune system can
recognize, and then implanting this part in a non lethal virus,
which they introduce to our body, and then our immune system learns
and remembers and is ready when the real virus comes.
See for example here on Ebola
vaccine, using vesicular stomatitis virus or chimpanzee
This has two drawbacks: (1) It's slow and can't be automated and
depends on sufficient expertise (2) if that specific part of the
real virus changes (mutates) the vaccine is useless.
Here I will offer a different approach which is a like generic
algorithm which you just need to apply to your specific virus and it
gets you a vaccine.
My solution depends on the fact that our body's natural immune
system can recognize and fight viruses if they are slow enough not
to be lethal (like the common flu), but when it faces an enemy like
Ebola for example it's advancing to fast and is lethal, so our
immune system doesn't have enough time to recognize it.
Viruses command our cells' photocopier
"copy machine" to repeatedly produce a lot of copies of the virus
code, until the whole cell explodes. It's like the virus is stuck in
the machine and press "repeat" after each copy.
Think of a virus like a computer code which means machine code,
which means assembly language. In some part of the virus there is
this command equivalent to "repeat" in pascal or "goto" in basic or
jump in assembly (there are many kinds of jump
commands in assembly, but as you will see the beauty of my
idea is that we don't need to understand the language). We need to
change only that single command to something else.
How it works?
When we create a non-replicating version of the virus, it looks
almost identical to the virus, except it will only replicate once,
and just float harmless inside the cell (with your permission, from
now on I'll just call this the "good virus"). On the other hand if
we put many of them in the blood stream, the natural immune system
have enough time to tackle them and develop resistance to the good
virus and in this way also to its almost identical twin the bad
the bad virus needs to stand in line both in entering the cells
and entering the photo-copy machine. This slows it down
considerably. Again giving time for our immune ststem to come up
with an "antidote".
Can't read the code!
that doesn't matter, we are using the fact that viruses are short
"programs" of code, about few thousand "lines" long. They are coded
in four letters, A,C,G,T which is like assembly language is coded in
16 hexadecimal "letters": 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F . So
imagine we have a short assembly program with somewhere a jump
hiding and we want to ruin that jump. We want ruin that specific
line only, without ruining the rest of the program.
So on our first trial (or "compilation") we go to the first "letter"
and replace it. Let's say we replace it to 0. and if it already was
zero we replace it to 1. Then we test ("run") our code. Did it work?
great! It didn't work? ok, so on our next trial we leave the first
"letter" as it was and change only the second "letter". and son on.
Now there's always a chance that by chance we created another
command which is equivalent in it's functionality to the original
command, let's say we replaced one kind of jump command in assembly
with another kind of jump command in assembly.
We will know that's what happened if we changed and tried each
individual command in the virus, and it's still a bad virus.
So if we see that's what happened we try another replacement scheme
for example making them all 1 (and if it's already 1 turn it instead
How each trial (or "compilation") is tested ("run") in a test
Remember how in chemistry there are two sides of the chemical
equation (reaction): the reactants and products. So in the same way
if we have culture of cells (the typical victims of the bad virus)
in a dish, and we infect them with the potential good virus (our
current compilation), we look what happens over time. If they all
die quickly then we did not hit the jump command, the virus is still
bad. If we see that the cells are still alive, we got a good virus,
and we good to our recipe and produce many copies of the good virus.
The good virus has two advantages: (1) It's very similar to the
original bad virus so whatever part(s) of it our body recognizes
there very high chance it will recognize in the bad virus when we
fight the real thing. (2) It has to go through a very specific
mutation to return to the bad virus (a specific single place, and a