For a reasonably high-level language that compiles to static binaries I can recommend Go
Upsides:
- can compile once and move binary around, all libraries included (makes the binary a bit big, a few MB even for simple scripts - no annoying GLIBC_2.14 errors)
- very simple language, not many pitfalls like for example C++
- amazing and intuitive support for concurrency baked into the language (goroutines) with great debugging software
- the compiler won't compile if you write messy code (unused variables etc.)
- blazing fast
- inbuilt GitHub support (you can import libraries via username/package, but very annoying versioning)
- reads Pythonic since the language is so simple, I've gone back to old tools written in golang and I can immediately see what's going on
- a tiny bit of pointer handling means that it's more explicit (unlike Python's implicit pointers that sometimes lead to unexpected behaviour)
Downsides:
- very simple language, you'll end up writing a lot of boilerplate (examples: all errors have to be handled, no generics so for example your function will have to check which type comes in)
- the compiler won't compile if you write messy code (i want to use that variable later you annoying thing!)
- still a little bit of pointer handling, more than e.g. Python - but no pointer arithmetic possible (luckily)
- package ecosystem isn't as amazing as Python/R, this is the biggest killer for me (but biogo looks nice)
If I would have a few more hours per day I would learn Julia - but days appear limited at 24h. It definitely looks interesting.
Is there something which could be done only with Julia and NOT with Python?
Is Julia considerably faster than Python?
Is Julia/ Rust really easy to learn or whether the transition from Python to something other is smooth?
If answers are "YES" then it should be considered.
PS: Even I don't know much about Julia or RUST and I am as curious as you. May be the experts will shed some light.
AFAIK: No-Yes-Yes
But nicely written Python code will always beat shitty Julia code, obviously.
actually Julia code is not that hard, and the idea behind Julia to avoid writing prototype code then rewrite it in more efficient language (that would be the case with Python, with respect to Cython and PyPy)
Coming from R or Python Julia looks quite similar to... both. So there are probably quite some gotcha's to keep in mind too!
+1 , I strongly agree, WouterDeCoster
The problem with new languages is the lack of libraries. Julia wasn't mature enough for my needs when I wanted to use it. However, Julia seems an improvement over the mess that R is but then it doesn't have the convenient Bioconductor packages. In the end, programming languages are just tools so you just need to use what fits the requirements of the task at hand.
Julia has been buzzing around for a few years now. At some point, I remember Douglas Bates (developer of lme4, among many other packages) saying he was dropping R (mainly due to having to support Solaris, but also for performance and difficulty of integrating C or C++ and R) in favour of Julia - I didn't follow the issue and don't know if he ever really dropped R.
There is an apparently active BioJulia project, and I have seen some developers starting (but not finishing yet) ports of their old code to Julia.
Anyway, I am really terrible at making predictions, so I will spare you on mine.
as you said there is some activities in developing mature BioJulia and It is really promising, but the issue will it continue?!