Dan Rosenstark, author of MIDI Designer, on Tech & Music

The Whisper Script, Packaged

2024-04-23T20:40:05.475000Z

Overview

This is a script called whisper.

Takes .m4a and .mp3 files from a Dropbox directory
Has ChatGPT Whisper endpoint transcribe them
Has ChatGPT take the Whisper transcription, correct it and make paragraphs
Creates a text file in another Dropbox folder
Sends and email to Evernote

You need:

An OpenAI API key
Dropbox folders on your Mac
If you use the email functionality, you need SMTP credentials and a 'make to' address for Evernote (or you can comment this part out).

Instructions

You need to change directories and generally think for yourself a bit. If you're not comfortable editing scripts, this might not be for you.

Some notes:

These scripts work for me, but my home directory is /Users/yourUser so you need to modify that.
Get an OpenAI API key
Create the Credentials file
Modify the scripts
Run whisper on its own first. You might need to handle Python dependencies with pip. ChatGPT can help you.
When you run Whisper inside the Launchctl context, you might get lost. Note that it dumps log files in /tmp
This blog screws up formatting a bit. You can see the raw Evernote note here. It's Markdown.

Credentials

I store these in $HOME/.secure_env

They should look like this

export OPENAI_API_KEY='' # beware this MIGHT have a dash in it!
export SMTP_SERVER=''
export SMTP_USERNAME=''
export SMTP_PASSWORD=''
export SMTP_PORT=''
export SMTP_SENDER=''
export EVERNOTE_EMAIL=''

The Whisper Script

I stored this in ~/scripts/whisper. Ensure it's executable with chmod +x whisper.

#!/usr/bin/env python3

import datetime
from pathlib import Path
import argparse
from openai import OpenAI
import os, sys
import smtplib

client = OpenAI()

# NOTE: you need this in the environment
# export OPENAI_API_KEY='your key'
# BEWARE of the launch agent running from here
# ~/Library/LaunchAgents/com.confusionstudios.watchvoicedictationfolder.plist
# and that guy runs the whisper-wrapper to handle paths and environment variables

def get_smtp_credentials():
    # Retrieve SMTP server, port, username, and password from environment variables
    smtp_server = os.getenv("SMTP_SERVER")
    smtp_port = os.getenv("SMTP_PORT")
    smtp_username = os.getenv("SMTP_USERNAME")
    smtp_password = os.getenv("SMTP_PASSWORD")
    smtp_sender = os.getenv("SMTP_SENDER")
    return smtp_server, smtp_port, smtp_username, smtp_password, smtp_sender

def send_email_to_evernote(subject, body):
    recipient = os.getenv("EVERNOTE_EMAIL")

    # Get SMTP credentials
    smtp_server, smtp_port, smtp_username, smtp_password, smtp_sender = get_smtp_credentials()

    try:
        # Connect to the SMTP server
        smtp_server = smtplib.SMTP_SSL(smtp_server, smtp_port)
        smtp_server.login(smtp_username, smtp_password)

        # Compose the email message
        message = f"Subject: {subject} @Diary\n\n{body}"

        # Send the email
        smtp_server.sendmail(smtp_sender, recipient, message)

        # Close the connection
        smtp_server.quit()

        print("Email sent successfully.")
    except Exception as e:
        print(f"Error sending email: {e}")

def get_creation_time(file_path):
    return datetime.datetime.fromtimestamp(file_path.stat().st_ctime)

def transcribe_with_whisper_api(file_path):
    print(f"Sending up audio file {file_path.stem} to Whisper for transcription.")
    audio_file = open(file_path, "rb")
    transcription = 
client.audio.transcriptions.create
(
        model="whisper-1", file=audio_file, response_format="text"
    )

    print(f"Got the transcription, length: {len(transcription)}. Now sending to ChatGPT for post-processing.")

    completion = 
client.chat.completions.create
(
        model="gpt-3.5-turbo",
        messages=[
            {
                "role": "system",
                "content": "The following is a transcript. Please make paragraphs out of the transcript. Do not alter it but except to fix homonyms, spelling discrepancies and possible voice transcription mistakes. Feel free to adjust punctuation. Also note the spelling of MIDI Designer. Do not respond to the transcript! THE FOLLOWING IS THE RAW TRANSCRIPT:",
            },
            {
                "role": "user",
                "content": transcription,
            },
        ],
    )

    return completion.choices[0].message.content

def process_file(file_path, output_file, dry_run=False):
    if dry_run:
        print(f"Would transcribe {file_
path.name
} into {output_file}")
    else:
        print(f"Processing {file_
path.name
}...")
        transcript = transcribe_with_whisper_api(file_path)
        with open(output_file, "w") as f:
            f.write(transcript)
        print(f"Generated {output_
file.name
}")
        send_email_to_evernote(output_
file.name
, transcript)
        print(f"Sent Evernote Email with Subject {output_
file.name
}")

def process_files(source_dir, output_dir, dry_run=False):
    # Load list of already processed files
    transcribed_file_path = source_dir / 'transcribed-files.txt'
    if transcribed_file_path.exists():
        with transcribed_file_
path.open
('r') as file:
            processed_files = {line.strip() for line in file}
    else:
        processed_files = set()

    voice_files = list(source_dir.glob("*.m4a")) + list(source_dir.glob("*.mp3"))
    for file_path in voice_files:
        if file_
path.name
 in processed_files:
            print(f"Skipping {file_
path.name
}, already processed.")
            continue

        creation_time = get_creation_time(file_path)
        formatted_time = creation_time.strftime("%Y-%m-%d-%H-%M")
        old_filename_without_extension = file_path.stem

        if old_filename_without_extension.isdigit():
            output_file_name = f"{formatted_time}.txt"
        else:
            output_file_name = f"{formatted_time} - {old_filename_without_extension}.txt"

        output_file = output_dir / output_file_name

        process_file(file_path, output_file, dry_run)

        if not dry_run:
            # Add file to processed list and update file
            processed_files.add(file_
path.name
)
            with transcribed_file_
path.open
('a') as file:
                file.write(file_
path.name
 + '\n')

def parse_arguments():
    parser = argparse.ArgumentParser(
        description="Process voice dictations and generate text files."
    )
    parser.add_argument(
        "--dry-run", action="store_true", help="Print out actions without executing"
    )
    return parser.parse_args()

def main():
    args = parse_arguments()
    source_dir = Path("~/Dropbox/x-fer/voice-dictation").expanduser()
    if not os.path.exists(source_dir):
        print(f"The source directory {source_dir} does not exist.")
        sys.exit(1)

    output_dir = Path("~/Dropbox/x-fer/voice-dictation-output").expanduser()

    output_dir.mkdir(parents=True, exist_ok=True)

    process_files(source_dir, output_dir, dry_run=args.dry_run)

if __name__ == "__main__":
    main()

The Launchctl Command That Loads Whisper Wrapper

This is ~/Library/LaunchAgents/com.confusionstudios.watchvoicedictationfolder.plist

