Bits On Bits

A humble place for humble observations about technology

[bitsonbits]

In Rails, you can delegate to objects that are defined inside methods using delegate.

This even works with memoization using ||=. Meaning that you can delegate to an object that is never actually instatiated except in the call to the delegate method:

class Cat def cat_name "Cat" end end class Dog delegate :cat_name, to: :cat def cat @cat ||= Cat.new end def cat_friend "My cat friend's name is #{cat_name}" end end dog = Dog.new dog.cat_friend # => "My cat friend's name is Cat"

[bitsonbits]

Chrome DevTools is just the best.

Selecting an element on the Elements screen and then typing $0 in the console will return the element that you have selected.

[bitsonbits]

New Sublime Packages:

Emmet

Scope Hunter

[bitsonbits]

Knowing that I will need to import React in every component file motivated me to create a snippet to do this.

Now when typing react plus Tab, the line import React from "react"; is inserted.

Putting an actual blank line inside the snippet definitions translates to the file you are inserting the snippet into, as well. This allows me to get a newline after the the import declaration!

[bitsonbits]

I want to get better about using shortcuts, snippets, and the like in my text editor.

Idea: I wanted to be able to unquote a selection, i.e., remove the quotation marks from around it.

Turns out there is already a package that does this.

It uses a Python script and binds the command to Cmd-'. Works for both double- and single-quoted strings!

[bitsonbits]

I don't know why Rails still loads JS in the head by default.

Every time I fire up a new app, my first event handler doesn't work, and it takes me way too long to figure out that the JS is loading before there are any elements to bind to.

Eventually I realize the problem, move the JS to the end of the body, and everything is fine.

[bitsonbits]

The easiest way to reload the console is simply to type reload!. But be aware that any existing instances of Active Record objects that you’re holding on to will also need to be reloaded (using their individual reload methods). Sometimes it’s simpler to just exit the console and start it up again.

-- The Rails Way

So that explains why reload! hasn't been "working" for me. I didn't remember that existing instances of Active Record objects need to be individually reloaded as well.

It is simpler to restart the console.

[bitsonbits]

The splat operator (*) acts like #flatten inside of an array:

[*[1, 2], *[3, 4], *[5, *[6, 7]]] # => [1, 2, 3, 4, 5, 6, 7]

But it only flattens one level, of course:

[*[1, 2], *[3, 4], *[5, [6, 7]]] # => [1, 2, 3, 4, 5, [6, 7]]

[bitsonbits]

Including a module in a class and extending an instance of that class with the module have the same effect.

module Greeter def hello puts "Hello." end end class Person include Greeter end class Vole end Person.new.hello # => "Hello." Vole.new.hello # => NoMethodError: undefined method `hello' for #<0x007fb0040bd978>0x007fb0040bd978> Vole.new.extend(Greeter).hello # => "Hello."

[bitsonbits]

In JavaScript, callback functions are always evaluated in their own context, unless you specifically bind one to them.

