Julia: Interdisciplinary science perspective¶
- For software development in interdisciplinary fields like materials science, quantum chemistry, biology, physics and countless others, one problem is to bundle the efforts from all involved research communities.
- Problem here is that each field has different methods and approaches, resulting in deviating demands, for example:
- Mathematicians often consider reduced models and edge cases
- Scientists want to develop scientifically sound models and not worry about numerics
- Computer scientists want to gain the best performance for a given hardware
- Practicioners want to use the software to understand molecules or materials,
so software should be easy-to-use, reliable and black-box
- As a result existing software is often only suitable for the research of some involved communities, but fails to provide a general platform. One example from materials science is that improvements suggested by mathematical analysis (working on the their toy codes) sometimes don't make it into the packages used by practicioners.
- I think Julia is well-suited to overcome these challenges of interdisciplinary software development. Both high-level and low-level developments can be jointly underdone and at the same time one is able to design interfaces, which can be used by people less oriented towards programming.
Julia: My wishlist¶
- Better support for more advanced unit tests (test tagging, test selection, fixtures, plugin system for tests)
- Better support for static code analysis
- Better support for code completion and refactoring in editors (at least in VIM it's still only mäh to this point)
- Package maturity and quality not uniformly distributed amoungst fields ... yet.
- I think these aspects are mainly a question of time ... the basics are there, but compared e.g. to Python things have not yet developed so much into a stable common ecosystem.
Julia: User perspective¶
- Rich and growing package landscape
- Bonus on top: Keep using all your favourite python, R, C, C++ snippets
- Open and welcoming community with plenty of places to ask for help
- Advantageous language design:
- Code generic by nature
- Multiple dispatch decouples packages (since e.g. it avoids the binary operator problem)
- Risk of "dependency hell" well reduced
- Surprisingly small effort to try something, even a cutting-edge features (like GPU, automatic differentiation, mixed precision)
- Often combining niche packages, which have certainly never been used jointly, just works out of the box ...
- ... or it takes 1 or 2 simple patches with few-line fixes to get it there
Julia: Developer perspective¶
- High-level language, good for rapid prototyping
- The first prototype has adequate speed to go beyond simplistic test cases
- Tools to inspect, benchmark and profile (
- Tricks to selectively optimise performance (
- Philosophy: First get it to work, then make it fast
- Combination of strong type system and just-in-time compilation:
- Code can be written generically
- User can pass domain-specific knowledge about his problem
to the compiler in the form of types (e.g. symetries, positive-definiteness ...)
- Enables short-cuts and dynamic switching to better algorithms
- Compilation goodies: Dead code elimination / constant propagation / ...
- Machine-specific optimisations can be used ... even on inhomogeneous clusters with nodes of different processor generations
- Philosophy: Write code once, but reuse it many times