NOTE: You need to adjust paths for everything in this plist except for the /tmp outputs which do give great debugging information.

<?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">
<dict>
    <key>Label</key>
    <string>com.confusionstudios.watchvoicedictationfolder</string>
    <key>ProgramArguments</key>
    <array>
        <string>/Users/yourUser/scripts/whisper-wrapper</string>
    </array>
    <key>WatchPaths</key>
    <array>
        <string>/Users/yourUser/Dropbox/x-fer/voice-dictation</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <false/>
    <key>StandardOutPath</key>
    <string>/tmp/whisper-wrapper.out</string>
    <key>StandardErrorPath</key>
    <string>/tmp/whisper-wrapper.err</string>
</dict>
</plist>

The Wrapper Script

Launchctl is missing stuff from the environment so you need this wrapper script. Ensure it's executable with chmod +x whisper-wrapper

#!/bin/bash
source $HOME/.secure_env
/opt/homebrew/bin/python3 $HOME/scripts/whisper #note the location of python AND the script, you might have to adjust

Also: you need to name the Python executable path so it can pick up its dependencies.

Version 0.01h

Weakify and Strongify Macros for Objective-C

2023-06-23T20:44:01.951000Z

I worked with Chat to hammer these out. Not sure why everybody on the Internet suggests typeof but anyway...

The correct syntax is indeed __typeof(), not typeof(). The __typeof() keyword is a GCC extension which is supported by both GCC and LLVM/Clang compilers. It allows you to declare a variable of the same type as another variable.

And so...

// weakify: creates a new weak reference 'weakSelf' to the variable (helps avoid retain cycles)
// Usage: weakify(self)
#define weakify(var) __weak __typeof(var) weakSelf = var;

// strongify: creates a new strong reference 'strongSelf' from the weak reference (ensures object stays in memory during block execution)
// Usage: strongify(weakSelf)
#define strongify(var) __strong __typeof(var) strongSelf = var;

Managing Git Submodules Branches When Switching Branches

2023-06-18T23:03:27.995000Z

Is This Written by ChatGPT?

Well, it's not not written by ChatGPT. But it's a collab.

Problem

Working with git submodules presents a unique challenge: when switching branches in the superproject (the main project), the submodule's branch doesn't automatically change. Instead, it stays on the previously checked-out branch. This lack of tracking can lead to inconsistencies between the superproject and the submodule, resulting in confusion and potential issues.

Note About Submodules

Before we delve into the solution, let's clarify the typical use of git submodules. Submodules are designed to allow a Git repository to be a subdirectory of another Git repository, maintaining their commits separately. In essence, submodules pin a specific commit, not a branch, from an external repository into your primary repository.

Therefore, if your submodule's branch needs to track the branch of your main project, it might indicate that these two components should not be separate repositories. However, in certain cases where you find tracking branches useful, the following solution could serve your needs.

Solution

To ensure that the submodule changes to a corresponding branch when switching branches in the superproject, we can create two scripts: one to set (record) the current branch of the submodule when switching branches, and another to restore the submodule to its recorded branch when switching back.

Implementation

In the implementation, we create two Python scripts: git-submodule-branch-set and git-submodule-branch-restore. Here's how they work:

When switching branches in the superproject, run git-submodule-branch-set. This script traverses all submodules, recording their current branch by creating a file in the superproject's .git directory. The filename is a combination of the branch name of the superproject and the path to the submodule, and the file's content is the name of the branch the submodule is currently on.
After switching back to a previous branch in the superproject, run git-submodule-branch-restore. This script goes through all submodules, looking for a corresponding file in the .git directory. If it finds one, it reads the submodule's branch from the file and checks out the submodule to that branch.

git-submodule-branch-set

This script records the current branch of the submodule when you switch branches in the superproject.

#!/usr/bin/env python3
# git-submodule-branch-set

import os
import subprocess

# Get the list of all submodules in the current repository
submodules_output = subprocess.check_output(['git', 'config', '--file', '.gitmodules', '--get-regexp', 'path']).strip().decode('utf8')
submodules = [line.split()[1] for line in submodules_output.split('\n')]

# Get the current branch of the superproject
branch = subprocess.check_output(['git', 'rev-parse', '--abbrev-ref', 'HEAD']).strip().decode('utf8')

for submodule in submodules:
    # Construct the filename where the submodule branch will be stored
    submodule_branch_file = os.path.join('.git', f'submodule_branch_{branch}_{submodule.replace("/", "_")}')

    # Record the current branch of the submodule
    submodule_branch = subprocess.check_output(['git', '-C', submodule, 'rev-parse', '--abbrev-ref', 'HEAD']).strip().decode('utf8')
    with open(submodule_branch_file, 'w') as file:
        file.write(submodule_branch)
    print(f"Submodule '{submodule}' set to branch '{submodule_branch}'")

git-submodule-branch-restore

This script restores the submodule to the recorded branch when you switch back to a previous branch.

#!/usr/bin/env python3
# git-submodule-branch-restore

import os
import subprocess

# Get the list of all submodules in the current repository
submodules_output = subprocess.check_output(['git', 'config', '--file', '.gitmodules', '--get-regexp', 'path']).strip().decode('utf8')
submodules = [line.split()[1] for line in submodules_output.split('\n')]

# Get the current branch of the superproject
branch = subprocess.check_output(['git', 'rev-parse', '--abbrev-ref', 'HEAD']).strip().decode('utf8')

for submodule in submodules:
    # Construct the filename where the submodule branch will be stored
    submodule_branch_file = os.path.join('.git', f'submodule_branch_{branch}_{submodule.replace("/", "_")}')

    # If a file exists that records the branch of the submodule, checkout to that branch in the submodule
    if os.path.isfile(submodule_branch_file):
        with open(submodule_branch_file, 'r') as file:
            submodule_branch = file.read().strip()
        subprocess.check_call(['git', '-C', submodule, 'checkout', submodule_branch])
        print(f"Submodule '{submodule}' restored to branch '{submodule_branch}'")

Why I like Evernote more than Notion

2023-06-18T18:13:46.035000Z

[ TinyUrl link to this note ]

Notion has a whole bunch of concepts. There are lists! Which are not quite the same as pages, but they also are pages. But you can’t put text on them. And, it’s hard to put pages under them, even though lists only contain other pages. Also, you can’t just say "I am going to list all the pages under this page in this page as a list." So it’s very powerful, and very flexible. And you can have links, and back links, and everything can be in multiple places, and… Didn’t I already go through this with Workflowy? It’s so amazing, it’s so flexible, it’s just like your mind, which is amazingly flexible and allows for massive complexity.

Enter Evernote, with its antiquated simple concepts. You have notebooks that have pages in them. You also can have notebook stacks, which can only contain notebooks. You cannot have notebook stacks of notebooks stacks of notebooks. You cannot put notebooks in other notebooks, nor can you put pages directly in notebook stacks. There is no way that I know of to get a list of pages inside a notebook in another page. Unless you want a link to the pages yourself.

So the paradigm is extremely simple.

