Without getting into the language flamewar (again), I want to point out that, while usually the maxim 'you get what you pay for' holds true, open source ('free') software has actually been an extremely successful model for distributing and maintaining software, and it is not the realm of 'skateboard hippie programmers'.
It is kind of counter intuitive. But my hypothesis is that being able to build off of others' infrastructure in the software world is so powerful that communities that follow the open source model do in fact Get Stuff Done. Let me stress that I'm not bashing proprietary software and a lot of times the proprietary model makes sense. But open source software also works well, and large successful corporations like Intel, Twitter, Facebook, Apple, Google all use plenty of open source software and contribute substantially to the open source community. In fact Linux is mostly maintained by corporate employees (cf.
http://www.extremetech.com/computin...-develops-linux-the-answer-might-surprise-you). Many, many technologies started life as closed source projects and were released as open source when the owners decided the cost of maintenance and development would be lower as an open source project. Examples include OpenJDK (the standard Java platform), Darwin (which OS X and iOS are based on) and many others.
-----------------------------------------------------------------------------------
Also the standard tagline "GC is for dummies, it invariably results in stop the world crap and you lose predictability" -- largely is true, but you can never escape non determinism. Like once you get rid of stop the world GC (usually by reimplementing in C++), you need to start worrying about when a call to free() is going to trigger a walk of the free list. Or when the scheduler is going to kick you off the next slice. Or when the CPU triggers some random interrupt. Or what the latency of serializing a packet header will be when a router
you don't even own is clogged. All of these things contribute to non-determinism at different points in the system, and GC is just one of the more obvious. As a system designer you need to figure out what the constraints your system must adhere to and code to that. If you are worried about millisecond or even microsecond level jitter then if you are a sufficiently talented programmer you can pull it off. If you are worried about nanosecond jitter then you either have deep pockets or are facing an impossible project.
Frankly, these days I am worried less about any particular performance constraint and more about correctness, being able to quickly write correct code is the way to get to the top. Fast code is useless if it fails, just look at Knight. Plus it takes so much longer to write. If you need more performance, it's easier to either buy a faster computer/cluster/supercomputer or literally to
just write a fucking compiler (aka code generator) to output the code that meets your performance specifications than to hand optimize and verify each line. So in my current worldview the best language is the one that has better codegen / correctness proving / productivity facilities than a better runtime. (Java and C++ both fail quite miserably in this regard, unfortunately).
.