Strongly Typed on Daniel Lyons

Adding Privacy-Friendly Comments to a Hugo Site with Chirpy

Thu, 01 Jan 2026 00:00:00 +0000

I needed a comment system for this blog. Not because I expect a flood of discussion (let’s be honest, most personal tech blogs don’t) but because those rare moments when someone has a question or insight are worth enabling. The challenge? Finding a solution that respects privacy, stays free or cheap, and doesn’t require a PhD in server administration.

The Search: What I Actually Needed

My requirements were straightforward:

Privacy-preserving - No aggressive tracking or data selling
No account required - Reduce friction for commenters
Anonymous commenting - Allow users to comment without revealing their identity
Free or cheap - This is a personal blog, not a business
Proper moderation - I need to delete spam and get notified of new comments
Simple setup - Ideally just drop in a script tag
Future flexibility - Open source preferred, so I could self-host later if needed

Why Not Disqus?

I tried Disqus first. It’s the obvious choice. It’s nearly ubiquitous, feature-rich, and easy to set up. But the more I learned about its privacy practices, the less comfortable I felt.

Ensuring Swift Compatibility on Linux

Sat, 13 Dec 2025 00:00:00 +0000

Ensuring Swift Compatibility on Linux

Swift has long had a reputation for being that iOS language, but the truth is that Swift has had cross-platform Linux support for nearly a decade. It’s robust and battle-tested in production, powering web backends, microservices, and command-line tools. That being said, like any platform, Linux has its own quirks and best practices that differ slightly from development on Apple platforms. This guide covers essential tips and strategies to ensure your Swift projects run smoothly on Linux.

How to Publish Unlisted Posts in Hugo

Mon, 18 Aug 2025 00:00:00 +0000

How to Publish Unlisted Posts in Hugo

Sometimes you want to publish a blog post that’s accessible via direct URL but doesn’t appear in your site’s normal navigation or discovery mechanisms. This is useful for sharing draft content with specific people, creating landing pages, or publishing content that you want to keep semi-private.

When creating unlisted posts, you typically have four main concerns:

Search Engine Visibility: You don’t want the post to appear in Google search results
Sitemap Inclusion: You don’t want it listed in your sitemap.xml
RSS Feed Inclusion: You don’t want it appearing in your RSS feeds
Site Listings: You don’t want it showing up on any list pages (homepage recent posts, category pages, tag pages, etc.)

Let’s address each of these concerns systematically.

Migrating Notes from Hugo/Quartz to Obsidian Publish

Fri, 30 May 2025 00:00:00 +0000

Migrating Notes from Obsidian Quartz to Obsidian Publish, Seamlessly Integrated with Netlify

It’s no secret that I am a very big fan of Obsidian. I use it for everything from note-taking to project management, and even as a publishing platform for my notes. In order to publish notes on the web, Obsidian offers Obsidian Publish, a service that allows you to host your notes as a static website. However, I had been using Obsidian Quartz for my publishing needs. I liked it primarily because it was free and open source, and I could host it myself on GitHub Pages. However, I found that the publishing workflow was a bit cumbersome. So I finally decided to migrate my notes from Obsidian Quartz to Obsidian Publish, while still keeping them under my main website (dandylyons.net) using Netlify as a proxy.

Goodbye Dataview! Hello Obsidian Bases!

Sat, 24 May 2025 00:00:00 +0000

Obsidian has recently unveiled a game-changing native feature: Bases. If you’ve ever wished for Notion-like database capabilities within your Obsidian vault, but with the security of open, human-readable formats that won’t lock you in, this is the update you’ve been waiting for. Bases, a new core plugin, is currently available for Catalyst members via early access (version 1.9.0 and above), and it’s set to revolutionize how we organize and interact with information in Obsidian.

Smooth Site Migration: Redirecting GitHub Pages to Netlify Path-by-Path (with Hugo & SEO in Mind)

Wed, 14 May 2025 00:00:00 +0000

Migrating a website can be a bit like moving houses – exciting, but you still need to ensure everyone who knew your old address can find you at the new one. When I recently moved my personal site from GitHub Pages (dandylyons.github.io) to Netlify (dandylyons.net), I faced this exact challenge. My old GitHub Pages site was still live, and simply letting it sit there wasn’t ideal for users or search engine optimization (SEO).

Icons in SwiftUI

Tue, 29 Apr 2025 00:00:00 +0000

Icons in SwiftUI

