Sorry for the slow reply, I hope people didn't assume I couldn't back up my earlier assertions, I've just been kinda busy. For this post I'll hold back on references since that's merely a contest of Google-fu and doesn't increase the global fundus of knowledge.
(Honestly, I didn't bother looking since Android developers obviously don't care for Task Killers evidenced by their removal of that part of the API. I can understand their motivation in making software more predictable by disempowering the user, plus Verizon et. all would rather not pay for the support issues task managers cause, but I disagree with that action. Going above them would be looking at the source code, but I didn't think that'd be appropriate for this audience.)
Can you provide a practical example where something like this occurs on even first gen android phones, let alone the HW packages we are seeing now?
The average Android app uses 15 - 30 MB of memory. The system and services use probably half of the total (even with more RAM there's more persistently loaded bloatware). A web browser uses a lot more (Dolphin after a couple page loads is at 60 MB), and document viewers are generally written poorly enough that they load the whole document into memory (easy to check with 30 MB powerpoints). Five times sixty is three hundred, so I don't think this is really a hypothetical situation at all.
I'd say no he can't because it is inaccurate, his description of the life cycle and what gets killed when is wrong.
Ok, I suppose I need to clarify my terms. Android has invented new terminology to describe apps, even though that's just one level of abstract away from the standard Linux model. I've been using the term "Activity" to refer to an application that's actively doing something that the user (hopefully) told it to. Technically, an Activity should just be a GUI frontend to a service, but most developers don't use them this way (if they did there wouldn't be perceivable delays). So, I'm not talking about services that sit around taking up memory without doing anything (except wake up the CPU periodically, which hinders idle time and reduces battery life somewhat).
The more I read about Android Apps, the more I am reminded of BeOS replicants. Ten or fifteen years ago these were used to run one application's code in a shelf in another application. They had multiple entry points, but the main two were the initial constructor, and the constructor/destructor that took/returned a compressed BMessage that could be used to reinstantiate the application to where it was left. That way, you could drag and drop an application (e.g. I wrote a calendar for the desktop) around without losing your privates. This resemblance isn't a coincidence. Palm bought the BeOS so it certainly affected the mobile landscape. The pervasive multithreadedness is very similar to the Android Application model (BView == Activity, BHandler == Broadcast Reciever, BMessages ~= Content Provider, Servers ~= Services).
The issue with this is that reinstantiation is entirely done by the program, and it's hardly different than relaunching. Resource-wise, it's basically not different at all. In fact, you need to reopen any handles you had, so it could be even more intensive. For android, that means the auto-closing/reopening is fairly wasteful compared to manually opening and closing, since you do a lot more work. Juggling three balls is easier than juggling fifteen, with a heck of a lot less hand movement. Google made the decision to pretend that all applications run all the time from a user experience perspective, not an efficiency perspective. No clue if they're on to something, as I'm not a typical user so I find it annoying.
To prevent this from being the 20% point in this post, my remaining points will be of the bullet type.
- Tasks running in the background cannot use no resources. If they didn't, they wouldn't have an active process (or thread in another process) at all. Disregarding memory for the moment, they will still cause wakes, still have open handles, and they're another app for Android to keep track of (not free).
- The user has a pretty good idea of what needs to be run and when. I, for instance, went on a hike a couple days ago, so I used GlueTrail quite a bit that day. Today, I'm not in the woods so it's pretty safe for me to not be running GlueTrail despite opening it several times recently. Google's predictive algorithms are universally weak following a recent spike in unusual activity. Just because I Google'd something to death today doesn't mean I want it to bias my search results tomorrow.
- Unused memory is wasted memory. To make use of unused memory, Linux will use a disk cache to keep recently loaded files in memory, and reduce the cache size as memory is needed. This is below the level of Android. Using 100% of your memory for applications means that you can't take advantage of this cache, and the SD card/NAND gets used more heavily (slower and uses more power).
- Finer control over active applications means that I can keep the ones I want active at all times, so I can switch to them instantly. Without that control they'll occasionally be killed, so I have to get them back to where I had them (if they don't completely reinstantiate, which is true for most activities), and that causes a delay in my work flow. 1-2 seconds might not seem long at most times, but if you have your hand on a hot oven it can seem like an eternity (e.g. you're looking something up while your superior is staring at you).
- The number of applications in the task switcher is six. Never three, nor seven. That's why I like to run a task switcher that lists running Activities. If I'm using the application, then it is running, and if I'm not using it then I'd prefer it not to be.
- A lack of user control only works when programmers can be trusted to serve the owner well. (I say "owner", since it should be the user, but is often a corporate overlord.) Android developers, sadly, aren't uniformly skilled/motivated enough to do that. If a ten-year-old's first app behaves poorly, you may need to kill it. Froyo offers a task killer for this obvious reason. OTOH, it's not the best task manager possible, so I'd like to run a better one. (Who am I kidding with the kid remark? In modern times most commercial software developers wish to maximize profits, so they put in minimal effort (expense) into their applications.)
- It's interesting to see a report of real world effects from these theoretical concepts. Professional users seeing the greatest difference makes sense. They are generally less likely to use tools ineffectively, like killing every possible application on their phone when the screen turns off. They're also more likely to know what they don't need.