class Foo { constructor() N2.bindHandler('click', '.bar', function(e) { this.baz(); //buzzer noise }); } baz() { //... } }

That doesn't work, as you can see, because the this context inside that jQuery callback function is the element that was clicked.

To bind a specific context, there are two options. The old way is an explicit bind.

function(x) { this.baz() }.bind(this)

But in ES6, you can use an arrow function to automatically bind the current this to the function.

(x) => { this.baz() }

Here's how to make the original code work using an arrow function.

class Foo { constructor() N2.bindHandler('click', '.bar', (e) => { this.baz(); //success noise }); } baz() { //... } }

[bitsonbits]

Today in fun JavaScript tricks:

> ['10', '10', '10'].map(parseInt) [ 10, NaN, 2 ]

This happens because #map is actually wants to pass in three arguments to the callback. In addition to the current element being processed in the array, it also tries to pass in the index of the current element and the array itself.

#parseInt actually takes two arguments. The second argument is the radix, or the base on which to calculate the integer.

So what really happens when #map processes the first element is:

> parseInt('10', 0) 10

And the second element:

> parseInt('10', 1) NaN

It doesn't know how to process a base of 1.

Finally, the third element:

> parseInt('10', 2) 2

'10' base two (otherwise known as binary) is 2.

[bitsonbits]

Changing the default save location for screenshots on macOS (and relaunching the UI):

defaults write com.apple.screencapture location /path/;killall SystemUIServer

Source

[bitsonbits]

Drew: Reveal intentions in the view instead of in business logic.

[bitsonbits]

To permanently add an SSH key to the macOS keychain, instead of needing to add it to the SSH agent on every reboot:

ssh-add -K /path/to/key

Source

[bitsonbits]

I think I encountered Enumerable#group_by in real code for the first time.

It's easiest to think about this, at first, in terms of an Array.

The method is a way to group the elements of the array by some condition of the elements' properties. It groups them into a hash, such that the "groups" are represented as the keys of the hash, and the groups of elements that correspond to each group are represented as that key's value. (So, the values are often (always?) Arrays).

In simpler terms. #group_by takes an Array, which is just one big container of stuff (or: a collection). It wants to sort that Array into many smaller containers (or collections), based on a given condition (which it takes as a block).

Every time #group_by iterates through the block you give it, it does two things: it evaluates the result of the block and assigns that result to a key; and it takes the element of the Array that got yielded to the block and puts it in a new Array.

This new Array is a value of the hash that #group_by is constructing. The key for this value is the result of the block when it was evaluated with the element that is getting put in the new Array.

The block evaluates to different results depending on the elements it receives. This is how #group_by divvies up the original collection into a set of smaller collections.

Several elements in the collection may evaluate to the same result when passed to the block. In that case, they will all be part of the same hash value, the value whose key is that result.

If all of the elements in the collection wind up in the same hash value, then you haven't split the collection up at all.

The example in the Ruby docs shows how to split up a collection of Integers based on their remainders when divided by 3:

(1..6).group_by { |i| i%3 } #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}

(This is a range, here, but the equivalent to that is the Array [1, 2, 3, 4, 5, 6].)

The original collection is the set of continuous Integers from 1 to 6. The condition to split the collection on, represented by the block, is i % 3.

So in the terms stated above, the "condition of the elements' properties," the property in question is "divisibility", and the condition is "divisibility by 3." We want a hash with groups of elements separated by their divisibility by 3.

Thus, the results of the block when passed the elements in the collection are the set of the possible remainders when an Integer is divided by 3: [0, 1, 2] (which you can get by calling #keys on the computed hash).

The values associated with these hash keys are the sets of elements from the original collection. Each key has an Array as its value, the Array of original elements that, when passed to the block, evaluate to that key. For example, i % 3 results in 0 for the elements 3 and 6, so the key 0 points to [3, 6].

If there is a duplicate value in the original Array, there will also be a duplicate value in the hash value of the key that corresponds to the duplicate value. So if you don't want those duplicates to propagate into your hash, you should call #uniq prior to calling #group_by (probably in the same chain, i.e., array.uniq.group_by).

And that's how to understand Enumerable#group_by when the Enumerable is an Array.

[bitsonbits]

JavaScript has an onpaste event. Saw it used on an <input> element, and the handler was just a trigger for the onchange event.

Interesting that a "paste" is not considered a "change"! I'll want to investigate that.

[bitsonbits]

git rebase --onto is a nice tool for replaying the commits made to a feature branch on top of a parent branch which has diverged.

This parent branch could be master, and it diverged because someone else pushed some commits to the remote repo that I'd like to incorporate into my feature.

Or in my case yesterday, the parent branch was a feature I had worked on before, that my new feature depends on. The earlier feature went through code review, and I made some new commits on it.

The command takes two arguments, the newbase and the oldbase. (It also has a three-argument form.) These are both commit references. Usually the newbase would just be the tip of the upstream branch. (Although I think in these cases, you don't necessarily need the --onto tool.)

But in some cases you want to discard later commits from that branch, and then you can just specify the SHA of the commit you want to rebase onto, as the newbase.

And oldbase also gives you the option of discarding commits. The whole idea is that you don't just have to replay all the commits from the downstream branch, after the point where they diverged, onto all the commits from the upstream branch. You have options now!

Here's a nice explainer.