James Sinclair

@jrsinclair.bsky.social

41 Followers 23 Following

I type for a living. Sometimes code, sometimes not.

Screenshot of some JavaScript code. The code is as follows:

const dropWhile = (pred, arr) => {
const idx = arr.findIndex(x => !pred(x));
return arr.slice(idx);
}

console.log(dropWhile(isVowel, ['a', 'e', 'i', 'o', 'u', 'b']));
// 🪵 ['b']

Screenshot of JavaScript code. The code is as follows:

const isVowel = (c) => ['a', 'e', 'i', 'o', 'u'].includes(c);

const takeWhile = (pred, arr) => {
const idx = arr.findIndex(x => !pred(x));
return arr.slice(0, idx);
}

console.log(takeWhile(isVowel, ['a', 'e', 'i', 'o', 'u', 'b']));
// 🪵 ['a', 'e', 'i', 'o', 'u']

A quote by John Ousterhout, from the book 'A Philosophy of Software Design'.

“Most modules have more users than developers, so it is better for the developers to suffer than the users. As a module developer, you should strive to make life as easy as possible for the users of your module, even if that means extra work for you. Another way of expressing this idea is that it is more important for a module to have a simple interface than a simple implementation.”

// With our Map-based approach, we essentially reimplemented
// the Set data structure. We might as well use the Set
// constructor directly.
const uniq = (xs) => [...new Set(...xs)];
const fruits = ['apple', 'banana', 'apple', 'orange', 'banana'];
console.log(uniq(fruits)); // 🪵 ['apple', 'banana', 'orange']

// To avoid traversing the array more than we need to,
// we can use a Map to keep track of the elements we've
// seen so far. This way we only traverse the array once.
const uniq = (xs) => Array.of(
(xs.reduce((m, x) => m.set(x, true), new Map())).keys()
);
const fruits = ['apple', 'banana', 'apple', 'orange', 'banana'];
console.log(uniq(fruits)); // 🪵 ['apple', 'banana', 'orange']

// A more efficient approach is to use .indexOf() to
// check if the current element is the first occurrence
// of that element in the array.
const uniq = (xs) => xs.filter(
(x, i) => xs.indexOf(x) === i
);
const fruits = ['apple', 'banana', 'apple', 'orange', 'banana'];
console.log(uniq(fruits)); // 🪵 ['apple', 'banana', 'orange']

// Naïve solution. This is inefficient because it
// traverses the array multiple times, and creates
// lots of new intermediate arrays. It works, though.
const uniq = (xs) => xs.filter(
(x, i) => !xs.slice(i + 1).includes(x)
);
const fruits = ['apple', 'banana', 'apple', 'orange', 'banana'];
console.log(uniq(fruits)); // 🪵 ['apple', 'banana', 'orange']

$Screenshot of a code snippet showing the use of an array tuple as a Maybe construct. Code reads as follows: // Suppose we want to retreive the weather conditions // for a given location. Perhaps we've retreived some // data from a weather API and we need to process it. const sensors = { ['Dartmoor']: { value: 10, unit: 'C' }, ['Baker Street']: { value: 18, unit: 'C' }, ['Scotland Yard']: { value: 68, unit: 'F' }, } const conditions = { ['Dartmoor']: 'Foggy', ['Baker Street']: 'Sunny', ['Scotland Yard']: 'Rainy', } const toCelsius = (fahrenheit) => (fahrenheit - 32) * (5 / 9); // Here we define a function that wraps our value in an // array if it's not nullish. We can then use .map(), // .flatMap(), .reduce() etc. to safely handle the // nullish case. const maybe = (value) => value == null ? [] : [value]; const getWeather = (location) => maybe(sensors[location]) .map(({unit, value}) => unit === 'F' ? toCelsius(value) : value) .flatMap( (temperature) => maybe(conditions[location]) .map((condition) => ({temperature, condition})) ) .map(({temperature, condition}) => `${location}: ${temperature}°C, ${condition}`) .reduce((_, x) => x, 'Weather conditions not available'); console.log(getWeather('Dartmoor')); // 🪵 'Dartmoor: 10°C, Foggy' console.log(getWeather('Scotland Yard')); // 🪵 'Scotland Yard: 20°C, Rainy' console.log(getWeather('Diogenes Club')); // 🪵 'Weather conditions not available'$

Screenshot of some JavaScript code showing two variables being swapped using array destructuring. The code reads as follows:

let a = 'left';
let b = 'right';

console.log([a, b]);
// 🪵 ["left", "right"]

// Swap two variables with array destructuring.
[b, a] = [a, b]
console.log([a, b]);
// 🪵 ["right", "left"]

$Screenshot of JavaScript code illustrating use of the nullish coalescing operator. The code reads as follows: function doSomething(configParam) { const config = configParam || DEFAULT_VAL; // ❌ // Rest of code } // The code above breaks if config param is a primitive // type (not an object). For example: '' || 'Unexpected' // ➡︎ 'Unexpected' 0 || 'Unexpected' // ➡︎ 'Unexpected' false || 'Unexpected' // ➡︎ 'Unexpected' // Instead, use the ?? operator function doSomething(configParam) { const config = configParam ?? DEFAULT_VAL; // ✅ // Rest of code }$