Icons are an incredibly powerful technique in modern UI design. They can convey meaning, add visual interest, and enhance the overall user experience. They can also take a lot of time to create and implement. Thankfully, SwiftUI comes with a built-in library of icons that you can use in your apps called SF Symbols. While SF Symbols are a fantastic resource, they still have a limited selection of icons (and very strict Apple guidelines). In this article, we’ll explore how to use SF Symbols in SwiftUI, we’ll learn about another open-source icon library, and finally we’ll learn how to create custom icons that fit your app’s design language.

Introducing: "Let There Be Sight" now in beta!

Mon, 21 Apr 2025 00:00:00 +0000

Introducing the Beta of Let There Be Sight: Alt Text Made Easy

Today, I’m excited to announce the iOS beta release of my latest project: Let There Be Sight — an app that makes it easy to describe any image with text. You can try it for free today via TestFlight:

👉 Join the beta on Apple TestFlight

But before you dive in, let me explain why this app matters.

Why Alt Text Matters

If you’ve spent any time in communities like Mastodon or Bluesky, you’ve probably seen people talking about the importance of alt text — short textual descriptions of images that make them accessible to people using screen readers.

Swift Error Handling: The Solution

Sat, 29 Mar 2025 00:00:00 +0000

Swift Error Handling: The Solution

In our last post Swift Error Handling: The Problem , we discussed the problems with error handling in Swift. In this post, we will explore some solutions to these problems and how to implement them in your code, and we will preview my new Catcher library which provides a variety of tools following these patterns. 19|

But alas, my library is not the solution. It is only a solution. In the last section, we will discuss some potential new Swift features that could eliminate these problems altogether.

Swift Error Handling: The Problem

Thu, 27 Mar 2025 00:00:00 +0000

Swift Error Handling: The Problem

Error handling is a fundamental aspect of robust iOS application development. As developers, we’re constantly dealing with operations that can fail - network requests, file operations, data parsing, and user input validation. Swift provides a structured approach to error handling, but like any system, it has its strengths and weaknesses. In this first post of a three-part series, we’ll explore the current state of Swift’s error handling system, examining both what works well and what could be improved.

Actually Useful Obsidian: Formatting

Tue, 18 Feb 2025 00:00:00 +0000

Today we start a new series on one of my favorite note-taking apps, Obsidian. In this series, we’ll cover the basics of Obsidian. Here we will intentionally NOT be doing anything particularly fancy. We won’t be using strange plugins or custom CSS. Instead we’ll be focusing on the most helpul, core features that I use every day. Beginners will be able to finally overcome the initial learning curve and start using Obsidian effectively. And experienced users will find helpful tools to simplify their setup!

What's the difference between class and class_name in Godot?

Tue, 11 Feb 2025 00:00:00 +0000

When you’re writing scripts in Godot, you might have noticed that some scripts use class and others use class_name. What’s the difference between these two keywords? Let’s find out.

`class_name` keyword

You may have noticed that so many GDScript scripts in Godot start with extends Node or extends Resource. This is because Godot uses a common programming feature called class inheritance.

extends Node
var str = "Hello, World!"

So when you use extends, you are telling GDScript that your class inherits from an existing class. So when we write extends Node, we are creating a new class that inherits from the Node class.

Easy Deep Copy Cloning in Swift

Tue, 04 Feb 2025 00:00:00 +0000

In most programming languages, there is some concept of value and reference types. In Swift, we prefer to use value types and value semantics whenever possible. This is because value types are easier to reason about since they cannot be mutated by other parts of the code.¹ However there are some times when we must use reference types. Is there a way to get our reference types to behave like value types? Yes, there is.

Introducing SelectiveEquatable

Thu, 12 Dec 2024 00:00:00 +0000

A few weeks ago, I released a blog post named “Selective Equality Checking in Swift”. In that post, I designed and implemented an API to check for equality on specific properties of a type. Today, I am excited to announce a new Swift protocol named SelectiveEquatable, that makes all of this even easier. Let’s see it in action.

Using SelectiveEquatable

To use the SelectiveEquatable protocol, all you need to do is add a conformance to it like this:

Am I Using Swift 5 or 6?

Tue, 19 Nov 2024 00:00:00 +0000

Swift is in the middle of a transition from Swift 5 to Swift 6. This transition is not as simple as it may seem. In this post, we will discuss how to determine which version of Swift you are using. But first we need to clear up some misconceptions.

