Still, GNOME 3.0 itself was a huge achievement. I almost feel guilty to be asking even more of it now, but to see how much we can do with the resources we have is very encouraging. Some of it will be rough, but we have the capacity to really push it to the limit. I will be very happy to see a new flux of applications made based on GNOME 3′s emerging HIG, especially if it inspires people to come up with creative ideas for applications that have been ignored in the past due to the WIMP-focused era of GNOME 2.

I think we’re really going to pick up some steam. As the vision of GNOME is more fully realized, and we get these new applications, I think people will begin to realize it was the right direction to go. I’m sure Ubuntu users won’t be able to resist some of the upcoming goodies, even if they don’t think they agree with the design ethos now.

That said, my recent tests between D, C/C++ and Mono have shown that Mono is significantly slower than native languages. Also, those benchmarks are interesting since Vala seems to perform identically to C. So it looks like I need to do more tests with Vala, just to be sure.

Concerning memory, I think GC is better all around. Modern GC’s are incremental, not “stop the world”, and don’t suffer from random stutters unless you’re pushing memory to the brink in which case you’ll have memory issues regardless. Plus you have easy ways to mark blocks as non-collected for things like Memory Pools where you’re managing everything yourself anyways. The big performance problem with ref-counting is you have to count each reference always, whereas in GC you can scan incrementally and stop when a time threshold is met. Since most applications usually aren’t allocating/deallocating memory every cycle the GC has more than enough time to collect at it’s own pace, instead of slowing down everything along the way. With the big added benefit to the programmer of not having to worry about memory cycles at all.

You also get things like memory compression with GC, where I don’t think that exists in Ref Counted systems (granted, I don’t know if that’s a design or implementation issue). Also, the lazy-deallocation of GC is usually a good thing (for performance and memory recycling), while in Ref Counting you have to manually craft that, or pay for deallocation at the end of each scope.

Beyond that however, Vala suffers from a few very important design mistakes:

First, it’s ref-counted not garbage collected. This is arguably slower and less stable, plus very easy to introduce circular references which will prevent memory from being collected all together. Honestly, I would probably rather manually manage memory than have to analyse every reference for those tricky-to-find ref loops.

Second, there’s no overloads or operators in Vala, which is a big deal when creating and using math libraries. If you write game code, or anything math oriented really, this is serious issue.

Again, MonoD is tackling these issues, and there’s a joint effort to standardize the parser and make that available to dev tools, but yes, it’s not quite there yet. Luckily though, D is now very stable and could be used to write some high-end commercial apps.

Honestly though, I’ve been spoiled by the convenience of languages like C#, but I’m not willing to sacrifice performance in some areas (nor do I think you should have to choose between the two). So really, only D offers the kind of productivity features (within the language) _and_ the performance of C/C++. I can’t really think of another option at this point.

Trolling aside, I tinkered with D in the past, and its a very nice language — especially after they finally wrangled the whole Phobos / Tango deal — but it’s still and has always lacked tooling support. One of the necessary trade-offs for me to deal with a staticly typed language (I normally do Python or Ruby) is robust tooling: an IDE with an integrated debugger, code completion (this IS a static language, after all), and the rest of the typical goodies are pretty much required. D still doesn’t have those, but hell, Ceylon, Kotlin, Dart — even Phantom if you wanna go there — have robust IDE support even though they’re all much younger. It really makes you question D and its value proposition when everything else seems to be zipping past it so quickly in terms of tooling support.

D has modern productivity language features comparable to C# and Java, without sacrificing the power and efficiency of native binaries. Granted it hasn’t really been an option until just recently, but It would be great to see more software move to D with proper SDKs and documentation.