http://www.microsoft.com/interop/cp/default.mspx

Shame really that someone couldn't even do the research to see if such wild claims about MS are in any way true.

To some degree yes.

http://research.microsoft.com/en-us/um/people/simonpj/papers/list-comp/index.htm

http://en.wikipedia.org/wiki/Singularity_(operating_system)

Sure, there's components written in assembly + C, C++. But it's quite possible to write the vast majority of an OS in a variant of C#. Also, have a look at C#'s "unsafe" extension which permits the normal C hackery.

SSTO is a dumb idea for bell shaped rocket engines due to their limitations. Aerospike and linear aerospikes can potentially offer SSTO capability.

http://en.wikipedia.org/wiki/Aerospike_engine

> It would mean that development cycles slow down, algorithmics finally win over brute force and that software quality would have a chance to improve (after going downhill for a long time). Um, nope. Companies will simply sell bigger boxes to run their bloated code. > GPUs as CPUs? Ridiculous! Practically nobody can program them http://www.nvidia.com/object/cuda_apps_flash_new.html > and very few problems benefit from them. Media encoding/transcoding. Scientific code, minimum spanning trees can also be done a a GPU. If you mean by a 'few problems' that it doesn't run Word/Office/Java etc, then yes. Otherwise if it's a case that the algorithmics (sic) can be done in a data parallel fashion, then the problem might be able to done on a GPU.

Strange. Mine's "Positive" and i'm swimming in mod points. Even when I don't use them.

Except any decent allocator should only need to cross the kernel threshold when expanding the heap -or- releasing "excess" for some value worth of free memory back to the OS.

Sun's java still needs to perform it's own internal memory management for the main heap. The minor heap is bump allocated, and live data copied from that to the main heap.

Only if your compiler/VM does escape analysis for stack allocation. Afaik, Sun's Hotspot and the JHC haskell compiler are capable of it, I don't know of any others.

Google are currently implementing a JIT for Dalvik. I don't have any experience using it though, as I've been hacking on the garbage collector.

Nitpick, but reference counting isn't the ony form of garbage collection out there. Reference counting is actaully fairly attractive as you get very incremental collection , not simply your application freezing dead while you examine the entire heap (as android does currently, and Go's current collector).

Also, IBM's Recycler which they are proposing was designed by David Bacon. Some of his more recent work is on hard-real time collectors for Java.
http://domino.research.ibm.com/comm/research_projects.nsf/pages/metronome.index.html

Finally, using the MMU on a cpu to assist with garbage collection is generally a disaster. Your program needs to be able to inspect and modify it's own page tables, or you're using the memory fault mechanism to allow the collector to progress. The first is a security + OS nightmare, and the second tends to be very slow.

But Mr. President.. we must not allow a holiday gap!

> I myself have no problem with unobtrusive ads that can help get the developers the money that they deserve.

That might be the case with advertising starting out in games, but it's likely to end up just as intrusive as it is on the web. Adverts don't sell their products unless you notice the adverts.

Compilers that implement something called Tail Call Optimization can convert recursive functions into iterative equivalents. This relies on the function either: returning a value *or* the result of a call to another function with new parameters. (it can be the same or different function) e.g. a way to do it in C would look like:

f(int x){
.. some code ..

if( cond )
return 0;
else
return f( x + y);
}

Although in C it can look very ugly, for functional languages such as Haskell or Erlang, it is required as you have to express loops through recursion due to only being able to assign to variables once. In these langauges, it looks a lot better as you can pattern match on the value of arguments, allowing you to concisely deal with obvious error or base cases, leaving you to handle the generic cases without worrying about those cases. Scheme implementations are required to implement tail call optimization.

Starting out most of you skills are crap and your weapons are in bad condition. Later on when you get your skills up and have good condition weaponry you're able to pick off targets from a longer distance with free aim. A second note is that nearly all weapons have a spread, so even with maxed small arms/energy weapons some weapons will still seem inaccurate. It's a nice touch of realism. Laser weapons, Lincoln's Reapter don't have spread, so you hit exactly where you're aiming with maxed skill/weapon condition. Also some weapons appear to be zeroed for a specific range, but you can get the hang of that pretty quickly.