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

Pen-y-Fan

Learning Plan for Design Patterns and Principles of Good Design

These learning resources primarily focus on programming using Good Design Principles and Design Patterns

• There is an emphasis on learning using PHP, although most patterns are universal to every object orientated language.

Pen-y-Fan

Learning Plan for Test Driven Development (TDD)

These learning resources primarily focus on Test Driven Development (TDD).

• There is an emphasis on learning using PHP, Laravel and PHPUnit.
• All these resources are free (at the time of writing)

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()