In the case that you wish to learn the family of C, Java, C# and C++, I suggest you to start with C and get acquainted with pointers. Try your best to understand dangling pointers and memory leak problems. Do dynamic memory allocation and try to avoid stated problems. Later, you'll see that Java and C# use dynamic memory allocation (implicitly) a lot. In this way, it may be useful to do a bit of Assembly to understand memory and addresses and how the memory works. I think, after that kinda training in C, you can understand references (in Java/C#) and garbage collection (which is done by JVM/CLR) better and write a better cost-effective program in Java/C# due to understanding GC an references. The above may apply to C++ as well, however, there is no (default) garbage collection in C++.

About a year ago, I read some of the papers published by Singularity researchers. As much as I remember, there weren't anything about a thin client or a web-based OS. In fact, the main idea of their OS is using programming languages techniques (static type-safety and static memory-safety) to isolate different processes. If you look at Singularity from a hardware view , there is just one big address space (and its corresponding process) but in reality there are many Software Isolated Processes managed by something like JVM or CLR (.Net run-time). As a consequence, the OS gets rid of all of those hardware-costs related to management of different address spaces in Memory Unit. To the extent I remember from my OS course, current operating systems use virtual memory to prevent one process from reading or modifying another process's address space (every process has one big address space from 0 to for example 4 GB and there is no way to have any kinda access to address spaces of other processes. i.e. the physical memory is completely hidden from the processes and they can see only their own virtual memory). As you might know, Virtual memory is completely interlinked with hardware and has its own cost. However, if they don't use hardware to isolate processes, what they use instead? To answer this question, suppose that you have a program that you are sure about its memory safety. That is the program doesn't violate its own memory boundary. In such a case you don't have to check this invariant at run-time on every memory access (or give the program a virtual address space). In fact, Singularity verifies the memory safety of every program before running it. Programs are not pure binaries and are some kinda intermediate languages like java byte-code or MSIL that can be easily verified. You may think by this kinda verification you have a bigger opportunity to download and execute codes on the fly something like JVM and java applets. After all, with having these light processes, you can think of a micro-kernel OS consisting of many processes communicating with each other.