You might check out http://www.ffconsultancy.com/products/index.html if you haven’t already – approaches to F# and OCaml from that perspective, though I’m not sure how close it gets to “people use it for real work.”

Yossi Kreinin wrote an interesting article where he challenged people to implement matrix algorithms in a type-safe way. His conclusion was many of them had intermediate steps that were very hard for most type systems to handle.

Have you considered using contracts for catching errors?

Fortran 77?

A little more seriously, a lot of this depends on what sorts of errors you expect to catch. Syntax is one thing, but like do you want something to catch ill-conditioned or singular matrices or something?

chapel seems like a promising new language for high-performance computing. I don’t know if it’s ready or not.

If you want a large library ecosystem, C++ is probably your best bet. The cores of both PyTorch and Tensorflow are written in C++. There are good linear algebra libraries (Eigen, Armadillo), more traditional machine learning libraries (OpenCV, MLPack).

I think you’re probably better off using whatever is popular in the community you operate in. You’ll have more tutorials, existing code, experienced people to draw on, etc. What you can do is use language-neutral techniques such as Design by Contract, Property[/Contract]-Based Testing, and fuzzing to catch most of those errors. For anything hard to express, just add a manual review and/or tests for it. The nice thing is you can incrementally adopt these using them as much or as little as you prefer.

Lobsters search will give you plenty of things to read on those.

OCaml has a few emergent tools, already used for some research in numerics and machine learning: owl (ocaml.xyz), lacaml (mmottl.github.io/lacaml) and slap (akabe.github.io/slap). They can also be used in jupyter nktebooks, by means of the ocaml-jupyter package, although for plotting they are not at the level of python yet.

For machine learning there are also ocaml-torch and tensorflow-ocaml which provide bindings to libtorch and tensorflow.

Biology field uses Java a lot, specifically ImageJ and Fiji.

“Scientific computing” is a big bucket, and it often depends a lot what particular field you’re working in. Genomics computes differently than weather forecasting, computes differently than quantum chemistry, etc. A lot of fields end up tied to a particular programming language based on the specialized libraries they’re working with, or just based on what language is used for their most common applications. For example, researchers who do molecular dynamics work with GROMACS, which is written in C++, will often do their other work in C++ because it’s familiar.

So… my first suggestion would be that you talk to the (other?) scientists you’re working with, and ask what they’re using. ;-) And if you’re not working with any scientists, I’d suggest you find some collaborators based on what you’re interested in!

FWIW: I have a lot of general experience in building and running large research computing clusters (“HPC”), and have worked mostly with physicists and chemists. At a high level I’d say the most commonly-used languages are C++ and Fortran, both of which are statically typed. Oftentimes throw in some CUDA or other GPU-programming language. (Disclaimer: I work at NVIDIA, so I see a lot of GPU applications.)

However, I’d say that experience is biased by mostly working with large (100+ node) clusters, where my users are more likely to be using some kind of multi-node parallelism framework based on MPI, which supports C++ and Fortran best. For those who mostly work with a single node at a time, I’d say that Python is probably the language I see used most, followed by Julia.

You may not know that you can typecheck Julia as well by defining a macro.

https://nextjournal.com/jbieler/adding-static-type-checking-to-julia-in-100-lines-of-code/

There are some limitations, but you can pick up a bunch of common issues with those macros. There are some static analysis tools as well (one included in the vscode Julia extension).

F# has a good community around it. I know at least one biopharmaceutical company that uses it for literally everything.

You should not stop worrying, if you don’t have a type checker you need comprehensive tests that make sure that your type assumptions are not violated. There are domains where mistakes are costly and those domains in my opinion should be leveraging every tool they can, compiler, static analysis (linter), and tests. F# supports units of measure for example which allow you to track the units such as “Meters/Second” and prevent you from multiplying to say “Meters/Hour” without a conversion, at compile time.

Would strong typing have helped in the recent case where Python code running on Windows (as opposed to on Linux or Mac) returned the results of a directory read in an unexpected order?

There is static typing for Python provided by MyPy.

What kind of errors are you trying to avoid with static typing?

I think I’ve seen some people on the Nim forums mention they do it.

I am pretty sure I’ve seen people in the Go community mention they do it (although I believe one needs some getting used esp. to the fact that one can’t use operator overloading for matrix operations).