Revert "spelling corrections using en_CA dictionary"

This reverts commit 104c305.

en_GB is preferred for Carpentries episodes, according to
carpentries/lesson-example#231

Author: tkphd

_episodes/01-basics.md

@@ -11,7 +11,7 @@ keypoints:
 ---
 
 The most basic use of Python is to use it as a fancy calculator.
-It is very easy to do basic math in Python.
+It is very easy to do basic maths in Python.
 
 ```python
 print(5 + 1)
@@ -33,7 +33,7 @@ Notice how leaving out `print()` gives us the same result as above.
 ```
 {: .output}
 
-Python can do all of the normal basic math operations you'd expect.
+Python can do all of the normal basic maths operations you'd expect.
 
 ```python
 5 + 3
@@ -76,7 +76,7 @@ Remainder division (`%`), gives the remainder after division.
 ```
 {: .output}
 
-Python follows the normal order of operations for math.
+Python follows the normal order of operations for maths.
 
 ```python
 4 + 1 * 6
@@ -124,7 +124,7 @@ weight_kg
 ```
 {: .output}
 
-We can perform math on variables the same way we would normally.
+We can perform maths on variables the same way we would normally.
 
 ```python
 print('weight in pounds:', 2.2 * weight_kg)
@@ -269,7 +269,7 @@ and pointed an arrow (`^`) at the bad part.
 ## Different types of data
 
 Computers are not smart, and have to be explicitly told how to handle different types of data.
-Although a human might know that you can't do math on a word, 
+Although a human might know that you can't do maths on a word, 
 our computer does not. 
 To work around this problem, programming languages store different types of data in different ways. 
 
@@ -336,7 +336,7 @@ For instance, we can even use the `+` sign to put strings together!
 ```
 {: .output}
 
-Note that math operations on strings will only work within reason.
+Note that maths operations on strings will only work within reason.
 Attempting to add a string to a number doesn't work!
 
 ```python
@@ -373,7 +373,7 @@ int
 ```
 {: .output}
 
-But what happens when we perform a math operation that would result in a decimal?
+But what happens when we perform a maths operation that would result in a decimal?
 
 ```python
 type(10 / 3)

_episodes/03-lists.md

@@ -8,7 +8,7 @@ objectives:
 - "Learn to use lists and Numpy arrays, and explain the difference between each."
 keypoints:
 - "Lists store a sequence of elements." 
-- "Numpy allows vector math in Python."
+- "Numpy allows vector maths in Python."
 ---
 
 At the end of the last lesson, we saw noticed that `sys.argv` gave us a new data structure:
@@ -175,7 +175,7 @@ List 1 is:  [1, 2, 3, 4, 5, 6, 7]
 Modifying `list2` actually modified `list1` as well.
 In Python, lists are objects.
 Objects are not copied when we assign them to a new value (like in R).
-This is an important optimization, 
+This is an important optimisation, 
 as we won't accidentally fill up all of our computer's memory by renaming a variable a couple of times.
 When we ran `list2 = list1`, it just created a new name for `list1`.
 `list1` still points at the same underlying object.
@@ -267,7 +267,7 @@ print(list1)
 {: .output}
 
 > ## Dynamic resizing of lists
-> Python's lists are an extremely optimized data structure.
+> Python's lists are an extremely optimised data structure.
 > Unlike R's vectors, there is no time penalty to continuously adding elements to list.
 > You never need to pre-allocate a list at a certain size for performance reasons.
 {: .callout}
@@ -323,13 +323,13 @@ for element in ['a', True, None]:
 ```
 {: .output}
 
-## Vectorized operations with Numpy
+## Vectorised operations with Numpy
 
 Numpy is a numerical library designed to make working with numbers
 easier than it would otherwise be.
 
 For example, say we had a list of a thousand numbers.
