Merge pull request #191 from coding-for-reproducible-research/issue190-julia_typos

Fix typos in Julia Intro notes

Author: liamjberrisford

individual_modules/introduction_to_julia/arrays_and_matrices.ipynb

@@ -52,7 +52,7 @@
    "metadata": {},
    "source": [
     "#### Constructor\n",
-    "It is also possible to make use of the `Array` constructor, allowing for more control over the arrays properties, relevant to when considering specific performance elements. The use of the constructor can be helpful in situations where performance is needed as to allow for the array to remain unitiatilised until the final values are put into the array, and not requiring the array to be populated with zeros and ones until that time arrives. \n",
+    "It is also possible to make use of the `Array` constructor, allowing for more control over the arrays properties, relevant to when considering specific performance elements. The use of the constructor can be helpful in situations where performance is needed as to allow for the array to remain uninitialised until the final values are put into the array, and not requiring the array to be populated with zeros and ones until that time arrives.\n",
     "\n",
     "The code below creates an uninitialized arrays of integers with 5 elements. If you print the values for the array you will get a different "
    ]
@@ -81,7 +81,7 @@
    "id": "f806f17f-f65f-4af0-8716-0892be608684",
    "metadata": {},
    "source": [
-    "#### Rnages and Comprehension \n",
+    "#### Ranges and Comprehension \n",
     "It is also possible to create arrays with the use of ranges and comprehension as seen below. If the value of `c` is printed as it is, it will give a `UnitRange` object, the `collect` function is able to convert the range into an array, which then gives the format seen before when printing the variable. "
    ]
   },
@@ -248,7 +248,7 @@
     "Manipulating arrays involved accessing and modifying their elements, as well as performing various operations on them. \n",
     "\n",
     "#### Indexing\n",
-    "Square brackets with indices can be used to access specific elements. Of note is that in Julia indexesing starts at 1."
+    "Square brackets with indices can be used to access specific elements. Of note is that in Julia indexing starts at 1."
    ]
   },
   {

individual_modules/introduction_to_julia/control_flow.ipynb

@@ -21,7 +21,7 @@
     "\n",
     "\n",
     "## Conditional Statements \n",
-    "Julia uses `if`, `else`, and `elseif` to allow your program to execute different sections of code based on whether a coniditon (or set of conditions) is true or false. For example the code below will determine if a given number is negative, positive or zero."
+    "Julia uses `if`, `else`, and `elseif` to allow your program to execute different sections of code based on whether a condition (or set of conditions) is true or false. For example the code below will determine if a given number is negative, positive or zero."
    ]
   },
   {

individual_modules/introduction_to_julia/functions.ipynb

@@ -62,7 +62,7 @@
     "    - **Parameter**: In the above function this is `radius`. The syntax of `::Float64` denotes type annotation for double precision floating point numbers. \n",
     "    - **Returns**: The computed area using the const\n",
     "\n",
-    "To then make use of the function there is a need to call the function with the arguement for the parameter, seen in the above with calculating the area of a circle with a radius of 5. \n",
+    "To then make use of the function there is a need to call the function with the argument for the parameter, seen in the above with calculating the area of a circle with a radius of 5. \n",
     "\n",
     "## Lambda (Anonymous) Functions \n",
     "Lambda functions are functions that are not bound to a name and often used as short code snippets that are passed onto higher-order functions. An example definition and usage of a lambda function can be seen below."
@@ -94,7 +94,7 @@
    "metadata": {},
    "source": [
     "## Multiple Dispatch\n",
-    "Multiple dispatch is a key feature of Julia, where the function that is called depends on the runtime types of all arguements, allowing for efficient and flexible code. Below is an example defining multiple version of an \"add\" function, where each handles a different type of input. "
+    "Multiple dispatch is a key feature of Julia, where the function that is called depends on the runtime types of all arguments, allowing for efficient and flexible code. Below is an example defining multiple version of an \"add\" function, where each handles a different type of input. "
    ]
   },
   {
@@ -137,7 +137,7 @@
     "The use of multiple dispatch has a range of different benefits including:\n",
     "- **Flexibility**: Functions can be written in a generic manner, with specific behaviour implemented for specific types.\n",
     "- **Performance**: Julia is able to optimize the method calls at runtime, leading to efficient code execution.\n",
-    "- **Extenability**: New types can be introducted without requiring existing code modification. "
+    "- **Extensibility**: New types can be introduced without requiring existing code modification."
    ]
   }
  ],

