idiomatic

#!/bin/bash
# usage: get [ RESOLUTION [ YEAR [ IDS... ] ] ]

resolution=${1:-SD}
year=${2:-2015}
shift
shift
ids=$*

RESOLUTION=$(echo $resolution | tr '[:lower:]' '[:upper:]')

mortenjust

func openAndSelectFile(filename:String){
    let files = [NSURL(fileURLWithPath: filename)];
    NSWorkspace.sharedWorkspace().activateFileViewerSelectingURLs(files);
}

podkovyrin

CVImageBufferRef imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
CVPixelBufferLockBaseAddress(imageBuffer,0);

size_t height = CVPixelBufferGetHeight(imageBuffer);
size_t width = CVPixelBufferGetWidth(imageBuffer);
size_t bytesPerRow = CVPixelBufferGetBytesPerRow(imageBuffer);

void *sourceData = CVPixelBufferGetBaseAddress(imageBuffer);

// Set a bunch of variables we need. The "radius" for the blur kernel needs to be positive and odd. The permute map maps the BGRA channels of the buffer to the ARGB that vImage needs.

czwen

xcrun simctl spawn booted launchctl debug system/com.apple.SpringBoard --environment DYLD_INSERT_LIBRARIES=/Applications/Reveal.app/Contents/SharedSupport/iOS-Libraries/libReveal.dylib

xcrun simctl spawn booted launchctl stop com.apple.SpringBoard

bennyty

		let duration = CMTime( value:10, timescale:600, flags: CMTimeFlags(rawValue: 0), epoch:0)
		let presentationTimeStamp = CMTime( value:0, timescale:600, flags:CMTimeFlags(rawValue: 0), epoch:0)
		var timingInfo = CMSampleTimingInfo( duration:duration, presentationTimeStamp:presentationTimeStamp, decodeTimeStamp:kCMTimeInvalid )
//		let potentialBlockBuffer = CMSampleBufferGetDataBuffer(sampleBuffer)
//		var imageBufferCopy = UnsafeMutablePointer<CVImageBuffer>.alloc(1)

		guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
			fatalError("Sample Buffer did not contain a pixel buffer")
		}

bennyty

guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
			
var copiedPixelBuffer : CVPixelBuffer?
CVPixelBufferCreate(
	nil,
	CVPixelBufferGetWidth(pixelBuffer),
	CVPixelBufferGetHeight(pixelBuffer),
	CVPixelBufferGetPixelFormatType(pixelBuffer),
	nil,
	&copiedPixelBuffer)

andymatuschak

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,

actuino

The setup of a bluetooth speaker on a Pi Zero W is pretty touchy.

Please get in touch via Twitter @actuino or http://www.actuino.fr/ if you've got comments or improvements to this quick draft.

First checks

• Use a solid power source
• check the speaker works on another hardware (android phone f.i.)
• make sure you've updated your Raspbian, install and run rpi-update just in case.

norsez

import AppKit
import AVFoundation

class MovieWriter: NSObject {
    func writeImagesAsMovie(_ allImages: [NSImage], videoPath: String, videoSize: CGSize, videoFPS: Int32) {
        // Create AVAssetWriter to write video
        guard let assetWriter = createAssetWriter(videoPath, size: videoSize) else {
            print("Error converting images to video: AVAssetWriter not created")
            return
        }

hooman

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


/// A protocol to provide an abstraction of types that hold a weak reference to a target object.
///
/// It is defined because a single generic implementation cannot support existentials, as they
/// do not conform to themselves or `AnyObject`. Most of its API is defined by protocol extensions
/// to makes it easier to create existential wrapper `struct`s or `final class`es.
///
/// Here is an example protocol and the corresponding weak reference