Edward George edwardgeorge

Client-side SSL

For excessively paranoid client authentication.

Updated Apr 5 2019:

because this is a gist from 2011 that people stumble into and maybe you should AES instead of 3DES in the year of our lord 2019.

some other notes:

Overview

There are lots of representations for strings. In most languages they pick one set of tradeoffs and run with it. In haskell the "default" implementation (at least the one in the prelude) is a pretty bad choice, but unlike most other languages (really) good implementations exist for pretty much every way you can twist these things. This can be a good thing, but it also leads to confusion, and frustration to find the right types and how to convert them.

Types

Disclaimer: I'm not the original author of this sheet, but can't recall where I found it. ~~If you know the author, please let me know so I give the attribution.~~

The original author seems to be Charles Edge, here's the original content, as pointed out by @percisely.

Note: Since this seems to be helpful to some people, I formatted it to improve readability of the original. Also, note that this is from 2016, many things may have changed, and I don't use macOS anymore, so I probably can't help in case of questions, but maybe someone else can.

Mac Network Commands Cheat Sheet

After writing up the presentation for MacSysAdmin in Sweden, I decided to go ahead and throw these into a quick cheat sheet for anyone who’d like to have them all in one place. Good luck out there, and s

Ways to remap caps lock to control on Windows 10

These methods in this gist worked for me on my U.S.-based keyboard layouts. I am unsure about other layouts. If you have problems, revert your changes; delete the registry key you created (and reboot).

Update: you should probably scroll down to approach 4 where I suggest using Microsoft PowerToys Keyboard Manager.

Approach 1. Manually through regedit

Navigate to and create a new binary value in HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout named Scancode Map.

Statically checked overloaded strings

This gist demonstrates a trick I came up with which is defining IsString for Q (TExp a), where a is lift-able. This allows you to write $$("...") and have the string parsed at compile-time.

On GHC 9, you are able to write $$"..." instead.

This offers a light-weight way to enforce compile-time constraints. It's basically OverloadedStrings with static checks. The inferred return type

	'use strict';

	module.exports = function CustomError(message, extra) {
	Error.captureStackTrace(this, this.constructor);
	this.name = this.constructor.name;
	this.message = message;
	this.extra = extra;
	};

	require('util').inherits(module.exports, Error);

	{-# LANGUAGE GeneralizedNewtypeDeriving #-}

	import Control.Monad.IO.Class
	import Control.Monad.Trans.Class
	import Prelude hiding (log)

	--------------------------------------------------------------------------------
	-- The API for cloud files.
	class Monad m => MonadCloud m where
	saveFile :: Path -> Bytes -> m ()

	{-# LANGUAGE GADTs, RankNTypes, TypeFamilies, DataKinds, PolyKinds, TypeOperators, ScopedTypeVariables #-}

	-- Lots of ways you can phrase this, but this works for me
	-- For folks who haven't seen it before, this is "the essence of the sum type" and sigma stands for sum.
	-- You see it far more often in dependent types than elsewhere because it becomes a lot more pleasant to
	-- work with there, but it's doable in other contexts too. Think of the first parameter to the data
	-- constructor as a generalized "tag" as we talk about in "tagged union", and the second parameter is the
	-- "payload". It turns out that you can represent any simple sum type you could write in Haskell this way
	-- by using a finite and enumerable `f`, but things can get more unusual when `f` isn't either. In such
	-- cases, it's often easier to think of this as the essence of existential types.