Jason Butler nythrox

Some of the books I'll be recommending are based on .NET. Do not be discouraged. We shouldn't strive to stick to a specific technology stack. Your ambitions and goals will evolve over time and that might lead you a completely new space. Moreover, there are lessons to be learned from an environment that's different from what you're used to.

Software Development

"C# in depth" by Jon Skeet (Book)
"F# for C# developers" by Tao Liu (Book)
F# to C# interop tips by Scott Wlaschin (Gist)
Effective F#, tips and tricks (Gist)

Create a repository and set it to private if you want

In your vault, run these commands substituting the values

git init
git add .
git commit -m "Initial commit"
git remote add origin [email protected]:<USERNAME>/<REPO_NAME>.git
git push -u origin master

Now...

A compile-time 4-Bit Virtual Machine implemented in TypeScript's type system. Capable of running a sample 'FizzBuzz' program.

Syntax emits zero JavaScript.

type RESULT = VM<
  [
    ["push", N_1],         // 1
    ["push", False],       // 2
 ["peek", _], // 3

START HERE: You are not so smart

Predictably Irrational https://www.amazon.com.br/dp/0061353248/
Rápido e devagar https://www.amazon.com.br/dp/853900383X/
Misbehaving: A Construção Da Economia Comportamental https://www.amazon.com.br/dp/8551004131/
Influence: Science and Practice https://www.amazon.com.br/dp/0205609996/

I recomend reading at least two of the above.

If you feel like you know enough about how your mind is ~~fucked-up~~ miscalibrated, you can move on to the lists below. Each one has a few sublists. The order of the sublists does not matter. For each sublist, the first link is the one I see as a good starting point, but the order does not matter too much, either.

	#!/usr/bin/env bash

	function house_builder() {
	# floors,rooms,has_garage
	echo "0,0,0"
	}

	function set_field() {
	local f r g
	IFS=, read f r g

	type _I = Reduce<[S, K, K]>
	// ^?
	type One = I
	type Zero = Reduce<[K, I]>
	// ^?
	type Add = { a: { b: { i: { z: ["a", "i", ["b", "i", "z"]] } } } }
	type Mul = { a: { b: { i: ["a", ["b", "i"]] } } }
	type Two = [Add, One, One]
	type Three = [Add, Two, One]
	type Six = [Add, Three, Two]

	public static class ExtensionMethods
	{
	public static TaskAwaiter GetAwaiter(this AsyncOperation asyncOp)
	{
	var tcs = new TaskCompletionSource<object>();
	asyncOp.completed += obj => { tcs.SetResult(null); };
	return ((Task)tcs.Task).GetAwaiter();
	}
	}

	const env = {
	m1: `import {func} from './m2.mjs'; console.log(func());`,
	m2: `export function func() { return 'abc'; }`
	};

	const inlineModule = (env, text) => `data:text/javascript;base64,${
	btoa(inlineModules(env, text))
	}`;

	const inlineModules = (env, text) => text.replace(

	interface Composable<B,C> {
	(b: B): C;
	I: <D>(f: (c: C) => D) => Composable<B,D>;
	o: <A>(f: (a: A) => B) => Composable<A,C>;
	}

	/*
	* Non-type safe internal function - type safety of result is guaranteed by
	* allowing creation only through `I` and `o` functions and methods
	*/

	// "controller"
	(ctx, next) => {
	let presenter = new Presenter(ctx)
	let interactor = new Interactor(presenter)
	interactor.handle(getRequestFrom(ctx))
	}

	class Presenter {
	constructor(ctx) { this.ctx = ctx }
	present(response) {