Spelling fixes

Author: fildon

src/blog/2021-07-03-mocking-in-jest-with-typescript-and-react/index.md

@@ -324,7 +324,7 @@ import { ThirdPartyWidget } from "third-party-library";
 
 jest.mock("third-party-library");
 
-describe("User copmonent", () => {
+describe("User component", () => {
   const mockThirdPartyWidget = ThirdPartyWidget as jest.MockedFunction<
     typeof ThirdPartyWidget
   >;

src/blog/2021-10-09-eslint-vs-prettier/index.md

@@ -21,7 +21,7 @@ But automated tools do still provide value.
 
 ## The Good News
 
-Rice's Theorem makes a distinction between _syntatic_ and _semantic_ properties of programs. Roughly speaking _syntactic_ is "how it is written", whereas _semantic_ is "how it behaves".
+Rice's Theorem makes a distinction between _syntactic_ and _semantic_ properties of programs. Roughly speaking _syntactic_ is "how it is written", whereas _semantic_ is "how it behaves".
 
 Most syntactic problems can be trivially identified and fixed. The most well-known of these are things like indentation and linebreaks. These things do not affect the _behavior_ of the program, but do create a consistent _syntactic_ standard for programmers.
 

src/blog/2021-12-04-react-testing-library-recipes/index.md

@@ -194,7 +194,7 @@ In this test suite, we simulate two different cases, one in which the API reject
 
 - `getBy*` verifies that something is rendered.
 - `queryBy*` can be used to verify that something is _not_ rendered.
-- `findyBy*` verifies that something is _eventually_ rendered.
+- `findBy*` verifies that something is _eventually_ rendered.
 - Prefer `*ByRole` wherever possible to encourage the use of semantic HTML and better accessibility.
 - Use the companion library [testing-library/user-event](https://github.com/testing-library/user-event) to simulate realistic user actions.
 

src/blog/2022-01-03-what-is-a-number/index.md

@@ -146,7 +146,7 @@ To demonstrate this, consider the following numbers:
 - Mantissa: 1.11
 - Exponent: -11
 
-This format has the advantage of being very flexible in accomodating both very large and very small numbers. It is called `Floating Point` because the _point_ in the number can _float_ up or down to wherever the first leading bit will be, e.g. in the last example we _float_ the point down by three places by using a -3 exponent. Now let's consider what happens when we try to evaluate the expression:
+This format has the advantage of being very flexible in accommodating both very large and very small numbers. It is called `Floating Point` because the _point_ in the number can _float_ up or down to wherever the first leading bit will be, e.g. in the last example we _float_ the point down by three places by using a -3 exponent. Now let's consider what happens when we try to evaluate the expression:
 
 `0.1 * 0.2`
 

src/blog/2022-08-13-simulating-dice/index.md

@@ -110,36 +110,36 @@ See below for an implementation of this process in TypeScript.
 const d = (n: number) => Math.floor(n * Math.random()) + 1;
 
 const produceOneResult = (n: number, repeatCount: number) => {
-  const rollResults = new Array(repeatCount).fill(0).map(() => d(n));
+	const rollResults = new Array(repeatCount).fill(0).map(() => d(n));
 
-  // This reads the results as a single number in base `n`
-  const result = rollResults
-    .map((roll, i) => (roll - 1) * n ** (repeatCount - i - 1))
-    .reduce((a, b) => a + b, 0);
+	// This reads the results as a single number in base `n`
+	const result = rollResults
+		.map((roll, i) => (roll - 1) * n ** (repeatCount - i - 1))
+		.reduce((a, b) => a + b, 0);
 
-  return result;
+	return result;
 };
 
 /**
  * Given a `dn`, simulate the outcomes of a `dm`
  */
 const simulateMwithN = (m: number, n: number) => {
-  /**
-   * `repeatCount` is the number of times we will need to roll the smaller die.
-   */
-  const repeatCount = Math.ceil(Math.log(m) / Math.log(n));
-  /**
-   * The maximum valid result is the largest multiple of n that is
-   * less than or equal to the size of our target space
-   */
-  const maxValidResult = Math.floor(n ** repeatCount / m) * m - 1;
-
-  let result: number;
-  do {
-    result = produceOneResult(n, repeatCount);
-  } while (result > maxValidResult);
-
-  return (result % m) + 1;
+	/**
+	 * `repeatCount` is the number of times we will need to roll the smaller die.
+	 */
+	const repeatCount = Math.ceil(Math.log(m) / Math.log(n));
+	/**
+	 * The maximum valid result is the largest multiple of n that is
+	 * less than or equal to the size of our target space
+	 */
+	const maxValidResult = Math.floor(n ** repeatCount / m) * m - 1;
+
+	let result: number;
+	do {
+		result = produceOneResult(n, repeatCount);
+	} while (result > maxValidResult);
+
+	return (result % m) + 1;
 };
 
 simulateMwithN(6, 4);
@@ -192,72 +192,72 @@ const d = (n: number) => Math.floor(n * Math.random()) + 1;
  * Then given some `n` on the unit interval, output which segment of `m` it belongs to.
  */
 const fromUnitNtoSegmentsM = (m: number) => (n: number) => {
-  if (n === 0) return 1;
-  return Math.ceil(n * m);
+	if (n === 0) return 1;
+	return Math.ceil(n * m);
 };
 
 /**
  * Given a die, map a single result to the unit interval
  */
 const fromDNtoInterval = (n: number) => {
-  const dieResult = d(n);
+	const dieResult = d(n);
 
-  const lowerBound = (dieResult - 1) * (1 / n);
-  const upperBound = lowerBound + 1 / n;
+	const lowerBound = (dieResult - 1) * (1 / n);
+	const upperBound = lowerBound + 1 / n;
 
-  return [lowerBound, upperBound];
+	return [lowerBound, upperBound];
 };
 
 /**
  * Given an interval and a die size,
  * narrow the interval using a single role of the die
  */
 const narrowIntervalWithDN =
-  (n: number) =>
-  (interval: Interval): Interval => {
-    // This generates a new unit interval
-    const [innerLower, innerUpper] = fromDNtoInterval(n);
+	(n: number) =>
+	(interval: Interval): Interval => {
+		// This generates a new unit interval
+		const [innerLower, innerUpper] = fromDNtoInterval(n);
 
-    // But we need to map it into our existing interval
-    const currentIntervalSize = interval[1] - interval[0];
-    const newLowerBound = interval[0] + innerLower * currentIntervalSize;
-    const newUpperBound = interval[0] + innerUpper * currentIntervalSize;
+		// But we need to map it into our existing interval
+		const currentIntervalSize = interval[1] - interval[0];
+		const newLowerBound = interval[0] + innerLower * currentIntervalSize;
+		const newUpperBound = interval[0] + innerUpper * currentIntervalSize;
 
-    return [newLowerBound, newUpperBound];
-  };
+		return [newLowerBound, newUpperBound];
+	};
 
 /**
  * Given a `dn`, simulate the outcomes of a `dm`
  */
 const simulateMwithN = (m: number, n: number) => {
-  // We'll use a tuple to track a range on the unit interval
-  let interval: Interval = [0, 1];
+	// We'll use a tuple to track a range on the unit interval
+	let interval: Interval = [0, 1];
 
-  const mapToDM = fromUnitNtoSegmentsM(m);
-  const mapFromDN = narrowIntervalWithDN(n);
+	const mapToDM = fromUnitNtoSegmentsM(m);
+	const mapFromDN = narrowIntervalWithDN(n);
 
-  // In this loop we repeatedly narrow our output interval
-  // Until its lower and upper bounds fit within the same segment of `dm`
-  while (mapToDM(interval[0]) !== mapToDM(interval[1])) {
-    interval = mapFromDN(interval);
-  }
+	// In this loop we repeatedly narrow our output interval
+	// Until its lower and upper bounds fit within the same segment of `dm`
+	while (mapToDM(interval[0]) !== mapToDM(interval[1])) {
+		interval = mapFromDN(interval);
+	}
 
-  return mapToDM(interval[0]);
+	return mapToDM(interval[0]);
 };
 
 /**
  * A test of the distribution of a simulated dice
  *
  * Outputs a record where each key is a die result,
- * and each value is how often that result occured
+ * and each value is how often that result occurred
  */
 const test = new Array(10000)
-  .fill(0)
-  .map(() => simulateMwithN(6, 4))
-  .reduce<Record<number, number>>(
-    (acc, curr) => ({ ...acc, [curr]: (acc[curr] ?? 0) + 1 }),
-    {}
-  );
+	.fill(0)
+	.map(() => simulateMwithN(6, 4))
+	.reduce<Record<number, number>>(
+		(acc, curr) => ({ ...acc, [curr]: (acc[curr] ?? 0) + 1 }),
+		{},
+	);
 
 /**
  * If the test is successful, each value should be roughly equal

src/blog/2022-11-21-langtons-ant-and-unanswerable-questions/index.md

@@ -37,7 +37,7 @@ We might have guessed that this chaos would proceed forever. But then at around
 
 The Ant has begun to build a structure known as the highway. The highway is an infinitely repeating pattern. It takes the ant 104 steps for each iteration of the highway, and each iteration extends the pattern along a diagonal trajectory.
 
-But we can change things. Instead of starting with a blank grid, we could set some cells to black at the begginning. If we then run the Ant it will generate different patterns. When people try this, they find that the highway _always seems to emerge sooner or later_. It is widely believed that the highway is inevitable, and yet this conjecture has never been proven nor disproven, despite many years of effort.
+But we can change things. Instead of starting with a blank grid, we could set some cells to black at the beginning. If we then run the Ant it will generate different patterns. When people try this, they find that the highway _always seems to emerge sooner or later_. It is widely believed that the highway is inevitable, and yet this conjecture has never been proven nor disproven, despite many years of effort.
 
 Such a simple system to define, and yet we are unable to answer the question "Does the highway always appear, no matter the starting state?"
 

src/blog/2023-09-23-the-skull/index.md

@@ -21,6 +21,6 @@ So there it was. A skull.
 
 No one else wanted it. They ummed and ahhed. It couldn't possibly be thrown away, but no one had the stomach to keep it. I had been respectfully silent all day. I'm not a blood relative after all, and was only there as a spare pair of hands. But finally I suggested that I could take it. To my surprise no one disagreed.
 
-Since then the skull has stayed with me. First I had I took it in hand luggage to England, and then it travelled with me again when I moved to the Netherlands permanantly. On both occasions I did not declare it and security never seemed to notice it.
+Since then the skull has stayed with me. First I had I took it in hand luggage to England, and then it travelled with me again when I moved to the Netherlands permanently. On both occasions I did not declare it and security never seemed to notice it.
 
 The skull still sits on my shelf. Some nights before I go to bed, I'll rest my hand on the crown. I'm not sure what I intend by this. But I have this almost desperate sense of wanting to understand what it means for this artefact to represent the remains of a human story. I know nothing about this story. I do not know the skull's age, gender or origin. But as I rest my hand on the crown, I will sometimes rest my other hand on my own head. In that moment I try to capture the feeling that I'm just a big bag of bones. That my two hands contain only superficially different contents. Somehow this calms me. I sleep easier when I can clear my mind of the day to day.

src/blog/2024-03-24-death/index.md

@@ -70,7 +70,7 @@ The call was put out to all friends and family, _this is it, come say your goodb
 > Spoke to mum in private on one occasion (you cant speak with, only to) and cried alot. Becky came back down late in the day and Dad came.
 > I’ve been at the hospital since 10 and up til now. (12 hours) Toni and Simon are staying the night with mum.
 
-I remember speaking to her that day. I was left alone in the room with her. I told her about school, and my saxophone lessons. I tried to keep talking, because I was afraid of what would happen when I ran out of things to say. But I didn't know what to say. I couldn't bare my own silence. But I couldn't bare to leave the room either. I needed someone to come in and relieve me from having to confront this reality. Eventually, with great guilt I left the room, just briefly to tell the others in the waiting room, that someone else should go be with her now. Immediately afterwards I stepped to one side in the corridoor, and weeped facing the wall. I couldn't see through my own hands and tears. But an anonymous nurse slipped in to hug me. I never saw their face. In that moment they were literally just a shoulder that I cried into. I owe them so much for that moment in which I was able to sob. Neither of us said a word during. I hope I at least mumbled a "thank you" afterwards, but I don't remember.
+I remember speaking to her that day. I was left alone in the room with her. I told her about school, and my saxophone lessons. I tried to keep talking, because I was afraid of what would happen when I ran out of things to say. But I didn't know what to say. I couldn't bare my own silence. But I couldn't bare to leave the room either. I needed someone to come in and relieve me from having to confront this reality. Eventually, with great guilt I left the room, just briefly to tell the others in the waiting room, that someone else should go be with her now. Immediately afterwards I stepped to one side in the corridor, and wept facing the wall. I couldn't see through my own hands and tears. But an anonymous nurse slipped in to hug me. I never saw their face. In that moment they were literally just a shoulder that I cried into. I owe them so much for that moment in which I was able to sob. Neither of us said a word during. I hope I at least mumbled a "thank you" afterwards, but I don't remember.
 
 > 9th of November 2005 Wednesday 03:03
 >

src/landingpage/index.njk

@@ -20,7 +20,7 @@ description: Explore interactive coding projects including Boids artificial life
 		<p>
 			An implementation of an artificial life program, first developed in the
 			1980s. In brief, just three simple rules lead to intelligent flocking
-			behaviour. Implemented all my own tooling from the groundup, including
+			behaviour. Implemented all my own tooling from the ground up, including
 			vector algebra and dynamic frame loop adjustments.
 		</p>
 	</article>