gatamar

Fork open-source project.
Create branch and make changes.
Push branch to your fork.
Visit open-source project and open a pull-request (select your fork's branch).
Wait for your PR branch to be merged into the open-source project's master.
Once merged, add the open-source project as a 'remote' (git remote add upstream <github.com/user/repo.git>).
git checkout master
git fetch upstream (convention states we use 'upstream' as the name of the remote).
git rebase upstream/master (alternative to fetch/rebase, is git pull --rebase upstream master).
git push origin master.

LLDB Custom Commands

[LLDB] can be customized with ~/.lldbinit to run commands and to load more commands from shell and python scripts. One option is [Chisel] which provides several commands which can be used to debug an software running in Xcode.

It is critical that LLDB can process the commands in ~/.lldbinit successfully as a failure can cause the debugger to fail or run in an undefined way. The configuration listed in this Gist prints a message at the start and end so that when the debugger is run it is clear if any errors are shown in the Xcode console they are related to LLDB.

Agile Contract Guide

This document is a guide to writing agile contracts. Unlike traditional contracts, an agile contract does not specify individual tasks to be completed by the Contractor. Rather, an agile contract specifies how the Client and Contractor interact, and how the Contractor is paid. The Deliverable Work performed for the contract is determined through an ongoing collaboration between the Client and the Contractor.

Agile contracts require a great deal of trust from both the Client and the Contractor. This trust is fostered through tight feedback cycles and well-defined responsibilities that both parties can expect from each other. More so than traditional contracts, an agile contract requires active participation from the Client.

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

The repository for the assignment is public and Github does not allow the creation of private forks for public repositories.

The correct way of creating a private frok by duplicating the repo is documented here.

For this assignment the commands are:

Create a bare clone of the repository. (This is temporary and will be removed so just do it wherever.)

git clone --bare [email protected]:usi-systems/easytrace.git

System Design Cheatsheet

Picking the right architecture = Picking the right battles + Managing trade-offs

Basic Steps

Clarify and agree on the scope of the system

User cases (description of sequences of events that, taken together, lead to a system doing something useful)
- Who is going to use it?
- How are they going to use it?

	defaults write com.apple.dt.Xcode ShowDVTDebugMenu -bool YES
	sudo mkdir -p /Applications/Xcode.app/Contents/Developer/AppleInternal/Library/Xcode
	sudo touch /Applications/Xcode.app/Contents/Developer/AppleInternal/Library/Xcode/AppleInternal.plist

	# Don't forget to restart Xcode

	// Simple RGB to Linear RGB function respecting negative values
	half channelToLinearChannel(half channel) {
	if (fabs(channel) <= 0.04045) {
	return channel / 12.92;
	}

	return sign(channel) * pow((fabs(channel) + 0.055) / 1.055, 2.4);
	}

	// Converting RGB to Linear RGB

	// test in playground targeting iOS
	import UIKit
	import QuartzCore

	let sRGBSpace = CGColorSpace(name: CGColorSpace.sRGB)!
	let linearSpace = CGColorSpace(name: CGColorSpace.linearSRGB)!

	func dumpImageFirstPixel(_ image: UIImage) {
	guard let cgImage = image.cgImage,
	let dataBuffer = cgImage.dataProvider?.data as Data?,

	import Foundation

	protocol Monoid {
	static var zero: Self { get }
	func appending(_: Self) -> Self
	}

	struct AnyMonoid<Type> {
	var zero: Type
	let append: (Type, Type) -> Type