# 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
• 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