We need to understand the difference between Swift 6 the compiler and Swift 6 the language mode.
We need to understand how to determine which version of the Swift compiler we are using.
We need to understand how to determine which version of the Swift language mode we are using.
We need to understand how to opt in or out of Swift 5 or Swift 6 language mode.

Note: This post will be primarily concerned with the native Swift Package Manager. Xcode has been known to behave slightly differently than SPM, and this post does not exhaustively cover all the ways Xcode may differ. This post assumes that you know how to use SPM and particularly how to declare a Swift Package using a Package.swift file. If you are not familiar with this, I recommend reading the Swift Package Manager Documentation.

Gradual Static Typing in GDScript

Wed, 13 Nov 2024 00:00:00 +0000

Any time we learn a new programming language, one of the first things we tend to fixate on is the syntax. But in many ways syntax is actually less important. The syntax is effectively the UI of the programming language. It’s how the language “looks”. But learning a language also requires understanding how a language “works”.

One of the first and most important things that we should learn about a programming language is its type system.¹.

Selective Equality Checking in Swift

Tue, 05 Nov 2024 00:00:00 +0000

The humble Equatable protocols is one of the most fundamental tools in Swift, but sometimes it is not always the best tool for the job. Last week we learned how to check equality for collections while ignoring order. Today we will learn how to pick and choose exactly what properties we would like to check equality on. But first let’s talk about the problem:

Why Not Just Use Equatable

For the majority of use cases the best option is to just use the plain old == operator. We get this operator automatically when a type conforms to Equatable. However it’s not always easy conform to Equatable. Here are some situations when it might not be feasible or even possible to conform to Equatable.

Unordered Equality Checking in Swift

Tue, 29 Oct 2024 00:00:00 +0000

Have you ever needed to compare two arrays in Swift, but the order of elements doesn’t matter? I find this often happens to me when convert between an ordered type such as Array and an unordered type such as Set or Dictionary. Today, we’ll explore how to implement unordered equality checking in Swift, starting with the basics and working our way up to a flexible, protocol-based solution.

What is Deep Equality?

Before diving into unordered equality, let’s briefly discuss deep equality. Many programming languages struggle with deep equality comparisons. Take JavaScript, for example:

A Deep Dive into Value and Reference Types in Swift

Tue, 22 Oct 2024 00:00:00 +0000

Understanding how Swift handles memory and data is key to writing efficient, bug-free code. In this post, we’ll explore the differences between value and reference types, and more importantly, what value and reference semantics mean in Swift. By the end, you’ll know how to think about these concepts when designing your own Swift code.

Value vs. Reference Types

Let’s start with an analogy that can help illustrate the difference between value and reference types: a library. Most libraries today have both physical books and digital books.

Swift Assertions Cheatsheet: How, Why, and When to Crash

Wed, 16 Oct 2024 00:00:00 +0000

As Swift developers, we have several assertion tools at our disposal. But how do we choose the right one for each situation? This blog post will explore the different types of assertions in Swift and provide a framework to help you decide which to use and when.

What is an assertion?

Essentially assertion is a way to check your program’s state at runtime. If the program is behaving correctly (i.e. if its state matches your expectation) then the assertion will do nothing. But if it is not behaving correctly, then the app will crash. In other words, assertions in Swift are a way to crash your program on purpose.

Exhaustive, Flexible, Multi-Typed Error Handling in Swift

Tue, 08 Oct 2024 00:00:00 +0000

Swift has long had fantastic error handling! Errors are simple value types that conform to the Error protocol.

struct IceCreamShop {
 enum Error: Swift.Error {
 case notEnoughMoney
 case flavorNotSoldHere
 }

 private(set) var availableFlavors: [String: IceCreamFlavor]
 private(set) var cashOnHand: Int
 private(set) var isFreezerOn = true
 private(set) var billLastPaidOn: Date
 // ...
}

I really like this pattern! Here, we define a new error type that conforms to the Error protocol. The definition feels a little strange but the call site is very nice. Normally we would simply conform a type to Error but our type is also called Error so we have to disambiguate. We define an enum type named Error and it conforms to the Swift.Error protocol (the Error protocol from the Swift standard library). Why go to this trouble? Because the nested type makes the purpose very clear. In the outside world we can refer to the type as IceCreamShop.Error, and inside the type we can call it Self.Error. So it is very clear that IceCreamShop.Error is designed to contain all the possible errors of the IceCreamShop type. However, this is just a naming convention and nothing in the compiler enforces which types of errors can be thrown.

