Hacker News Reader

My observation is that quite often, systems built with the 'advanced' languages are more sophisticated and are much closer to cutting-edge researchy ideas. That also tends to correlate with 'niche' and 'small company'. The essential complexity of the problem must be surmounted. If performance is the gate, C is still the best.

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.

My observation is that quite often, systems built with the 'advanced' languages are more sophisticated and are much closer to cutting-edge researchy ideas. That also tends to correlate with 'niche' and 'small company'.

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.

It doesn't help when developers aren't willing to seriously investigate and code in the languages, but rather throw mud on the ideas.

/done with thread

It might help to look not at languages, but at attributes of languages. For example, garbage collection has gone from an expensive feature in "advanced" languages to something used in almost every programming language. This is compelling evidence that garbage collection is, in general, a good thing.

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.

The only place you may see a data driven argument to support advanced languages would be a journal on software engineering or the like. (I'm a little skeptical that many CTO's read academic journals.) Developers in the field are not going to publish formal studies on language comparisons. CTO's most likely would have to use the method suggested by pjscott.

> 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".

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.

More productive doesn't mean more performant.

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.

The most obvious slam-dunk I can think of is Emacs. Twenty years later there's still nothing else like it when it comes to extensibility and interactivity.

Well, the advanced languages often compile through low level languages like C anyhow, to get the performance they have. In terms of productivity, I remember running into this comparison including Haskell and C++ from '94.

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.

Languages like Haskell give more benefit in security/stability, testing, and refactoring. They maybe feel like they help you develop faster since they usually involve less typing, but typing isn't really the bottleneck for developing a major application. Any major project also has considerations other than code. To take the example from your other comment, there is an (open source) FPS written in Haskell, but it doesn't have the artwork, story, or level design of a modern production FPS, and someone still had to think about how to design the thing.

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.