Martin Gratzer mgratzer

For those of you who want to remove all in “Advertisers and Businesses” / "Who uploaded a list with your info and advertised to it":

Go to https://www.facebook.com/ads/preferences/?entry_product=ad_settings_screen and open the section "Advertisers you've interacted with"
Collapse all sections but keep "Advertisers and Businesses" open
Open Web Inspector
Copy-paste this script to load all advertisers: smt=setInterval(() => {let x=document.querySelector('div[shade=medium]'); x ? x.click() : clearInterval(smt), console.log('done')}, 1000)
It will output a number. Wait for it to say “done” in the console. This may take a long time. you'll notice the scrollbar changing while it's loading all advertisers.
Copy-paste this and press enter:

Code is clean if it can be understood easily – by everyone on the team. Clean code can be read and enhanced by a developer other than its original author. With understandability comes readability, changeability, extensibility and maintainability.

General rules

Follow standard conventions.
Keep it simple stupid. Simpler is always better. Reduce complexity as much as possible.
Boy scout rule. Leave the campground cleaner than you found it.
Always find root cause. Always look for the root cause of a problem.

Design rules

A composable pattern for pure state machines with effects

State machines are everywhere in interactive systems, but they're rarely defined clearly and explicitly. Given some big blob of code including implicit state machines, which transitions are possible and under what conditions? What effects take place on what transitions?

There are existing design patterns for state machines, but all the patterns I've seen complect side effects with the structure of the state machine itself. Instances of these patterns are difficult to test without mocking, and they end up with more dependencies. Worse, the classic patterns compose poorly: hierarchical state machines are typically not straightforward extensions. The functional programming world has solutions, but they don't transpose neatly enough to be broadly usable in mainstream languages.

Here I present a composable pattern for pure state machiness with effects,

Cryptographic Best Practices

Putting cryptographic primitives together is a lot like putting a jigsaw puzzle together, where all the pieces are cut exactly the same way, but there is only one correct solution. Thankfully, there are some projects out there that are working hard to make sure developers are getting it right.

The following advice comes from years of research from leading security researchers, developers, and cryptographers. This Gist was [forked from Thomas Ptacek's Gist][1] to be more readable. Additions have been added from

	//
	// FacebookAuth.swift
	// GitHub: ethanhuang13
	// Twitter: @ethanhuang13

	import AuthenticationServices
	import SafariServices

	/*
	Updated:

	/// Used to identify traits of the current UI Environment - especially useful for cross-platform code
	public struct MNCUITraits: Withable {

	/// Does not identify the device type, but the idiom of the layout to apply
	/// This means that e.g. on iPad the layoutIdiom can be `.phone`, if run in Split Screen or SlideOver
	public enum LayoutIdiom {
	case phone(hasRoundCorners: Bool)
	case pad(hasRoundCorners: Bool)
	case mac
	}

	import Foundation
	import CryptoKit

	protocol PasswordProtocol {
	var name: String {get}
	var issuer: String? {get}
	var image: URL? {get}
	var generator: GeneratorProtocol {get}
	}

	// swift-tools-version:4.0
	import PackageDescription

	#if os(Linux)
	import Glibc
	#else
	import Darwin.C
	#endif

	enum Enviroment: String {

	import Foundation

	protocol Channel: IteratorProtocol {
	func send(_ value: Element?)
	}

	/// A blocking channel for sending values.
	///
	/// `send` and `receive` must run in separate separate execution contexts, otherwise you get a deadlock.
	final class BlockingChannel<A>: Channel {

	//: Playground - noun: a place where people can play
	import UIKit

	private class Weak: Hashable {
	let hashValue: Int
	weak var value: AnyObject?

	init(value: AnyObject) {
	self.value = value
	self.hashValue = ObjectIdentifier(value).hashValue