What does the double exclamation marks (!!) means in Javascript?
As we all know, JavaScript is not a static language, but a dynamic language. That means a variable can reference or hold a value of any type and the type can be changed at any point. To better understand the double exclamation marks purpose let's consider you want to convert to a boolean the presence of a value:
const user = 'Doru';
console.log(typeof user); // => string
But we want a boolean, therefore a true/false only. Not truthy, but true. Not falsey, but false! We can sort that with a function:
function isUserPresent(user) {
  if(user) {
    return true;
  return false;

isUserPresent('Doru'); // => true
isUserPresent(''); // => false
isUserPresent(0); // => false
Neat! But that is way too bulky. Let's use the !! magic:
const user = 'Doru';
console.log(!!user); // => true

const anotherUser = null;
console.log(!!anotherUser); // => false
Simple, concise, and effective.
React routing on Github Pages
Deploying Single Page Apps on Github Pages is fine if your app never navigates away from you index.html
However, if you have a more complex app and have /about or /user/21, Gihub Pages will fail. Here's the fix I usually use, that I found in a github repo some time ago:
There are two steps:

In the <head> section of your index.html, just before </head> closing tag, which usually resides in you /public folder add the following:
<!-- Start Single Page Apps for GitHub Pages -->
  <script type="text/javascript">
    // Single Page Apps for GitHub Pages
    // https://github.com/rafrex/spa-github-pages
    // Copyright (c) 2016 Rafael Pedicini, licensed under the MIT License
    // ----------------------------------------------------------------------
    // This script checks to see if a redirect is present in the query string
    // and converts it back into the correct url and adds it to the
    // browser's history using window.history.replaceState(...),
    // which won't cause the browser to attempt to load the new url.
    // When the single page app is loaded further down in this file,
    // the correct url will be waiting in the browser's history for
    // the single page app to route accordingly.
    (function(l) {
      if (l.search) {
        var q = {};
        l.search.slice(1).split('&').forEach(function(v) {
          var a = v.split('=');
          q[a[0]] = a.slice(1).join('=').replace(/~and~/g, '&');
        if (q.p !== undefined) {
          window.history.replaceState(null, null,
            l.pathname.slice(0, -1) + (q.p || '') +
            (q.q ? ('?' + q.q) : '') +
<!-- End Single Page Apps for GitHub Pages -->
In the same /public folder create a 404.html file and add the following content to it:
<!DOCTYPE html>
    <meta charset="utf-8">
    <title>Single Page Apps for GitHub Pages</title>
    <script type="text/javascript">
      // Single Page Apps for GitHub Pages
      // https://github.com/rafrex/spa-github-pages
      // Copyright (c) 2016 Rafael Pedicini, licensed under the MIT License
      // ----------------------------------------------------------------------
      // This script takes the current url and converts the path and query
      // string into just a query string, and then redirects the browser
      // to the new url with only a query string and hash fragment,
      // e.g. http://www.foo.tld/one/two?a=b&c=d#qwe, becomes
      // http://www.foo.tld/?p=/one/two&q=a=b~and~c=d#qwe
      // Note: this 404.html file must be at least 512 bytes for it to work
      // with Internet Explorer (it is currently > 512 bytes)

      // If you're creating a Project Pages site and NOT using a custom domain,
      // then set segmentCount to 1 (enterprise users may need to set it to > 1).
      // This way the code will only replace the route part of the path, and not
      // the real directory in which the app resides, for example:
      // https://username.github.io/repo-name/one/two?a=b&c=d#qwe becomes
      // https://username.github.io/repo-name/?p=/one/two&q=a=b~and~c=d#qwe
      // Otherwise, leave segmentCount as 0.
      var segmentCount = 0;

      var l = window.location;
        l.protocol + '//' + l.hostname + (l.port ? ':' + l.port : '') +
        l.pathname.split('/').slice(0, 1 + segmentCount).join('/') + '/?p=/' +
        l.pathname.slice(1).split('/').slice(segmentCount).join('/').replace(/&/g, '~and~') +
        (l.search ? '&q=' + l.search.slice(1).replace(/&/g, '~and~') : '') +

Please pay attention to segmentCount if you're NOT using a custom domain as it may need changed to 1.

Many thanks to Rafael for this!
Fix iGlasses virtual camera on Zoom (OSX)
Let's make zoom.us app for Mac to accept iGlasses or any other virtual camera again on a Mac.

First, make sure you have Xcode installed, then just open a Terminal window and run the following:
sudo codesign --remove-signature /Applications/zoom.us.app/
Restart Zoom andyou should have any of your virtual cameras available again.
Install Git completion on Mac OSX
If you're like me and use the command line for everything Git, then you are missing the autocompletion when on a Mac. So, if you are using zsh, and you should, it's super simple, just install ohmyzsh:
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
Otherwise, if you are still using bash (goodie but oldie), then let's add autocompletion via Homebrew:
brew install bash-completion
Then add the following to ~/.bash_profile
if [ -f `brew --prefix`/etc/bash_completion.d/git-completion.bash ]; then
  . `brew --prefix`/etc/bash_completion.d/git-completion.bash
Restart your terminal and try to type git checkout or git branch, then hit the TAB to have a list of available branches. It’s very similar to the built in bash autocomplete for files and folders.
Simple arrays intersect in JavaScript
Arrays intersection is a way of comparing content of two arrays. Making use of Array.filter and Array.includes methods, we will get the items existent in both arrays.
const shoppingList = ['πŸ₯“', 'πŸ§€', 'πŸ₯š', 'πŸ₯›'];
const refrigeratorContent = [
  '🍲', 'πŸ₯—', 'πŸ₯’', 'πŸ₯“', 'πŸ§€', 'πŸ“', 
  'πŸ₯‘', '🍎', 'πŸ₯š', 'πŸ—', 'πŸ₯›', 'πŸ₯©'

const intersection = shoppingList.filter(element => refrigeratorContent.includes(element));
If we now compare the length of the resulted intersection array with our shoppingList, we will conclude that all items already exist in refrigeratorContent array.
// => β–Ί(4) ["πŸ₯“", "πŸ§€", "πŸ₯š", "πŸ₯›"]
To make it easier to work with, if all we want is a Boolean, we can assign a constant as follows:
const result = intersection.length === shoppingList.length ? true : false;
// => true
Let us take it further and only show only what must be bought from our shoppingList, by removing 'πŸ₯›' from refrigeratorContent array:
const shoppingList = ['πŸ₯“', 'πŸ§€', 'πŸ₯š', 'πŸ₯›'];
const refrigeratorContent = [
  '🍲', 'πŸ₯—', 'πŸ₯’', 'πŸ₯“', 'πŸ§€', 'πŸ“', 
  'πŸ₯‘', '🍎', 'πŸ₯š', 'πŸ—', 'πŸ₯©'

const mustBuy = shoppingList.filter(element => refrigeratorContent.includes(element) ? null : element);
//=> β–Ί["πŸ₯›"]
Programming languages are always fun!
Array some() and every()
.some() it's incredibly helpful, especially when paired with claims systems:
const isNeg = x => x < 0;

[1, 3, 7, -4, 8].some(isNeg);
// => true

[1, 3, 7, 72, 0, 21].some(isNeg);
// => false
.every() will check for all items in array and expects all to be evaluated as truthy:
[4, 3, 2, 1].every(x => x >= 1);
//=> true

[4, 3, 2, 1].every(x => x < 1);
// => false
Sometimes we may need the index and/or the initial array for complex validations and this is accessible as usual by accepting beyond the element, also the index and intital array as parameters.
const array = [4, 3, 2, 1];
array.some((element, index, array) => {
  // advanced checks here
About "this" in JavaScript
In what we call "strict mode", this will always be undefined as long we're not inside of an object.
'use strict'
// => undefined
In regular mode, also called sloppy mode, this will refer to Window.
// => β–ΊWindow {postMessage: Ζ’, blur: Ζ’, focus: Ζ’, close: Ζ’, parent: Window, …}
Here's how "this" works in methods by looking at different methods defining shapes.

"this" bound by default to object:
const plane = {
  type: 'cargo',
  capacity: 5000,
  summary: function() {
    console.log(`Selected a ${this.type} plane with a capacity of ${this.capacity}.`)

// ==> Selected a cargo plane with a capacity of 5000.
A different approach, very useful in specific cases, that will provide same result:
const plane = {
  type: 'cargo',
  capacity: 5000,

plane.summary = function() {
  console.log(`Selected a ${this.type} plane with a capacity of ${this.capacity}.`)
} // we simply attach the method to the object at a convenient time

// ==> Selected a cargo plane with a capacity of 5000.
But here's a tricky one:
const plane = {
  type: 'cargo',
  capacity: 5000,
  summary: () => {
    console.log(`Selected a ${this.type} plane with a capacity of ${this.capacity}.`)

// ==> Selected a undefined plane with a capacity of undefined.
This is happening because "this" is lexically bound, and creating an arrow function, "this" will be derived from the arrow function itself, therefore will be undefined.

In Browser, "this" has a different use, in the sense the it will refer to the HTML element that got the event:
document.querySelector('#button').addEventListener('click', function(e) {
  console.log(this); // => HTMLElement
What is Object.seal() in Javascript?
This is a very interesting method, similar to Object.freeze(), but only limiting the ability to add or remove properties.
const cat = {
  name: `Fifi`

// => {name: "Fifi"}

cat.name = `Mimi`;
// => {name: "Mimi"}

cat.breed = `Chartreux`;
// => {name: "Mimi"}
As you can see, breed property has not been added, but the name property's value could be changed.
Object.values() in Javascript
It's fairly simple, but very powerful in some scenarios:
const car = { 
  make: 'Futurissima',
  model: 'Coupe',
  year: 2038,
  transmission: 'automatic'

// => β–Ί(4) ['Futurissima', 'Coupe', 2038, 'automatic']
Object.values() also works with arrays.
Get current location in Node.js
If you need the location of the executed JavaScript file in Node.js, then __dirname will be your choice:
console.log(__dirname); // => /users/doru/dev (example output)
If you're referencing a file when importing/requiring it, it's best to use the dot notation:
// will look into current working directory in utils folder after an api.js file

import api from ('../utils/api')
// will look into up one level directory, in utils folder, after an api.js file
If directly in node, then you must use process.cwd():
process.cwd(); // => /Users/doru/dev (example output)