What’s New in Swift 5.0?
Date: 2019-01-23 Location: iOS Orlando
Swift is constantly evolving which means Swift developers should be constantly learning! Richard discusses the upcoming changes in Swift 5.0 as well as ABI stability (what it means and why it’s important), Swift Evolution, and how to get started early with Swift 5.0 using snapshot builds.
Swifty Algorithms - Fibonacci
Date: 2019-02-20 Location: iOS Orlando
Dive into writing algorithms and data structures using our favorite programming language: Swift! In a short presentation Richard will code through a problem by starting with a straight-forward implementation and iterating on it to become more efficient and more Swifty; no computer science background required. To kick things off we are starting with a classic: the Fibonacci sequence.
Swifty Algorithms - Radix Sort
Date: 2019-03-20 Location: iOS Orlando
Richard is back with another Swifty algorithm implementation. This time we step through radix sort, a lesser-known sorting algorithm that is actually non-comparative (meaning the sorting happens without comparing values against one another).
Swifty Algorithms - Minimum Coin Change
Date: 2019-04-17 Location: iOS Orlando
Another month means another Swifty algorithm presented by Richard! This time we take a look at the minimum coin change problem, which goes something like this: given any amount of requested change find the least amount of coins necessary to fulfill the request. We tackle this first using a straightforward greedy algorithm; but to make it work for any set of coin denominations we must also explore the dynamic programming solution!
Swifty Algorithms - Merge Sort
Date: 2019-06-19 Location: iOS Orlando
After a short month off, Richard is back with another Swifty algorithm. This time we will code through a divide and conquer algorithm classic: merge sort. This algorithm sorts through an array by dividing it into smaller arrays that are to be sorted and then eventually merged back together. We will also explore Swift’s amazing generics capabilities to make the sorting algorithm really powerful!
Swift Package Manager
Date: 2019-08-21 Location: iOS Orlando
Richard will be exploring the Swift Package Manager. We will explore how it works, it’s new integration into Xcode 11, how it is different from third-party solutions such as CocoaPods and Carthage, how to start using it within your projects, and even how to make your own Swift Package!
Apple CryptoKit: Encryption and Keys and Signatures, Oh My!
Date: 2019-09-18 Location: iOS Orlando
Richard will take us through a quick look into Apple’s new CryptoKit framework that is new for macOS 10.15 Catalina, iOS 13, watchOS 6, and tvOS 13. We’ll look through examples using this new Swift-only framework including hashing, authenticating data, encrypting data, verifying signatures, and public-key cryptography; all while using a super simple, clean, and easy-to-use API provided by Apple to help developers write more secure applications without the need to rely on third-party frameworks for something as critical as cryptography.
Tiny SwiftUI (on watchOS)
Date: 2019-10-16 Location: iOS Orlando
While a lot of the attention surrounding SwiftUI has naturally focused on iOS, Richard takes a moment to see how SwiftUI can be used to make a watchOS app as well. Richard will explore some of the differences between using SwiftUI on iOS versus watchOS, the challenges still remaining with UI development on watchOS, how SwiftUI compares to WatchKit, and watchOS-specific aspects about making a SwiftUI app for the Watch (such as utilizing the Digital Crown).
Combine in Action
Date: 2019-11-20 Location: iOS Orlando
Combine, Apple’s new declarative framework that (at least in part) powers SwiftUI, can be used for many things outside of user interface development. Richard takes a look at how we can use Combine with some of Foundation’s most-used APIs: Timer, NotificationCenter, and URLSession. We’ll see how some of these new uses compare to their imperative counterparts and explore the power that comes from using these APIs in new declarative approaches.
Programmatic UIKit Basics
Date: 2020-01-15 Location: iOS Orlando
SwiftUI isn’t the only way to create all of your UI in code; in this presentation Richard shows how to create a 100% programmatic UI using UIKit and iOS 13. He covers how to configure a new Xcode project to not use Interface Builder and Storyboards, how to setup iOS 13’s SceneDelegate to set a programmatic root view controller, how to set views properly in UIViewController, discusses some advantages to build programmatic UIs in UIKit, and more by building a small to-do list app live from “New Project” to working prototype!
View Controller Composition
Date: 2020-02-19 Location: iOS Orlando
Architecture in iOS has been a hot topic as of late and most of the proposed solutions aim to reduce the problem of “Massive View Controllers” (i.e. having view controllers take on too many responsibilities). One way to help avoid this problem is to utilize view controller composition: separating larger view controllers into smaller child view controllers. Richard will discuss some insights about the “Massive View Controller” problem, give an overview of some solutions, and show an example of how to transform a large view controller into a “container” view controller that encompasses several “child” view controllers.
How to Make a Living Creating Mobile Apps
Date: 2021-04-05 Location: Underdog Devs: Spring Into Swift
Get a peek into the story of one developer’s journey (spoiler alert: mine) and stay for some advice about the learning process, what skills an aspiring iOS developer should focus on, and what steps you can take to help you get your first job. Of course, these are all just my opinions!
Building Tic-Tac-Toe with SwiftUI
Date: 2021-04-19 Location: Underdog Devs: Spring Into Swift
Build a simple Tic-Tac-Toe game in SwiftUI to get an understanding about how views are constructed, how navigation works, and how logic can be encapsulated. In this presentation we’ll also look at how state is the backbone for how SwiftUI renders views and view updates and some important reasons why keeping single sources of truth is so important in SwiftUI!
Date: 2022-01-20 Location: Underdog Devs Xcoders
The Swift programming language can be used for many different types of jobs, but often times lightweight scripting is an overlooked task that Swift is well-suited for. In this presentation we’ll go through how to use Swift for scripting, how to build some simple wrappers to make scripting easier to work with, and briefly talk about some tools to make more advanced Swift scripting straightforward.
Date: 2022-02-24 Location: Underdog Devs Xcoders
UICollectionView has evolved rapidly over the last few years. Apple has been enhancing this UIKit API to enable creating powerful, dynamic user interfaces through the addition of compositional layouts, diffable data sources, and even a new list style to replicate the look and feel of table views. Join us for this presentation to learn all about these new features to level up your UICollectionView knowledge!
SwiftUI: Understanding State
Date: 2022-04-28 Location: Underdog Devs Xcoders
SwiftUI changes the way that developers handle state management by introducing easy ways to create, update, and react to state. However, there are many details about handling SwiftUI state, its various property wrappers, and how to best structure Views and ObservableObjects that aren’t so obvious or intuitive. In this presentation Richard will cover techniques such as substate, how to avoid unnecessary View redraws, creating container Views, and more to help you better understand SwiftUI state!
Building with SwiftUI and Concurrency
Date: 2022-05-25 Location: Underdog Devs Xcoders
When SwiftUI was released in 2019, it was launched alongside a declarative framework for processing values over time: Combine. However, in 2021 we gained access to all-new language features such as async/await that can describe asynchronous and concurrent operations using more synchronous-looking and structured patterns. In this presentation Richard will walk through building a simple game of Simon using SwiftUI and the new Swift concurrency features to drive asynchronous state changes.