I've been looking a lot at the 6502 processor simulation (http://visual6502.org) and it's interesting to consider the different levels of abstraction possible for chip simulation. The current simulator simulates abstract on/off transistors, which is sufficient for almost everything, but it doesn't exactly handle some unsupported opcodes that put conflicting signals on the bus. For that, you'd need to simulate actual voltage levels. If the transistors were very small, the voltage abstraction would break down because each electron starts to count. The simulator also ignores propagation delays. Moving up the hierarchy, people have gate-level 6502 simulations, which are tricky to implement exactly since the 6502 uses a lot of pass transistors and stored charge, rather than strictly Boolean logic. And then the typical CPU simulator runs at the register level, which is a lot simpler, but often gets the corner cases wrong (e.g. decimal arithmetic with invalid inputs).

The point is that circuits can be simulated at many different levels of detail, with low-level simulations more likely to get things exactly right, but with high-level simulations much faster, easier to write, and easier to understand.

Likewise, it will be interesting to see with cell simulations how much complexity can be abstracted away and still have a useful simulation. To get all the protein interactions right for example, you'd need to simulate individual atoms, which is insanely slow. So to simulate a cell, you're probably running at the level of protein and chemical concentrations and known interactions, which is faster but introduces error. For instance, how much do local concentrations matter? And to simulate a multicellular organism, you're probably going to make the cells fairly abstract.

Personally, I think the key area for biology is going to be dealing with cell state. Cells hold state in a lot of different ways over many time frames (eg epigenetics), and I think computer scientists have a lot to offer biologists in understanding state. Someone else mentioned the few hundred cell types in the human body, but the internal state makes a huge difference. (Not to mention distributed state, such as how the brain stores information.)

I wonder if it would be possible (in the not so distant future) to simulate an entire human, but 'cache' the results of parts of the simulation. Let the program decide where a certain interaction has been calculated too much and create its own level of abstraction.

Sort of like how image compression algorithms store an abstraction of the image for large, uniform areas and get more granular for complexity, but applied to simulation instead

Porting researchy Matlab code to optimized Fortran or C could potentially give you the same results as throwing more hardware at the problem, but cheaper and probably faster.

But unless the optimizations change the complexity, you're still going to be very limited: the constant factors may let you go from 1 cell in Matlab to 100 cells in C on the same hardware, but that's still just 100 cells and now you're stuck.