This week, let’s take a look at a few key characteristics of the most common Swift data structures, and also how we sometimes might need to venture outside the realm of the standard library to find the right data structure for our needs.

Let’s take a look at how caching can be an incredibly powerful tool in various situations, how to build an efficient and elegant caching API in Swift, and how strategically caching various values and objects can have a big impact on the overall performance of an app.

This week, let’s take a look at how subscripting works in Swift, and a few different ways to incorporate it into the way we design APIs — including some brand new capabilities that are being added in Swift 5.1.

This week, let’s take a look at computed properties — and how they can let us build really elegant convenience APIs, how to avoid accidentally hiding performance problems when deploying them, and a few different strategies for picking between a computed property and a method.

This week, let’s take a look at a technique that can let us leverage Swift’s type system to perform data validation at compile time — removing potential sources of ambiguity, and helping us preserve type safety throughout our code base — by using phantom types.

When thinking about code architecture or system design, it’s quite easy to only think about big-picture, overarching concepts — but most often we can also make a big impact on the quality of our code base by improving some of the more minor details. This week, let’s take a look at one technique for doing such local improvements, by refactoring large functions into dedicated, rule-based systems.

One really interesting aspect of Swift’s overall design is how centered it is around the concept of value types. This week, let’s take a look at a few different ways in which we can make use of the semantics of value types — and how doing so could significantly improve the flexibility of our value-based code.

Deciding whether or not to generalize a piece of code to fit more than one use case can sometimes be quite tricky.

This week, let’s take a look at a few key factors that can help us strike a nice balance between being able to reuse as much of our code as possible, while also avoiding making things too complicated or ambiguous in the process.

This week, let’s take a look at a few different ways that we can tweak the way Swift’s Codable API works, and how doing so can let us bridge many of the differences between our Swift types and the serialized data used to represent them — without having to fall back to implementing all of our serialization code from scratch.

While a big part of writing testable code comes down to how our dependencies are managed, how we structure and manage our testing data is often equally important. This week, let’s take a look at a few different techniques that can enable us to define such data more easily — and how that can have a big impact on how much effort that’s required to both read and manage our tests.

Even though most of our classes, structs, and other types might have initially been created to solve a very specific problem — over time, we quite often find ourselves wanting to use a highly similar version of that same type or logic, but for something entirely different. This week, let’s take a look at a technique for making that happen — that involves making certain types increasingly configurable.

This week, let’s take a look at a few techniques that we can use to prepare ourselves for undergoing major paradigm shifts when it comes to the APIs and technologies that we use to build apps — using the shift from imperative UI development with UIKit to the declarative nature of SwiftUI as an example.

SwiftUI brings a new, declarative way to build UIs for Apple’s platforms, and also pushes the Swift language itself to new limits — by making heavy use of a set of key new syntax features, that are being introduced as part of Swift 5.1, in order to provide a very DSL-like API. This week, let’s take a first look at those features and how they work.

The start of WWDC 2019 is now just hours away, and — like most developers working within the Apple ecosystem — I’m getting really excited.

While there’s already been a ton of predictions, rumors and leaks posted about what we might see from Apple’s biggest developer event of the year — I thought I’d dedicate my 120th weekly Swift article to something special — dreams.

This week, let’s take a look at how well the new 3.0 version of the Swift Playgrounds app for iPad walks the balance between simplicity and power, and how some of its new features really improves the ways it can be used as a highly portable, advanced Swift development tool.

View controllers tend to play a very central part in the apps we build. However, many view controllers end up taking on too many responsibilities, resulting in lots of intertwined logic, often mixed with view and layout code.

This week, let’s take a look at a technique that lets us mitigate that problem by extracting our view controllers’ core actions, without having to introduce any additional abstractions or architectural concepts.

One major benefit of Swift’s protocol-oriented design is that it enables us to write generic code that’s compatible with a wide range of types, especially if such generic code targets one of the protocols found within the standard library.

This week, let’s take a look at how we can wrap the Sequence protocol in generic containers, that’ll let us encapsulate various algorithms behind easy-to-use APIs.

Pure functions might seem like a mostly theoretical concept at first, but they have the potential to give us some very real, practical benefits — from increased reuse and testability, to more predictable code.

This week, let’s take a look at how pure functions might be used in Swift — and how we can apply them to solve real problems in a very nice way.

Establishing a solid structure within a code base is often essential in order to make it easier to work with. That tends to be especially true for model code, which is often used by many different features with various requirements.

This week, let’s take a look at a few different techniques for structuring the data that makes up our core models, and how improving that structure can have a big positive impact on the rest of our code base.

Being able to observe changes in various values is essential for many different kinds of programming styles and techniques.

While there are a number of abstractions that we can create to be able to observe and communicate such value changes in different ways — Swift comes built-in with a simple, yet powerful way to attach observations to any kind of non-lazy, stored property — appropriately named property observers.