1 - can express 'weird' things that other languages would not be able necessarily express without strange gyrations.
2 - if you can develop in it, you're probably on the upper half of the developer bell curve. That brings systemic improvements in general.
Why hasn't this happened? Preumably if you use an advanced language you'll be a lot more productive because of the language and because you have the best developers.
Why haven't we seen shops that use advanced languages just utterly clean up? "Oh, you're doing 30fps with 1m vertices -- we just did 90fps with 50m vertices -- and btw, we did this w/o using the GPU". Or "Chrome? We built a new web browser that supports every draft of every aspect of HTML5, w/ a Javascript parser that runs at twice the speed of Chrome, and we wrote a new H264/WebM codec that doesn't require a GPU and can do HD video on a 286".
It just seems like for all the advantages that using an advanced language presumably gives, the software I see is simply "competitive". Maybe it will be the best in some spaces, but within the range that one would expect the best to be if everyone used C, for example.
And even among those who know these advanced languages really well, we don't see them fighting for them in their organization the way one might think given all they should presumably provide. Think Norvig, Steele, Abelson, Meijer, etc...
If development time, algorithms, and ability to wrap the language around the problem is the gate, an advanced language is going to be better.
According to the Alioth Shootout, OCaml, Haskell, and SBCL are in shouting range of C/C++ speeds. Link:
http://shootout.alioth.debian.org/u64q/which-programming-lan...
Therefore, if I was selecting an 'advanced' language for a performant real-world system, I would select one of those.
I agree, but I think this is the problem. If advanced languages are better, its surprising that it doesn't manifests itself in virtually any way that one can measure.
For example, if you're a CTO deciding which language to use, there is virtually no data to suggest using an advanced language is advantageous except religious arguments. Which is odd given they're supposed to confer both a superior language and superior developers.
Where's the beef? If I'm building a skyscraper, I'm using steam shovels, not standard shovels. The data makes it clear which is more effective. There's no remotely similar argument to be made for advanced languages.
Or how about the idea of having special syntax for some common data types, like lists and dictionaries and (sometimes) sets? This kind of thing is spreading and becoming more popular, because it really does seem to make people's jobs easier.
Some more up-and-coming language attributes include type annotations, more immutability by default, and Erlang-style message passing concurrency. And maybe support for asynchronous I/O, either with JavaScript-style anonymous functions or with coroutines. Some of these things really can make certain programming tasks dramatically easier.
The religious arguments tend to be anchored to languages, but there's some real information if you look past that to a deeper level.
/done with thread
> Why haven't we seen shops that use advanced languages just utterly clean up? "Oh, you're doing 30fps with 1m vertices -- we just did 90fps with 50m vertices -- and btw, we did this w/o using the GPU".
More productive doesn't mean more performant. It means building systems more quickly, a phenomenon for which there is ample evidence.
Large companies using less productive languages can still achieve great performance because they can throw lots and lots of resources at the problem, even if the payoff per head is much lower.
Where performance matters, I'd think they'd just build codegen systems, using the advanced language. They should still have a fundamental advantage here since they could build codegen systems faster and presumably with better codegen techniques.
It means building systems more quickly, a phenomenon for which there is ample evidence.
So what is the evidence?
Large companies using less productive languages can still achieve great performance because they can throw lots and lots of resources at the problem, even if the payoff per head is much lower.
But even with small/medium sized companies you don't see this happening. It just seems like everytime someone tries to show me how some company has done something incredible with advanced languages it is really borderline. It's never, "wow, slam dunk"
For example, I've never seen a Wolfenstein 3D from an advanced language. Soemthing that just blows away everything else. WordLens wasn't done with some advanced language. Google search engine. Excel. VMWare. There aren't a lot of big jumps in SW, but few, if any, seem to have come to market quickly (if at all) due to advanced languages.
You'd think they'd be able to take these advanced languages and top flight devs to change the face of software. But it usually turns into arguments about how their code is less buggy or produced faster. Both hard to really judge objectively given one rarely writes the same program concurrently in two different languages. And the delta rarely seems large enough that it is obvious.
http://www.nt.ntnu.no/users/haugwarb/Programming/Haskell/has...
I'm also curious as to why functional programming hasn't been more successful. I think that, whilst such languages are especially elegant for some forms of control flow, they require more mental contortions than mixed-paradigm languages. Since this makes them less comfortable, they're less popular still.
While it depends on what you're comparing to (is the competition writing assembly by hand or writing Python in a functional style?), I don't think you'll see someone working in an advanced language getting to market shockingly faster (and their code won't run faster), or something similarly strikingly noticeable from the outside. More likely, when a company working in an advanced language does get ahead, you'll see them having a much easier time keeping up with competition and adapting to new trends due to much lower maintenance overhead. Resources expended on debugging and refactoring isn't a measure we really look at when talking about most successful projects, but it is still worth improving.
So, most of the time, you end up with a piece of software that's short and sweet and hopelessly brittle.
I've been using Haskell a bunch lately, and I've found that by the time the compiler stops snarling and hissing at me, most of the stupid little bugs are gone. That's a nice thing sometimes, even if appeasing the type system can be annoying.