So for MIDI Designer, for instance, I have a Notebook stack called MIDI Designer. Then, inside that I have a notebook called MD tickets. And another notebook called MD tickets closed. And then I have another Notebook called MIDI Designer knowledge, or MIDI Designer K base. And then I have another Notebook called MIDI Designer marketing. If I was serious about marketing, that might become several notebooks.

And so, Evernote is the ultimate trash bin, but it’s very organized for how to record information. And where information will be later. For instance, for my day job, I have another notebook under the Day-Job Stack called meetings. and another notebook called journal, which contains notes by week, mostly.

Somehow, the simple paradigm lines up nicely and keeps me from feeling overwhelmed and confused. Notion, on the other hand, is so flexible I can never figure out where to go next, and definitely not quickly.

I should note that I do some things outside of Evernote. Or a lot of things. For instance, I use Microsoft To Do for my to do list. And that’s on top of my bullet journal that I keep in Notability on iPad with pencil. And then I have my journal in Day One. I should note that it's important to pick winners in other categories to avoid thrash. I had picked Wunderlist which became Microsoft To Do but... sniff.

Update

Things I do with Evernote that Notion doesn't do (I think):

I pay Evernote to be able to email notes to my Evernote notebooks.
Evernote can publish individual notes, which is how you're reading this.
I use Evernote to publish my blogs, including this one via Postach.io and some that are critical to my business. It's not perfect, clearly.

Things Evernote sucks at:

Their document scanner on iOS is the worst, but you can use Genius Scan.
Their Apple Pencil app also sucks but you can use any other.
They don't do great with code blocks, but at least they don't mangle things like OneNote
I haven't used Evernote much for collaboration, so I don't know how it does. It ain't Google Docs, that's for sure.

Swift Watch and Run

2023-06-18T18:13:01.044000Z

This is my Swift "run on change" watcher script.