How to Visualize a Dependency Graph of Swift Dependencies

Wed, 02 Oct 2024 00:00:00 +0000

As projects grow in complexity, it is common to use two techniques:

Depend on external libraries.
Split your codebase into multiple smaller modules.

These techniques have a number of benefits including:

You can reduce build times by only building select modules, instead of the entire project.
You can reuse modules in other projects.
Swift forces you to define external APIs with the public keyword, thus enforcing best practices.

But a modularized codebase also increases complexity by creating a web of dependencies. Small changes in one module, can have vast ripple effects down the dependency chain. For this reason, it can be immensely helpful to visualize your dependency graph like this.

Abstractions Increase Complexity: Here's Why That's Not A Bad Thing

Tue, 01 Oct 2024 00:00:00 +0000

I’m starting to see a pattern that seems to replay again and again. A shiny new technology comes out that solves a problem. A bunch of developers flock to it, evangelizing it to everyone else. Eventually the tech disappoints. The developers complain that the new solution is so complicated, and they long for the next shiny new thing.

Surely this pattern has existed for a long time, and will continue to repeat. But why does it happen? I think it’s because we have fallen for a fallacy. The fallacy is this:

The Swift Ranges Cheatsheet

Wed, 25 Sep 2024 00:00:00 +0000

Ranges are fantastic for when we want to work with a range of sorted values that contain no duplicates.

Core Concepts:

Ranges in Swift define a sequence of values between two bounds (lower and upper) and are widely used in loops, slicing collections, and pattern matching.
There are different types of ranges that control whether the bounds are included or excluded.
Pattern Matching: Ranges can be used in switch statements or if conditions to check if a value falls within a specific range.
Comparable: Ranges must hold a Comparable type.
Prefer ranges when you want to work with a sequence of values without storing the elements in memory, unlike an array that holds all its values.

Range Types Side by Side:

Syntax	Range Type	Description	Lower Bound (✅/❌)	Upper Bound (✅/❌)	Includes Upper Bound (✅/❌)
`a..<b`	`Range`	Half-open range; includes lower bound, excludes upper bound	✅	✅	❌
`a...b`	`ClosedRange`	Closed range; includes both lower and upper bounds	✅	✅	✅
`a...`	`PartialRangeFrom`	Range with only a lower bound	✅	❌	❌
`...b`	`PartialRangeThrough`	Range with only an upper bound, includes upper bound	❌	✅	✅
`..<b`	`PartialRangeUpTo`	Range with only an upper bound, excludes upper bound	❌	✅	❌
`...`	`UnboundedRange`	Range without any bounds	❌	❌	❌

Common Use Cases:

Iteration:

for i in 0..<5 {
 print(i) // Outputs 0 to 4
}

Pattern Matching:

Ranges are great to use in switch or if-case conditions to check if a value lies in a range.¹

Swift 6's New @retroactive Attribute

Tue, 24 Sep 2024 00:00:00 +0000

Swift 6.0 introduced the @retroactive attribute to address a specific issue with protocol conformances. Here’s what you need to know:

The Problem

Suppose you are using a type from an external library and realize that the type does not conform to a protocol such as Codable. You might be tempted to add your own conformance.

import ExternalLibrary
extension ExternalType: Codable {
 // implementation here
}

However, doing this can be quite problematic. What happens if the library owner later adds their own conformance? Which code will execute? Your conformance or their conformance? The answer is that the behavior will be undefined at runtime, since we don’t know which conformance will “win”. Even worse, this same problem will propagate to every library that imports your library.¹

Demystifying Modern macOS Development

Mon, 23 Sep 2024 00:00:00 +0000

Introduction

For many years Apple, arguably left the Mac to languish for years while it focused on iOS and the iPhone. The Mac repeatedly got features years later than its mobile cousins, and the hardware was often behind and underpowered. But now, Mac app development is currently in the best state that it has been in a very long time, thanks to three major developments:

Apple released Catalyst, which translates iPad apps into native macOS apps.
SwiftUI’s learn once, apply anywhere design has made it dramatically easier to share code between macOS and iOS
Apple silicon allows us to run iOS apps natively on the Mac without even translating.

The good news is that we’ve never had so many powerful, first-party supported ways to develop Mac apps. The not so good news is that it’s never been so confusing. Today we will dive into the subtle differences between each of these approaches.

