Khan's Blog

Using OpenType Attributes with UIFont

2026-02-06T06:00:00.000Z

OpenType Features

Modern fonts come with hidden attributes that modify their look in subtle ways. Some examples are making the 4 glyph have an open back, making the 6 and 9 glyphs have straight tails rather than curved, and many more.

On the web, you can activate these features with well-defined, documented, CSS modifiers. It's very easy to load in a font, say you want the alternate G glyph, and move on! Here's the very lengthy documentation from Mozilla for that.

I've used these features a couple of times previously, once for replicating the beautiful typography that Xcode uses for its line number gutter. A while ago, for CodeEdit, we were stumped as to how Xcode was making their line number font have open fours, straight tailed sixes and nines, until we found the following in a different open-source project.

func rulerFont() -> NSFont {
    /// Set the open four
    let alt4: [NSFontDescriptor.FeatureKey: Int] = [
        .selectorIdentifier: kStylisticAltOneOnSelector,
        .typeIdentifier: kStylisticAlternativesType
    ]
    
    /// Set alternate styling for 6 and 9
    let alt6and9: [NSFontDescriptor.FeatureKey: Int] = [
        .selectorIdentifier: kStylisticAltTwoOnSelector,
        .typeIdentifier: kStylisticAlternativesType
    ]
    
    let features = [alt4, alt6and9]
    let descriptor = font.fontDescriptor.addingAttributes([.featureSettings: features, .fixedAdvance: fontAdvance])
    return NSFont(descriptor: descriptor, size: 0) ?? font
}

We were not OpenType experts, so this tipped us off that we were missing something. This led us down a rabbit hole of figuring out exactly what the font was, including what features, attributes, and sizes it had until we had it perfect.

Eventually we were able to perfectly replicate the Xcode font, it's hilariously specific but pixel perfect, check it out.

This still left me wondering how I could find what features a font supported, or how in the world you could find those seemingly random C identifiers.

Finding Which Features a Font Supports

I'm now working on a version 2.0 of my budgeting app OpenBudget, and while designing in Sketch I found that to make some small currency labels legible, I wanted three specific OpenType features:

Open Currency.
Open Fours.
Straight Six and Nine.

Sketch handily lets you view all the available options for a font in a nice menu with labels and checkboxes. However, if you try and google "UIFont OpenType Open Four" you'll be sorely disappointed. I knew that CoreText had constants somewhere for each feature, but looking up the CoreText headers yields a list of undocumented constants. As it turns out Apple's CoreType predates OpenType, so the identifiers don't match to what OpenType calls them and Apple has no documentation for what each of them do.

Eventually I stumbled upon the CoreText documentation for font features and found the following magical CoreText function.

func CTFontCopyFeatures(_ font: CTFont) -> CTArray?

Every font in Cocoa stores a list of every supported feature in their features array. If you pass a UIFont or NSFont to this function (thank goodness for class bridging) you'll find a map like the following.

{
    CTFeatureTypeIdentifier = 35;
    CTFeatureTypeName = "Alternative Stylistic Sets";
    CTFeatureTypeSelectors =     (
                {
            CTFeatureOpenTypeTag = ss01;
            CTFeatureOpenTypeValue = 1;
            CTFeatureSelectorIdentifier = 2;
            CTFeatureSelectorName = "Straight-sided six and nine";
        },
                {
            CTFeatureOpenTypeTag = ss02;
            CTFeatureOpenTypeValue = 1;
            CTFeatureSelectorIdentifier = 4;
            CTFeatureSelectorName = "Open four";
        },
                {
            CTFeatureOpenTypeTag = ss03;
            CTFeatureOpenTypeValue = 1;
            CTFeatureSelectorIdentifier = 6;
            CTFeatureSelectorName = "Vertically centered colon";
        },
                {
            CTFeatureOpenTypeTag = ss04;
            CTFeatureOpenTypeValue = 1;
            CTFeatureSelectorIdentifier = 8;
            CTFeatureSelectorName = "Open currencies";
        },
    );
},

You may note here, that these labels indicate these constants are exactly what I'm looking for.

Mapping Selectors To Identifiers To UIFont

Now, if you take the map you printed from your font and try to put it into a features array, you'll quickly realize that you don't have a whole lot of information. Here's how to read that map to find exactly what to put in your Swift code.

For creating a UIFont or NSFont, we need to create an array of attribute dictionaries. Here's what they look like.

let attribute: [UIFontDescriptor.FeatureKey: Int] = [
    .type: // The type of attribute we're adding
    .selector: // What option we're enabling (or disabling) on the type.
]

For NSFont, the type and selectors are named selectorIdentifier and typeIdentifier.

Features With Unnamed Constants