individual_modules/introduction_to_julia/io.ipynb

@@ -20,10 +20,10 @@
     "- Implement data processing tasks using various file formats \n",
     "\n",
     "## Overview of I/O\n",
-    " I/O (Input/Output) operations involve reading data from data streams and outputing data into streams, these typically involve writing data to files and reading data from files.\n",
+    " I/O (Input/Output) operations involve reading data from data streams and outputting data into streams, these typically involve writing data to files and reading data from files.\n",
     "\n",
     "### File Handling \n",
-    "File handling can be used in a number of different circumstances including data processing, storage and retrival, alongside creating logs and configuration files."
+    "File handling can be used in a number of different circumstances including data processing, storage and retrieval, alongside creating logs and configuration files."
    ]
   },
   {
@@ -33,7 +33,7 @@
    "source": [
     "## Basic File Operations \n",
     "### Opening and Closing Files \n",
-    "The first arguement to the function `open()` gives the filepath for the file that is to be opened, with the second arguement outlining the permissions, in the case below, read denoted with `r`, but write access could be set with `w`. "
+    "The first argument to the function `open()` gives the filepath for the file that is to be opened, with the second argument outlining the permissions, in the case below, read denoted with `r`, but write access could be set with `w`."
    ]
   },
   {
@@ -55,7 +55,7 @@
    "id": "73256311-4553-41cf-a428-9b880ff27ffa",
    "metadata": {},
    "source": [
-    "Ofcourse simply opening and closing the file is not a lot of use, and at the very least we will want to read the data in the file. \n",
+    "Of-course simply opening and closing the file is not a lot of use, and at the very least we will want to read the data in the file.\n",
     "\n",
     "### Reading from and Writing to Files \n",
     "#### Reading from a text file \n"
@@ -136,7 +136,7 @@
    "id": "85d11a40-f4a8-4e34-bc0e-520ca7f5a608",
    "metadata": {},
    "source": [
-    "As you can see from the output the only content within the file is the content that we have put into the file. If we want to instead append data to the file, then we can make use of the arguement `a` rather than `w`."
+    "As you can see from the output the only content within the file is the content that we have put into the file. If we want to instead append data to the file, then we can make use of the argument `a` rather than `w`."
    ]
   },
   {

individual_modules/introduction_to_julia/operations.ipynb

@@ -19,7 +19,7 @@
     "- Understand the syntax and usage of different operators in Julia\n",
     "- Implement basic mathematical and logical operations in Julia scripts\n",
     "\n",
-    "## Arthmetic Operations"
+    "## Arithmetic Operations"
    ]
   },
   {

individual_modules/introduction_to_julia/package_management.ipynb

@@ -14,15 +14,15 @@
     "# Package Management\n",
     "## Learning Objectives\n",
     "- Understand the basics of Julia's package management system\n",
-    "- Add, remove, and update packages using Julias package manage (Pkg)\n",
+    "- Add, remove, and update packages using Julia's package manage (Pkg)\n",
     "- View and manage installed packages in your Julia environment\n",
     "- Explore common Julia packages and their functionalities\n",
     "- Implement package management best practices in your Julia projects \n",
     "\n",
     "As seen at various points throughout this course, Julia makes use of packages to provide access to key functionality that you will likely you commonly within your workflow. \n",
     "\n",
     "## Overview of Julia's Package System \n",
-    "Julia has a rich ecosystem of packages, enabling access to extended functioanlity for a number ofvarious tasks, including data analysis, visualisation, and scientific computing to name a few. The Julia package manager (Pkg) is a powerful tool for managing these packages. \n",
+    "Julia has a rich ecosystem of packages, enabling access to extended functionality for a number of various tasks, including data analysis, visualisation, and scientific computing to name a few. The Julia package manager (Pkg) is a powerful tool for managing these packages.\n",
     "\n",
     "The use of the Pkg manager allows for effective package management, making it easy to install, update, and manage dependencies.\n",
     "\n",
@@ -53,7 +53,8 @@
     "tags": []
    },
    "source": [
-    "of note is that before you are able to use a package you first need to import it, which in Julia can be achieved with the use of 'using <package-name>`. Infact within Julia Pkg is also a package and so needs to be imported before you are then able to import other packages. \n",
+    "Of note is that before you are able to use a package you first need to import it, which in Julia can be achieved with the use of 'using <package-name>`.\n",
+    "In fact within Julia Pkg is also a package and so needs to be imported before you are then able to import other packages.\n",
     "\n",
     "### Removing Packages\n",
     "Removing packages can be achieved with the use of `Pkg.rm`. For example to remove the package \"Plots\" we could make use of the command `Pkg.rm(\"Plots\")`\n",
@@ -118,12 +119,13 @@
     "[JuliaDB.jl](http://juliadb.org/latest/)\n",
     "\n",
     "## 5. JuMP.jl\n",
-    "`JuMP.jl` is a domain-specific modeling language for mathematical optimization embedded in Julia. It is used for linear programming, nonlinear programming, and other optimization problems.\n",
+    "`JuMP.jl` is a domain-specific modelling language for mathematical optimization embedded in Julia.\n",
+    "It is used for linear programming, non-linear programming, and other optimization problems.\n",
     "\n",
     "[JuMP.jl](https://jump.dev/JuMP.jl/stable/)\n",
     "\n",
     "## 6. Distributions.jl\n",
-    "`Distributions.jl` provides a large collection of probability distributions and related functions. It is useful for statistical modeling and probabilistic computations.\n",
+    "`Distributions.jl` provides a large collection of probability distributions and related functions. It is useful for statistical modelling and probabilistic computations.\n",
     "\n",
     "[Distributions.jl](https://juliastats.org/Distributions.jl/stable/)\n",
     "\n",

individual_modules/introduction_to_julia/performant_code.ipynb

@@ -12,7 +12,8 @@
    },
    "source": [
     "# Performant Code\n",
-    "Julia was designed for high-performance numerical and scientific computing. In order to fully utilise Julia capabilities writing performant code is cruical, particularly for the computationaly intensive tasks it has been desinged for. \n",
+    "Julia was designed for high-performance numerical and scientific computing.\n",
+    "In order to fully utilise Julia capabilities writing performant code is crucial, particularly for the computationally intensive tasks it has been designed for.\n",
     "\n",
     "## Learning Objectives\n",
     "- Understand the basics of performance tuning strategies in Julia\n",
@@ -32,7 +33,9 @@
     "### Type Stability\n",
     "**Definition**: Type stability means that the type of a variable's value is predictable and consistent within a function. Julia's Just-In-Time (JIT) compiler can optimize type stable code more efficiently. \n",
     "\n",
-    "In the example below, type stability is achieved through the use of the type hinting done with the use of `::Vector{Int}` in the function arguement declaration. The `::Vector{Int}` in Julia specifies that the variable should be a vector (array) of integers, ensuring type stability and enabling the compiler to optimize the code more effectively. Type hinting is achieved with the use of the `::`."
+    "In the example below, type stability is achieved through the use of the type hinting done with the use of `::Vector{Int}` in the function argument declaration.\n",
+    "The `::Vector{Int}` in Julia specifies that the variable should be a vector (array) of integers, ensuring type stability and enabling the compiler to optimize the code more effectively.\n",
+    "Type hinting is achieved with the use of the `::`."
    ]
   },
   {
@@ -112,7 +115,8 @@
    "metadata": {},
    "source": [
     "### Avoiding Global Variables \n",
-    "Global variables can lead to type instability and hinder the compiler's optimization efforts. In order to tackle the issues of global vairbales, local variables should be used within functions and pass necessary global data as arguments."
+    "Global variables can lead to type instability and hinder the compiler's optimization efforts.\n",
+    "In order to tackle the issues of global variables, local variables should be used within functions and pass necessary global data as arguments."
    ]
   },
   {
@@ -348,7 +352,7 @@
    "id": "ce43ab12-540a-4ee3-8ada-bf64884e549c",
    "metadata": {},
    "source": [
-    "We can see that running code to run the sum of 1000 rand numbers took a defined amount of time to run. If we increase the size of the numbers that we want to sum over then it will take longer to run. Understanding how the time taken to run the code will change when the size of the input data changes is key to being able to understadn the complexity of the code. It is common place to have a large computational task that is run for a smaller subset of data that will then be able to be used to extrapolate to an estimate of the time it will take the full computational run. "
+    "We can see that running code to run the sum of 1000 rand numbers took a defined amount of time to run. If we increase the size of the numbers that we want to sum over then it will take longer to run. Understanding how the time taken to run the code will change when the size of the input data changes is key to being able to understand the complexity of the code. It is common place to have a large computational task that is run for a smaller subset of data that will then be able to be used to extrapolate to an estimate of the time it will take the full computational run."
    ]
   },
   {