Being a computer scientist with a strong interest in languages (languages in the broadest sense possible: programming, natural and cognition related issues), I am in an holy grail quest for a programming language that:
First and foremost allows me to express my computations in a way that is close to the problem domain (as opposed to close to the machine). As I am working in a biology setting that means being able to talk about concepts around genes, epidemics and pharmacology in my programs. I don’t want to think about CPUs, memories and things like that when I am coding. Prolog and Lisp are good examples here. I also need programs that can evolve over time as knowledge changes, I need strong metaprogramming and Domain Specific Language facilities.
Unfortunately I have a couple more requirements coming from the day to day reality…
Real world: I want a language that interacts with existing libraries and that I can easily make available to other people to use, inspect and change. I need Bio* libraries, graphics plotting libraries. I my personal case I decided that I want to work inside the JVM, so I need a language that works in the Java world (Jython, JRuby, Scala, Groovy, … Java).
Software engineering: Programs have to be easy to maintain and debug. I guess there is no way around explicit typing on the debug and tool construction front.
Ridiculous religious fanatic quest? Yes, it might be, but I am pursing it.
The truth is that we are not far away from this grail.
Scala is almost there. Lacks metaprogramming and things like type inference are a bit amateurish (compare it with CAML).
JRuby is maybe there, I could live with it, I guess. The lack of explicit typing will make things difficult in the long run on the software engineering front.
I decided to give a final try to yet another language: Groovy, and up to now it is going very OK. Seems to nail all the fundamental points. I especially love the effort on good metaprogramming facilities.
I decided, for pragmatic reasons, that after this one I will stop my pursuit for the grail. If Groovy proves a blunder of some sorts I will revert to JRuby and carry on.
Hi,
the lack of optionnal typing in JRuby is definitely an issue. Still, core devs of JRuby are now working in hard to provide a JRuby to Java typed compiler. Meaning that you would be able to specify Java types using an optionnal syntax within JRuby code. Then, when using this code from the Java language, types will be enforced. How nice is it?
I suggest to have a look to this in a few weeks or months. I don’t think it’s targeted for JRuby 1.1 unfortunately, but soon later hopefully.
Cheers,
Raphaël Valyi.
If you really want to raise the level of abstraction closer to the problem domain (away from the format compiler/interpreter), perhaps you could consider non-embedded DSLs. This allows you to give language that maps to the problem domain and then use generators (much simpler to make than compilers) to the preferable target language. This gives the natural possibility to map to other implementation languages than just one. Some of the technology alllows you also to satisfy, at least partially, the evolution side: you can change the syntax and semantics of the language without loosing your existing specifications. For cases on variety of domans see http://www.dsmforum.org/cases.html
Raphaël,
I am (very pleasantly) impressed with Groovy, but if I find a roadblock JRuby is my plan B, it is good to know that at least some kind of support is expected in the future. For things like auto-completion, a standard mechanism of declaring parameters is important, also for debugging and maintenace, IMHO.
Jyha-Pekka,
I do believe that having a “Turing complete” language is fundamental, especially in an environment where not all is know about the problem domain and extensibility and knowledge upgrade is fundamental. It is not clear for me that making a generator is easier (I have actually done a couple of them, for web form and html generation - nothing fancy) than an embedded DSL, as long as the language underneath helps.
Consider Mathematica: coming from the Lisp family, it has the “everything is an expression” concept that allows meta-programming, and its pattern language allows Prolog-type backtracking. With a gazillion mathematical symbols and forms it allows you define your own interpretations for nicely-typeset domain-specific notations. It has J/Link for interfacing with Java (see the Wolfram Workbench as a decidedly non-toy example of that interface), as well as language bindings for C, .NET, and Python. Of course it has graphics plotting libraries. Bio* libraries, I’m not sure, but it’s worth taking a look. This is coming from a Wolfram employee who is a programming language buff.
Joel,
I would (and I like Mathematica)… if it was free.
[…] Tiago searches for the Holy Grain of programming languages […]