Sasha K akovalev

Who pays when startup employees keep their equity?

JD Maturen, 2016/07/05, San Francisco, CA

As has been much discussed, stock options as used today are not a practical or reliable way of compensating employees of fast growing startups. With an often high strike price, a large tax burden on execution due to AMT, and a 90 day execution window after leaving the company many share options are left unexecuted.

There have been a variety of proposed modifications to how equity is distributed to address these issues for individual employees. However, there hasn't been much discussion of how these modifications will change overall ownership dynamics of startups. In this post we'll dive into the situation as it stands today where there is very near 100% equity loss when employees leave companies pre-exit and then we'll look at what would happen if there were instead a 0% loss rate.

What we'll see is that employees gain nearly 3-fold, while both founders and investors – particularly early investors – get dilute

Applied Functional Programming with Scala - Notes

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

Please 🌟 this gist to vote for this proposal!

Make linting great again!

No other topic in software development probably has so much controversy as linting.

With a wrong workflow linting can be really a pain and will slow you and your team down. With a proper setup, though, it can save you hours of manual work reformatting the code and reducing the code-review overhead.

A vision for data interchange in Elm

How do you send information between clients and servers? What format should that information be in? What happens when the server changes the format, but the client has not been updated yet? What happens when the server changes the format, but the database cannot be updated?

These are difficult questions. It is not just about picking a format, but rather picking a format that can evolve as your application evolves.

Literature Review

By now there are many approaches to communicating between client and server. These approaches tend to be known within specific companies and language communities, but the techniques do not cross borders. I will outline JSON, ProtoBuf, and GraphQL here so we can learn from them all.


	<!--
	This demo shows two ways to detect changes to a DOM node `.textContent`, one
	using a `MutationObserver` and the other using an ES2015 `Proxy`.

	From testing, a `Proxy` appears to be 6-8x faster than using a MO in Chrome 50.

	Update: removing the `Proxy` altogether speeds up the MO to be inline with the Proxy.
	This has something to do with how the browser queues/prioritizes Proxies over MO.

	/**
	* Delays calling the given function until the browser is notifying us
	* about a certain minimum budget or the timeout is reached.
	* @param {!Window} win
	* @param {number} startTime When we started waiting for idle.
	* @param {number} minimumTimeRemaining Minimum number of millis idle
	* budget for callback to fire.
	* @param {number} timeout in millis for callback to fire.
	* @param {function()} fn Callback.
	*/


	class Model<T> {
	props: T;
	constructor(initial: T \| void){
	if (initial) {
	this.props = initial;
	}
	}
	set<K extends keyof T>(propName: K, value: T[K]) {
	this.props[propName] = value;

	"use strict";
	/**
	* processDependenciesBlockForChunk() would go into insane recursion in the old code, this patch fixes that up
	* by using a stack to process the work instead; it also checks module membership into chunk.modules using a Set
	* to speed things up.
	*
	* Original code license:
	* MIT License http://www.opensource.org/licenses/mit-license.php
	* Author Tobias Koppers @sokra
	*/

	"use strict";

	const worker = new Worker("worker.js");

	self.onfetch = e => {
	const transform = new TransformStream(); // creates an identity transform
	e.respondWith(new Response(transform.readable));

	// Give the worker the writable end. An identity transform stream will just shuffle
	// bytes written there into transform.readable.

	// install @types/react-redux and other nonsense

	import * as React from 'react'
	import { connect } from 'react-redux'
	import { YourActualAppState } from './wherever-it-is.ts'

	export function mapStateToProps({
	whatever
	}: YourActualAppState) {
	return {