You'll see the top-level dictionary here has a CTFeatureTypeIdentifier key. This key maps to the "Feature types" enum from those CoreText headers I referenced earlier. That's the .type we're looking for. To find the selector, we'll take a look at the CTFeatureOpenTypeTag. The CTFeatureOpenTypeTag (if it's available on your feature) maps to a constant we can provide to CoreText to indicate if we want the feature on or off. That constant looks like:

kStylisticAlt[Number][On/Off]Selector

If we look at the map from earlier, to enable "Open currencies" we have the dictionary:

{
    CTFeatureOpenTypeTag = ss04;
    CTFeatureOpenTypeValue = 1;
    CTFeatureSelectorIdentifier = 8;
    CTFeatureSelectorName = "Open currencies";
},

So we'll want the fourth selector, and we'll want it on. So we get the constant.

kStylisticAltFourOnSelector

And we already determined the type from the parent (number 35) which maps to the kStylisticAlternativesType constant in the CoreText headers. Combining this gives us the resulting Swift dictionary.

let altCurrency: [UIFontDescriptor.FeatureKey: Int] = [
    .selector: kStylisticAltFourOnSelector,
    .type: kStylisticAlternativesType
]

Features With Named Constants

There's a second case here, you'll likely see other font features that don't have the number-based constants. Instead, those dictionaries will look like:

{
    CTFeatureTypeExclusive = 1;
    CTFeatureTypeIdentifier = 37;
    CTFeatureTypeName = "Lower Case";
    CTFeatureTypeSelectors =     (
                {
            CTFeatureSelectorDefault = 1;
            CTFeatureSelectorIdentifier = 0;
            CTFeatureSelectorName = Default;
        },
                {
            CTFeatureOpenTypeTag = smcp;
            CTFeatureOpenTypeValue = 1;
            CTFeatureSelectorIdentifier = 1;
            CTFeatureSelectorName = "Small Capitals";
        }
    );
},

For these, head to the CoreText headers, find your type constant (37 here, kLowerCaseType) and search the headers for that constant. The options here will have their own enum. This is the case for all options that have set standard options. For the previous example some fonts may have different features enabled by different numbers there. Here, the options are known beforehand.

/*
 *  Summary:
 *    Selectors for feature type kLowerCaseType
 */
enum {
  kDefaultLowerCaseSelector     = 0,
  kLowerCaseSmallCapsSelector   = 1,
  kLowerCasePetiteCapsSelector  = 2
};

Conclusion

After printing the font features and doing this investigating, I now have the following extension for UIFont.

import UIKit

extension UIFont {
    public func currency() -> UIFont {
        /// Set the alt currency
        let altCurrency: [UIFontDescriptor.FeatureKey: Int] = [
            .selector: kStylisticAltFourOnSelector,
            .type: kStylisticAlternativesType
        ]

        /// Set the open four
        let alt4: [UIFontDescriptor.FeatureKey: Int] = [
            .selector: kStylisticAltOneOnSelector,
            .type: kStylisticAlternativesType
        ]


        /// Set alternate styling for 6 and 9
        let alt6and9: [UIFontDescriptor.FeatureKey: Int] = [
            .selector: kStylisticAltTwoOnSelector,
            .type: kStylisticAlternativesType
        ]

        let newDescriptor = fontDescriptor.addingAttributes([
            .featureSettings: [alt4, alt6and9, altCurrency]
        ])
        return UIFont(descriptor: newDescriptor, size: pointSize)
    }
}

Which gives me this beautiful typography for my currency labels.

This is one of the many changes I'm working on for version two of OpenBudget. Modifying fonts slightly for labels like this that are common throughout my app is essential for making everything legible.

It's a little annoying that CoreText doesn't map nicely to OpenType feature names, but honestly it's understandable. I think there's an opportunity here for some lookup tool that could select a font, open it up, and list all the available features with a preview. But honestly, now that I know how to find those features, it's such a small one-time task that I don't really mind doing it by hand.

Cross Compiling Swift

2025-03-29T05:00:00.000Z

I recently did a few small projects in Swift, and I wanted to run each of them on my home server running Gentoo Linux. I decided to do each of them in Swift, not because I thought it'd be easiest, but because I was curious about the challenge of compiling Swift from my Mac to my Linux machine. I'd heard lots recently about new static Linux Swift SDKs (and the Swift SDK API being introduced), and have always had an interest in Vapor

Link Embed Bot

The first project was a small link embedding bot for Discord. Some websites don't support Discord's embed UI when sending their links. One such website is Instagram. My friends often send memes and such from Instagram, and we'd used the ddinstagram URL previously to embed those videos in Discord messages, but that URL has become flaky and often just refuses to embed anything (it's a volunteer-run service and I don't want to bash on it, it works about 70% of the time).

So my goal was to create a Discord bot that would run 24/7 with an open WebSocket connection. That could get a little more expensive than I was willing to pay if run on a cloud provider (I was hoping to pay nothing). The bot would download images too, so it needed some memory. Thankfully, my home server meets those requirements perfectly. It's on all the time and has 8GB of RAM.

I used the DiscordBM package (the same one that powers Vapor's Penny bot!) to implement it, and I won't go into the details of reverse engineering Instagram's API to download images, reels, and videos from their server and upload them to Discord, but it is really cool if I do say so myself.

Your browser does not support the video tag.

Anyways, what I ended up with was a working Swift executable package. When executed, it started the connection with Discord and began processing events. The issue was, I wanted to run this on my Gentoo machine, but I had developed it on my Mac. In comes the power of static Linux Swift SDKs!

Method 1: Static Linux Swift SDK

Swift introduced static Linux Swift SDKs a while ago to help meet the need to compile Swift programs for a platform other than the one it's being compiled on. A Swift SDK contains the information Swift needs to know to create a statically linked executable. This executable contains the Swift runtime, standard libraries, even libraries the standard library depends on. This executable will run on any Linux machine once compiled, with no dependencies.

The downside of this method is that we cannot make use of the fact that most distros ship with dynamically linkable libraries. We have to statically link the binary, which causes the resulting binary to be quite large. This isn't the biggest deal, but isn't very user-friendly if you were looking to ship a user application. However, for a server-based app like mine, it really doesn't matter.

Step 1: Install the Open-Source Toolchain

This part is very important. You need to use the open source Swift toolchain from Swift.org. This is different from the Swift toolchain that is installed with Xcode, and includes support for features like Embedded Swift and Swift SDKs. Installing an open source Swift version is really straightforwards with the new Swiftly tool.

Using Swiftly

Follow the instructions on Swift.org to install Swiftly and the latest version of Swift.

Using an Installer

Download the install package from Swift.org and download the Package Installer .pkg file. Open the installer and it'll install a new .xctoolchain Xcode toolchain file on your system.

This tripped me up for a while. When you run swift after installing a toolchain using this method, you'll still be using Xcode's version of Swift. You'll have to run the specific toolchain you just installed using xcrun like: `bash xcrun --toolchain swift swift build -c release ` This may be an issue with my machine and my path settings. Having used swiftly since, it seems to work much better. I'd highly recommend using swiftly!

Step 2: Install the Swift SDK

Swift makes downloading and installing the Swift SDK itself very easy. Grab the URL and checksum from Swift's install page.

swift sdk install <URL-or-filename-here> [--checksum <checksum-for-archive-URL>]

You can list installed Swift SDKs with swift sdk list and see more options with swift sdk --help. It doesn't matter which toolchain (Xcode or open source) you use to install the SDK, they'll install to the same spot.

Quick note, I've been made aware that there's two closely named concepts that are very different. SDKs are an Xcode/Clang concept, but Swift SDKs are what we're working with. I've gone back and edited this (as of Sept 9th, 2025) to make sure I've referenced the correct SDK concept!

Step 3: Compile using the Swift SDK

Now that everything is installed, compiling the package is very easy. Make sure you're using the open source toolchain by running it using xcrun (yeah, I know that sentence didn't make sense. If someone has a suggestion for how I'm doing this wrong, please DM me).

Just run swift build with the specified Swift SDK and in release mode for performance.

xcrun --toolchain swift swift build --swift-sdk x86_64-swift-linux-musl -c release

Captain, It's Wednesday

The second project I did was the captainitswednesday.com bot on Bluesky. This little app was much simpler. I used the ATProtoKit Swift library by Christopher Riley to send posts for the Bluesky account and set up a really simple cron job to post every Wednesday at 9 a.m. The issue I had with this project was actually a compiler crash when using the previously discussed static Linux Swift SDKs. So I realized I'd have to go back to the original method for cross-compiling Swift, Docker.

Method 2: Docker Containers

Docker is a really cool tool. I've been digging into it recently, and I've known for a while that the Vapor community has had to use Docker to compile their applications for Linux cloud hosts before Swift really started building out tooling for both cross-compilation and even Linux as a target platform. There is actually a guide on Swift's website for packaging Swift projects, which mentions being able to compile to Linux. However, I found that I still needed some more information after reading it, so I'll outline the steps I took here.

The Docker cross-compilation method uses a Docker container to compile your Swift project in the Docker container, then copies the executable file out of the container for use. It might be easier to just ship the Docker container with the compiled executable, but for my use case (and I'm sure others), I didn't want to run Docker; I just wanted an executable to kick off.

A note about architecture: Each command listed in this section will contain a --platform flag to indicate the target architecture. Each example will compile to x86 (amd64), swap that out with arm64 to target an ARM CPU.

Step 1: Download the target Docker container

The official Swift guide mentions a swift:bionic container that I think is obsolete. I'd suggest downloading the swift:latest package, which is an Ubuntu container with everything you need to use Swift pre-installed. There are other Linux flavors you could use if necessary (bookworm, AmazonLinux2, Fedora, etc.), but in most cases, you'll be compiling against the Linux standard libraries and system calls, which should stay the same between most distributions. For instance, compiling in the Ubuntu container worked fine for running on my Gentoo server.

docker pull swift:latest --platform linux/amd64

Step 2: Compile & Copy Out

Now that we have the Swift container, Docker makes it really easy to spin up a container. This command will mount the current directory in the /workspace folder in the container and set it as the working directory.

We'll then run some bash commands in the container to: compile the Swift package in Release mode, delete the contents of the .build/install directory, and copy the compiled output to the .build/install directory.

docker run --platform linux/amd64 \
  --rm \
  -v "$PWD:/workspace" \
  -w /workspace \
  swift:latest \
  /bin/bash -cl '\
    swift build -c release --static-swift-stdlib && \
    rm -rf .build/install && \
    mkdir -p .build/install && \
    cp -P .build/release/CaptainItsWednesday .build/install/'

Note: Change the path of the cp step to match your target's name. In my case it was CaptainItsWednesday. You could also copy the entire release directory here if you need.

Step 3: Profit

I have this whole step in a script named deploy.sh that then copies the resulting executable into my home server using scp

scp .build/install/CaptainItsWednesday khan@homeserver.local:/home/khan/

Pretty nice to have around. If you want to verify the resulting executable's target platform you can run file against it to check.

file .build/release/CaptainItsWednesday
> .build/install/CaptainItsWednesday: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, with debug_info, not stripped

Another tip is to add a stripping step to remove all unnecessary code from the final executable. That reduced my resulting executable from 100MB to 64MB. Still large, but a significant improvement. My final deploy script looks like this, including the copy to my home server and strip steps.

docker run --platform linux/amd64 \
  --rm \
  -v "$PWD:/workspace" \
  -w /workspace \
  swift:latest \
  /bin/bash -cl '\
    swift build -c release --static-swift-stdlib && \
    strip --strip-unneeded .build/release/CaptainItsWednesday && \
    rm -rf .build/install && \
    mkdir -p .build/install && \
    cp -P .build/release/CaptainItsWednesday .build/install/' \
&& scp .build/install/CaptainItsWednesday khan@homeserver.local:/home/khan

And it works on a test run!

Final Thoughts

Swift's cross-compilation capabilities have come a long way from only compiling using Docker. It's nice having these instructions down somewhere even as it continues to get better, and I expect I'll continue amending this post as the tooling gets better. Shoutout to the new Swiftly tool too, I got to try that out while I was writing this up and it's a huge improvement.

It's very exciting to see the Swift devs continue to hammer away at Linux and cross-compilation. I think my only remaining pain point is the confusion surrounding the toolchain, SDKs, and why (even using Swiftly) you can only run the open-source toolchain using xcrun.

I continue to have a blast programming in Swift. The language feels 'right' in a way other languages have not. I'm extremely grateful to be a part of this community and I'm excited for Swift's tooling to continue to improve. It's a long way from where it was when I started using Swift back in Swift 4. It made both of these afternoon projects super fun and exciting.

New Blog, New Me

2024-11-03T05:00:00.000Z

Why Restart?

Previously, my blog was published using the popular Jekyll static site generator. While Jekyll worked well for a long time, it has became a serious pain to maintain.

I often have long periods of time where I don't post. Ideally when I come back after a year of not posting I'd like my tools to work just as well as they did previously. Jekyll did not meet this requirement well. With Ruby increasingly losing popularity and Gems requiring some serious finagling, I often had to completely reinstall the entire tool and all dependencies every time I wanted to write a new post. This was not working well.

Therefore, my new system had the following requirements:

No or few outside dependencies. Whatever dependencies are used need to be well known to me and well known what they do.
Familiar tools. I need whatever this is built on to be entirely familiar to me. At this point (2024) this likely means Swift and JavaScript.
Static HTML. I dislike overuse of JS libraries. This means no TailwindCSS, no React, only CSS, JS and HTML.

Existing Tools

If you're familiar with the Swift ecosystem, you may have heard of the tool Publish by John Sundell. This looks like it was going to be a perfect tool! It is actually a really nice tool. It's well built, entirely Swift, and fairly extendable. However, while it likely works for a lot of developers and blogs, mine needed some customizations that the library did not support.

Publish's markdown rendering engine Ink though, turned out to be perfect. It did require some modification to support LaTeX, but it's very fast and I was very surprised to find that it didn't rely on any C libraries like cmark. This ended up being one of two dependencies I allowed and I'm very thankful for the work John has done on this package.

Swift Result Builders

Swift seems the obvious choice for building my own blog. I've been in love with the language for years now, and it continues to improve. One of the features that I've been eyeing for a long time but hadn't been able to dig into myself is Result Builders.

Using result builders for HTML has been well documented, and I think it's perfect for this job. My goal was to make some Swift syntax that can compile into HTML. Ideally it should look kind of like SwiftUI, and it shouldn't be a hinderance to maintaining or building the website itself.

The core of my website is the following protocol:

protocol Component {
    associatedtype Body: Component

    @HTMLBuilder
    var body: Self.Body { get }

    var html: String { get }
}

extension Component {
    var html: String { body.html }
}

This allows me to define components that can optionally provide HTML contents. Similar to SwiftUI, I defined a TupleComponent for the result builder to use. This one is fun because it uses Swift's new parameter packs to take multiple types of components in the initializer. I did have to use a [any Component] in one spot, and I'd very much like to not have to do that but I'll revisit that in the future.

struct TupleComponent: Component {
    init<each Content>(_ content: repeat each Content) where repeat each Content: Component {
        func buildHTML<T: Component>(_ item: T, html: inout String) {
            if T.self != EmptyComponent.self {
                html += item.html
            }
        }
        var value = ""
        repeat buildHTML(each content, html: &value)
        self.html = value
    }

    init(_ components: [any Component]) {
        self.html = components.filter { type(of: $0) != EmptyComponent.self }.map { $0.html }.joined()
    }

    var body: some Component {
        fatalError("")
    }

    var html: String
}

Also similar to SwiftUI, some components need to not have their children evaluated. In the previous example, TupleComponent's body compiles to Never but still produces HTML using it's children. To get around this I used Swift's typing system to extend Never to be a component. While I was at it I made an EmptyComponent similar to SwiftUI's EmptyView to help myself avoid fatalErrors.

extension Never: Component {
    var body: some Component { self }
    var html: String { "" }
}

struct EmptyComponent: Component {
    var body: some Component { fatalError() }
    var html: String { fatalError() }
}

This component type made simple HTML tags easy to make Swift-y syntax for, and allowed for nesting content easily.

struct A<Content: Component>: Component {
    let url: String
    let content: () -> Content

    init(_ url: String, @HTMLBuilder content: @escaping () -> Content) {
        self.url = url
        self.content = content
    }

    var body: some Component {
        content()
    }

    var html: String {
        return "<a href=\"\(url.path()\">" + content().html + "</a>"
    }
}

Then, because I was using a protocol as my base type, I was able to extend some standard lib types for my HTML builder. One key thing is Strings. Again, I used that Never extension to make this possible, as Strings won't ever have HTML children to evaluate.

extension String: Component {
    var body: some Component { fatalError() }
    var html: String { self }
}

Finally, using that I was able to define a result builder that combines components and allows for the syntax I was aiming for.

@resultBuilder
enum HTMLBuilder {
    static func buildBlock<each Content>(_ content: repeat each Content) -> TupleComponent where repeat each Content: Component {
        TupleComponent(repeat each content)
    }

    static func buildOptional(_ component: TupleComponent?) -> TupleComponent {
        if let component {
            component
        } else {
            TupleComponent([EmptyComponent()])
        }
    }

    static func buildEither<Content: Component>(first component: Content) -> Content {
        component
    }

    static func buildEither<Content: Component>(second component: Content) -> Content {
        component
    }

    static func buildArray(_ components: [any Component]) -> TupleComponent {
        TupleComponent(components)
    }
}

To actually generate the HTML document I just added a small function that uses the .html property on the Component type. This also adds a few common sense things for an HTML document like the language, HTML5 support, etc.

enum HTMLRenderer {
    static func render<Content: Component>(@HTMLBuilder page: () -> Content) -> String {
        "<!DOCTYPE html><html lang=\"en\" data-theme=\"light\">" + page().html + "</html>"
    }
}

This is slightly different from other methods I've seen around. The primary difference is the use of a root protocol type for each component, rather than inheritance from a class. I also wanted a system very similar to SwiftUI, in that there is no children array on any components. Instead, each component is a distinct element in the hierarchy of the page.

But Why?

A good question to ask is is this effort worth it? I certainly think so. This resulted in a syntax that lets me express the HTML content of the webpage, while mixing in Swift logic that is never exposed to the browser.

For example, after a little more work the entire home page is represented using just this component.

struct HomePage: Component {
    var body: some Component {
        let posts = /* Get All Posts */

        Page(title: "Posts", description: "Khan Winter's Blog Posts", path: "index.html", loadCodeStyles: false) {
            Tag("div", ["class": "home"]) {
                Tag("div", ["class": "home-header"]) {
                    Img(resourceName: "avatar-large.webp", alt: "Avatar", size: (128, 128))
                    P { "Khan's Online Web Log (aka: my blog)!" }
                }

                Tag("ul") {
                    for (post, path) in posts {
                        let url = path.deletingPathExtension().appendingPathExtension("html").path()

                        Tag("li") {
                            A(url) {
                                P { post.createdAt.formatted() }
                                H(3) { post.title }
                                P { post.excerpt }
                            }
                        }
                    }
                }
            }
        }
    }
}

The largest benefit being able to use logic like for loops, variables, and branches directly in the page's code.

for (post, path) in posts {
    // ...
}

To me, this is very appealing. This is written in raw Swift, meaning as long as I have a Swift compiler on my machine it'll work. It also generates static HTML, with dynamic structure like loops and branches performed without JavaScript or an ugly syntax like Liquid. It meets the last goal I set for myself by not having any unecessary dependencies (Ink is pure Swift, doesn't even need Foundation).

So yeah, for my use case and my blog it was very worth the effort. On top of that, I got to explore Result Builders! You can check out the entire site on my GitHub if you'd like to check out more.

Bundling

The last thing I wanted was to minify my website's assets. There's a few lines of JS and CSS for highlighting code, displaying Math, etc. I've liked esbuild in the past so I decided to run esbuild on each file using Bun (instead of NodeJS). The speed Bun provided is awesome. It's so fast that the script I made to minify all the JS and CSS files was moved to be in the main loop when generating the site rather than something that happens only when I deploy. Serious props to the team at Bun. Figured I'd share that while I was at it.

CloudFlare

I'm not only moving domains and site generators, but also my hosting provider. I've used Github pages and Netlify in the past, and while I don't have any issue with them in particular they have some rough edges a few years in. Netlify is nice, but they've clearly adjusted their target audience to larger businesses. Most of the features they provide just don't apply to a little site like mine (beyond the CDN). Github Pages is pretty much perfect, but not transparent enough for my liking. I prefer to know when my content will be live after deploying it.

I initially was going to just host my static files in R2, CloudFlare's block storage offering. While setting that up I noticed they offer a static site hosting which I'm trying out. So far, I've loved it. My site's download speed is faster than either Github or Netlify. They offer unlimited bandwidth, and DNS setup with them was faster than any other provider I've worked with. I don't usually give shoutouts for things like this but CloudFlare has been awesome to work with so far.

Last Thing - Page Preloading

After all this work, all of the HTML, JS, and CSS for my site (not including images and videos) is only 0.33MB on disk uncompressed (97KB compressed using ZSTD, CloudFlare's default compression mechanism). Each new page is roughly 18KB uncompressed, which is nothing to download for most internet connections. Well, HTML has this nice feature that allows you to pre-fetch pages for navigation. Inspired in part by this Youtube Video, I decided to preload the entire blog on each page.

Give it a try yourself! If you've made it this far. Clicking the "Random" navigation button a few times really shows off how zippy it is. Ironically, that's what powers that "Random" nav button. It uses the cached pages as the list to choose randomly from!

Is this tidbit useful anywhere else in any other context? No. But it's really funny to me to make every visitor download and cache the entire blog just to save a few milliseconds loading the post they're looking for 😉.

Conclusion

So that's the post. New domain, new blog, new me! This has mostly been my rambling about some cool Swift features and a few things I found while rewriting this website. I hope it was worth the read!

Hide Desktop macOS Shortcut

2024-11-01T05:00:00.000Z

I often find myself needing to hide my desktop icons. Whether for a demo for CodeEdit, sharing my screen for work, or any other task that requires sharing my screen, I prefer to have my desktop contents hidden.

So here's a really simple Automator script to toggle your desktop. To show your desktop items again just run the script! Note: it kills Finder, so any finder panels you have open will be closed when this is run.

Throw this in a Run Shell Script action in a new automation:

previous_val=$(defaults read com.apple.finder CreateDesktop)

if [ "$previous_val" = "true" ]
then
	defaults write com.apple.finder CreateDesktop 'false'
	defaults write com.apple.WindowManager StandardHideWidgets -int 1
else
    defaults write com.apple.finder CreateDesktop 'true'
	defaults write com.apple.WindowManager StandardHideWidgets -int 0
fi


killall Finder

Then I like to export it to an application so I can run it easily from Spotlight

Demo Video:

Your browser does not support the video tag.

Sort a List of Objects

2021-08-07T05:00:00.000Z

Sorting Objects In A DB

Lists of objects can often be sorted by a variable, eg calendar events are often sorted by the date they are for. Like so:

Event 1: 10:00 AM
Event 2: 11:00 AM
Event 3: 12:00 PM

Sometimes though, we need to sort objects in a list that don't have an easy way to sort, or we need to allow users to sort the objects to their desire. The user will most likely expect his/her sort order to be kept, and we also can't just store an Array of objects in a db.

The other problem is if we give all the objects a number value to sort by, we can't update every single object in the database with a new sort number. That's just impractical and a waste of compute time and energy.

The solution is to sort the items by a Double variable. The objects will look basically like this at first:

Item 1: 10.0
Item 2: 20.0
Item 3: 30.0

When the user moves Item 3 up a slot, we just give it a number between items 1 and 2, like this:

Item 1: 10.0
Item 3: 25.0 <- Inserted here
Item 2: 20.0

If a user moves Item 3 back down, we just add 10.0 to the biggest item's order, and get the list we started out with:

Item 1: 10.0
Item 2: 20.0
Item 3: 30.0

Finally, if the user moves Item 3 to the top of the list, we find a number between 0.0 and Item 1's order, and give it to Item 3:

Item 3:  5.0 <-- Halfway between 0 and 10
Item 1: 10.0
Item 2: 20.0

Pretty simple! We don't have to update every single item in the list, and Doubles can be divided for a long time, so it will be rare to run out of space between items in the list.

This article will give an example of how to give users the ability to sort items and keep the sort order using Core Data in SwiftUI. This same method applies to any database/UI framework that allows you to sort your items by a Double type.

There's also a fully functional example project available for download here that implements the ideas talked about.

Order Variable

The main idea behind this solution is having a variable on all our objects in the list that's a Double type. For this example, say we have a list of items that we're going to allow the user to sort at will. The Item object may look something like this:

struct Item {
    var id: UUID = UUID()
    var label: String
    var order: Double
}

Notice that we're adding an order variable as type Double to this object. In Core Data, this can be done super easily by just adding a variable of type Double to your .xcdatamodeld file.

When we go to fetch the Todos we'll just sort them by the order variable. For Core Data this looks like this:

@FetchRequest(sortDescriptors: [NSSortDescriptor(keyPath: \Item.order, ascending: true)], animation: .default)
private var items: FetchedResults<Item>

Updating The Order

There are 2 pieces of code we need to modify to make this actually work:

When an Item is added
When an Item is moved

Added

When an Item is added, we need to give it an initial order value. The code may look something like below, where I'm just getting the biggest order value, and adding more onto it for the new object. If there aren't any Items I just give it a value of 100.0

func addItem() {
    withAnimation {
        let newItem = Item(context: viewContext)
        newItem.label = "New Item!"

        if items.count > 0 { // Check if there are items
            newItem.order = items.last!.order + 25.0 // Add some more to the order
        } else {
            newItem.order = 100.0 // Give some padding from 0.0 for later
        }

        try! viewContext.save()
    }
}

Awesome, now when items are added they will automatically go to the bottom of the list. If there are no items, we'll give ourselves some padding numerically for the next case.

Moved

When an item is moved, things get a little more tricky. There are 3 paths here to handle:

The item is moved to the top of the list
The item is moved to the bottom of the list
The item is put somewhere in the middle

We'll always need to find an order value between two values to insert the item somewhere.

For the three cases the upper and lower order values will be between:

0.0 -> next list item
last list item -> last list item + 100.0
Next destination list item -> destination list item

In swift this looks like the following code

var upper: Double
var lower: Double

if destination == items.count {
    print("Appending to the end of the list")
    lower = items.last!.order
    upper = items.last!.order + 100.0
} else if destination == 0 {
    print("Inserting into the begining")
    lower = 0.0
    upper = items.first?.order ?? 100.0
} else {
    print("Inserting into the middle of the list")
    // Find the upper and lower sort around the destination and make some sort orders
    upper = items[destination - 1].order
    lower = items[destination].order
}

Then, we can get numbers between the upper and lower limits like

var newOrders: [Double] = stride(from: lower, to: upper, by: (upper - lower)/Double(sourceItems.count + 1)).map { $0 }
newOrders.remove(at: 0)

We're handling the case where we're moving more than one item too. So if two items are inserted between 10.0 and 20.0 we should generate 12.5 and 17.5 to insert both the items in the correct spot.

Then, its a simple matter of updating the sort order of the objects!

var i = 0
source.forEach { index in
    items[index].order = newOrders[i]
    i += 1
}

try! viewContext.save()

Done! 🎉

Here's the code from the example project in action.

Your browser does not support the video tag.

Implementing Sin(x)

2021-05-08T05:00:00.000Z

Previously on...

In my last post, I used Taylor Series to come up with a function to estimate $$sin(x)$$ for any number between $$0$$ and $\frac{\pi}{2}$ . While this is cool, it's rather useless. But, thankfully, I can use the numbers we can already to calculate any number of $$sin(x)$$ .

If you haven't read my previous post, it's a good read and will definitely make this post make much more sense. You can read that post here.

Sin Repeats

$$sin(x)$$

has an awesome property that I'm going to take complete advantage of for this implementation. Sin is the exact same from $$0$$ to $\frac{\pi}{2}$ everywhere else on the number line. All the rest of the numbers are flipped horizontally, or vertically, or both.

It's easier to see this with the graph of $$sin(x)$$ .

It's pretty easy if you can rotate your phone/laptop to see that the curve from $$0$$ to $\frac{\pi}{2}$ is the flipped horizontally between $\frac{\pi}{2}$ and $\pi$ , then horizontally and vertically between $\pi$ and $\frac{3\pi}{2}$ , and finally flipped vertially from $\frac{3\pi}{2}$ to $2\pi$ .

Flip Flops 🩴

Since we can already calculate all the numbers from $$0$$ to $\frac{\pi}{2}$ in $$sin$$ , all we've gotta do is figure out some swift functions to flip flop around our existing results.

Here's what we're starting with, with each quadrant that we need to flip or flop in a different color.

Vertical Flips

It's pretty easy to flip a function vertically. In math it's called the reflection of a function. All we have to do is make the entire function negative and it'll be flipped vertically.

Source: https://mathbitsnotebook.com/Algebra1/FunctionGraphs/FNGTransformationFunctions.html

The only areas we need to vertically flip $$sin(x)$$ are between $\pi$ and $2\pi$ , where $$sin(x)$$ is negative.

After applying the vertical flops, our graph looks like this

Horizontal Flops

Now all we have to do is flop the blue and purple lines backwards. We can do this by just shifting the $$x$$ value $\frac{\pi}{2}$ to the left.

After the horizontal flop we end up with this graph.

Sweet! Now we can use these flip flops in our sin function in swift to calculate any value for $$sin(x)$$ .

Swift Flip Flops 🐥🩴

Now to implement these stylish shoes in Swift.

Vertical Flips

As said before, all we have to do to flip a function vertically is make sin negative. That's super easy in swift, so here's the vertical flip function.

sin(-input)

Horizontal Flops

All we need to do here is subtract $\frac{\pi}{2}$ from the input variable and we're good to go!

sin(input - (Double.pi/2))

Finally...

Yay! Now all we have to do is

Reduce $$x$$ to be between $$0$$ and $2\pi$ .
Flip flop our way to our result!

Here are the few rules that we'll need to follow to figure out which flip or flop to use.

If $$x$$ is between $\pi$ and $2\pi$ , flip it vertically.
If $$x$$ is between $\frac{\pi}{2}$ and $\pi$ or $\frac{3\pi}{2}$ and $2\pi$ , flip it horizontally.

With these rules in mind, we almost have the swift code written for us! I'll just take those "If $$x$$ is..." and turn them into if statements.

Here's the final swift implementation of $$sin(x)$$ .

let S1 = -1.66666666666666324348e-01;  // -1/(3!)
let S2 = 8.3333333332248946124e-03;    //  1/(5!)
let S3 = -1.98412698298579493134e-04;  // -1/(7!)
let S4 = 2.75573137070700676789e-06;   //  1/(9!)
let S5 = -2.50507602534068634195e-08;  // -1/(11!)
let S6 = 1.58969099521155010221e-10;   //  1/(13!)

func usersin(_ xOrig: Double) -> Double {
    // Reduce x to be between 0 and 2pi
    var x = xOrig.truncatingRemainder(dividingBy: 2 * Double.pi)

    // If it's between pi/2 => pi or 3pi/2 => 2pi. Flip it horizontally
    if (x > Double.pi/2 && x < Double.pi) || (x > (3*Double.pi)/2 && x < 2*Double.pi) {
        x = x - (Double.pi/2)
    }

    let z = x*x                          // x^2
    let v = z*x                          // x^3
    let r = S2+z*(S3+z*(S4+z*(S5+z*S6))) // Taylor function part 1/2

    // Flip the function if needed, eg between pi and 2pi
    if x > Double.pi && x < Double.pi * 2 {
        return -x+v*(S1+z*r)             // Taylor function part 2/2 (but negative)
    } else {
        // No need for vertical flip
        return x+v*(S1+z*r)             // Taylor function part 2/2
    }
}

Benchmark

I decided to test the speed of this implementation, and the benchmarks look pretty good. For 1,000,000 $$sin(x)$$ operations, the results look like:

Time elapsed for User Sin: 0.7528519630432129 s.
Time elapsed for Normal Sin: 0.6716610193252563 s.

So not too far off between them. The code I used to benchmark is below.

#!/usr/bin/swift

import Foundation

... User sin defined up here ...

func printTimeElapsedWhenRunning(title: String, operation: (() -> Void)) {
    let startTime = CFAbsoluteTimeGetCurrent()
    operation()
    let timeElapsed = CFAbsoluteTimeGetCurrent() - startTime
    print("Time elapsed for \(title): \(timeElapsed) s.")
}

printTimeElapsedWhenRunning(title: "User Sin") {
    for i in 0..<1000000 {
        let _ = usersin(Double(i))
    }
}

printTimeElapsedWhenRunning(title: "Normal Sin") {
    for i in 0..<1000000 {
        let _ = sin(Double(i))
    }
}

After running this code ~10 times the results were within 0.001s of each other, so the error from this test is negligible.

Conclusion

While it's fun to figure out and define our own implementation of $$sin(x)$$ , it's not super practical. Other programers have already figured out this math, and have figured out ways of making it slightly faster than my own. So, is it practical? No. But it was fun to do!

How Computers Calculate Sine

2021-03-17T05:00:00.000Z

Computers aren't infinite.

How can computers compute (no pun intented) infinite functions like sin so fast? Take video games for instance, that need to compute trig functions incredibly fast 100's of times a second to render frames. If sine and cosine took long at all, we would never have video games.

How do computers do it?

Historically computer scientists have two ways of getting around this problem.

Store a table of sine and cosine values, then reference that table whenever you need. Java does this, and it works fairly well until you need a value of sine that isn't in the table
Estimate $$sin(x)$$ using another function.

Here I'll show you how computers estimate sin for any value.

Sine and derivatives

Before we take a deeper dive into the math, there's two concepts we need to understand.

Sine

For a little background I'll start by explaining two important concepts. First, $$sin(x)$$ . You may remember this fun function from a high school algebra class. $$sin(x)$$ has these important properties.

Sine is infinite, meaning it'll have a value at any number you put into it.
It's also periodic, which means that it repeats itself over and over again (like a wave).

Here's a graph of y=sin(x).

As you can see, the value of sin(x) goes up and down between $$-1$$ and $$1$$ .

You can also tell that it's not coming to an end. It'll go on forever from −∞ all the way to +∞.

One more important thing about sine is that the curve 0 to $\frac{\pi}{2}$ is repeated on the entire rest of sine. The curve might be backwards or upside down, but it's always exactly the same.

That means if we can figure out values for any point in $$0$$ to $\frac{\pi}{2}$ , we can figure out points for anywhere on sine.

Derivatives

A derivative is the core concept of Calculus. Basically, when you take a derivative of a function, you create another function that measures the rate of change of the original function. It can be confusing, but a really good example of this comes from physics.

If we have a particle that's moving according to the position function

x=vt+\frac{1}{2}at^2

We can take the Derivative of that funciton, to get

$$ v=at $$

Velocity is the derivative of the position function. It's literally, the change in position over time. We can even take the derivative of Velocity to get

a=\left(some\:number\right)

Acceleration. Acceleration is the change in velocity over time.

Here's a graph of all these functions over time. You'll notice the velocity is going up at a constant rate a, and the position is going up exponentially. If we dropped a ball off a cliff. The ball would fall faster over time, so the velocity would steadily increase, but the acceleration would always be $9.81\frac{m}{s^2}$ .

Finally, derivatives are shown using this syntax $derivative\:of\:f\left(x\right)=f'\left(x\right)$ So from now on, if you see f'(x) that's the derivative of the function f. If we add more ' to the function if grows in derivatives. So the second derivative of f is $second\:derivative\:of\:f\left(x\right)=f''\left(x\right)second\:derivative\:of\:f\left(x\right)=f''\left(x\right)$

How do we use derivatives to calculate sine?

A: Taylor Series

Taylor series estimate a function. Basically, a mathemetician named Brook Taylor realized that any function is equal to this sum

f\left(x\right)=f\left(0\right)+\frac{f'\left(0\right)}{1!}x+\frac{f''\left(0\right)}{2!}x^2+...

Each part that we're adding up is the $$nth$$ derivative of f divided by the number n! it's at, times $$x^n$$ . If we add up infinity of these functions, this Taylor series will be perfectly equal to $$f(x)$$ .

Each time we add one of the parts above, we're adding a degree to the Taylor series. So the above function is to the 3rd degree.

Taylor series work on the idea that the function is related to it's derivatives somehow. So we can get the initial value of $$f(x)$$ at $$f(0)$$ , and the next derivative $$f'(x)$$ gives us the direction it should go next. Each derivative we add in this way points the Taylor series in the correct direction more and more until it's exactly equal to the entire original function.

But, we don't always have to add up to infinity. In fact, the series is very close to $$f(x)$$ for a short bit after only a few sums of the Taylor series.

This comes in handy if say, we only need to know values for a specific part of the function say *ahem* 0 to $\frac{\pi }{2}$ .

In fact, this is the Taylor series to the 7th degree, which happens to equal $$sin(x)$$ nearly exactly from $$0$$ to $\frac{\pi }{2}$ .

sin(x)=x-\frac{x^3}{3!}+\frac{x^5}{5!}-\frac{x^7}{7!}+\frac{x^{11}}{11!}-\frac{x^{13}}{13!}+\frac{x^{15}}{15!}

The graph above shows that the Taylor series is equal to $$sin(x)$$ until $\frac{\pi}{4}$ , where it starts to wander.

Computer time!

Now we have a function we can use to estimate $$sin(x)$$ anywhere along $$sin(x)$$ .

Since the function isn't infinite, we can translate it to a computer function very easily. Heres sin(x) in Swift.

let S1 = -1.66666666666666324348e-01;  // -1/(3!)
let S2 = 8.3333333332248946124e-03;    //  1/(5!)
let S3 = -1.98412698298579493134e-04;  // -1/(7!)
let S4 = 2.75573137070700676789e-06;   //  1/(9!)
let S5 = -2.50507602534068634195e-08;  // -1/(11!)
let S6 = 1.58969099521155010221e-10;   //  1/(13!)

func usersin(_ x: Double) -> Double {
    let z = x*x                          // x^2
    let v = z*x                          // x^3
    let r = S2+z*(S3+z*(S4+z*(S5+z*S6))) // Taylor function part 1/2
    return x+v*(S1+z*r)                   // Taylor function part 2/2
}

Here's how this works.

First, we're storing the larger numbers at the top. These numbers are constants, so we can set them statically outside the function.
The variables z, and v are placeholder variables for powers of x, they're there mostly for readability
r is the first part of the actual Taylor function. I found that if I kept the entire polynomial in one declaration it messed up the final result.
We return the final Taylor function.

To test this implementation, we can import Foundation and compare it to Swift's built-in sin.

#!/usr/bin/swift

import Foundation

let S1 = -1.66666666666666324348e-01;  // -1/(3!)
let S2 = 8.3333333332248946124e-03;    //  1/(5!)
let S3 = -1.98412698298579493134e-04;  // -1/(7!)
let S4 = 2.75573137070700676789e-06;   //  1/(9!)
let S5 = -2.50507602534068634195e-08;  // -1/(11!)
let S6 = 1.58969099521155010221e-10;   //  1/(13!)

func usersin(_ x: Double) -> Double {
    let z = x*x                          // x^2
    let v = z*x                          // x^3
    let r = S2+z*(S3+z*(S4+z*(S5+z*S6))) // Taylor function part 1/2
    return x+v*(S1+z*r)                   // Taylor function part 2/2
}

func printUserSin(_ input: Double, name: String) {
    print("x\t=\t\(name)")
    print("usersin(x):\t\(usersin(input))")
    print("sin(x):\t\t\(sin(input))")
    print("")
}
printUserSin(Double.pi/6, name: "Pi/6")
printUserSin(Double.pi/8, name: "Pi/8")
printUserSin(Double.pi/21, name: "Pi/21")
printUserSin(Double.pi/2, name: "Pi/2")
printUserSin(Double.pi/2 - 0.01, name: "Pi/2 - 0.01")

Which spits out:

x	=	Pi/6
usersin(x): 0.4999999999999961
sin(x):     0.49999999999999994

x	=	Pi/8
usersin(x): 0.38268343236508884
sin(x):     0.3826834323650898

x	=	Pi/21
usersin(x): 0.14904226617617444
sin(x):     0.14904226617617444

x	=	Pi/2
usersin(x): 1.000000000251294
sin(x):     1.0

x	=	Pi/2 - 0.01
usersin(x): 0.9999500006418387
sin(x):     0.9999500004166653

Which is nearly completely accurate for all the values we gave it, plenty close for any calculation we may need, and plenty fast as well!

Conclusion

I've shown a very naive implementation of $$sin(x)$$ . It doesn't take into account values outside of $$0$$ to $\frac{\pi}{2}$ and doesn't account for negative values. In fact, this is the bare minimum you would want from a sin function.

In a future post I'll go over some of the tricks computer scientists have used to get around those problems, and compare speeds of this function with C and C++.

If you'd like to run the code above on your own, create a file called main.swift and copy-paste the code into that file. Then runchmod +x main.swift && ./main.swift to run the script.

The Search Engine Matrix

2021-02-03T06:00:00.000Z

Search engines rank pages based on how likely you are to visit them

For a person, this might be a simple thing to understand. You would probably think the search engine should probably rank websites that are more popular higher on the list. However, computers don't understand popularity inherently. We have to convert a human problem, "How popular is this website" into a math problem. How does one do that?

The answer: Matrices

A bit of a primer

If you haven't taken Linear Algebra, there's a good chance you have never heard of matrices. So here's a brief explaination.

Matrices hold numbers in a grid, sort of like a Sudoku board. Below is a matrix called the Identity Matrix You can think of it as the 1 of matrices.

I=\begin{pmatrix}1&0&0\\ 0&1&0\\ 0&0&1\end{pmatrix}

You can use matrices like other numbers, adding, subtracting, multiplying, dividing etc. For instance if we multiply I by 2 we get

I\cdot 2=\begin{pmatrix}2&0&0\\ 0&2&0\\ 0&0&2\end{pmatrix}

We can also put numbers in where we currently have 0 like below, as well as have different numbers of rows and columns.

I_2=\begin{pmatrix}1\\ 0\\ 0\end{pmatrix},\:I_3=\begin{pmatrix}1&\frac{1}{2}&\infty \\ sin\left(\theta \right)&\pi &\log \left(20\right)\\ -1&2&\frac{3}{4}\end{pmatrix}

If you multiply a narrow matrix by a wider matrix with the same number of rows, you'll end up with a narrow matrix. This will come in handy later when calculating probabilities.

I_2\cdot I=\begin{pmatrix}1&0&0\\ 0&1&0\\ 0&0&1\end{pmatrix}\begin{pmatrix}1\\ 0\\ 0\end{pmatrix}=\begin{pmatrix}1\\ 0\\ 0\end{pmatrix}

Turning the human problem into a computer problem

Say, for instance, we have a group of 3 websites which are linked in a graph like this:

In this graph, website 1 links only to website 2, website 2 links to both 1 and 3, and website 3 links to both 1 and 2.

For each website we want to know how it links to the other websites mathematically. So, for website 2, we'll make a single-column matrix like this:

This matrix only has one column, which adds up to 1. We got the numbers for the matrix by adding up all the links that that website links to, and dividing one by that sum, eg: $\frac{1}{Number\:Of\:Links}$ . We'll now create this matrix for each website, and combine them into one, larger matrix which we'll label $$A$$ .

A=\:\begin{pmatrix}0&\frac{1}{2}&\frac{1}{2}\\ 1&0&\frac{1}{2}\\ 0&\frac{1}{2}&0\end{pmatrix}

Each column in this matrix represents how one of the three websites links to the other two.

Follow the links

Now that we have a matrix representing the website graph, we can start following it around to different websites. We'll start at website 3. We've got a 50/50 chance of going to either website 1 or website 2. I'll roll a dice and it landed on website 2, so we'll go there.

Now that we're at website two, we have a 50/50 chance of going to either website 3, or website 1. The dice picks website 1.

Website 1 is different, it only links to website 2. So I don't even have to roll a die, I can only go to website 2.

This is a lot of writing, so I'll convert this into a formula.

We'll start our walk through the links at page one. This is step one, so we'll name this variable $$p_0$$ . $$p_0$$ is going to be a matrix representing the probability of us being on any page after we've taken 0 steps. We're starting at website 1, so we have a 100% probability in the next step of going to website 2, meaning the matrix looks like this.

p_0=\begin{pmatrix}0\\ 1\\ 0\end{pmatrix}

If I multiply $$p_0$$ by $$A$$ (which we created earlier) we'll end up with the probability of being at any of the resulting websites after one step ( $$p_1$$ ).

p_1=A\cdot \:p_0=\:\begin{pmatrix}0&\frac{1}{2}&\frac{1}{2}\\ 1&0&\frac{1}{2}\\ 0&\frac{1}{2}&0\end{pmatrix}\cdot \begin{pmatrix}1\\ 0\\ 0\end{pmatrix}=\begin{pmatrix}0\\ 1\\ 0\end{pmatrix}

The resulting matrix tells us that we have a 100% probability of being at website 2 after one step. This makes sence, since website 1 only links to website 2.

To find the next step, we just multiply $$p_1$$ by $$A$$ to get $$p_2$$ .

p_2=A\cdot \:p_1=A\cdot A\cdot p_0=A^2p_0=\:\begin{pmatrix}0&\frac{1}{2}&\frac{1}{2}\\ \:1&0&\frac{1}{2}\\ \:0&\frac{1}{2}&0\end{pmatrix}\cdot \begin{pmatrix}0\\ \:1\\ \:0\end{pmatrix}=\begin{pmatrix}\frac{1}{2}\\ 0\\ \frac{1}{2}\end{pmatrix}

I'm starting to see a patern. For each step we take, we're really just adding one power to $$A$$ . On step one, we found $$A^1*p_0$$ , on step two we found $$A^2*p_0$$ , and so on. Because of that, we can say the following formula is true.

$$ p_n=Ap_n=A^np_0 $$

If we take a larger number of steps, we'll find the probability of being at any website in the graph.

What if we find $p_{15}$ ? (by the way I'm using symbolab for these smaller computations)

p_{15}=\:\begin{pmatrix}0&\frac{1}{2}&\frac{1}{2}\\ 1&0&\frac{1}{2}\\ 0&\frac{1}{2}&0\end{pmatrix}^{15}\begin{pmatrix}1\\ 0\\ 0\end{pmatrix}=\begin{pmatrix}0.333313\\ 0.444763\\ 0.221924\end{pmatrix}

This means after 15 steps through each website, we've got the highest probability of landing on website 2, then website 1, then website 3.

Congrats! You've found how likely a user is to navigate to each of these three sites!

This seems really work-intensive

It is tough to calculate $$p$$ for each step, what if we had a huge graph of websites. We wouldn't know if we needed to stop walking the graph at 15 steps or 500! So how can we solve this problem?

Side note: I'm going to redefine $$A$$ from now on, so we're working with 5 websites.

A=\begin{pmatrix}0&\frac{1}{3}&\frac{1}{2}&\frac{1}{2}&0\\ \frac{1}{2}&0&0&0&0\\ 0&\frac{1}{3}&0&0&0\\ 0&\frac{1}{3}&\frac{1}{2}&0&1\\ \frac{1}{2}&0&0&\frac{1}{2}&0\end{pmatrix}

For starters lets define the actual formula we're working with here ( $$n$$ is the number of steps we take).

p_{n+1}=Ap_n

If we take $\infty$ steps, this equation becomes

p_\infty =Ap_\infty

Which is equal to a proof meaning that $$p$$ is actually something called an eigenvector which corrensponds to $$A$$ and an eigenvalue of 1 since $$p_n$$ will always add up to 1. (More about eigenvectors and eigenvalues)

Using this proof we can use the calculation below to find an eigenvector of $$A$$ which I'm going to call $$R$$ . $$I$$ is the identity matrix. (now I'm using Matlab for these calculations since it's easier to work with matrices, I'll include the code at the bottom of this page)

I=\begin{pmatrix}1&0&0&0&0\\ \:\:0&1&0&0&0\\ \:\:0&0&1&0&0\\ \:\:0&0&0&1&0\\ \:\:0&0&0&0&1\end{pmatrix},\:R=rref\left(A-I\right)

After this computation, $$R$$ equals

R=\begin{pmatrix}1&0&0&0&-0.8\\ 0&1&0&0&-0.4\\ 0&0&1&0&-1.33\\ 0&0&0&1&-1.2\\ 0&0&0&0&0\end{pmatrix}

From which we can draw the eigenvector $$v$$ and the probability matrix $$p$$ . The first equation takes only the left column of $$R$$ and then sets the 5th value to 1. Since $$p$$ is a probability matrix, it always needs to add up to 1, so we divide it by it's sum to reduce it down to 1.

v=-R\left(:,5\right),\:v\left(5\right)=1

p=\frac{v}{sum\left(v\right)}

At this point, $$p$$ equals

p=\begin{pmatrix}0.2264\\ 0.1132\\ 0.0377\\ 0.3396\\ 0.2830\end{pmatrix}

Which is the final probability matrix.

Conclusion

Using some fun math we're able to turn a human problem (what's the most popular page) into a computer problem (what's the probability of reaching any page). This is the job of computer scientists, to be able to break down problems in our world into their mathematical components, and tell a computer how to solve them.

KhanAcademy has some great resources on Matrices, Eigenvectors and Eigenvalues if you'd like to learn more here -> https://www.khanacademy.org/math/linear-algebra

If you have access to Matlab, and want to check my work or mess around on your own, here's the Matlab code I used for the second example.

>> A = [0 1/3 1/2 1/2 0; 1/2 0 0 0 0; 0 1/3 0 0 0; 0 1/3 1/2 0 1; 1/2 0 0 1/2 0];
>> I = eye(5); R = rref(A-I);
>> v=-R(:,5); v(5)=1; p=v/sum(v);
>> p

p =

    0.2264
    0.1132
    0.0377
    0.3396
    0.2830

Save Codable Dates In Firestore

2021-01-07T06:00:00.000Z

Lets say we have a Codable object we want to save in Firestore

This object has name, and dateUpdated properties. The dateUpdated property is a Date object. The implementation looks like this:

class Name: Codable {
    var name: String
    var dateUpdated: Date
}

To make my life easier, I've added a custom init to this object to convert it from [String: Any] to a Name object.

extension Name {
    init(dictionary: [String: Any]) throws {
        let data = try JSONSerialization.data(withJSONObject: dictionary, options: .prettyPrinted)
        self = try decoder.decode(Self.self, from: data)
    }
}

Pretty easy! Now when I get a response from Firestore I can just convert it to my object like this.

if let document = snapshot.documents.first {
    let data = document.data()
    let name: Name? = try? Name(data)
}

And I have a function that converts the object into a dictionary to save it to firestore.

func dictionary() throws -> [String: Any] {
    let data = try JSONEncoder().encode(self)
    guard let dictionary = try JSONSerialization.jsonObject(with: data, options: .allowFragments) as? [String: Any] else {
        throw NSError()
    }
    return dictionary
}

What's the problem?

If you try saving an object with a Date property to Firestore, Firestore automatically changes the Date to a Timestamp. This probably wouldn't be a problem, unless you're trying to decode that same object where you'll get the error:

"Invalid type in JSON write (FIRTimestamp)"

This is being caused because Swift's Foundation doesn't know how to decode Firestore's Timestamp type from JSON.

How do you fix it?

It's pretty simple actually, we just tell the JSONDecoder and JSONEncoder to use a special way of encoding/decoding dates. It's just a few line's change for each of the methods in the class.

extension Name {
    init(dictionary: [String: Any]) throws {
        let data = try JSONSerialization.data(withJSONObject: dictionary, options: .prettyPrinted)
        let decoder = JSONDecoder() // Change
        decoder.dateDecodingStrategy = .secondsSince1970 // Change
        self = try decoder.decode(Self.self, from: data) // Change
    }

    func dictionary() throws -> [String: Any] {
        let encoder = JSONEncoder() // Change
        encoder.dateEncodingStrategy = .secondsSince1970 // Change    
        let data = try encoder.encode(self)
        guard let dictionary = try JSONSerialization.jsonObject(with: data, options: .allowFragments) as? [String: Any] else {
          throw NSError()
        }
        return dictionary
    }
}

All this is doing is telling swift to save our dateUpdated date as a number instead of an actual date. This way, Firestore doesn't try to change any Date types to Timestamps and we don't get the aforementioned error.

The change made was instead of using a bare JSONEncoder or JSONDecoder, I changed it to use this:

let encoder = JSONEncoder()
encoder.dateEncodingStrategy = .secondsSince1970

This is applicable to other environments too. If you're building a server using swift, you can use those custom JSONEncoder/JSONDecoder date strategies to encode date types so you know what they'll look like on the server side. The other options for date strategies can be found in the documentation.

Scripting With Swift

2020-11-04T06:00:00.000Z

Create the script

Launch the terminal and cd into the directory you want your script to be. Eg: cd Desktop/Scripts.

Enter touch main.swift to create a new swift file.

Then, to make it executable change the chmod on the file with chmod +x main.swift. This makes it so your computer recognizes the file as something that can be run. Instead of something to read.

Launch Xcode (or another editor) and open your new swift file. Then add this bit to the top:

#!/usr/bin/swift // This is crucial. Without it your script will not run.

print("Hello World")

Now, go back to your terminal and run the script using ./main.swift. It should read something like

user@Computer ~ % ./main.swift 
Hello World
user@Computer ~ %

One more thing to note

Xcode's autocomplete will not work for scripts. So what I do is create a playground, write and debug the script and then when it's ready copy-paste it into the script file you just made. Then, you have autocomplete while writing the script.

Programatic UI in UIKit without Storyboards

2020-11-04T06:00:00.000Z

This doesn't reflect my opinions circa 2024, however I'm leaving this public cause removing media is always bad. This was written while I was in high school, so take it with a large grain of salt and don't judge my writing abilities 😅.

Why are storyboards all that bad?

Answer: They're not

Really, storyboards are super good at helping create UI. They make it easy to see exactly what you're building and work with constraints on each view. Sometimes though, it's easier to not use them. For more repetitive views, using storyboards will be a pain, having to link every single input and output to your UIViewController file, copy-pasting the whole thing. It leads to bugs and spaghetti code.

Sometimes though, in an app with many views storyboards get messy and overloaded. It then becomes easier to use programmatic views and try not to use storyboards. Otherwise there's no disadvantage to using them.

The best way that I've found to create View Controllers programmatically is this.

We'll be making a simple UI with a label, image and button as an example.

First, create your UIViewController. We'll call it SampleViewController

import UIKit

class SampleViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()

    }
}

There. Now lets add a few methods underneath the viewDidLoad() function.

private func setUpViews() {

}

private func setUpConstraints() {

}

These methods will hold our UI setup code. Let's add some variables to the top of this class to reference the 3 UI item's we're going to add

class SampleViewController: UIViewController {

var label: UILabel?
var button: UIButton?
var image: UIImage?

...

Great! Now lets populate those variables.

In the setUpViews() function put this code in.

private func setUpViews() {

    label = UILabel()
    label?.text = "Hello World!"
    label?.translatesAutoresizingMaskToConstraints = false //Important to do with all views. If you don't set this to false, iOS will break all the constraints you will set.

    button = UIButton()
    button?.titleLabel.text = "Press Me"
    button?.tintColor = .systemBlue
    button?.translatesAutoresizingMaskToConstraints = false //Important
    button?.addTarget(self, action: #selector(buttonPressed), for: .touchUpInside) //Will return an error right now, ignore it as we haven't added the target function yet.

    image = UIImage()
    image?.image = UIImage(systemName: "gamecontroller")
    image?.translatesAutoresizingMaskToConstraints = false //Important

    //Add the views we just created to the view hierarchy
    view.addSubview(label!) //we can force-unwrap these because we know we just made them and they won't be nil.
    view.addSubview(button!)
    view.addSubview(image!)
}

Awesome! It's easy right? You have complete access to each view you're adding right here in this function. You modify it and add targets and images cleanly and knowing exactly what each one is going to be.

Now lets add some constraints and lay out our UI.

We'll be using layout anchors to layout our views. They're much simpler to deal with than constraints.

In the setUpConstraints() function we defined before enter this.

private func setUpConstraints() {
    NSLayoutConstriant.activate([
        // Place the label in the top
        label.topAnchor.constraint(equalTo: view.topAnchor),
        label.leftAnchor.constraint(equalTo: view.leftAnchor, constant: 16),
        label.rightAnchor.constraint(equalTo: view.rightAnchor, constant: -16),

        // put the button centered below the label
        button.topAnchor.constraint(equalTo: label.bottomAnchor),
        button.widthAnchor.constraint(equalToConstant: 250),
        button.heightAnchor.constraint(equalToConstant: 100),
        button.centerXAnchor.constraint(equalTo: view.centerXAnchor),

        //put the image below the button
        image.topAnchor.constraint(equalTo: button.bottomAnchor),
        image.leftAnchor.constraint(equalTo: view.leftAnchor, constant: 16),
        image.rightAnchor.constraint(equalTo: view.rightAnchor, constant: -16)
    ])
}

The function NSLayoutConstraint.activate([]) activates multiple constraints at once. So we use it here to activate all of ours at once.

Make sure to add the setUpViews() and setUpConstraints to your viewDidLoad() function. Otherwise our code won't ever be executed :).

Let's also add the button target code at the end of the file:

@objc func buttonPressed() {
    print("You Pressed the Button!")
}

Sweet! You're all done! You've made a UIViewController with a UI without any storyboards.

Here's the full code:

import UIKit

class SampleViewController: UIViewController {

    var label: UILabel?
    var button: UIButton?
    var image: UIImage?

    override func viewDidLoad() {
        super.viewDidLoad()
     
        setUpViews()
        setUpConstraints()
    }

    private func setUpViews() {
        label = UILabel()
        label?.text = "Hello World!"
        label?.translatesAutoresizingMaskToConstraints = false //Important to do with all views. If you don't set this to false, iOS will break all the constraints you will set.

        button = UIButton()
        button?.titleLabel.text = "Press Me"
        button?.tintColor = .systemBlue
        button?.translatesAutoresizingMaskToConstraints = false //Important
        button?.addTarget(self, action: #selector(buttonPressed), for: .touchUpInside) //Will return an error right now, ignore it as we haven't added the target function yet.

        image = UIImage()
        image?.image = UIImage(systemName: "gamecontroller")
        image?.translatesAutoresizingMaskToConstraints = false //Important

        //Add the views we just created to the view hierarchy
        view.addSubview(label!) //we can force-unwrap these because we know we just made them and they won't be nil.
        view.addSubview(button!)
        view.addSubview(image!)
    }

    private func setUpConstraints() {
        NSLayoutConstriant.activate([
            // Place the label in the top
            label.topAnchor.constraint(equalTo: view.topAnchor),
            label.leftAnchor.constraint(equalTo: view.leftAnchor, constant: 16),
            label.rightAnchor.constraint(equalTo: view.rightAnchor, constant: -16),

            // put the button centered below the label
            button.topAnchor.constraint(equalTo: label.bottomAnchor),
            button.widthAnchor.constraint(equalToConstant: 250),
            button.heightAnchor.constraint(equalToConstant: 100),
            button.centerXAnchor.constraint(equalTo: view.centerXAnchor),

            //put the image below the button
            image.topAnchor.constraint(equalTo: button.bottomAnchor),
            image.leftAnchor.constraint(equalTo: view.leftAnchor, constant: 16),
            image.rightAnchor.constraint(equalTo: view.rightAnchor, constant: -16)
        ])
    }

    @objc func buttonPressed() {
        print("You Pressed the Button!")
    }
}

Getting Started With Vapor 4.0

2020-11-04T06:00:00.000Z

What is Vapor?

Vapor is a modern server-side swift framework. It's community built , with tons of support for databases, hosting and user management. It's built on my favorite language Swift, meaning it's easy to learn, and has type safety built in.

I'll be building a small time tracking API similar to Toggl over the course of a few posts, this is the first in this series.

Get Started - Installation

Install Swift

If you're running a Mac, and already have Xcode installed. Great, you can skip this step. If not, go to the App Store and download it.

If you're running a Linux computer, you'll have to go over to the Swift Downloads page, and follow the instructions there for your distribution.

Install Vapor

We're going to need the vapor toolbox to run any project we make.

To install it on mac, you'll need homebrew installed. Once installed, run brew install vapor and homebrew will install it all for you. Then when it's done, verify your installation by running vapor -help. You should see a list of available commands.

If you're on Linux, you'll have to build vapor from source. Just run these commands in a terminal.

git clone https://github.com/vapor/toolbox.git
cd toolbox
git checkout <desired version>
make install

Then verify it's installed correctly by running vapor -help.

Creating a project

Now, we're going to set up our working directory. I'm going to build a time logging API, so I'll name my project TimeLog.

We'll just run vapor new TimeLog and follow the prompts given to you. You'll probably want to answer no to all the questions and get a bare-bones template to get started. For that, you can add a -n flag to the end of the prevous command like this vapor new TimeLog -n.

Sweet! Now you have an empty vapor project!

Get a Database Running

I'm going to be using the Postgres database, as it's the one I have the most experience with. Vapor supports tons of databases. So you should be able to follow along with this tutorial no matter which one you choose.

If you don't have any databases installed, I'd recommend Postgres. This gist helped me a lot when I first installed it.

Since I'm using Postgres, I've created a database named time-table and opened the database to the url postgres://<Admin-Name>:@localhost:5432/time-table. Since this isn't goint to be a public project quite yet, I left off giving the database a password. If you're planning on releasing this server to the world, you need a password.

Once you have the url of your database, make a .env file in the root directory of your project. Then, insert the url you just made like this DB_URL=postgres://<Admin-Name>:@localhost:5432/time-table on the first line. Then you're all set with your database.

Finally, Swift

Dependencies

Make an Xcode project by running vapor xcode in your project's directory.

For this series, I'm going to be using a few SPM packages. If you're following along, install them by opening the Package.swift and adding these three dependencies below .product(name: "Vapor", package: "vapor"),:

.product(name: "Fluent", package: "fluent"),
.product(name: "FluentPostgresDriver", package: "fluent-postgres-driver"),
.product(name: "JWT", package: "jwt")

Then, below where it says .package(url: "https://github.com/vapor/vapor.git", from: "4.0.0"), add these lines.

.package(url: "https://github.com/vapor/fluent.git", from: "4.0.0"),
.package(url: "https://github.com/vapor/fluent-postgres-driver.git", from: "2.0.0"),
.package(url: "https://github.com/vapor/jwt.git", from: "4.0.0-rc.1"),

This will install Fluent, Vapor's database framework, JWT, which we'll use for user authentication and the Fluent Postgres Driver so we can use our Postgres database.

Connect the database

In your configure.swift file under Sources > App add the following extension to the top of the file.

extension Application {
    static let databaseURL = URL(string: Environment.get("DB_URL")!)!
}

This uses the .env file we made earlier to get the database url. You can use .env files for other things like admin keys and passwords you don't want plain in your code for anyone to see.

Now lets use that url in the configure(_ ) function add the following line to the top.

try app.databases.use(.postgres(url: Application.databaseURL), as: .psql)

Right now, Xcode will throw an error, so import the required dependencies at the top of the file.

import Fluent
import FluentPostgresDriver
import JWT

Conclusion

There we go! You now have an empty vapor project with an empty database and all the dependencies installed. I'll be making a part 2 soon for this series, when it's up it'll be linked right here!

Save Arrays of Objects in Realm

2020-05-14T05:00:00.000Z

The problem: Realm only allows you to save lists of objects (like arrays) in the `List<T>` format.

For instance we'll take this dog object. The dog can have multiple Collars, but you have to store them in a list like so.

class Dog: Object {
    @objc dynamic var name = ""
    @objc dynamic var age = 0

    let collars = List<Collar>()
}

class Collar: Object {
    @objc dynamic var color = "Blue"
    @objc dynamic var favorite = false
}

This makes for slightly confusing code when trying to retrieve the collars from the dog and do other operations. However, we can abstract the list and make it an array property by adding one propery to the Dog object

class Dog: Object {
    @objc dynamic var name = ""
    @objc dynamic var age = 0

    var collars: [Collar] {
      get {
        return _collars.map{ $0 }
      }
      set {
        _collars.removeAll()
        _collars.append(objectsIn: newValue)
      }
    }
    // The original property is here, we simply renamed it and added the above collar variable.
    let _collars = List<Collar>()
}

We change the collars property to _collars, then make a new variable collars that realm wont track.

This variable has two key parts: a getter, and a setter.

The getter simply maps the _collars object to an array and returns the array.

get {
    return _collars.map{ $0 }
}

The setter removes all the values using .removeAll() and then sets the _collars list from the given array.

Now we can use the collars property just like any other array. Just make sure to use it in a write block when writing the object to storage like so:

try! realm.write {
    dog.collars = [Collar(color: "Red", favorite: false), Collar(color: "Blue", favorite: true)]
}

This method makes it easier to work with the List<> object and allows for simpler, easier to read code in the rest of your app.

Subclassing Sprites in SpriteKit

2020-05-11T05:00:00.000Z

Subclassing

Subclassing SKSpriteNodes makes it easy to have multiple classes of a similar sprite. One use case for this would be in a breakout-like game where there are multiple kinds of blocks that can do different things.

In this example we'll start with a normal BlockNode. Then, we'll subclass it to create a new type of block called ExplosionNode.

Block Node

The code for the original block node looks like this.

class BlockNode: SKSpriteNode {
    
    var background: SKShapeNode?
    
    convenience init(size: CGSize) {
        self.init(texture: nil, color: .clear, size: size)
        
        background = SKShapeNode(rectOf: size, cornerRadius: 5)
        background!.fillColor = .darkGray
        background!.strokeColor = .lightGray
        addChild(background!)
    }
    
    override init(texture: SKTexture?, color: UIColor, size: CGSize) {
        super.init(texture: texture, color: color, size: size)
    }
    
    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    public func endBlock() {
        guard let scene = self.scene as? GameScene else { self.removeFromParent(); return }       
        removeFromParent()
    }
    
}

This simple SKSpriteNode class creates a block with a grey background. It can be created using BlockNode(size: CGSize()).

In the game when the ball touches the block, endBlock() is called to remove the block.

Now that we have a normal block lets make another, more fun, block.

Explosion Block

We can easily subclass the BlockNode by adding it to the class definition of ExplosionBlockNode like so.

class ExplosionBlockNode: BlockNode {
	...
}

Now lets override the init function that makes the block grey, and instead make it red.

    convenience init(size: CGSize) {
        self.init(texture: nil, color: .clear, size: size)
        
		background = SKShapeNode(rectOf: size, cornerRadius: 5)
        background!.fillColor = .red
        background!.strokeColor = .darkGray
        addChild(background!)
    }

Now the block can be created using the same method as the normal block, except now using ExplosionBlockNode(size: CGSize()). This initializer will create a red block instead of a grey one.

We can also change the endBlock() function to being special for the explosion block by simply adding it to the ExplosionBlockNode like this.

    override public func endBlock() {
        guard let scene = self.scene as? GameScene else { self.removeFromParent(); return }

        let scoreLabel = SKLabelNode(text: "Boom")
        scoreLabel.color = .red
        scoreLabel.position = self.position
        scoreLabel.fontSize = 24
        scene.addChild(scoreLabel)
        scoreLabel.run(.sequence([.group([.moveTo(y: self.position.y + 50, duration: 0.4), .fadeOut(withDuration: 0.3)]), .removeFromParent()]))

        scene.addChild(field)
        field.run(SKAction.sequence([SKAction.wait(forDuration: 0.05),SKAction.removeFromParent()]))
        removeFromParent()
    }

Now when we call the endBlock method on the explosion block it'll add a little label saying "Boom" that fades quickly and animates up.

The final explosion block code looks like this.

class ExplosionBlockNode: BlockNode {

    convenience init(size: CGSize) {
        self.init(texture: nil, color: .clear, size: size)

        background = SKShapeNode(rectOf: size, cornerRadius: 5)
        background!.fillColor = .red
        background!.strokeColor = .darkGray
        addChild(background!)
    }

    override public func endBlock() {
        guard let scene = self.scene as? GameScene else { self.removeFromParent(); return }

        let scoreLabel = SKLabelNode(text: "Boom")
        scoreLabel.color = .red
        scoreLabel.position = self.position
        scoreLabel.fontSize = 24
        scene.addChild(scoreLabel)
        scoreLabel.run(.sequence([.group([.moveTo(y: self.position.y + 50, duration: 0.4), .fadeOut(withDuration: 0.3)]), .removeFromParent()]))

        scene.addChild(field)
        field.run(SKAction.sequence([SKAction.wait(forDuration: 0.05),SKAction.removeFromParent()]))
        removeFromParent()
    }

}

Using Dependencies in Swift Scripts

2020-05-05T05:00:00.000Z

Swift-sh

Swift-sh is an amazing dependency package from Max Howel. The library makes it easy to use any Swift Package Manager (SPM) package into your Swift scripts. (more on writing Swift scripts)

In this example I'll be importing the Colors library by paulot and the Progress library from jkandzi . A mixture of these two libraries makes for fun, colorful script output like this.

Which I think is fun. We'll be importing both libraries using Swift-sh.

Install Swift-sh

To install swift-sh you'll need homebrew installed on your mac.

Then, it's just a simple command to install

brew install mxcl/made/swift-sh

Go check out [Max's GitHub](https://github.com/mxcl) and [Patreon](https://www.patreon.com/mxcl). He's an amazing programmer and has built tons of important open source tools

Create The Script

cd into the directory you'll run your script in and run touch main.swift to create an empty script. Then make it executable using chmod +x main.swift.

Now open the file using any editor and enter this on the first line.

#!/usr/bin/swift sh

This tells the terminal to use swift sh to execute our script, which is exactly what we want.

Import Progress

Next, in the main.swift file do a normal import like you would in any other Swift project.

import Foundation
import Progress
import Colors

If you run this code right now you'll get an error because there aren't any packages linked to your script. Let's import Progress with swift-sh like this.

import Progress // jkandzi/Progress.swift

The comment after the import statement tells swift-sh to retreive the SPM package Progress.swift from GitHub. You tell swift-sh where the package is by giving it the path to the repository on GitHub.

Import Colors

Now that Progress is imported successfully lets import Colors.

Colors doesn't have SPM support naturally, so I'm going to give it one. I've downloaded the source code from here and grabbed all the files in the folder Colors. I've deleted the files Colors.oInfo.plist and ANSITextColorCode.o as the script doesn't need them.

Now go back to the directory your script is in and run mkdir Colors. cd into the new directory and run mkdir Sources.

Next, drag and drop the downloaded Colors folder into the Sources folder you just made.

The last thing we need to make is a Package.swift file. This tells SPM what code is available for this package. Make one using touch Package.swift

Your file structure should look like this.

Open Package.swift and copy-paste the following into the file.

// swift-tools-version:5.1
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "Colors",
    products: [
        .library(
            name: "Colors",
            targets: ["Colors"]),
    ],
    targets: [
        .target(
            name: "Colors",
            dependencies: [])
    ]
)

Save it, and you now have a SPM package!

Lets go back to the main.swift file and import Colors using swift-sh like this.

import Colors // ./Colors/

Run The Script

Now that all the dependencies are working, your script should look like this.

#!/usr/bin/swift sh

import Foundation
import Colors // ./Colors/
import Progress // jkandzi/Progress.swift

Add this code to give some fun output when you run the script.

#!/usr/bin/swift sh

import Foundation
import Colors // ./Colors/
import Progress // jkandzi/Progress.swift

print(Colors.Red("The Script is Running, Downloading Important Data..."))
for _ in Progress(0...100) {
    sleep(1)
}
print(Colors.Green("Script Complete!"))

To run the script run ./main.swift in the same directory as the script. If you get an error saying zsh: permission denied: ./main.swift run chmod +x main.swift to fix it.

Your terminal should now be counting down from 101, nice job!

Full usage documentation for swift-sh can be found here. I've only covered two ways of using this library but there's much more you can do with it.

Easy Container Controllers in Swift

2020-02-23T06:00:00.000Z

What are container controllers?

Container controllers are like a larger, older brother to the UIViewController. They come in extremely handy when dealing with things like Auth state and UIViewController transitions. UIKit already comes with a few container controllers that you most likely know very well. Some examples of these are the UINavigationController, or the UITabViewController. Each of those controllers have one or more sub-controllers and help with things like transitions or UI that needs to stay similar between each of the sub-controllers they contain.

Why should I spend the time to make one?

Container controllers do a few things that make life as a developer much easier. First, they naturally separate your UI code. Instead of having your Auth.onSignOut() function in your AppDelegate (which can get very messy, very quickly), you have the Auth.onSignOut() happen in a separated container that can directly interact with it's sub-controllers without having to use any window.controllers.first junk.

First we need a few extensions.

Make a new file for this extension and put the following code in.

import UIKit

extension UIViewController {
    /*
     This method gives us a function to quickly add a child view controller,
     it takes care of adding the child, adding the view as a subview and then
     telling the subview that it's moved to a new parent.
     */
    func add(_ child: UIViewController) {
        addChild(child)
        view.addSubview(child.view)
        child.didMove(toParent: self)
    }

    /*
     This method makes it simpler to remove a child view controller.
     */
    func remove() {
        // First we check if the parent view controller exists,
        // if not we can stop the whole thing right now.
        guard parent != nil else { return }

        // Here we enumerate through each subview telling them that their
        // going to be removed and then removing them.
        children.forEach({
            $0.willMove(toParent: nil)
            $0.view.removeFromSuperview()
            $0.removeFromParent()
        })

        // These tell this view controller that it will be moving to nil parent
        // and then removes it from the parent view controller.
        willMove(toParent: nil)
        view.removeFromSuperview()
        removeFromParent()
    }
}

Read through the comments above for more detail on this peice of code. Basically this extension makes it easier to add and remove child view controllers.

Implementing the Container Controller.

Here's the main code of the controller.

import UIKit

class ContainerController: UIViewController {

    static let shared = ContainerController()

    var displayedView: UIViewController?

    override func viewDidLoad() {
        super.viewDidLoad()

        if displayedView == nil {
            displayedView = UIStoryboard(name: "Main", bundle: nil).instantiateInitialViewController()
            add(displayedView!)
        }
    }

    public func transitionTo(_ view: UIViewController) {
        if displayedView != nil{
            displayedView!.remove()
        }
        add(view)
        displayedView = view
    }
}

Simple. In it we give a simple UIViewController with one method called transitionTo(_ view:) which can be called by outside controllers to change what view is displayed.

We also added a default view to be displayed in the viewDidLoad(). It just makes sure that when we initialize this class it automatically populates the displayedView variable. In this example I intitialize the root controller from the main storyboard, but you can replace it with any view controller or even omit this code entirely.

Also! I created a singleton by adding a static let shared = ContainerController() variable. You can read more about singletons here but they basically make it so we can keep track of one container controller for the entire app.

TL;DR: Some people dislike singletons. However, in this case the ability to access the container controller from anywhere in your app without having to implement a delegate method or callback into every single view controller greatly outweighs the tiny bit of overhead a singleton creates.

Sweet. How do I use it?

Really easily. The main way I use it is in my AppDelegate (or SceneManager) like so:

import UIKit

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        var controller: UIViewController!

        let container = ContainerController.shared

        // In this example I'm using FirebaseAuth for authentication.
        // I check if a user is logged in, and if they are I send them
        // to the "Admin" view. Otherwise they go to the "Auth" view.
        if Auth.auth().currentUser != nil {

            let storyboard = UIStoryboard(name: "Admin", bundle: nil)
            controller = storyboard.instantiateInitialViewController()!

        } else {

            let storyboard = UIStoryboard(name: "Auth", bundle: nil)
            controller = storyboard.instantiateInitialViewController()!

        }

        // Make the container the root view controller.
        self.window?.rootViewController = container
        self.window?.makeKeyAndVisible()

        // Transition to the pre-defined controller
        container.transitionTo(controller)

        return true
    }

}

Really fairly simple to use. It can also be used from a view controller after the app is already running. To access the container at the root one can simply use ContainerController.shared.

This post was heavily inspired by John Sundell's post here. Go check it out, he's an amazing writer and developer.

Firebase Auth State Listeners iOS

2019-12-19T06:00:00.000Z

Firebase auth lets you pass a handler function when the auth state changes.

In my use case I need to receive state change alerts. My user might be disabled by an admin or a bot, or the account is stopped for security reasons. But, I need to update user interfaces and data code to match that the user is logged out.

Fortunately its easy with firebase

Somewhere in your startup code -I use a container view for all my views, but the AppDelegate or SceneManager works well here- put this snippet in.

func setAuthListener() {
    Auth.auth().addStateDidChangeListener { (auth, user) in
        guard let user else {
            // The user is either logged out, or something went wrong. 
            // You can use the Auth.auth().currentUser.reload() function 
            // to try to find the error using the FIRErrorCode enum
            return
        }

        // Otherwise, we now have a signed in user. Usually that just means 
        // we carry on, but you could put some custom handler here too.
    }
}

Then just fire that function somewhere at the start of your app, or in a container controller like we made in this article.