jaredpalmer

import React from 'react';
import Route from 'react-router-dom/Route';
import Link from 'react-router-dom/Link';
import Switch from 'react-router-dom/Switch';

const App = ({ routes, initialData }) => {
  return routes
    ? <div>
        <Switch>
          {routes.map((route, index) => {

gvergnaud

const State = state => new Proxy({
  state,
  listeners: [],
  subscribe(listener) {
    this.listeners.push(listener)
    return () => this.listeners.filter(x => x !== listener)
  },
  set(stateUpdates) {
    this.state = Object.assign({}, this.state, stateUpdates);
    this.listeners.forEach(f => {

gvergnaud

// safe objects won't throw when trying to get a
// property which doesn't exist.

const safe = value => new Proxy({
  extract() {
    return value
  }
}, {
  get(obj, key) {
    return key === 'extract'

sebmarkbage

let cache = new Map();
let pending = new Map();

function fetchTextSync(url) {
  if (cache.has(url)) {
    return cache.get(url);
  }
  if (pending.has(url)) {
    throw pending.get(url);
  }

ryandabler

// Create "backend" object to hold data for getters and setters on main object
const _ = Object.create( null );

Object.defineProperties(
    _,
    {
        firstname: {
            value: 'John',
            writable: true,
            enumerable: false,

gadzhimari

Step 1

Download and run the Adobe Creative Cloud Cleaner Tool, their multi-app uninstaller and wipe assistant. Adobe does recommend running individual application uninstallers first, your call. Click the Clean All option.

Step 2

Type a one line command in terminal find ~/ -iname "*adobe*" and it's shows up all files which match pattern.

To remove all files

`sudo rm -rf /Applications/Adobe* /Applications/Utilities/Adobe* /Library/Application\ Support/Adobe /Library/Preferences/com.adobe.* /Library/PrivilegedHelperTools/com.adobe.* /private/var/db/receipts/com.adobe.* ~/Library/Application\ Support/Adobe* ~/Library/Application\ Support/com.apple.sharedfilelist/com.apple.LSSharedFileList.ApplicationRecentDocuments/com.adobe* ~/Library/Application\ Support/CrashReporter/Adobe* ~/Library/Caches/Adobe ~/Library/Caches/com.Adobe.* ~/Library/Caches/com.adobe.* ~/Library/Cookies/com.adobe.* ~/Library/Logs/Adobe* ~/Librar

kislayverma

I was at Amazon for about six and a half years, and now I've been at Google for that long. One thing that struck me immediately about the two companies -- an impression that has been reinforced almost daily -- is that Amazon does everything wrong, and Google does everything right. Sure, it's a sweeping generalization, but a surprisingly accurate one. It's pretty crazy. There are probably a hundred or even two hundred different ways you can compare the two companies, and Google is superior in all but three of them, if I recall correctly. I actually did a spreadsheet at one point but Legal wouldn't let me show it to anyone, even though recruiting loved it.

I mean, just to give you a very brief taste: Amazon's recruiting process is fundamentally flawed by having teams hire for themselves, so their hiring bar is incredibly inconsistent across teams, despite various efforts they've made to level it out. And their operations are a mess; they don't really have SREs and they make engineers pretty much do everything,

jjcodes78

How to setup next.js app on nginx with letsencrypt

next.js, nginx, reverse-proxy, ssl

1. Install nginx and letsencrypt

$ sudo apt-get update
$ sudo apt-get install nginx letsencrypt

Also enable nginx in ufw

gvergnaud

/**
 * # How does `A extends B` work in TypeScript?
 * 
 * If you think about types in terms of sets containing possible values, 
 * the `string` type is the set of all possible strings,
 * the `number` type is the set of all possible numbers,
 * the `'hello'` type is a set containing only the string 'hello'
 * and the `2` type is a set containing only the number 2.
 * 
 * Then you can think of `A extends B` as asking this question:

gvergnaud

/**
 * # Assigning properties to an object type in TypeScript
 * 
 * When we want to assign some properties on a object type
 * we usually use the `&` operator:
 * 
 * type B = A & { someProperty: string }
 * 
 * It seems to work at first sight, but it doesn't behave exactly
 * as we would expect when we try to override properties that already