jesseschalken

My preferred code style is 2-space K&R. This is intended to provide a justification for this style.

Why K&R?

K&R style has the following properties:

1. Provides symmetric size (in terms of screen space consumed) between the opening and closing syntax of a clode block.
2. Forces no empty or meaningless lines, thereby avoiding artificial distance between related things that should be together.
3. Consumes the minimum vertical space while keeping the opening and closing syntax of a block on separate lines from the content.

jesseschalken

Interfaces and Sum Types

The way different programming languages implement the mapping of runtime polymorphic values to code both at the source level and in the language implementation is a defining characteristic. There are two opposite approaches that languages facilitate to varying degrees:

1. Interfaces / Traits / Abstract Classes / Inheritance / Method Overriding (from here on, just "Interfaces")
2. Sum Types / Algebraic Data Types / Tagged Unions / Pattern Matching (from here on, just "Sum Types")

Example

You have two types: A, containing a string, and B, containing an int, and two operations: x and y.

jesseschalken

• ⚪ = uninitialized memory
• 🔵 = value 1
• 🟢 = value 2

	name	operator	note
⚪ → 🔵	construction	A()	constructor may require parameters constructor may have multiple overloads
🔵 → ⚪	destruction	~A()

jesseschalken

import { ClientReadableStream } from "grpc-web";
import { Observable } from "rxjs";

export function grpcToRx<T>(f: () => ClientReadableStream<T>): Observable<T> {
  return new Observable<T>(subscriber => {
    const stream = f();
    stream.on("error", e => subscriber.error(e));
    stream.on("end", () => subscriber.complete());
    stream.on("data", x => subscriber.next(x));
    return () => stream.cancel();

jesseschalken

<?php

class Uri implements \Psr\Http\Message\UriInterface {
	const PASS     = 'pass';
	const USER     = 'user';
	const PORT     = 'port';
	const SCHEME   = 'scheme';
	const QUERY    = 'query';
	const FRAGMENT = 'fragment';
	const HOST     = 'host';

jesseschalken

<?php

/*
MIT License

Copyright (c) 2021 Jesse Schalken

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights

jesseschalken

fun Iterable<Boolean>.toBrailleString(): String =
  chunked(8) {
    fun p(i: Int, j: Int) =
      if (i < it.size && it[i]) 1 shl j else 0

    '\u2800' +
        p(0, 0) + p(1, 1) + p(2, 2) + p(3, 6) +
        p(4, 3) + p(5, 4) + p(6, 5) + p(7, 7)
  }.toCharArray().concatToString()

jesseschalken

T.also(block: (T) -> Unit): T
T.apply(block: T.() -> Unit): T
T.let(block: (T) -> R): R
T.run(block: T.() -> R): R

jesseschalken

export interface HashImpl<T> {
  hash?(value: T): unknown;
  equals(a: T, b: T): boolean;
}

export class AssociationList<K, V> implements Map<K, V> {
  private inner: {readonly key: K; value: V}[] = [];

  constructor(
    private readonly impl: HashImpl<K>,

jesseschalken

C	C++
T* owning a single object	T
T* borrowing a single object	T&
T* owning a single object, nullable	std::optional<T>
T* owning a single object, polymorphic	std::unique_ptr<T>
T* owning an array (dynamic size)	std::vector<T>
T[N] owning an array (static size)	std::array