Sure. It's pretty straightforward. Dawkins is making an argument against intelligent design. He does so by setting up an artificial argument:
1) The eye is "backwards"; light has to pass through the wiring
2) any engineer dislikes disarray; why would they design a photoreceptor where the light has to pass through the wiring
3) therefore, it's unlikely that eyes were "designed", for if they were, they would be much nicer and more tidy.
(see The Blind Watchmaker, "This means that the light, instead of being granted an unrestricted passage to the photocells, has to pass through a forest of connecting wires, presumably suffering at least some attenuation and distortion (actually probably not much but, still, it is the principle of the thing that would offend any tidy-minded engineer)".
In short, Dawkins argument is weak- it appeals to design tidiness, not to any real facts or logic about how evolution works. But as this modelling (oh, and I see they did some experimental work as well) shows, it's just as likely that the mammalian eye configuration isn't as bad as he said.
The arguments against intelligent design should be based on reality. Dawkins is probably right about this sort of thing (that there is no ID), but he's typically right for the wrong reason (specious logic).
(Dawkins then further argues against parallel evolution, although we're now finding out it's also quite common. he's wrong about a lot of things).
I should further argue that finding the eye in this configuration "backwards" according to some, is really just applying human aesthetics about how things should be engineered, where biology is a combination of happenstance and optimization. I suspect, as we tease out the biophysics of the eye further, we will find many more examples of how Dawkins' simple logic (which isn't really logic, but more based on aesthetics and intuition) doesn't really explain things.
On Android you could accomplish this, but iOS has some fairly inane restrictions around running any type of VM. It's enforced somewhat arbitrarily, but it lets Apple yank any VM or app-hosting type thing on their whim. It was originally put into place to keep Adobe Flash and Air off iOS.
I also disagree that you always need mobile for everything. This seems geared toward communicating and collaborating, so yes mobile would be a must for mass adoption. But if it's geared toward devs or professional work that's not necessarily true.
GC doesn't preven all the memory leaks. En easy example is a stack class backeed by an array. If you need more members, you allocate a bigger array and copy members. (The GC takes care of the smaller old array).
So far so good. But You forget to allocate smaller array (and copy members) when you consume too much memory. So 1000000* push(something) followed by 1000000*pop() keeps plenty allocated memory not in usage.
(It's not as brutal as malloc() and forget the result but still pretty awfull situation in a large project.)
According to that definition of memory leak, I guess you can call anything that doesn't eagerly free memory for memory leak. And the term gets quite weak and vague in that case.
The issue with this code is not that it isn't eager enough. It deoesn't free the memory ever (for value of ever "till the whole stack is not freed, that can be the whole runtime of the program").