Benchmarking in Swift with swift-collections-benchmark

Tue, 17 Sep 2024 00:00:00 +0000

There is an age-old adage of programming which states “Make it work, then make it right, then make it fast.” Today we will be focusing on how to make it fast, with the help of a valuable technique called Benchmarking.

When developing software, especially when working with algorithms and data structures, performance is often a key concern. You may have experienced a piece of code that behaves well in your tests, but when it’s exposed to real-world data, performance degrades. This is where benchmarking comes in. Benchmarking allows developers to measure how long a piece of code takes to run, helping to identify bottlenecks and areas for optimization.

Using Custom Components in Swift's Regex

Tue, 10 Sep 2024 00:00:00 +0000

In our last article we learned about Swift’s Regex type and the various different ways to create them. Today we’re going to dive a little deeper into one of those methods. We’ll be building a custom RegexComponent using the CustomConsumingRegexComponent protocol.

For a quick refresher, remember that we can create a custom parser using the RegexBuilder DSL like this:

import RegexBuilder

Regex {
 Capture {
 Repeat(count: 3) {
 One(.digit)
 }
 }
 "-"
 Capture {
 Repeat(count: 3) {
 One(.digit)
 }
 }
 "-"
 Capture {
 Repeat(count: 4) {
 One(.digit)
 }
 }
}

Don’t forget that we can use many built-in parsers provided by Foundation like this:

The Many Faces Of Swift's Regex

Tue, 03 Sep 2024 00:00:00 +0000

In Swift 5.7, Swift added native support for regular expressions through a new type, Regex. Regular expressions have been a staple part of programming for decades and provide many capabilities including:

data detection
data validation
string parsing

However, regular expressions can also be notoriously difficult to use due to:

Using Optionals with SwiftUI Bindings

Tue, 27 Aug 2024 00:00:00 +0000

Optionals are an invaluable, core feature of Swift, and Bindings are the same for SwiftUI, but unfortunately it can be difficult to get them to play nicely with each other. Bindings are one of the core ways to empower child views to talk to parent views, and they are used throughout the SwiftUI framework. For example all of these core components use Bindings.

TextField("Last name", text: $person.lastName)
DatePicker("Death date", selection: $person.deathDate)
ColorPicker("Favorite color", selection: $person.favoriteColor)

But this gets much more complicated if you need a Binding for an Optional property. SwiftUI rarely, if ever, provides Views that accept an Optional Binding.

Exhaustive Testing Made Easy

Tue, 20 Aug 2024 00:00:00 +0000

Testing is vitally important in virtually any tech stack. That is, unless you want to shut down 8.5 million computers worldwide. ¹ Testing is more than a tedious chore. It’s an automated warning system of current bugs. What is not automated (at least not entirely) is writing the tests. It takes time to write tests, and we have to know what needs to be tested. No matter how well your tests are written, if your tests don’t cover a particular situation, then it won’t be caught. This means that we need to assert on every value in our code. This is tedious and error-prone.

How to Take Full Advantage of Swift Package Index

Tue, 13 Aug 2024 00:00:00 +0000

The Swift Package Index (SPI) is an invaluable resource for both package users and maintainers, streamlining the process of discovering, using, and managing Swift packages. Whether you’re looking to integrate a package into your project or contribute your own, SPI offers a range of features to maximize your productivity and collaboration. This blog post will guide you through the best practices for leveraging SPI to its full potential.

Tips for Package Users

How to Open SPI From GitHub

Perhaps you’ve already found a package you like on GitHub. You can easily jump to viewing the package on SPI simply by changing the url to swiftpackageindex.com. For example, if you are currently at the GitHub repo for the new Swift Testing framework at https://github.com/swiftlang/swift-testing then simply change the url to https://swiftpackageindex.com/swiftlang/swift-testing. If the package is already indexed on SPI then it will take you to the page. If not, then it will guide you through an easy process to request adding it to SPI.

Boost Your Productivity with These macOS Typing Shortcuts

Tue, 06 Aug 2024 00:00:00 +0000

Mastering keyboard shortcuts can significantly enhance your productivity on macOS. These shortcuts are versatile and work in nearly any text field across various macOS apps, including browsers. Moreover, many of these shortcuts can be combined, offering even more powerful text navigation and editing capabilities.

[BONUS] Vim Equivalents:

Many power users and coders may be familiar with Vim, which is a powerful text editor. All of these features are already available in Vim, or any editor that supports Vim key bindings, but if you are using an app that does not support Vim key bindings, then you do not have access to those features. On the other hand, the keyboard shortcuts, below, are available in almost every app in macOS. Non-Vim users can experience many (definitely not all) of the powerful features that Vim users already enjoy, except across the operating system, and without the obtuse syntax. For learning purposes, I’ll include the Vim equivalents in this article.

How to Scroll to a Percentage in a ScrollView

Tue, 30 Jul 2024 00:00:00 +0000

SwiftUI can make many tasks extremely easy, yet SwiftUi struggles to do other seemingly simple tasks. Today we will learn how to accomplish one of those tasks. We will create a ScrollView that can programmatically scroll to a specific location within the ScrollView. First let’s create a new type called ProgrammaticScrollView.

struct ProgrammaticScrollView<Content: View>: View {
 @Binding private var scrollID: Int?
 let content: () -> Content
 init(scrollID: Binding<Int?>, @ViewBuilder content: @escaping () -> Content) {
 self._scrollID = scrollID
 self.content = content
 }

 var body: some View {
 ScrollView {
 ForEach(1..<101) { num in
 VStack {
 Text("\(num)").frame(maxWidth: .infinity, alignment: .leading)
 .id(num)
 Spacer()
 }
 }
 }
 .scrollPosition(id: $scrollID, anchor: .top)
 }
}

Here we’re using iOS 17’s new scrollPosition(id: anchor:) method. This method receives an id of type Binding<(some Hashable)?> and then scrolls to a child view with that id. As you can see there are 100 child views numbered 1 to 100, each with a corresponding id. Programmatically scrolling is now as simple as changing the value of our scrollID Binding!

Hello Hugo

Tue, 23 Jul 2024 00:00:00 +0000

Hello!

Welcome to my personal site! Here I will be posting my projects and things I’m learning.

I’ve recently rewritten this site in hugo! I appreciate how blazingly fast and customizable it is. The code for this site can be found here.

Dev Diary

Now I’d like to share some of my journey of creating this site.

When creating this site, I had a few priorities:

It should be statically generated.
It should be easy to write on using Markdown.
It should be customizable.
It should support modern “tablestakes” website features. (dark mode, social previews, favicons etc.)
It should be developed in Swift.

Initial Priorities

It should be statically generated

One of my first encounters with the concept of statically generated sites was Swift by Sundell. This has been one of my favorite blogs for years, and so eventually I learned that John Sundell created his site using something called Static Site Generation, which is when the entire site generated ahead of time statically.

Concrete and "Soft" Types in Swift

Mon, 01 Apr 2024 00:00:00 +0000

In our last article, we learned about how the generics system is deeply integrated into Swift at practically every level. This can give us magical features that help like Type Inference which makes our code easier to read and right, but it can also lead frustrating and confusing compile-time errors. Furthermore, most modern Swift libraries are filled with generic code, especially in Apple first-party frameworks such as SwiftUI, Combine, and the recently announced SwiftData. I hope that I’ve made a strong case that generics in Swift are simply too important to ignore. So without further ado, let’s dive into generics, albeit with a slightly different approach than you might expect.

Explicit and Implicit Types in Swift

Sat, 16 Mar 2024 00:00:00 +0000

Generics are one of the most powerful features in Swift, yet they can often feel overwhelming, even for seasoned Swift developers. In this series we’ll learn how to make generics simple, useful, and even fun!

Back to Basics

But to start off, we’ll look somewhere you probably won’t expect: declaring variables.

let strings = ["John", "Paul", "George", "Ringo"]
let oneLongString = strings.joined(separator: ", ")

This seemingly simple piece of code has some hidden functionality. Consider for a second, what type is strings. That’s easy. It’s an Array. But that answer is only half correct. Notice, how does strings know about the joined method? How does it know how to join the elements? What if that was an array of numbers?. Here, most Swift developers would say that the answer is Type Inference. And while that answer is technically correct, it’s still missing part of the story.

How to add Apple’s “Night Mode” to your SwiftUI Views

Thu, 14 Sep 2023 00:00:00 +0000

Tip: Try the code for yourself! If you like this, please try the Swift Package that I created called PlusNightMode.

Note: I originally posted this blog post to Medium, here.

