getify

What Hiring Should Look Like

This is definitely not the first time I've written about this topic, but I haven't written formally about it in quite awhile. So I want to revisit why I think technical-position interviewing is so poorly designed, and lay out what I think would be a better process.

I'm just one guy, with a bunch of strong opinions and a bunch of flaws. So take these suggestions with a grain of salt. I'm sure there's a lot of talented, passionate folks with other thoughts, and some are probably a lot more interesting and useful than my own.

But at the same time, I hope you'll set aside the assumptions and status quo of how interviewing is always done. Just because you were hired a certain way, and even if you liked it, doesn't mean that it's a good interview process to repeat.

If you're happy with the way technical interviewing currently works at your company, fine. Just stop, don't read any further. I'm not going to spend any effort trying to convince you otherwise.

getify

// note: this requires a JS library for the IO monad, for example Monio: https://github.com/getify/monio/blob/master/MONIO.md#io-monad-one-monad-to-rule-them-all

const getFavoriteMovies = userID => IO(function*(){
  const movieIDs = yield fetch(`/movies/${userID}`);
  const movieData = yield Promise.all(
    movieIDs.map(movieID => fetch(`/movie/${movieID}`))
  );
  const itemsHTML = movieData.map(v => v.title)
    .reduce(
      (html, title) => `${html}<li>${title}</li>`,

getify

// Adapted from: https://www.geeksforgeeks.org/find-length-largest-region-boolean-matrix/

"use strict";

var M1 = [
	[ 0, 0, 1, 1, 0 ],
	[ 1, 0, 1, 1, 0 ],
	[ 0, 1, 0, 0, 0 ],
	[ 0, 0, 0, 1, 1 ]
];

getify

function Foo(who) {
	this.me = who;
}

Foo.prototype.identify = function() {
	return "I am " + this.me;
};

function Bar(who) {
	Foo.call(this,"Bar:" + who);

getify

Comparing: array method chaining, generator delegations, and transducing

I'm writing this quick post to respond to a recent twitter conversation where claims were made about the merits (or lack thereof) of transducers, as they relate to composing list comprehensions (map, filter).

For comparison sake throughout the rest of my post, below you'll find three (actually four!) implementations of a simple list operation demo:

• Array Method Chaining (jump to analysis)
  • Alternate: Array Method Composition (jump to analysis)
• Generator/Iterator Delegations (jump to analysis)
• Transducing (jump to analysis)

getify

An Open Letter To Assholes Who Hire People

About a month ago I tweeted out some frustrations about an interview process I had gone through.

Recently interviewed with a major (global) tech company. They absolutely knew me and my background. Still tried to have me run thru multiple rounds of tech interviews.

..thread..

getify

class Foo {
   constructor(x) { this.foo = x; }
   hello() { console.log(this.foo); }
}

class Bar extends Foo {
  constructor(x) { super(x); this.bar = x * 100; }
  world() { console.log(this.bar); }
}

getify

// ..

const nextTodoID = State(state => {
	var todoCounter = (state.todoCounter ?? 0) + 1;
	return {
		value: todoCounter,
		state: {
			...state,
			todoCounter
		}

getify

let {
	name: USER_NAME,
	displayName: USER_DISPLAY_NAME,
	id: USER_ID,
	regChallenge: USER_REG_CHALLENGE
} = await (
	fetch("/api/register-passkey",{
		// ..
	})
	.then(resp => resp.json())

getify

In defense of blocks for local scopes (Part 1)

---

[EDIT: I've added a part 2 to this blog post, to address some of the feedback that has come up: https://gist.github.com/getify/706e5e10822a298375da40f9cc1fa295]

---

Recently, this article on "The JavaScript Block Statement" came out, and it received some good discussion in a reddit thread. But the general reaction seems to be against this approach. That saddens me.