PimCoumans

class Button: UIButton {
    
    private class Subview: UIView {
        // Never allow isUserInteractionEnabled in any button subview
        override var isUserInteractionEnabled: Bool {
            get { false }
            set { super.isUserInteractionEnabled = false }
        }
    }
    

donnywals

import Foundation

@propertyWrapper
struct YMD {
  var wrappedValue: Date?
}

extension YMD: Codable {
  func encode(to encoder: Encoder) throws {
    if let date = self.wrappedValue {

gelin

#!/usr/bin/env python3

PRINTER = '/dev/usb/lp0'  # the printer device

DOTS_MM = 8  # printer dots per mm, 8 == 203 dpi
WIDTH_MM = 100  # sticker width, mm
HEIGHT_MM = 35  # sticker height, mm
GAP_MM = 2      # sticker gap, mm

FONT = "0"  # built-in vector font, scalable by X and Y

onderweg

const DATA_HND = 0x002d;

const parseData = (data) => {
    const rawTemp = data.readInt16LE(0);
    const rawHum = data.readInt16LE(2);
    return {
        temperature: rawTemp / 100,
        humidity: rawHum / 100
    }
}

hardillb

Basic MQTT bridge can be found here:
https://github.com/hardillb/TRADFRI2MQTT


Bridge adds a mDNS entry for a COAP sever:

Service Type: _coap._udp
Service Name: gw:b0-72-bf-25-bf-59
Domain Name: local
Interface: wlan0 IPv4

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,

pvzig

import Foundation
import SlackKit

class RobotOrNotBot {

    let verdicts: [String:Bool] = [
        "Mr. Roboto" : false,
        "Service Kiosks": false,
        "Darth Vader": false,
        "K-9": true,

nakiostudio

/**
 Writes a set of objects in the database.
 
 - parameter objects:         Array of `Objects` to be stored on the database
 - parameter configuration:   Realm `Configuration` in which the write action will be performed
 - parameter update:          Enabled the custom *update* maintaining existing relationships
 */
static func write(objects : [Object], configuration: Realm.Configuration, update: Bool = false) {
    if let realm = try? Realm(configuration: configuration) {
        realm.beginWrite()

jimrutherford

//
//  CrashlyticsDestination.swift
//
//  Created by Jim Rutherford on 2015-12-10.
//

import UIKit
import Crashlytics

public class CrashlyticsDestination: BaseDestination {

davetrux

import Foundation

//You have to create a bridging header in your project containing:
// #import <CommonCrypto/CommonHMAC.h>

extension String {
    
    func digestHMac256(key: String) -> String! {
        
        let str = self.cStringUsingEncoding(NSUTF8StringEncoding)