Concluding Remarks

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 (BenchmarkTools, Profile, @code_llvm, @code_native, ...)
  • Tricks to selectively optimise performance (@threads, @inbounds, @views, @simd, ...)
  • 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