The language, I like is PHP. PHP looks dirty, doesn’t have this or that…..so what?? I love it. It just cuts my development and maintenance time.

May be we should seriously consider using php in bioinformatics provided your requirement of multi-processor handling capabilities exists with it. If it doesn’t handle, use a C/C++ library for that part. That’s all man !!!!!!

Have you checked (what other’s are doing??) this article:

http://www.pubmedcentral.nih.gov/articlerender.fcgi?artid=2241925

IMHO Scala has the worst syntax ever (Anyone is free to disagree) and it just complicates smaller brains who want to develop bigger things. I have a small brain which cannot understand umpteen programming language paradigms.

Twitter could have retained RoR and used a low level module for essential area. Even they could have resorted to PHP. Worst!! Perl has a solution for that task already.

Groovy’s speed increase by 5x doesn’t make it any better than PHP

Final solution:

1) Good or bad or worst stick to PHP for 90% of tasks.
2) For algorithms, multiple-processor, Graphics options resort to Good C/C++ libraries.

That’s all you need. (Whether it is bioinformatics or any other informatics)

Keep it simple and stupid (KISS)

Cheers,
Cmezs

Haskell has a Template Haskell.
http://www.haskell.org/th/

This was a SIMPLE example to illustrate a point. Sometimes a certain function causing bad typing inferences might be chained many functions up and calling many other things. That might be a nightmare going through many many functions. This is an example for illustrative purposes only, I still remember when I first got a problem like this, with caml light, circa 14 years ago. More or less 800 lines of code separated where the compiler was signaling the error and where the error really was. Me and my colleague went home 4am or so in the morning. I had a rehash of this a couple of years ago when I implemented a population genetics simulator in caml.

Of course the simpler solution is to explicit type anything in sight, but that is throwing inferred typing away. I can make my population genetics code available where this pattern is easily seen: some functions have some parameters explicitly typed: A bug was traveling through there.

Regarding val vs var: I absolutely agree with you on this one. Scala’s designers seem to think that the whole imperative world is going to jump-ship on mutability and begin to meditate on the purity of their composed functions (it’s no coincidence that one of the features of pure-functional languages is called *higher-order* functions). With that said, I’ve found myself structuring around immutability in my Scala code without any detrimental effect on my code. I’m not ready to abandon var just yet, but that’s not what Scala is all about. It’s a hybrid language, so you use whatever works best for a given scenario.

I am not suggesting that Groovy does better in that respect (for what I know, it does not), but that is not the point here. The point is about Scala: Call me cynical but it there is mass adoption (which I doubt) the style will be mostly imperative.

If you feel that Scala does not solve the multi-core problem, then how does Groovy do? I would think it is even worse than Scala, but I now very little about Groovy, so I could well be wrong.

Caml can be a type debugging hell, imagine this: Function fa has a bug (a typing bug), function fa, calls fb (passing a wrong parameter type) which calls fc. Now the caml interpreter will infer a certain (wrong) type for fc. Now you call fc from elsewhere, say fd, and the compiler will throw an error in fd. Notice that the error is far, far away in fa. Solution, explicit typing everywhere on the chain (which you can do in caml)… On the example above, when fc is explicitly typed then the error will be raised on the correct chain of calls. But with explicit typing we are throwing type inference away in the first place…

Regarding Scala, you can see some comments that I have made on the scala mailing lists with my needs. I would just add another point: lack of good documentation and a community that is still small – maybe the things that I need are there but I could not discover it. With groovy its a different story…

You do realize you can ask the interpreter/compiler what the types of everything are in CAML, don’t you? CAML is one of the last languages I’d expect to give you type debugging hell.

Meta-programming is little more than a poor substitute for higher-order functions IMO. But if you see a higher value than “little”, maybe you could tell us where you’ve missed it in Scala.