#!/bin/sh
# swiftWatchAndRun
if [ $# -ne 1 ]; then
    echo "Use like this:"
    echo "   $0 filename-to-watch"
    exit 1
fi
if which fswatch >/dev/null; then
    echo "Watching swift file $1"
    while true; do fswatch --one-event $1 >/dev/null && echo "----------------"; echo `date +"%m-%d-%y %I:%M%p"`; echo "----------------" && swift $1; sleep 0.1; done
else
    echo "You might need to run: brew install fswatch"
fi

WeakArray for the Last Time (Swift 4.2)

2018-11-19T13:40:26.668000Z

I am obsessed with weak arrays. If you're trying to use multiple "protocolized" delegates, you need a weakly-held array of delegates.

This one started with this great article and expanded from there. Big thanks to Varindra Hart for the wise counsel as always.

@objc public protocol Equalable: class {
    @objc func isEqual(_ object: Any?) -> Bool
}

/// Store AnyObject subclasses weakly
/// * Note: if you wish to use a protocol, it must:
///   - be marked with `@objc`
///   - have all methods marked with `@objc`
///   - refine Equalable
public struct WeakArray<Element: Equalable> {
    private var items: [WeakBox<Element>] = []

    public init(_ elements: [Element]? = nil) {
        guard let elements = elements else { return }
        items = elements.map { WeakBox($0) }
    }

    public mutating func append(_ newElement: Element) {
        let box = WeakBox(newElement)
        items.append(box)
    }

    public mutating func remove(_ element: Element) {
        items.removeAll { item in
            return item.unbox?.isEqual(element) ?? false
        }
    }

    public var unboxed: [Element] {
        let filtered = items.filter { $0.unbox != nil }
        return filtered.compactMap { $0.unbox }
    }

    public var boxedCount: Int {
        return items.count
    }
}

extension WeakArray: Collection {
    public var startIndex: Int { return items.startIndex }
    public var endIndex: Int { return items.endIndex }

    public subscript(_ index: Int) -> Element? {
        return items[index].unbox
    }

    public func index(after idx: Int) -> Int {
        return items.index(after: idx)
    }
}

private final class WeakBox<T: Equalable> {
    weak var unbox: T?
    init(_ value: T) {
        unbox = value
    }
}

GitHub Gist

The need to have your protocol conform to @objc is a bug in Swift. See the StackOverflow question about this.

Modifiable: Modify and Assign without Temporary Variables

2018-06-17T13:46:19.472000Z

This Protocol & Extension allow you to assign and modify all in one line.

I've been meaning to write this for a long time. It's working in Swift 4.1. It's definitely a tiny bit tricky, definitely not necessary, and perhaps too cute to be worth it. But it is cute!

import UIKit

/// Modifiable, Dan Rosenstark 2018, inspired from:
/// https://medium.com/@victor.pavlychko/using-self-in-swift-class-extensions-6421dab02587
protocol Modifiable {}

extension NSObject: Modifiable {}

extension Modifiable {
    func modify(block: (Self)->()) -> Self {
        block(self)
        return self
    }
}

/// examples
let view = UIView().modify { $0.backgroundColor = .green }
print(view.backgroundColor == UIColor.green)

Xcodebuild: Valid Destinations on OSX?

2018-10-19T15:16:40.925000Z

To get a list of valid destinations, specify an erroneous key-value pair and xcodebuild will spit out the combinations that work.

List Destinations Command

xcodebuild test -destination 'platform=iOS Simulator' -workspace Register.xcworkspace -scheme ThatTestTarget

Output Example

Available destinations for the "ThatTestTarget" scheme:

{ platform:iOS Simulator, id:145A9B7E-B336-4819-8059-2FFEC408E05E, OS:11.1, name:iPad (5th generation) }
{ platform:iOS Simulator, id:69ABAF6F-ADA3-4E38-AC97-D71001447663, OS:9.3, name:iPad 2 }
{ platform:iOS Simulator, id:550E2F18-406D-4586-84BB-E48F1D704F27, OS:10.3.1, name:iPad Air }
{ platform:iOS Simulator, id:94734F1C-775F-40FA-9015-8196C08805EF, OS:11.1, name:iPad Air }
{ platform:iOS Simulator, id:1DB953DD-CD97-4EC7-8006-BCF01DF3E63F, OS:11.1, name:iPad Air 2 }
{ platform:iOS Simulator, id:DE3072DA-2E31-423D-9D77-220626F8B90A, OS:11.1, name:iPad Pro (9.7-inch) }
{ platform:iOS Simulator, id:3B5D18DB-13B5-4F28-B654-7D2ECDD1F6F0, OS:11.1, name:iPad Pro (10.5-inch) }
{ platform:iOS Simulator, id:A4225E3A-512C-4F42-ADD9-1E7E448C4D27, OS:11.1, name:iPad Pro (12.9-inch) }
{ platform:iOS Simulator, id:684FF1BA-8784-4B7C-B4E5-5231772F0FAC, OS:11.1, name:iPad Pro (12.9-inch) (2nd generation) }

Change Colons for Equals Signs, Remove Spaces, Ignore the ID

So if you want to use this destination:

platform:iOS Simulator, id:684FF1BA-8784-4B7C-B4E5-5231772F0FAC, OS:11.1, name:iPad Pro (12.9-inch) (2nd generation)

Change the colons for commas, remove the spaces, remove the ID, so you get this string:

platform=iOS Simulator,OS=11.1,name=iPad Pro (12.9-inch) (2nd generation)

Then the entire command would be:

xcodebuild test -destination 'platform=iOS Simulator,OS=11.1,name=iPad Pro (12.9-inch) (2nd generation)' -workspace Register.xcworkspace -scheme ThatTestTarget

From my StackOverflow Answer here

Square in Autolayout in Swift 3/4

2017-12-31T01:43:41.347000Z

Sometimes I marvel about how StackOverflow has been taken over by a zealous group of idiots who close questions at will. Here's today's example, and below is my answer, since I can't put it on the SO question itself.

extension UIView {
    func constrainToSquareRelativeToView(_ view: UIView, multiplier: CGFloat = 1.0) {
        translatesAutoresizingMaskIntoConstraints = false
        let widthConstraint = NSLayoutConstraint(item: self, attribute: .width, relatedBy: .lessThanOrEqual, toItem: view, attribute: .width, multiplier: multiplier, constant: 0)
        widthConstraint.priority = .defaultLow
        let heightConstraint = NSLayoutConstraint(item: self, attribute: .height, relatedBy: .equal, toItem: view, attribute: .height, multiplier: multiplier, constant: 0)
        heightConstraint.priority = .defaultLow
        let squareConstraint = NSLayoutConstraint(item: self, attribute: .height, relatedBy: .equal, toItem: self,    attribute: .width, multiplier: 1.0, constant: 0)
        let centerX = NSLayoutConstraint(item: self, attribute: .centerXWithinMargins, relatedBy: NSLayoutRelation.equal, toItem: view, attribute: .centerXWithinMargins, multiplier: 1, constant:0)
        let centerY = NSLayoutConstraint(item: self, attribute: .centerYWithinMargins, relatedBy: NSLayoutRelation.equal, toItem: view, attribute: .centerYWithinMargins, multiplier: 1, constant:0)
        view.addConstraints([widthConstraint, heightConstraint, squareConstraint, centerX, centerY])
    }
}

Here's my result (inside which I'm playing with a UICollectionView, but that's another story):

How I Survive on Any Unix (Bash)

2019-09-20T05:24:13.128000Z

If you must type it all

export EDITOR=nano
PS1='\h:\w\$ '

If you can copy and paste:

export EDITOR=nano


function parse_git_dirty {
  [[ $(git status 2> /dev/null | tail -n1) != "nothing to commit, working tree clean" ]] && echo "*"
}
function parse_git_branch {
  git branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e "s/* \(.*\)/(\1$(parse_git_dirty))/"
}
export PS1='\h:\[\033[1;33m\]\w\[\033[0m\]$(parse_git_branch)$ '

Solution for No Optionals in Swift String Interpolation

2017-12-31T01:47:40.042000Z

This is probably a bad idea, but it's fun to consider (for a brief moment).

// Solution is reduced from here
// https://github.com/T-Pham/NoOptionalInterpolation

/// Anything that can be unwrapped.
public protocol Unwrappable {
    
    /// Returns the unwrapped value of the receiver.
    func unwrap() -> Any?
}

extension Optional: Unwrappable {
    
    /// Returns the unwrapped value of the `Optional`.
    public func unwrap() -> Any? {
        switch self {
        case nil:
            return nil
        case let unwrappable as Unwrappable:
            return unwrappable.unwrap()
        case let any:
            return any
        }
    }
}


public extension String {
    
    /// Creates an instance containing the unwrappable's representation.
    init(stringInterpolationSegment expr: Unwrappable) {
        if let unwrapped = expr.unwrap() {
            self.init(stringInterpolationSegment: unwrapped)
        } else {
            self.init("nil")!
        }
    }
    
    init(stringInterpolationSegment expr: Optional<T>) {
        self.init(stringInterpolationSegment: expr as Unwrappable)
    }
    
}

/**
 Force the default behavior
 */
postfix operator *

public postfix func *(optional: Optional<Any>) -> String {
    if "\(optional)" == "nil" {
        return "nil"
    }
    return "Optional(\"\(optional)\")"
}

My Time/Datestamp Applescript

2023-06-22T21:28:03.403000Z

Original

Here's the .scpt file that will open in Script Editor on Mac. You can set it up as a keystroke (CMD-Shift-D for me) in FastScripts (free for up to 10 scripts).

-- yar2050 (Dan Rosenstark)'s favorite date format 
-- 2017-08-03 update
on fillInZero(int)
    if (int < 10) then set int to "0" & int
    return int as string
end fillInZero

set theDate to (current date)
set theHour to fillInZero(hours of (theDate) as integer)
set theMinutes to fillInZero(minutes of (theDate) as integer)
tell theDate to get (its month as integer)
set theMonth to fillInZero(result)
set theDay to fillInZero(day of theDate)
tell (theDate) to get (its year as integer) & "-" & (theMonth) & "-" & theDay & " " & (theHour) & ":" & theMinutes
set date_ to (result as string)
tell application "System Events"
    set frontmostApplication to name of the first process whose frontmost is true
end tell

tell application frontmostApplication
    delay 0.2 -- I have no idea why this is necessary
    activate
    tell application "System Events"
        if (frontmostApplication = "Evernote") then
            keystroke "h" using {command down, shift down}
            keystroke "b" using {command down}
            keystroke date_
            keystroke "b" using {command down}
        else
            keystroke date_
        end if
    end tell
end tell

2023-06 - Update

Working with ChatGPT we came up with this. Much better.

set formattedDate to do shell script "date '+%Y-%m-%d %H:%M'"

tell application "System Events"
    keystroke formattedDate
end tell

-- display alert "AppleScript is working" message "Date: " & formattedDate

Just Because It Compiles: More Notes from Swift 3 Upgrade

2017-10-05T15:14:54.043000Z

This is the method signature for the superclass:

public func sendRequest<T: Request>(request: T, handler: (Result<T.Response, Error>) -> Void) -> NSURLSessionDataTask? {

and this is in the subclass

override func sendRequest<T : RequestType>(request: T, handler: (Result<T.Response, PayLib.Error>) -> Void) -> NSURLSessionDataTask? {

and in Swift 3 this got translated to be the same, except for some minor changes:

open func sendRequest<T: Request>(_ request: T, handler: @escaping (Result<T.Response, Error>) -> Void) -> URLSessionDataTask? {

Subclass:

override func sendRequest<T : RequestType>(_ request: T, handler: @escaping (Result<T.Response, PayLib.Error>) -> Void) -> URLSessionDataTask? ```

Now that was good enough for Swift 2. In Swift 3, a call to this method resulted in a crash with no interesting information.

The reason was the mismatch between RequestType and Request (RequestType is the protocol which the Request Protocol extends). So the fix was merely to have the signatures match exactly.

override func sendRequest<T : Request>(_ request: T, handler: @escaping (Result<T.Response, PayLib.Error>) -> Void) -> URLSessionDataTask? {

I'm not sure that there's a point here, except that: Just because Xcode likes it, it compiles and it works in Swift 2 doesn't mean that it won't cause a runtime crash in Swift 3. Or something like that: check everything by hand/eye!

Change Shortcuts for Next and Previous Tab in Safari, Mac

2017-10-04T18:19:47.470000Z

Show Only Apps in Search Results, iOS 11

2017-09-30T13:16:54.399000Z

I want my iPad (and iPhone) to show Apps first when I hit CMD-space or slide down for search. This is the setting to change.

And this is what search results look like without all the clutter.

Optional Block Parameters and Fix-Its

2017-09-19T10:38:31.795000Z

Consider this fix-it:

Now if this happens to you -- as it happened to me -- as part of a massive code conversion to Swift 3, you might be tempted to follow the fix it. Then your code would read like this:

var blockWithOptionalParam: ((NSString?)->())?

func assignBlockWithNonOptionalParameter() {
    let tempBlock: (NSString)->() = {
        print("count of string \($0.appending("appendMe"))")
    }
    blockWithOptionalParam = tempBlock as! ((NSString?) -> ())
}

This might be fine, but would result in a crash if you ever passed a nil to your blockWithOptionalParam. The only safe thing to do, really, is to ignore the fix it and handle the optional properly:

func assignBlockWithNonOptionalParameter() {
    let tempBlock: (NSString?)->() = {
        guard let text = $0 else { return }
        print("count of string \(text.appending("appendMe"))")
    }
    blockWithOptionalParam = tempBlock
}

So What?

For some other cases -- and I'm not sure what the difference is, yet -- Xcode always suggests casting the block rather than fixing the optional in the block. I'm unable to show this example in the lab, but it does show up in the codebase I'm working on currently.

Enabling Command-Line Pipe for Atom on OS X

2018-02-15T16:55:30.034000Z

Pipe to Atom Command-Line Tools

This allows you to pipe from the command line to Atom. Simplest example:

ls -l | atom

Set It Up

Make sure you've run File -> Install Shell Commands first.

Edit your /usr/local/bin/atom (in Atom, for instance):

atom /usr/local/bin/atom

Below this code:

if [ $REDIRECT_STDERR ]; then
  exec 2> /dev/null
fi

insert this code

if [ ! -t 0 ]; then
   TEMPFILE="$(mktemp)"
   cat > "$TEMPFILE"
   set "$TEMPFILE" "$@"
fi

Save the file and now piping should work.

This comment is also on GitHub here.

2018-02-15: Update

This does tend to break from time to time (perhaps on Atom update?). You'll need to reapply.

* osx os x macos

Breakpoint Swift Deinit in Xcode

2017-09-12T10:51:18.625000Z

Setting up the Breakpoint

It's actually very simple to breakpoint the deinit method of a Swift class. Given a class called Test47, the symbolic breakpoint merely looks like this:

And that's about it.

Notes

If there is no body to your deinit method, the breakpoint will not fire (it gets optimized out or something similar).
There is no difference in syntax, for the Xcode symbolic breakpoints, between class and instance methods.
There are no deinit methods for structs, so your SOL on that one.

Swift 3.x Calls Objective-C

2017-11-13T20:19:30.762000Z

Maybe you or a colleague named a constant with PascalCase in an Objective-C method (class or like this:

+ (UIColor *)SKDarkBlue;

and in Swift 2, you could call it easily with

self.checkStateBand.backgroundColor = UIColor.SKDarkBlue;

But in Swift 3, the casing is automatically changed for you... isn't that nice!?

self.checkStateBand.backgroundColor = UIColor.skDarkBlue;

This example is great because you can see what happens to two initial caps.

What if it's just one?

- (void) FirstCapMethod;

looks like this in Swift 3:

ObjCObject().firstCapMethod()

Fun!

Does Your Constant End in Notification?

Objective-C Notification

extern NSString * const SKMagTekSwiperDisconnectedNotification;

Gets called like this from Swift

let someNotification = NSNotification.Name.SKMagTekSwiperDisconnected

Swift and Object-C Interop, Simplest Possible Example

2017-09-08T15:27:07.182000Z

Start with a Single View App (Swift) in Xcode 9 Beta 6 called SwiftObjCInterop.

Swift Calls Objective-C

Create an Objective-C Class

Create an Objective-C class called ObjCObject

This will automatically give you the Bridging Header to call the Objective-C from Swift (that was easy!):

Select Create Bridging Header which will produce the file SwiftObjCInterop-Bridging-Header

Add a Method to `ObjCObject`

Add a method like this in your .m file

- (void) test {
    NSLog(@"Yes we are ObjCObject and we are testing");
}

and this in your .h

- (void) test;

Add ObjCObject to your Bridging Header

#import "ObjCObject.h"

Test Swift Calls Objective-C

Put this in your viewDidLoad:

ObjCObject().test()

Run the project. Now Swift calls Objective-C.

Objective-C Calls Swift

This is slightly trickier in an existing project, but in a new project there are no issues.

Include this in your ViewController.swift file:

@objc(testSwift)
func testSwift() {
    print("yes ViewController is printing")
}

For some reason, you need the @objC tag to be able to see your method from Objective-C.

Include this import in your .m file:

#import "SwiftObjCInterop-Swift.h"

And add this to your test method in your Objective-C class:

ViewController *vc = [[ViewController alloc] init];
[vc testSwift];

That's it.

Using Markdown with Postach.io

2017-09-12T14:00:36.276000Z

Hello World!!!

This HTML is highlighted with Prism using code marks for the highlighting like language-html

<!DOCTYPE html>
<html>
<head>
   ...
   <link href="themes/prism.css" rel="stylesheet" />
</head>
<body>
   ...
   <script src="prism.js"></script>
</body>
</html>

Why Bother?

I do love my work on code highlighting in Evernote. But this markdown stuff may be cooler? Hard to decide. With Markdown, it's definitely more flexible to pop out to a text editor and then back in.

[Testing edit from iPad... just added this]

Are there extra lines or not?

let stringSet = Set(["car", "boat", "bike", "toy"])
let stringArray = stringSet.sorted()

print(stringArray)
// will print ["bike", "boat", "car", "toy"]

Okay, the extra lines are only there if you switch the format using Make Plain Text. Do NOT use Make Plain Text, and always use Simplify Formatting

What About Embeds?

Will Postachio deal with the embeds, still?

[So this embed got removed because I edited this note on iPad... so that's an issue. Maybe a big issue?]

OMG that's absolutely awesome. Which means you could also do iframes and probably even random html.

Lazy Array in Swift

2017-08-19T19:58:17.791000Z

Obviously if you google "lazy array in Swift," you'll find out the right way to do this, which uses NSPointerArray and whatever else. As you should.

But sometimes you want to make your own to see how far you can get in half an hour with generics. Here's my naive implementation.

import Foundation

private class WeakWrapperAnyObject> {
    weak var thing: T?
    
    init(_ thing:T) {
        self.thing = thing
    }
}

struct WeakArrayAnyObject> : Sequence {
    
    private var array: [WeakWrapper<T>] = []
    var count: Int { return objects.count }
    
    init(_ objects: [T]) {
        append(objects)
    }
    
    var objects: [T] {
        get {
            let retVal: [T?] = array.map { $0.thing != nil ? $0.thing : nil }
            return retVal.flatMap { $0 }
        }
    }
    
    mutating func append(_ object: T) {
        array.append(WeakWrapper(object))
    }
    
    mutating func append(_ objects: [T]) {
        array.append(contentsOf: objects.map { WeakWrapper($0) })
    }
    
    mutating func compress() {
        array = array.filter{ $0.thing != nil }
    }
    
    // MARK: - Sequence Protocol methods 
    
    typealias Iterator = IndexingIterator<Array<T>>
    
    func makeIterator() -> Iterator {
        return objects.makeIterator()
    }
}

let firstObject = NSString(string: "one")
 
var things = WeakArray([firstObject, NSString(string: "two"), NSString(string: "three")])
 
things.count
 
for thing in things {
    print("Just one \(thing)")
}
 
things.compress()

Of course, I did have to look some stuff up, particularly to understand how easy Sequence was to implement (since I already have an array).

Method Selection in Swift

2017-08-19T18:22:50.388000Z

When I was growing up, methods were selected based solely on the stuff on the right side of the equals sign. Not so in Swift. Consider this example.

class ThingWithTwoSameNamedMethods {
    func doIt() {
        let h: Int = doIt()
        print("thank you for calling outer doit \(h)")
    }

    func doIt() -> Int {
        return 32
    }
}

let _: Void = ThingWithTwoSameNamedMethods().doIt()
let someInt: Int = ThingWithTwoSameNamedMethods().doIt()
let sum = ThingWithTwoSameNamedMethods().doIt() + 4

If this doesn't scare you, it should, because like most things in Swift: if it's compiling, it's wonderful. But if it's not compiling, for any reason, method selection and typing information is just not there... and you cannot infer it.

Code Blocks in Postachio

2017-09-12T14:10:20.669000Z

My final CSS (which is linked from this blog):

/** this is for the markdown stuff **/
:not(pre) > code[class*="language-"], pre[class*="language-"] {
    border: 1px solid gray;
    border-radius: 5px;
    background-color: #ffffe0;
}


/** non-markdown background and border **/
div[style*="box-sizing: border-box;"] {
   background-color: #ffffe0;
   border: 1px solid gray;
   border-radius: 5px;
}

/** non-markdown indention **/
div[style*="box-sizing: border-box;"] div {
    margin: 0px;
    padding: 5px !important;
    overflow: auto;
    white-space: pre-wrap;
}

/** non-markdown line-height consistency **/
div[style*="box-sizing: border-box;"] div,
div[style*="box-sizing: border-box;"] div span,
div[style*="box-sizing: border-box;"] div span  {
    line-height: 15px;
    font-size: 14px;
    font-family: Monaco, Menlo, Consolas, monospace;
}

div.posts div.item .post-content p,
div.posts div.item .post-content div,
.post-content div {
  line-height: 1em !important;
  margin-top: .25em;
  margin-bottom: .25em;
  padding-top: 0px;
  padding-bottom: 0px;
}

.post-content div div {
    margin: 1px !important;
padding: 1px !important;
}

/** markdown **/
.post-content p {
    background-color: white;
    line-height: 1em !important;
    margin-top: .5em !important;
    margin-bottom: 1em !important;
    padding: 0px;
}

div.posts h3, div.post-content h3 {
    position: relative;
    padding: 0 0 12.5px 0;
    margin: 0;
    font-size: 1.55rem;
    font-family: 'Roboto';
    font-weight: 300;
    color: #0e3029;
}

Which works with this solution in Evernote and this other solution using Markdown in Postachio (make sure to use languages like language-swift for your code blocks to activate Prism).

Also note Elliot's solution here, which attacks this whole problem from another side.

Swift 2 to 3, Method Calls, Magic First Parameters & Automatic Conversion Woes

2017-08-22T01:17:07.104000Z

Swift 2 Calling Swift 2

Consider these two methods in Swift 2:

func doThis(thing: AnyObject) {}

func doThisThing(thing thing: AnyObject) {}

are called like this in Swift 2.

doThis("")

doThisThing(thing: "")

So:

The first parameter in the doThis method cannot be named by the caller.
Whether the method name ends in the first parameter name or not, the behavior doesn't change.

Swift 2 Calling Objective-C

Here are two methods in Objective-C:

- (void) doIt:(NSObject *)thing;

- (void) doThisThing:(NSObject *)thing;

Both of these methods get called without their first parameter name from Swift 2:

someObjcObject.doIt("")

someObjcObject.doThisThing("")

So:

First parameter name is not used.
The method name is the same as the method name in Objective-C.
This is true even if the method end in an obvious parameter name, like "doThisWithThing"

Objective-C Calling Swift 2

The method name is the same as that seen in Swift unless you've doubled up on the parameter name as in the above example. So:

func doThis(thing: AnyObject) {}

func doThisThing(thing thing: AnyObject) {}

results in this calling code in Objective-C (note the altered method name in the second example):

[vc doThis:@""];

[vc doThisThingWithThing:@""];

The first method doesn't change even if we use an underscore in the Swift method declaration:

func doThis(_ thing: AnyObject) {}

So:

The method names translate normally
Doubled-up parameter names get added to the method name in Objective-C with the conjunction "with"

Changes in Swift 3

There is no automatic removal of the first parameter name, so:

func doThisThing(thing: AnyObject) {}

gets called like this:

doThisThing(thing: "" as AnyObject)

If you want to remove the first parameter label for callers, you can use an underscore, of course.

Weird Automatic Conversion to Swift 3

So this converted just fine:

func doThis(thing: AnyObject) {}

func doThisThing(thing thing: AnyObject) {}

// calling code
doThisThing(thing: "what")
doThis("what")

and became this in Swift 3

func doThisThing(thing: AnyObject) {}

func doThis(_ thing: AnyObject) {}

// calling code
doThisThing(thing: "what" as AnyObject)
doThis("what" as AnyObject)

So that makes sense.

Converting Again

Now you realize that your massive conversion needs to forward merge more Swift 2 code into the same target. Xcode warns you not to do automatic conversion again, but you do it anyway.

The two methods now look like this, which makes no sense (the second one has now lost its parameter label):

func doThisThing(_ thing: AnyObject) {
    print("doThisThing \(thing.hash)")
}

func doThis(_ thing: AnyObject) {
    print("doThis \(thing.hash)")
}

// calling code
doThisThing("what" as AnyObject)
doThis("what" as AnyObject)

In this simple case the callers get updated, but the Objective-C callers do not:

And in many cases, your calling code will be broken in Swift as well.

Calling Objective-C from Swift 2 vs. 3

The automatic madness deepens with Swift 3 interop.

Consider this signature in Objective-C:

+ (NSObject *)deserializeNewOrExistingObjectFromAPIV1JSON:(NSDictionary *)json

In Swift 2 you called it this way:

ThatObject.deserializeNewOrExistingObjectFromAPIV1JSON(json.dictionaryObject)

But this changes in Swift 3 to:

ThatObject.deserializeNewOrExistingObject(fromAPIV1JSON: json.dictionaryObject)

And now the result comes back as a forced optional, whereas in Swift 2 it came back as a non-optional.

Which may or may not get picked up by the automatic converter. The more complex your compilation target is, the less likely the automatic conversion is to succeed.

Some capitalization changes as Objective-C gets magically converted:

- (instancetype)initWithJSON:(NSDictionary *)messageBody

// Swift 2
ThatObject(JSON: dict)!

// Swift 3
ThatObject(json: dict)

And some stuff gets even weirder in Objective-C interop:

+ (id)findForUuid:(NSString *)uuid

// Swift 2
ThatObject.findForUuid(uuid)

// Swift 3
ThatObject.find(forUuid: tender.uuid)!

Code Highlighting in Evernote... Kinda

2017-09-12T14:02:44.230000Z

A while back, Evernote for Mac added Code Blocks. To enable this feature, you cannot use the App Store version of Evernote.

In addition, you have to check Enable Code Block in Preferences

Code blocks were okay, allowing you to do nice simple stuff maintaining your plain text formatting like this:

    func commonInit() {
        self.backgroundColor = UIColor.black;
        let imageView = UIImageView(image: UIImage(named: "splash.png")!)
        imageView.contentMode = .scaleAspectFit
        self.addSubview(imageView)
        constrain(self, imageView) { me, imageView  in
            imageView.size == me.size
            imageView.center == me.center
        }
    }

But there was no way to keep your colored syntax formatting (from Xcode, App Code and others) until Evernote 6.11 for Mac (or sometime like that).

Here's how to do it:

Type one line of text
Turn that into a code block
Replace the contents of that code block with code you paste from Xcode
That's it!

Stubbed Code Block

Stub a code block

Stubbed Code Block, Content Replaced

func commonInit() {
    self.backgroundColor = UIColor.black;
    let imageView = UIImageView(image: UIImage(named: "splash.png")!)
    imageView.contentMode = .scaleAspectFit
    self.addSubview(imageView)
    constrain(self, imageView) { me, imageView  in
        imageView.size == me.size
        imageView.center == me.center
    }
}

In Atom: Use Copy as RTF

The Copy as RTF package in Atom will make this work there too. Fun!

Associated Object Support for Swift 2.3

2017-08-19T14:04:35.079000Z

This is your AssociatedObjectSupport.swift. It's for Swift 2.3 and it's based on this. It can handles nulls, and non-objects, too (by wrapping them in Lifted).

import UIKit

final class Lifted {
    let value: Any
    init(_ x: Any) {
        value = x
    }
}

extension NSObject {
    func setAssociatedObject(value: T, associativeKey: UnsafePointer<Void>, policy: objc_AssociationPolicy = .OBJC_ASSOCIATION_RETAIN_NONATOMIC) {
        if let v: AnyObject = value as? AnyObject {
            objc_setAssociatedObject(self, associativeKey, v,  policy)
        }
        else {
            let liftedObject = Lifted(value)
            objc_setAssociatedObject(self, associativeKey, liftedObject,  policy)
        }
    }
    
    func getAssociatedObject(associativeKey: UnsafePointer<Void>) -> T? {
        let value = objc_getAssociatedObject(self, associativeKey)
        if let value = value as? Lifted {
            return value.value as? T
        }
        return value as? T
    }
}

Example UIView Extension

And here's an example extension to UIView that uses it. Note the clever use of a private struct to get static variables on the Extension nicely.

extension UIView {    
    private struct AssociatedKeys {
        static var viewExtension = "viewExtension"
        static var anotherView = "someOtherView"
        static var someFloat = "someFloat"
    }
        
    var someFloat: Float {
        get {
            return getAssociatedObject(&AssociatedKeys.someFloat) ?? 0.0
        }
        set {
            setAssociatedObject(newValue, associativeKey: &AssociatedKeys.someFloat)
        }
    }
    
    var baseTransform: CGAffineTransform? {
        get {
            return getAssociatedObject(&AssociatedKeys.viewExtension)
        }
        set {
            setAssociatedObject(newValue, associativeKey: &AssociatedKeys.viewExtension)
        }
    }
    
    var anotherView: UIView? {
        get {
            return getAssociatedObject(&AssociatedKeys.anotherView)
        }
        
        set {
            setAssociatedObject(newValue, associativeKey: &AssociatedKeys.anotherView)
        }
    }
}


Using the Example

var view = UIView()
view.baseTransform = CGAffineTransformIdentity
print("what's up \(view.baseTransform)")
view.baseTransform = nil
print("what's up \(view.baseTransform == nil)")
view.anotherView = UIView()
print("you got another view? \(view.anotherView)   \(view.anotherView?.anotherView)")
view.anotherView = nil
view.someFloat = 32.5
print("what's it? \(view.someFloat)")

Associated Object Support for Swift 3.x

2017-08-25T15:34:19.609000Z

Of course in Swift 3, this is all trivial... but plus, if you're not using self, why bother? (Credit to this Swift 2.x example)

extension NSObject {
    func setAssociated(value: T, associativeKey: UnsafeRawPointer, policy: objc_AssociationPolicy = .OBJC_ASSOCIATION_RETAIN_NONATOMIC) {
        objc_setAssociatedObject(self, associativeKey, value,  policy)
    }

    func getAssociated(associativeKey: UnsafeRawPointer) -> T? {
        let value = objc_getAssociatedObject(self, associativeKey)
        return value as? T
    }
}

extension UIView {
    
    private struct AssociatedKeys {
        static var viewExtension = "viewExtension"
        static var anotherView = "someOtherView"
        static var someFloat = "someFloat"
    }
    
    var someFloat: Float {
        get {
            return getAssociated(associativeKey: &AssociatedKeys.someFloat) ?? 0.0
        }
        set {
            setAssociated(value: newValue, associativeKey: &AssociatedKeys.someFloat)
        }
    }
    
    var baseTransform: CGAffineTransform? {
        get {
            return getAssociated(associativeKey: &AssociatedKeys.viewExtension)
        }
        set {
            setAssociated(value: newValue, associativeKey: &AssociatedKeys.viewExtension)
        }
    }
    
    var anotherView: UIView? {
        get {
            return getAssociated(associativeKey: &AssociatedKeys.anotherView)
        }
        
        set {
            setAssociated(value: newValue, associativeKey: &AssociatedKeys.anotherView)
        }
    }
}

var view = UIView()
view.baseTransform = CGAffineTransform.identity
print("what's up \(view.baseTransform)")
view.baseTransform = nil
print("what's up \(view.baseTransform == nil)")
view.anotherView = UIView()
print("you got another view? \(view.anotherView)   \(view.anotherView?.anotherView)")
view.anotherView = nil
view.someFloat = 32.5
print("what's it? \(view.someFloat)")

My own notes: you cannot get proper weak object support with Associated Objects, so only use them if you do not extend the actual class yourself.

Later Note

That's really not true: by wrapping your object in a Weak wrapping object, you can always get weak object support. So that's quite cool.

Subprojects in Xcode with Static Libs

2017-08-17T18:17:11.894000Z

Static libraries produce .a files. The catch is: static libraries cannot contain Swift files. But anyway...

Workspaces and Projects

You can add projects to projects (subprojects) or to workspaces
Projects can be saved as workspaces
Add a project to another project -- or a workspaces -- by adding the .xcodeproj file.

Early Setup

Add GBDevice as a submodule

git submodule add https://github.com/lmirosevic/GBDeviceInfo.git GBDeviceInfo

Set It Up

Create a new, Single View Application for iOS
Add the .xcodeproj for an Xcode project that produces a .a file

In this example we're using GBDevice.
Set up the primary project like this

Import Objective-C to Swift

Create a new header file called BridgingHeader.h
Add it to the Build Settings for the Single Window App
Utilize it in a Swift file

let version = GBDeviceInfo.init().modelString
print(version)
That's it.

The kicker is: you cannot use Swift in a static library, so there's that. Hence this other article I wrote (longer, and uses Cocoapods)

Hangouts, Spaces on OSX

2017-08-17T18:17:10.413000Z

So this frustration has existed since Mavericks:

Chrome apps (incl. Hangouts) don't play well with OSX Spaces

The answer is in the Hangouts App itself... shut this option off.

Focusrite Saffire MixControl for Scarlett 18i8

2017-08-17T18:17:11.092000Z

I was baffled trying to figure out the MixControl, but it's actually quite amazing. Using Mixes as an intermediate bus point (is that right?) is awesome.

SOME INSTRUCTIONS

Define Your Mixes

You have four mixes that you can use:

Left: 1, 3, 5 7
Right ones cannot be configured separately: 2, 4, 6, 8
You can rename the mix

At the top you're configuring which inputs go into the Mix.

Note that the stereo button "aggregates the 2 mono channels together into a single stereo"

Analog Ins
- from Front Panel: 1 and 2, 3 and 4
- from Back Panel: 5 and 6, 7 and 8
Daw Inputs: 1 to 7 (L) and 2-8 (R)

These are your DAW output destinations, exactly as labeled.
SPDIF and ADAT

Mix Output

You can use the Mix Output dropdown to define where the Mix outputs
Note for Headphone Outputs on Front Panel
- Line H/P L and R are called "Output 3" and "Output 4" in the Routing Panel
- Anlg Out 5 and 6 are called "Output 5" and "Output 6" in the Routing Panel

Routing Panel

You can use the routing panel to route individual inputs OR mixes to each output.
Monitor Outputs 1 and 2 are in back
The ones that show a little headphone are the front panel headphone mixes: 1-2 and 3-4

Dan Says

Name your mixes
Do not route inputs to outputs directly: instead, use mixes
Do not use the Routing Panel: use the checkboxes in the Mix Output to define the routing
Note: using the checkboxes in the Mix Output requires setting both L and R channels of the Mix Output, so you have to check all boxes separately.

Also see the Manual Online

Postach.io Embeds

2017-08-19T17:00:50.613000Z

Postachio can embed most of what I need. All the embed codes are here, and note you can use an iFrame directly.

SOME EXAMPLES

Test This: Workflowy

This is a simple iframe, width is 100%, height is 700, frameborder is 0. I'm using http instead of https for the src URL. Still not sure how to escape the HTML so I can show it to you. Using the entities for less than and greater than doesn't work.

Soundcloud

Gist

YouTube

Test This

Test This: Hiding

Using simple HTML comments to hide stuff works well!

Hollow Circle with CoreDrawing and Swift

2017-08-17T18:17:11.367000Z

Thanks to Paintcode and a bit of thinking on my part, I was able to put my one-method-to-rule-them-all together. It draws a variable-size donut with a variable angle. The drawShadow bit is still in progress.

Importing Swift to Objective-C, Multiple Modules

2017-08-17T18:17:11.927000Z

This goes by Module (i.e., target), not by project (ignore the confusion on the Internet).

So in my MIDI Designer project, which includes several targets, we change the generated name for all the modules, stored in the Objective-C Generated Interface Header Name property, from

$(SWIFT_MODULE_NAME)-Swift.h

MidiDesignerAllTargets-Swift.h

Then in each Objective-C class, you can import directly in the .m like this:

#import "MidiDesignerAllTargets-Swift.h"

Make sure to keep the name of your global import handy!

Dynamic Instantiation of Swift Classes and Interface Builder

Most of the time, it's enough for a Swift class to inherit NSObject to be able to be used from Objective-C.

For dynamic instantiation and, more importantly, use in Interface Builder, you need to specify the class' name explicitly using @objc. For example:

@objc(SliderV2)

class SliderV2: Slider {

Additional Notes

You can't see the header at all? It's not being generated? This answer has your back. Basically you need to:

Define a Product Module Name (no spaces) for the Project
Set Defines Module must be set to Yes in Build Settings, under Packaging

In Xcode 8, the Objective-C Generated Interface Header Name will be under Swift Compiler, General. Same same.

Password Assistant on OSX

2017-08-17T18:17:10.762000Z

Well, this is one terrible way to import from Blogger to Postach.io... definitely not ideal.

Scheme for Pragma Mark Organization in Objective-C

2018-05-28T14:53:41.599000Z

Here's an article that I wrote in 2012 for myself...

If you want to be like all the smart people you read about on the Internet, you'll keep your files really well-organized. If you have such long files that you need to use pragma marks (which some people, including Jeff Atwood, I recall, think means that your files are too long) you have a basic organizational problem. Now the solution to this is, of course, "bust the file up into sections and stick to those." But what would those sections be? So I'm usually going by functionality, but then I inevitably lose it and end up with no organization at all, or (worse) using it in half the file.

The reason that I failed is that I cannot use a scheme that requires you to know what each method does. That's very time-consuming and, in a sense, redundant with the messages you see passed in the code.

So here's my new scheme, which is very easy to use because it doesn't require you to think. I've been trying this for a while and it's great.

#pragma mark - class methods 

#pragma mark - initializers, dealloc, and lifecycle methods 

   // like didMoveToSuperview 

#pragma mark - property accessors 

#pragma mark - public overrides 

#pragma mark - public property accessor overrides 

#pragma mark - public methods 

#pragma mark - protocol A methods 

#pragma mark - protocol B methods 

#pragma mark - dependent-object lifecycle 

   // like viewDidLoad, viewDidAppear, etc., NOT like hideView 

#pragma mark - Methods not in public interface 

#pragma mark - Not Implemented