Sasha K akovalev

Bitcoin for laypeople

(Chinese version available here, courtesy of @jiangplus

(This is an English translation of my Danish blog post, Bitcoin for voksne)

Bitcoin is a digital currency that has no central authority. It's a currency where you do not have to rely on anyone to know it's worth it. As a concept, it's similar to gold. Gold has a value in itself, as opposed to, say a $100 note that only has value if the U.S. government says it has value. Similarly, the idea of Bitcoins is that they have value by themselves.

Let's try to understand how Bitcoin works.

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.

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.

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

	import * as fs from 'fs';

	// Public: Download a file and store it on a file system using streaming with appropriate progress callback.
	//
	// * `sourceUrl` Url to download from.
	// * `targetFile` File path to save to.
	// * `progressCallback` Callback function that will be given a {ByteProgressCallback} object containing
	// both bytesDone and percent.
	// * `length` Optional file length in bytes for cases where the server will not supply the
	// Content-Length header but the value is known in advance. Without either the

	// 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 {

	"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.

	"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
	*/


	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;

	/**
	* 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.
	*/