Professional Development League North/South stats & predictions

The outcomes of tomorrow's fixtures could significantly alter the league standings:

• Title Race Intensification**: Key victories could propel leading teams further ahead or close gaps between rivals vying for promotion spots.
• Promotion Playoff Qualifiers**: Teams currently on the cusp of playoff qualification will be looking for results that secure or jeopardize their positions.
• Relegation Battles**: Lower-ranked teams face critical matches that could determine their fate regarding relegation or survival in the league.
fluffykitten/fluffykitten.github.io<|file_sep|>/_posts/2019-07-03-git-commit-messages.md --- layout: post title: "Git Commit Messages" date: "2019-07-03" tags: - git --- A good commit message is useful not only when you're reviewing code, but also when you're trying to figure out what happened six months ago. So here are some things I've learned over time about writing commit messages. ## Summary A commit message should consist of: * A one-line summary. * A blank line. * A detailed explanation. The summary line should be no more than **50 characters** long. This makes it easier to read when scanning through logs, and makes sure you don't have too much text showing up when viewing diffs. The detailed explanation should start at least **72 characters** from the left margin. This helps keep it readable when wrapping lines at that width. The detailed explanation should include: * Why you made this change. * How it was implemented. * What alternatives you considered. It should not include: * Things that can be deduced from reading the code itself. * Information already covered by references. ## Grammar Commit messages should always use imperative mood. This means using verbs like *fix*, *add*, *change*, *remove*, etc. This convention comes from Git itself. When you create a commit using `git commit -m "message"`, the message is used as though you were saying: bash $ git commit -m "Fix bug" # => git commit --amend -m "Fix bug" In other words: *if applied, this commit will fix bug*. ## References If your change addresses an issue or pull request, include that information at the end of your message: text Fixes #123 Closes #456 These keywords let Git know that this commit addresses certain issues, and allows those issues be closed automatically when this commit is merged. If your change addresses multiple issues, you can reference them all: text Fixes #123 Closes #456 Also fixes #789 Note that you can use any keyword you want; `fixes` isn't special in any way. But using common keywords like `fixes` or `closes` lets people know what happened. If you use an uncommon keyword, you'll need to explain what it means later on. ## Examples ### Good text Fixes #123 Fixes problem where widget bar would not display properly when opened after clicking on notification icon. Widget bar would not update until after closing then re-opening it. This fix ensures it updates immediately upon opening without needing any extra steps. Previously tried changing bar width dynamically based on screen size, but this caused performance issues due excessive re-rendering. References: https://example.com/issues/123 https://example.com/issues/456 ### Bad text Fixing issue where widget bar wouldn't display properly after clicking notification icon. Previously tried changing bar width dynamically based on screen size, but this caused performance issues due excessive re-rendering. This fix ensures widget bar updates immediately upon opening without needing any extra steps. References: https://example.com/issues/123 https://example.com/issues/456 <|repo_name|>fluffykitten/fluffykitten.github.io<|file_sep|>/_posts/2019-01-22-coding-style.md --- layout: post title: "Coding Style" date: "2019-01-22" tags: - coding style --- I'm often asked about my coding style, so I figured I'd write down my thoughts here so I don't forget them later. I'm going to break these into three categories: 1. **Language specific**: syntax choices that depend on language features. 2. **Code layout**: whitespace choices like indentation levels or line length. 3. **Code quality**: things like commenting or naming conventions. ## Language specific I'll only cover JavaScript here because I don't know enough about other languages. And even then I'll only cover things I think are important enough. ### Arrow functions Arrow functions were added in ES6/ES2015, and allow us to write shorter function expressions: js // Function expression syntax (ES5) const add = function(a,b) { return a + b; }; // Arrow function syntax (ES6) const add = (a,b) => { return a + b; }; They also have an interesting quirk: js const numbers = [1,2]; const doubles = numbers.map(function(number) { return number * number; }); console.log(doubles); // [1,4] const doubles = numbers.map(number => { return number * number; }); console.log(doubles); // [1,2] const doubles = numbers.map(number => number * number); console.log(doubles); // [1,4] If there are no arguments or more than one argument, you need parentheses around them; otherwise you don't. And if there's only one statement, you don't need curly braces or `return`. But why do we need parentheses around arguments? Why does `number => number * number` evaluate differently than `number => { return number * number }`? Well because functions are objects too! We can call them directly like any other object: js function add(a,b) { return a + b; } add(1); // NaN (no second argument) add(1)(2); // NaN (second argument not passed) // If we turn it into an arrow function... const add = (a,b) => { return a + b; }; add(1); // NaN (no second argument) add(1)(2); // NaN (second argument not passed) // ...but if we don't use curly braces... const add = (a,b) => a + b; add(1); // NaN (no second argument) add(1)(2); // ...then it works! // ...because now we're returning an object instead of calling a function! It turns out arrow functions don't work quite like normal functions: they're called immediately instead of returning themselves like functions do! So if we want our arrow function expressions behave like regular ones, we need parentheses around our arguments so they get passed correctly! ### Classes ES6 also added classes, which allow us define more complex objects using class syntax: js class Point { constructor(x,y) { this.x = x; this.y = y; } get distance() { return Math.sqrt(this.x * this.x + this.y * this.y); } set distance(distance) { const ratio = distance / this.distance; this.x *= ratio; this.y *= ratio; } } const p = new Point(5,-5); console.log(p.distance); // ~7.0710678118654755 // Now let's set its distance... // We'll move its position twice as far from (0,0). // So if its position was at (-5,-5), // it should now be at (-10,-10). // // If we just set p.distance = p.distance * Math.sqrt(2), // then its position would stay relative to its old position, // so (-5,-5) would become (-10,-10), which is correct! // // But if we set p.distance = -Math.sqrt(50), // then its position would stay relative to its old position too! // // We want it relative to (0,0), // so we need some way of telling our Point object where our origin is... // // Luckily we can use getters/setters! // This will move p twice as far from its current position... // Which is correct because p starts out at (-5,-5)! // // But if p started out at (-10,-10), // then setting its distance again would move it twice as far again! // // This doesn't make sense because p started out twice as far away already! // // We want p always start out at distance zero from (0,0)! // // To do this we need another setter method... // class Point { constructor(x,y) { this.x = x; this.y = y; } get distance() { return Math.sqrt(this.x * this.x + this.y * this.y); } set distance(distance) { const ratio = distance / this.distance; this.x *= ratio; this.y *= ratio; } set origin(x,y) { const dx = x - this.x; const dy = y - this.y; this.x += dx; this.y += dy; } } const p = new Point(-10,-10); console.log(p.distance); // ~14.142135623730951 console.log('Setting origin...'); console.log('------------------'); const q = new Point(0,0); q.origin = p.x,p.y; console.log(q.distance); // ~14.142135623730951 console.log('Setting distance...'); console.log('--------------------'); q.distance *= Math.sqrt(2); console.log(q.distance); // ~20 console.log('Setting origin again...'); console.log('------------------------'); q.origin = q.x,q.y; console.log(q.distance); // ~20 Arrow functions work differently than normal functions, and classes work differently than objects created using `Object.create()`! I prefer arrow functions because they're shorter than regular functions, and classes because they're easier than working with prototypes directly. ## Code layout Code layout refers to things like indentation levels or line length limits. It doesn't matter how you indent your code as long as you're consistent! ### Indentation levels Indentation levels help us see how nested our code is without having too many braces cluttering everything up! Here's an example: js function greet(name) { if (!name) { throw new Error('No name given!'); } else if (!name.trim()) { throw new Error('Name cannot be empty!'); } else { console.log(`Hello ${name}!`); } } You can see how each block starts after its parent block finishes: the first `if` starts after its parent function ends, and its children start after it ends too! If we didn't indent our code correctly, it would look something like this: js function greet(name) { if (!name) { throw new Error('No name given!'); } else if (!name.trim()) { throw new Error('Name cannot be empty!'); } else { console.log(`Hello ${name}!`); } } This makes