I wonder if IE7 is as leakalicious as its younger sibling.

I wouldn't be surprised if IE7 was even worse

I was curious about this since I recently installed FF for the first time ever since IE came with a tabbed browser. My task manager shows FF with one page open using 48240K of memory and IE8 with the same page open using 47812K (that would be a combination of the page's process and the browser process). Am I reading this wrong?

Piz,
In order for the numbers to be meaningful, you generally have to add the part that is in virtual memory to the part that is in physical memory. If you don't use a program for a long time, it will tend to drift into much slower virtual memory; whereas if you use all its features a lot, it will stay in or drift toward faster physical memory. This is because in order for any code or data to be used, the part that is needed must be in physical memory. If you run out of physical memory, something that isn't being used as often gets pushed into virtual memory. This is important in a way, because the operating system decides what should be in physical memory and what part should be in virtual memory. If the OS is not moving idle parts of the program to virtual memory, according to reasonable logic, the program will appear to be hogging physical memory. Also, if you completely discard virtual memory, you're throwing out the fact that at some point everything in virtual memory must have been in physical memory, even if it wasn't there for long. Virtual memory hogs are not much better because they are physical memory hogs on computers with more physical memory, and require more page file space and memory swapping delays on older systems. Hence it is really the memory totals that should be considered. Ideally, the computer would never use virtual memory, but that would require a lot of physical RAM.

Some things that tend to kill IE8's performance are having more than one tab or IE window open, or putting your computer into hibernation and then waking it up. For some reason, the numbers always seem to look far worse after a hibernate.

I also notice that IE tends to have at least one more instance running in the task manager than I have windows open. Tabs don't appear to generate a new process though. Hence I don't know if it is really IE8 that is causing the problem, or if it is, perhaps, Flash Player or some other plugin using a separate IE instance to implement some type or ridiculous multithreading or multicore support that IE8 doesn't provide direct access to.

If what you're really concerned about is your computer going slow, you might want to look at your virus scanner. It usually uses mega memory, creates tons of page faults, and constantly bugs the OS for 1MB blocks of memory that it quickly discards. This tends to make for as bad or worse behavior performance wise than just taking up a lot of RAM with idle code or data, since idle information will get moved to virtual space and essentially become a file on the hard disk until needed. Yes, the page file can still become fragmented, but for the sake of argument, using huge amounts of memory is not bad as long as the idle information really is not being used.

I think a big problem is that most programming environments don't really give an obvious way to tell the Windows Loader to not load certain things until needed, nor to set up huge blocks of information such that the OS will attempt to move them out of memory first, before other things.

Also, memory is not used very efficiently anyway, since most programs use memory according to pages, meaning one byte being used could be killing access to 4,000+ bytes that aren't. Long story.

Anyway, reducing the amount of memory IE uses would probably be a good thing, but it may not be hurting your computer's performance as much as you think. Problems are likely due to supporting so many different revisions of so many different features, and the OS not handling memory as well as it could. When looking at numbers, consider physical and virtual memory together, because anything in virtual memory could randomly end up in physical memory at any time.