bzerangue

Verify and Repair Disk Permissions via Terminal (Mac OS X)

Verify Permissions

diskutil verifyPermissions /

Repair Permissions

diskutil repairPermissions /

hooman

// The correct implementation of `Equatable` (and `Comparable`) can be tricky for class
// hierarchies. To make it easier, it is better to follow a well-defined pattern. Here
// is my suggestion on how to do it:

// 1. Define a protocol for polymorphic test function for equality (or comparison): 
// Note: operators are not polymorphic (not virtual in C++ terms)). The function to 
// call is determined and hard-coded at compile time.

/// A protocol to ammend `Equatable` for use with `class` types.

santoshrajan

// Author - Santosh Rajan

import Foundation

let jsonObject: [AnyObject] = [
 ["name": "John", "age": 21],
 ["name": "Bob", "age": 35],
]

func JSONStringify(value: AnyObject, prettyPrinted: Bool = false) -> String {

pxpgraphics

//
//  ArrayExtensions.swift
//  MyDailyGrind
//
//  Created by Paris Pinkney on 7/8/14.
//  Copyright (c) 2014 PXPGraphics. All rights reserved.
//

import Foundation

nicklockwood

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.

calebd

import Foundation

/// An abstract class that makes building simple asynchronous operations easy.
/// Subclasses must implement `execute()` to perform any work and call
/// `finish()` when they are done. All `NSOperation` work will be handled
/// automatically.
open class AsynchronousOperation: Operation {

    // MARK: - Properties

mchambers

// Here we'll use Swift's IDE-supporting reflect()
// function to build a basic JSON serializer.

// Per the fine engineers at WWDC, Swift's reflection support
// exists purely to support the IDE and the Playground. But
// we can have some fun with it anyway. ;)

class SerializerBase {
}

staltz

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

---

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

---

mchambers

// Let's define a basic Swift class.
class Fruit {
    var type=1
    var name="Apple"
    var delicious=true
}

// We can get at some info about an instance of an object using reflect(), which returns a Mirror.
reflect(Fruit()).count
reflect(Fruit())[1].0

shadcn

// Creates a UIColor from a Hex string.
func colorWithHexString (hex:String) -> UIColor {
  var cString:String = hex.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet()).uppercaseString
  
  if (cString.hasPrefix("#")) {
    cString = cString.substringFromIndex(1)
  }
  
  if (countElements(cString) != 6) {
    return UIColor.grayColor()