Are some Functional Programming languages syntactically geared for better performance?

Question

I hear about the manifold increase in productivity, while using certain languages (RoR). I have also heard about some VMs being more optimal than others (GHC?). Yet others are trying to optimize their language of choice by improving the underlying architecture (Unladen Swallow)

However, while reading a paper ("SSA is functional programming"), I had a question on whether a particular language, by the virtue of its syntax , can (someday) be the language with the best performance.

I guess what I am asking is that, whether a particular syntax, is THEORETICALLY the best geared one to produce the best machine code. I would be very interested in the underlying theory for any opinions - I was discussing this with some friends and we were knocking about ideas about the information content of a particular syntax.

Please do note I am talking about languages which have atleast first class functions - no ASM please.

Answer 1

This is highly subjective

The syntax of a language is just a method of expressing desired semantics. It is the semantics that drive performance. The 'performance implications of syntax' is equal to the performance implications of semantics given that past syntax analysis the syntax is often irrelevant.

The performance implication of semantics comes down to the environment that those semantics are being run in. This is why we have a CPU and a GPU, because they each can perform the semantics of a given low-level language quicker.

There is not really an answer to this without explicitly stating the target environment. A cluster of machines will deal better with concurrent programs, and there are syntax that express concurrency such as Erlang.

What you should be focusing on perhaps is how a generalized virtual machine or environment can provide the best performance for a wide range of semantics. For example, if you ported the Erlang syntax to JVM, could the virtual machine recognize that the language was single-assignment and concurrent without the requirement of locks? Could it optimize for this? Stackless virtual-machines are a good example of attempts to make efficient a generalized environment dependent on required semantics.

Really the question is: can the environment be optimized for a class or constrained set of semantics, when the environment is by definition, general?

I would recommend learning a bit about compilers (and where syntax stops mattering) and then look at something like LLVM, then re-ask yourself the question. As to if function languages are more suited to performance depends on the environment the translation is being executed in (multi-core, distributed, small-embedded device).

Answer 2

Well GHC at least compiles Haskell code into C and then compiles that, so it can't possibly be faster than the same algorithm written in C, right? At the very best it can be just as efficient, and that's only with a good optimizing compiler. The code generated from the Haskell->C conversion is very inflexible, big blocks of code repeated for each instruction so it may very well be worse.

Now this being said, I think a language's libraries are what dictate what the language is best suited for more than the actual language itself (assuming it has acceptable performance), so this isn't the very best question to ask.

Answer 3

From a blog entry about c vs. ocaml:

The Objective-Caml bytecode interpreter was faster than the carefully hand-optimized C program! Why? Because the OCaml compiler could recognize that the arrays were completely independent - it didn't need to worry about one iteration of the loop stepping on the values used by another. The C compiler couldn't apply a lot of useful optimizations, because it couldn't be sure that they were valid.

It's not so much about syntax, though.