Luis Ascorbe Lascorbe

Chat GPT "DAN" (and other "Jailbreaks")

libdispatch efficiency tips

The libdispatch is one of the most misused API due to the way it was presented to us when it was introduced and for many years after that, and due to the confusing documentation and API. This page is a compilation of important things to know if you're going to use this library. Many references are available at the end of this document pointing to comments from Apple's very own libdispatch maintainer (Pierre Habouzit).

My take-aways are:

You should create very few, long-lived, well-defined queues. These queues should be seen as execution contexts in your program (gui, background work, ...) that benefit from executing in parallel. An important thing to note is that if these queues are all active at once, you will get as many threads running. In most apps, you probably do not need to create more than 3 or 4 queues.
Go serial first, and as you find performance bottle necks, measure why, and if concurrency helps, apply with care, always validating under system pressure. Reuse

Step 0:

Get Homebrew installed on your mac if you don't already have it

Step 1:

Install highlight. "brew install highlight". (This brings down Lua and Boost as well)

Step 2:

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,

Videos

Introduction to Functional Programming Johannes Weiß - https://vimeo.com/100786088
ReactiveCocoa at MobiDevDay Andrew Sardone - https://vimeo.com/65637501
The Future Of ReactiveCocoa Justin Spahr-Summers - https://www.youtube.com/watch?v=ICNjRS2X8WM
Enemy of the State Justin Spahr-Summers - https://www.youtube.com/watch?v=7AqXBuJOJkY
WWDC 2014 Session 229 - Advanced iOS Application Architecture and Patterns Andy Matuschak - https://developer.apple.com/videos/play/wwdc2014/229/
Functioning as a Functionalist Andy Matuschak - https://www.youtube.com/watch?v=rJosPrqBqrA
Controlling Complexity in Swift Andy Matuschak - https://realm.io/news/andy-matuschak-controlling-complexity/

Hacking UIView animation blocks for fun and profit

In this article, I'm going to explore a way that we can create views that implement custom Core Animation property animations in a natural way.

As we know, layers in iOS come in two flavours: Backing layers and hosted layers. The only difference between them is that the view acts as the layer delegate for its backing layer, but not for any hosted sublayers.

In order to implement the UIView transactional animation blocks, UIView disables all animations by default and then re-enables them individually as required. It does this using the actionForLayer:forKey: method.

Somewhat strangely, UIView doesn't enable animations for every property that CALayer does by default. A notable example is the layer.contents property, which is animatable by default for a hosted layer, but cannot be animated using a UIView animation block.

	//
	// Obfuscator.swift
	//
	// Created by Dejan Atanasov on 2017-05-31.
	//

	import Foundation

	class Obfuscator: AnyObject {

	class Cache<T> {
	private lazy var objects = [String : T]()

	func object(forKey key: String) -> T? {
	return objects[key]
	}

	func addObject(_ object: T, forKey key: String) {
	objects[key] = object
	}

	# Delete remote branches already merged with development
	git branch -a --merged \| grep -v "\*" \| grep -v master \| grep -v main \| grep -v develop \| cut -d'/' -f 3-4 \| xargs -n 1 -I {} git push origin :{}

	# Delete local merged branches
	git branch --merged \| grep -v "\*" \| grep -v master \| grep -v main \| grep -v dev \| xargs -n 1 -I {} git branch -d {}

	# Delete local squashed branches DANGEROUS https://github.com/not-an-aardvark/git-delete-squashed
	git for-each-ref refs/heads/ "--format=%(refname:short)" \| while read branch; do mergeBase=$(git merge-base master $branch) && [[ $(git cherry master $(git commit-tree $(git rev-parse $branch\^{tree}) -p $mergeBase -m _)) == "-"* ]] && git branch -D $branch; done

	# Delete all local branches except main

	func colorWithGradient(frame: CGRect, colors: [UIColor]) -> UIColor {

	// create the background layer that will hold the gradient
	let backgroundGradientLayer = CAGradientLayer()
	backgroundGradientLayer.frame = frame

	// we create an array of CG colors from out UIColor array
	let cgColors = colors.map({$0.CGColor})

	backgroundGradientLayer.colors = cgColors