The following is the first of (hopefully) several experiments related to this topic.  It explores three different "mediums" through which a reality containing a sentient life form could come to be.

Medium 1:  Computer 

For the sake of this experiment, let's suppose that we are already at the point of being able to run a sentient mind within a computer program. Let's have it be a program that doesn't take input from the user - it simply runs on and on, never terminating until someone turns it off (think of one of those virtual fishbowl screensavers). The program has no random variables and no user input, so it runs the same way every time it is started. We have a display through which we can monitor our sentient being. If it helps to visualize the situation better, we can imagine it having a virtual body (as in a video game) and living in a virtual habitat filled with whatever would make our hypothetical sentient being happy.

So we start up our program. We see our sentient life form walking around its habitat, going about its business. Being sentient, it observes its environment and thinks about it. Maybe we gave it the ability to keep a journal, which we can read, in order to see that it is indeed thinking about its virtual world.

Since we're running this program on a computer, we know that it will eventually end - even if we make a herculean effort to keep it running until the end of time, it would probably eventually end due to a power outtage or an operating system crash. Sadly this means the end for the sentient being living inside.

Or does it? We stated earlier that this program has no randomization built in, and no user input, so it runs the same way each time. So we can theoretically just run the program again, watching our sentient being go through the same routine it did the first time, only hopefully longer this time, and our sentient being gets to live a little longer. But is it only a copy of the original? Did the original experience "actual" death or have we managed to defeat death, at least for a little while?

In an effort to make sure our sentient being never "actually" dies, we come up with a fail-safe - for each clock tick of the CPU, we store the entire contents of the computer's memory onto a backup disc. What this means is that if there is a power outtage, say, 23 hours into the program, we can find the contents of the disc at the exact time our creature died, copy it back into memory (once the power comes back on), and start running it again from there on out. Since there is no user input, there's no way for the sentient being to know anything happened at all. It continues its existence life exactly as it would have without the crash, performing the same routines and making the same notes in its journal.

But one might wonder - isn't this just the same as if our sentient being had died, and we just made a clone that we pawned off as the real thing? After all, during the power outtage, the computer was completely shut off, its memory presumably erased of any electric charge that could let us pretend our sentient being still had "life" to it.

Wracked with guilt over the demise of our hypothetical senteint being (and its "copies"), we try to think of a way to avoid making a copy and actually keep it alive continuously during power outtages . . . maybe we can find an expensive, persistant RAM chip . . .

We're about to invest in some fancy new hardware when out of the blue we realize we're in bigger trouble than we thought: we've been running our program on a multithreading OS, and it's been effectively killing and reviving our sentient being many (millions) of times a second as it takes time out to run other programs, swaps our program out of virtual memory, and the like. Depending on how our sentient being's program was implemented, it may find its neurons being reallocated to different parts of RAM, thus "killing" it piecemeal as well.

And if this weren't bad enough, we realize a potentially bigger, less surmountable flaw - we're running this sentient being on a comptuer with a CPU. That means that the actual calculations are being run on data that is copied from RAM to tiny little bits of memory called "registers" within the CPU - and then copied back again. And potentially in a different order than we wrote our program in.  If it's a multi-processor CPU, the calculations aren't even happening in the same place.  And if the implementation is really complex, it might even be run over a network on several different machines - maybe even with instances written in different programming languages or running different CPU architectures.

Perhaps we could be ok with this last part - we might decide the computer's operation is kind of analogous to our own organic bodies re-synthesizing themselves out of food and don't really the "count" the constant changes as "death". But for the sake of this hypothesis, let's say it drives us crazy.  Let's say that we feel bad for our sentient being and its millions of copies constantly dying, and wish to come up with a system that wouldn't involve all the copying.

Medium 2:  Paper 

We might start by analyzing the source code - the instructions we actually entered by hand which we later compiled into a working program.  Considering it to be a life and death sitatuion, we pause execution of the computer program, print out the numerical contents of our sentient being's neurons and trace the execution of the program on paper, hoping that we can think of some way to unify all of the execution in one place and avoid any unecessary threading, copying, paging, and what have you.  This might be a futile quest - and isn't a very sensible undertaking anyway - but remember, this is all hypothetical.

For the sake of illustration, let's pretend that at the time of our printout, the sentient being was making an entry in its journal, which it was going to start with "Dear Diary," but only got as far as the first 'D'.  Let's pretend that we trace (on paper) the execution of the program for the equivalent of 2 virtual seconds.  It might take years in Earth time for us to finish, but we think it's for a noble cause. 

Once we are finally finished, we think we have some good optimizations to keep the program from paging or using threads or whatever.  But now we've come against another problem.  Our computer is still paused at the point where our sentient being was writing the letter 'D'.  However, on paper we've traced the code to the point where our sentient being has finished the sentence it was writing in its journal - "Dear Diary,".  Should we try to somehow copy the results of our program trace back into the computer's RAM so that it has the most up-to-date version?  But if we do that, aren't we killing the being already in there and making another copy?

Worse, we may wonder - is our trace of the program just a mere prediction of how the program would behave, or is it the same as if we actually ran the program?  Clearly the output is the same.  In this case, the trace we made on paper is simply yet another copy, and aren't we killing this copy by deciding to not continue on with our trace?  Is it possible that this sentient being could be alive and thinking as mere symbols on a piece of paper?  And supposing we could ask the sentient being being traced whether it was any less "real", would we end up tracing our way to the point where it replies, "of course not."

Medium 3: Empty Void

The flaw in our logic is the notion that we're only predicting the program's behavior, and that somehow our trace on paper is any less "real" than running the program in the computer.  Although the fact that the computer runs on electricity may seem to give it more credence as a viable medium for sentience, we have to remember that at any point it is actually just a bunch of circuits with differing amounts of voltage that we arbirarily call "1" and "0".  And while the computer's process is physically automated, one could argue that tracing a program by hand is merely a very roundabout automation process utilizing a complex kind of organic chemistry we call a "human".

Before we move on, there is one more step to thought experiment - one that even our ethically conflicted theoretical counterparts cannot validate experimentally:

If we decide that our sentient being is still going to have the same thoughts and experiences whether we run it on a computer or trace out the code out on paper, might it be possible that the same is true if we do neither?  Imagine that we wrote down the code but never ran it - the plans are in place, and their output was more or less guaranteed from the time they were conceived.  At this point we have essentially reduced our life form to an algorithm without a physical implementation.  If we think of the process as akin to, say, long division, we could consider the lifeform's existence to be "true" whether we trace through each step or not - much the same way that 42 divided by 3 is going to result in the number 14 whether we trace each step or not.

If the latter is true, then our sentient being is alive and well no matter what we do.  In fact it actually is just as real as you and I, and not merely a player in a thought experiment.  Not only this but every possible algorithmically computable "reality" exists.

This concludes the first thought experiment.  Next I'd like to discuss some of the conclusions we can draw from it.