Screens have propagated to practically every area of our lives and while that has been tremendously beneficial in many ways, it has led chronic sleep issues. To address this, Apple and the rest of the tech industry has slowly rolled out a variety of features to tackle this problem. First, there was Night Shift, Dark Mode, then Screen Time. Now in iOS 17, Apple has introduced “Night Mode”, except it’s not in it’s own feature. It’s buried inside of other features (StandBy on iPhone, and the Wayfinder watch face on Apple Watch Ultra).

How to use a JS for...of loop with an index

Thu, 07 Sep 2023 00:00:00 +0000

Note: I originally posted this blog post to Medium, here.

JavaScript’s for...of loop is a powerful construct for iterating over elements in an iterable, such as arrays, strings, or other iterable objects. However, unlike the traditional C-style for loop, the for...of loop doesn’t provide a built-in index. But fear not! In this blog post, we’ll learn how to use the for...of loop with an index.

The Traditional `for...of` Loop

Before diving into adding an index, let’s quickly review how the standard for...of loop works:

7 Ways to Organize SwiftUI Code

Thu, 06 May 2021 00:00:00 +0000

NOTE: I originally posted this blog post to Medium, here.

SwiftUI is a complete paradigm shift in how we write apps for Apple platforms. It’s functional and declarative rather than object-oriented and imperative. And there is no need for ViewControllers anymore! While all of this means that we can write code that is more readable, testable, and reusable, it also means that we don’t have decades of tried and true architecture patterns to draw from.

Strongly Typed on Daniel Lyons

Adding Privacy-Friendly Comments to a Hugo Site with Chirpy

The Search: What I Actually Needed

Why Not Disqus?

Ensuring Swift Compatibility on Linux

Ensuring Swift Compatibility on Linux

How to Publish Unlisted Posts in Hugo

How to Publish Unlisted Posts in Hugo

Migrating Notes from Hugo/Quartz to Obsidian Publish

Migrating Notes from Obsidian Quartz to Obsidian Publish, Seamlessly Integrated with Netlify

Goodbye Dataview! Hello Obsidian Bases!

Smooth Site Migration: Redirecting GitHub Pages to Netlify Path-by-Path (with Hugo & SEO in Mind)

Icons in SwiftUI

Icons in SwiftUI

Introducing: "Let There Be Sight" now in beta!

Introducing the Beta of Let There Be Sight: Alt Text Made Easy

Why Alt Text Matters

Swift Error Handling: The Solution

Swift Error Handling: The Solution

Swift Error Handling: The Problem

Swift Error Handling: The Problem

Actually Useful Obsidian: Formatting

What's the difference between class and class_name in Godot?

class_name keyword

Easy Deep Copy Cloning in Swift

Introducing SelectiveEquatable

Using SelectiveEquatable

Am I Using Swift 5 or 6?

Gradual Static Typing in GDScript

Selective Equality Checking in Swift

Why Not Just Use Equatable

Unordered Equality Checking in Swift

What is Deep Equality?

A Deep Dive into Value and Reference Types in Swift

Value vs. Reference Types

Swift Assertions Cheatsheet: How, Why, and When to Crash

What is an assertion?

Exhaustive, Flexible, Multi-Typed Error Handling in Swift

How to Visualize a Dependency Graph of Swift Dependencies

Abstractions Increase Complexity: Here's Why That's Not A Bad Thing

The Swift Ranges Cheatsheet

Core Concepts:

Range Types Side by Side:

Common Use Cases:

Iteration:

Pattern Matching:

Swift 6's New @retroactive Attribute

The Problem

Demystifying Modern macOS Development

Introduction

Benchmarking in Swift with swift-collections-benchmark

Using Custom Components in Swift's Regex

The Many Faces Of Swift's Regex

Using Optionals with SwiftUI Bindings

Exhaustive Testing Made Easy

How to Take Full Advantage of Swift Package Index

Tips for Package Users

How to Open SPI From GitHub

Boost Your Productivity with These macOS Typing Shortcuts

[BONUS] Vim Equivalents:

How to Scroll to a Percentage in a ScrollView

Hello Hugo

Dev Diary

Initial Priorities

It should be statically generated

Concrete and "Soft" Types in Swift

Explicit and Implicit Types in Swift

Back to Basics

How to add Apple’s “Night Mode” to your SwiftUI Views

How to use a JS for...of loop with an index

The Traditional for...of Loop

7 Ways to Organize SwiftUI Code

`class_name` keyword

The Traditional `for...of` Loop