1,739 karma · joined August 21, 2009
Works great, easy to debug, tons of open-source components to plug in when we need, sufficiently performant, thoroughly battle tested.
And these are medium update rate apps, not games, but not static forms either.
I think this paper started with a conclusion, and worked backwards to justify it.
I say almost, because we still have some QA code used for unit tests that is Java.
It is needs to be repeatedly brought (but gently).
Forward links to success stories, provide counter arguments to FUD (but again, gently!)
I say gently because it's easy to create enemies by making people look bad, and that's a no-no, you have to gradually wear down the old consensus and build a new one.
That is great, but runs into the next problem with concurrent programming - shared data - where, for performance, you absolutely have to share memory between heaps and pass ownership between heaps.
Erlang has specific escape hatches for that, I wonder how that would in a functional language.
Not saying it can't be done, just that it seems to be fairly hard.
If you can generate enough energy, you can push enough energy into other circuits that they saturate (reach the end of their working range) and will output noise.
Which is both a blessing and a curse - on the one hand, consistency, on the other hand, not welcoming to people who want to try something different.
I find exceptions to be a perfectly fine error handling mechanism.
I certainly prefer it to cluttering my code with explicit checks for return codes and such like.
() they solve a handful of use-cases really really well.
() if you are writing relatively decent C++, most code is pretty much exception safe already
() lots of abstractions are dangerous when mis-used
() they are sufficiently low cost that they almost never show up in the fairly extensive perf profiling I do on a large real-world application (LibreOffice). And LibreOffice throws exceptions __a lot__
(*) Except for toolchain writers, nobody cares how they are implemented
It's quite a natural optimisation.
I started writing some fancy asynch code, but on checking with a profiler, the thread overhead was pretty negligable, so I left it alone.
Effectively, I am doing a manual implementation of displaying a "timeline" of commits that apply that code.
But whatever works for you :-)
(1) git blame <file> (2) git blame <uninterestinghash>^ <file>
which tells blame to go back to before the hash and do the blame.
I run that loop repeatedly, picking the most recent hash each time (by date/time), until I get back to the change that interests me.