-There's no way to do vector math without iterating through all the
+There's no way to do vector maths without iterating through all the
 elements!
 
 ```python
@@ -350,7 +350,7 @@ print(new_vals[:5])
 {: .output}
 
 That was a lot of work.
-Numpy lets us do vector math like in R, saving us a lot of effort.
+Numpy lets us do vector maths like in R, saving us a lot of effort.
 The most basic function is `np.array()` which creates a numerical
 array from a list.
 A numpy array is a collection of numbers that can have any number of dimensions.
@@ -449,6 +449,3 @@ array([ 0,  8, 16, 24, 32])
 > Retrieve everything defined in the range of
 > rows 4-5 and columns 1-4.
 {: .challenge}
-
-<!--  LocalWords:  sys argv th IndexError Traceback idx vals np timeit
- -->

_episodes/05-functions.md

@@ -257,7 +257,7 @@ list(filter(less_than_3, values))
 That was very inconvenient.
 We had to define an entire function just to only use it once.
 The solution for this is to write a one-time use function that has no name.
-Such functions are called either anonymous functions or lambda functions (both mean the same thing).
+Such functions are called either anonymous functions or lamdba functions (both mean the same thing).
 
 To define a lambda function in python, the general syntax is as follows:
 
@@ -310,7 +310,7 @@ list(filter(lambda x: x<3, [1,2,3,4,5]))
 ## map/filter style functionality with Numpy arrays
 
 Although you *could* use a for-loop to apply a custom function to a numpy array in a single go, 
-there is a handy `np.vectorize()` function you can use to convert your functions to a vectorized numpy equivalent.
+there is a handy `np.vectorize()` function you can use to convert your functions to a vectorised numpy equivalent.
 Note that this is purely for convenience - this uses a `for-loop` internally.
 
 ```python

_episodes/06-parallel.md

@@ -47,7 +47,7 @@ The number of concurrent tasks that can be started at the same time, however is
 Now imagine that all workers have to obtain their paint form a central dispenser located at the middle of the room. 
 If each worker is using a different colour, then they can work asynchronously. 
 However, if they use the same colour, and two of them run out of paint at the same time, 
-then they have to synchronize to use the dispenser - 
+then they have to synchronise to use the dispenser - 
 one should wait while the other is being serviced.
 
 In our analogy, the paint dispenser represents access to the memory in your computer.
@@ -65,7 +65,7 @@ Suppose that worker A, needs a colour that is only available in the dispenser of
 worker A should request the paint to worker B and worker B should respond by sending the required colour.
 
 Think of the memory distributed on each node/computer of a cluster as the different dispensers for your workers.
-A *fine-grained* parallel program needs lots of communication/synchronization between tasks, 
+A *fine-grained* parallel program needs lots of communication/synchronisation between tasks, 
 in contrast with a *course-grained* one that barely communicates at all. 
 An embarrassingly/massively parallel problem is one where all tasks can be executed completely independent from each other (no communications required).
 
@@ -88,7 +88,7 @@ each good at certain types of tasks:
 ### Asynchronous programming
 
 Often times, certain computations involve a lot of waiting. 
-Perhaps you sent some information to a web server on the internet and are waiting back on a response.
+Perhaps you sent some information to a webserver on the internet and are waiting back on a response.
 In this case, if you needed to make lots of requests over the internet, 
 your program would spend ages just waiting to hear back.
 In this scenario, it would be very advantageous to fire off a bunch of requests to the internet,
@@ -250,13 +250,13 @@ AttributeError: Can't get attribute 'sleeping' on <module '__main__'>
 The `multiprocessing` module has a major limitation:
 it only accepts certain functions, and in certain situations.
 For instance any class methods, lambdas, or functions defined in `__main__` wont' work.
-This is due to the way Python "pickles" (read: serializes) data
+This is due to the way Python "pickles" (read: serialises) data
 and sends it to the worker processes.
 "Pickling" simply can't handle a lot of different types of Python objects.
 
 Fortunately, there is a fork of the `multiprocessing` module called `multiprocess` 
 that works just fine (`pip install --user multiprocess`). 
-`multiprocess` uses `dill` instead of `pickle` to serialize Python objects
+`multiprocess` uses `dill` instead of `pickle` to serialise Python objects
 (read: send your data and functions to the Python workers),
 and does not suffer the same issues.
 Usage is identical:

_episodes/11-snakemake-intro.md

@@ -14,7 +14,7 @@ keypoints:
 Let's imagine that we're interested in
 seeing the frequency of various words in various books.
 
-We've compiled our raw data i.e. the books we want to analyze
+We've compiled our raw data i.e. the books we want to analyse
 and have prepared several Python scripts that together make up our
 analysis pipeline.
 
@@ -37,7 +37,7 @@ we will be working with:
 {: .output}
 
 The first step is to count the frequency of each word in a book.
-The first argument (`books/isles.txt`) to wordcount.py is the file to analyze,
+The first argument (`books/isles.txt`) to wordcount.py is the file to analyse,
 and the last argument (`isles.dat`) specifies the output file to write.
 
 ```bash
@@ -85,7 +85,7 @@ to 1515 2.38057825267
 ```
 {: .output}
 
-Let's visualize the results.
+Let's visualise the results.
 The script `plotcount.py` reads in a data file and plots the 10 most
 frequently occurring words as a text-based bar plot:
 

_episodes/12-snakefiles.md

@@ -237,7 +237,7 @@ rule count_words_abyss:
     jobid: 0
 
 Finished job 0.
-1 of 1 steps (100%) done
+1 of 1 steps (100%) doneat
 ```
 {: .output}
 
@@ -475,6 +475,3 @@ The following figure shows the dependencies embodied within our
 Makefile, involved in building the `results.txt` target:
 
 ![results.txt dependencies represented within the Makefile](../fig/02-challenge-dag.svg "results.txt dependencies represented within the Makefile")
-
-<!--  LocalWords:  wordcount Snakefiles
- -->

_episodes/14-patterns.md

@@ -27,7 +27,7 @@ rule count_words:
 
 
 `{file}` is another arbitrary [wildcard]({{ page.root }}/reference/#wildcard),
-that we can use as a placeholder for any generic book to analyze.
+that we can use as a placeholder for any generic book to analyse.
 Note that we don't have to use `{file}` as the name of our wildcard - 
 it can be anything we want!
 

_episodes/15-snakemake-python.md

@@ -17,7 +17,7 @@ keypoints:
 Despite our efforts, our pipeline still has repeated content, 
 for instance the names of output files/dependencies.
 Our `zipf_test` rule, for instance, is extremely clunky.
-What happens if we want to analyze `books/sierra.txt` as well?
+What happens if we want to analyse `books/sierra.txt` as well?
 We'd have to update everything!
 
 ```python

_episodes/16-resources.md

@@ -239,7 +239,7 @@ is use a Python multiline string (begin and end with `'''`)
 One important addition we should be aware of is the `&&` operator.
 `&&` is a bash operator that runs commands as part of a chain. 
 If the first command fails, the remaining steps are not run.
-This is more forgiving than bash's default "hit an error and keep going" behaviour.
+This is more forgiving than bash's default "hit an error and keep going" behavior.
 After all, if the first command failed, it's unlikely the other steps will work.
 
 ```python
@@ -334,7 +334,7 @@ Snakemake will assume that the resources in question are unlimited.
 > Or maybe a type of rule uses a lot of network bandwidth as it downloads data.
 > In all of these cases, `resources` can be used to constrain access 
 > to arbitrary compute resources so that each rule can run at it's most efficient.
-> Snakemake will run your rules in such a way as to maximize throughput given your
+> Snakemake will run your rules in such a way as to maximise throughput given your
 > resource constraints.
 {: .callout}
 

_episodes/17-cluster.md

@@ -136,7 +136,7 @@ ssh -X yourUsername@graham.computecanada.ca
 > You can use this feature for this tutorial
 > (I've already added all of the files to version control for you),
 > but if you want to use this feature in your own work, 
-> you should familiarize yourself with a VCS tool like Git.
+> you should familiarise yourself with a VCS tool like Git.
 >
 > For more information on how to use this feature, see 
 > [http://snakemake.readthedocs.io/en/stable/snakefiles/deployment.html](http://snakemake.readthedocs.io/en/stable/snakefiles/deployment.html)