JavaScript reaches another level of Ouroboros.

Coates does an excellent job decrying what passes for leftist “radicalism” when it comes to race.

One does not find anything as damaging as the carceral state in the Sanders platform, but the dissonance between name and action is the same. Sanders’s basic approach is to ameliorate the effects of racism through broad, mostly class-based policies—doubling the minimum wage, offering single-payer health-care, delivering free higher education. This is the same “A rising tide lifts all boats” thinking that has dominated Democratic anti-racist policy for a generation. Sanders proposes to intensify this approach. But Sanders’s actual approach is really no different than President Obama’s. I have repeatedly stated my problem with the “rising tide” philosophy when embraced by Obama and liberals in general. (See here, here, here, and here.) Again, briefly, treating a racist injury solely with class-based remedies is like treating a gun-shot wound solely with bandages. The bandages help, but they will not suffice.

There is an apparent juxtaposition here, between the rights to believe and say whatever you want, and the rights of the audience to be protected from acts that interfere with their security, which may result in mistreatment, etc.

I say “apparent,” because there is no conflict here. The Universal Declaration of Human Rights is a singular declaration, not a combination of individual articles. The right to expression is there as long as that expression does not interfere with any of the other rights granted the audience. Freedom of Speech is not the primary right; it is part of a larger whole that in totality provides us all with freedom.

literally me 2 hours ago

Yet they keep calling me for money.

If you work in WordPress, you may have run into difficulties displaying errors that may occur on the save_post hook. Since WordPress redirects before loading the post edit page, you don’t have access to anything done on that hook hook when the post edit page loads. I detail 3 possible solutions to in this article for Sitepoint.

Fat Arrow Functions, One-Line Callbacks, and Composing Promises

I’m not really a fan of fat arrow functions in ES2015 for the same reason I don’t like the introduction of class: JavaScript is a prototypal language, so attempting to cram class-based inheritance is squeezing a round peg into a square hole. The prototype chain and closure scoping make for a number of interesting patterns for solving problems and structuring your code, and I’d rather see more exploration about what power that gives us . Eric Elliott has written a number of really interesting articles about object composition that have been really thought provoking.

Fat arrow functions are primarily used to bind a function’s this to its lexical scope. That’s not all it does; they also bind their arguments and super as well. There’s a great explanation about how they fully work, but their common purpose is to bind this to the scope of the arrow function. That’s not what we need; we need to use scoping more effectively so binding this isn’t necessary and play into the strengths of the language.

I am, however, a huge fan of Promises, and I’ve been working on a project recently that makes heavy use of them, and not only do they make handling asynchronous code a breeze, it’s much easier to build concurrency into the application as well. With the Bluebird library, composing Promise chains and setting up dependencies for a set of asynchronous actions is fun. It is during the composition of these chains that fat arrow functions make for some really elegant syntax.

When you’re composing together a chain of Promises to retrieve a particular value, you’ll often find yourself doing these one-off transformations:

doSomething().then(function(value) {
    return value.prop
});

This is a really simple example, but something that comes up all the time when composing Promise chains: You need to take the value from a previous function and do some small manipulation to it to get the value you’re looking for.

With fat-arrow functions, the above 3 lines become a single line:

doSomething().then(value => value.prop);

Fat arrow functions, when written as a one-liner, automatically returns the value, so any function that works as simply as this does are vastly improved by writing them this way. This comes up all the time, especially when using libraries that depend on Promise chains. You’ll often find yourself calling asynchronous methods on asynchronously returned objects, so chaining together a set of Promise methods become really clean:

doSomething().then(value => value.asyncMethod())
    .then(asyncMethodValue => asyncMethodValue.prop);

If you have 3 or 4 of these steps, you can see how writing these becomes an absolute joy.

The other thing writing fat arrow functions do is, when written on one line like this, they always return a value. One of the most annoying bugs to solve is a Promise chain is falling down because you forgot to return a value or a Promise somewhere. Because one-line fat arrow function always return a value, they protect you from making this mistake and save you from a lot of time debugging stupid problems.

Most of my callbacks are being written in this pattern, and it’s been really lovely. Fat arrow functions look a little weird compared to what we’re used to, but they have some nice use cases.

By any consistent ethical standard, a black person’s right to walk down the street unmolested trumps homeowners’ right to use the police for real estate segregation. Yet the cop callers are more concerned about the overpolicing of their language than the overpolicing of their streets.