Merge pull request #278 from coding-for-reproducible-research/julia_session_2

Julia session 2 Content

Author: liamjberrisford

_toc.yml

@@ -113,6 +113,8 @@ parts:
                   - file: individual_modules/introduction_to_julia/control_flow
                   - file: individual_modules/introduction_to_julia/functions
                   - file: individual_modules/introduction_to_julia/arrays_and_matrices
+                  - file: individual_modules/introduction_to_julia/io
+                  - file: individual_modules/introduction_to_julia/package_management
           - file: course_homepages/python
             sections:
               - file: individual_modules/section_landing_pages/introduction_to_python

individual_modules/introduction_to_julia/array.bin

@@ -0,0 +1,4 @@
+1
+-4.3
+42
+3.14

individual_modules/introduction_to_julia/data/numbers.txt

@@ -754,7 +754,7 @@
     "\n",
     "The benefits of this are:\n",
     "\n",
-    "- **Performance**: Julia will pick the most specific method and compile optimised machine code for that method. This is especially valuable for methods that get called multiple times (e.g. within a loop).\n",
+    "- **Performance**: Julia will pick the most specific method and compile optimised machine code for that method. This is especially valuable for methods that get called multiple times (e.g. within a loop). To make best use of this, it's important to ensure we write functions in a way that allows Julia to infer the types input/output at each step of the computation (more about this later in the course).\n",
     "- **Extensibility and flexibility**: Code can be written in a way to provide special cases for specific types when needed. Users can add new methods to functions (even those from the standard library or other packages) for new types they define without modifying the original code, a form of polymorphism.\n",
     "- **Clarity**: We can use the dispatch mechanism instead of writing functions with long chains of type-checking `if-else` statements.\n",
     "\n",

individual_modules/introduction_to_julia/functions.ipynb

@@ -61,7 +61,7 @@
     "Each method shares the same name `add` but has different implementations for the types it handles. This makes the code:\n",
     "\n",
     "- **Clear and concise**: There is no need to add different code paths through functions based on checking types of arguments.\n",
-    "- **Fast**: Julia compiles a specialised version for each method call at runtime. \n",
+    "- **Fast**: Julia compiles a specialised version for each method call as required, using *just-in-time* (JIT) compilation. \n",
     "- **Extensible**: New implementations of `add` can easily be added for new combinations of types.\n",
     "\n",
     "Julia is also designed to be **dynamically typed**; you do not need to declare types for variables, as the type is determined at runtime, alongside using automatic memory management (garbage collection), so you don't have to manually allocate or free memory in typical usage. \n",
@@ -70,8 +70,8 @@
     "\n",
     "Julia incorporates many features that make it powerful for numerical and scientific computing:\n",
     "\n",
-    "- **High Performance**: Thanks to JIT compilation using LLVM, Julia can approach or match the speed of C and Fortran for many tasks, meaning you often don't need to rewrite performance-critical code in another language. Code written in pure Julia is typically fast if written with performance in mind. \n",
-    "- **Multiple Dispatch**: Multiple dispatch allows the standard library and packages to define methods optimised for different types (e.g. arrays of floats vs ints) seamlessly. This contributes to performance. It also makes it straightforward to extend the code to support new types as-and-when useful.\n",
+    "- **High Performance**: Julia can approach or match the speed of C and Fortran for many tasks, meaning you often don't need to rewrite performance-critical code in another language. Julia features just in time compilation using LLVM and, where possible, specialises function calls according to types that are inferred during compilation. This means that code written in pure Julia is typically fast if written in a way that maximises Julia's type inference capabilities (as well as other performance considerations).\n",
+    "- **Multiple Dispatch**: Multiple dispatch allows the standard library and packages to define methods optimised for different types (e.g. arrays of floats vs ints) seamlessly. As well as being at the heart of Julia's performance capabilities, it also makes it straightforward to extend the code to support new types as-and-when useful.\n",
     "- **Good support for Numerical Computing**: Julia has built-in support for things like arbitrary precision arithmetic, regular expressions, and powerful libraries for linear algebra and random numbers. Julia's package manager makes it easy to add external packages for specialised functionality, such as statistics, plotting, optimisation, etc.\n",
     "- **Interactive and Reproducible**: Julia can be used interactively (e.g. via the REPL or Jupyter notebooks) just like Python or R, which is great for exploration. Julia also has the built-in `Pkg` standard library that uses **Project** and **Manifest** files to pin exact dependency versions and ensure your environment can be recreated anywhere.\n",
     "- **Learning from older languages**: To some extent, Julia has been able to implement lessons that other languages had to learn the hard way, especially around it's tooling. For example, its package management system is easy to use, it has unit testing support directly in the standard library, and it has a a go-to [documentation generator](https://documenter.juliadocs.org/stable/).\n",