BigNerdCoding

#!/bin/bash

STYLE=$(git config --get hooks.clangformat.style)
if [ -n "${STYLE}" ] ; then
  STYLEARG="-style=${STYLE}"
else
  STYLEARG="-style=file"
fi

format_file() {

BigNerdCoding

#!/usr/bin/env ruby -w

class String
  def starts_with?(prefix)
    prefix.respond_to?(:to_str) && self[0, prefix.length] == prefix
  end
end

HEADER_REGEX = /^#import\s+["<](.*)[">]/

BigNerdCoding

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" 
    "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<array>    
    <dict>
        <key>ApplicationIdentifier</key>
        <string>com.microsoft.VSCode</string>
        <key>ApplicationName</key>
        <string>Visual Studio Code</string>

BigNerdCoding

// http://basememara.com/enum-based-queue-factory-gcd/
enum Queue: String {
    private static var pools = [String: DispatchQueue]()
    
    case database = "io.zamzam.databaseQueue"
    case transform = "io.zamzam.transformQueue"
    case network = "io.zamzam.networkQueue"
    
    /**
     Create dispatch queue.

BigNerdCoding

#! /usr/bin/env python3
import os
import sys
import json

def main() :
    #Get Var 
    input_crash = sys.argv[1]
    input_dSYM = sys.argv[2]
    output_crash = sys.argv[3]

BigNerdCoding

#! /usr/bin/env python3

import os
import sys

def findFile(path, name) :
    for dic_name in os.listdir(path) :
        sub_path = os.path.join(path, dic_name)
        if os.path.isfile(sub_path) :
            if dic_name == name :

BigNerdCoding

WIP: Things I've learned about these compiler flags and project settings

Whole Module Compilation Optimizations: Why these terms are sometimes misleading

When you look up how to compile swift faster for debug builds, people very earnestly give advice that seems contradictory: you should "try using the whole module optimization flag," and also "never use whole module optimization for debugging". [^1]

This is confusing because some of us are using these two general words:

compilation: "turning text into an executable program"

BigNerdCoding

libdispatch efficiency tips

I suspect most developers are using the libdispatch inefficiently due to the way it was presented to us at the time it was introduced and for many years after that, and due to the confusing documentation and API. I realized this after reading the 'concurrency' discussion on the swift-evolution mailing-list, in particular the messages from Pierre Habouzit (who is the libdispatch maintainer at Apple) are quite enlightening (and you can also find some good tweets from him on the subject).

• https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20170828/date.html
• https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20170904/date.html

My take-aways are:

• You should have very few queues that target the global pool. If all these queues are active at once, you will get as many threads running. These queues should be seen as execution contexts in the program (gui, storage, background work, ...) that benefit from executing in parallel. Start with few of them, reuse

BigNerdCoding

public class Channel<Value> {
    
    private class Subscription {
        
        weak var object: AnyObject?
        private let notifyBlock: (Value) -> Void
        private let queue: DispatchQueue
        
        var isValid: Bool {
            return object != nil

BigNerdCoding

Work in Progress: Phoenix + Vue + Brunch

This documents how I integrate Vue 2.0 with Phoenix 1.x using the default brunch pipeline.

The toolchain

Start out by adding the vue-brunch plugin. You will need a version later than 1.2.3 in order to be able to use the extractCSS option (see later). At the time of writing, 1.2.3 was still the version fetched by npm so I suggest just getting the tip of the dev branch for now (this branch is for Vue 2.0 compatibility anyway):

npm install git+https://github.com/nblackburn/vue-brunch.git#dev --save-dev