Swift Unwrapped

Swift Unwrapped

A 30-minute spin off of Swift Weekly Brief and other Swifty news.

Three years after first discussing concurrency in Swift with Chris Lattner, we dive into the latest round of proposals and forum discussions — although this time it is actually happening.

Today we talk about the latest Swift open source project, Swift Atomics. The library you shouldn't use but want to anyway.

Today we welcome special guest, Jordan Rose to discuss implementing the Swift runtime in Swift.

Swift 5.3 will be released very soon. What should we expect?

There's a lot happening recently in the world of package managers, registries and indexes. Let's unwrap that.

Is it pronounced "Tuple" or "Tuple"?

Swift Foundation is now building on Windows and passing all tests, interop with C++ is being discussed on the forums, and new Swift libraries are available.

We discuss recent news, evolution proposals, and Swift 6

We discuss a recent Swift Evolution pitch from Ben Cohen on Modify Accessors.

The way Swift reports compilation diagnostics like errors, warnings and fixits is about to improve in Swift 5.2.

Would you like some Swift in your Swift? The compiler driver is getting a shiny new implementation in Swift and there's no shortage of opportunities to contribute.

The Swift of tomorrow... today! The Standard Library Preview Package would allow you to try out upcoming Swift features before they officially ship with new language versions.

We invite special guest, Doug Gregor, back to the show to discuss all things Swift 5.1

What's one feature missing from the Swift Package Manager that CocoaPods has had for years? Binary dependencies! But how would this work in SPM?

We discuss the new generic math functions coming to Swift, as well as approximate equality for floating point numbers.

A concept that's been in and out of conversation for Swift since 2015, property behaviors - uh, delegates - uh, wrappers - are now back with the full weight of SwiftUI behind it.

In this episode with special guest Keith Smiley, we cover the growing number of tools that let you build things in Swift, a few of which are made by Apple, as well as some others like CMake, Bazel and Buck.

Although we usually discuss new features being added to Swift, this episode is all about removing things from the language.

In what is sure to lead to significant community discussion, there's now a pitch for adding a style guide and formatter to Swift. ​

If this proposal is accepted, we'll be seeing Key Paths in a lot more places.

The Swift project is working on official support for the industry-standard Language Server Protocol and we can barely contain our excitement.

It's the most wonderful time of the year again... the time when the Swift community considers adding a Result type to the standard library. Except that this time it'll probably work!

In this episode, Jesse and JP dive in to opaque result types, which could help prevent leaking of implementation details to library consumers.

String literals are the gift that keep on giving with each Swift version, and Swift 5 is no exception, with raw strings.

We discuss Jordan Rose's recent forums post on a proposed plan for module stability.

A recent type checking speedup had very small source compatibility breakages, but nonetheless went through the evolution process and it was accepted!

The Never type has some very unique properties and behavior. We introduce the type and discuss a recent proposal (SE-215) to make it conform to Hashable and Equatable.

We welcome Kelvin and Vincent to the show to discuss Data Structures and Algorithms in Swift.

An in-depth conversation about Swift 4.2 and beyond with Ted Kremenek, Manager of the Languages and Runtimes team at Apple.

We discuss the announcements from WWDC 2018 with special guest, Greg Heo.

We discuss recent proposals on adding unicode properties to characters and Unicode.scalar.

Escaping or non-escaping? That is the question.

IUOs are dead, long live IUOs! With this change, IUOs are no longer a type but rather a special variant of Optional.

Now that Swift for TensorFlow has been open sourced and documentation is available, we share some very interesting findings.

Swift will soon have a more robust hashing strategy, and it doesn't involve always returning zero for hashValue.

Randomness gets a long overdue Swift treatment.

We cover a few recent Collection & Sequence Swift Evolution proposals.

It happened. Google forked Swift. Swift for Tensorflow has wide-reaching implications and we just had to share our thoughts.

We cover two recent Swift Package Manager proposal pitches.

We go over the Swift 4.1 release highlights with Ben Cohen and Doug Gregor from the Swift team. Part 2 of 2.

We go over the Swift 4.1 release highlights with Ben Cohen and Doug Gregor from the Swift team. Part 1 of 2.

Thoughts on Dave DeLong's "protocol wishlist" for Swift and other ideas for improving Swift's protocols.

Swift.org is officially participating in the Google Summer of Code program, and there are some great project ideas.

We discuss Connor Wakamo's proposal to revamp the Playground QuickLook APIs

We discuss Jordan Rose's proposal to address issues with struct initializers

The pace is picking up early 2018, so there's a lot to cover.

The King is dead, long live the King!

We dissect Michael Ilseman's recent document with potential optimizations and improvements to String in preparation for ABI stability.

Swift 4.1 will include support for conditional protocol conformance, and we're excited to use it!

We discuss the recent efforts improving & instrumenting the Swift compiler's performance.

We discuss Chris Lattner's recent "Dynamic Member Lookup" proposal.

The source compatibility suite has been useful in catching compatibility issues before official Swift releases are cut, but it leaves much to be desired especially around communication with project maintainers outside Apple.

Think thread safety with Swift is the same as C languages, with slightly different syntax? Think again!

Brief discussion around some recent proposals.

How do you even profile without Instruments.app?

We discuss Swift’s numeric protocols and types, especially those of the floating point variety.

We discuss the first release of the HTTP server library from the Swift Server APIs project.

Since many of you are probably migrating to Swift 4 as you listen to this, we figured we'd share our thoughts on the transition.

We share our tips for measuring & improving Swift compilation times, as well as share some news about recent efforts to test compile times within the Swift repo.

We welcome Mike Ash to the show to discuss the implementation details of weak references in Swift and how they've changed.

We discuss some recent Swift Evolution proposals, Xcode 9 GM, along with a boatload of Follow Up (tm) from Ted Kremenek and Pierre Habouzit.

All about the recent refactoring pieces announced at WWDC 2017 and open sourced in the last few months.

We welcome Chris Lattner to the show to discuss concurrency in Swift 5 and beyond!

We share our thoughts on the newly announced goals for Swift 5.

The fourth and final episode in our series on ABI Stability, we cover the remaining categories of decisions that must be made to stabilize the ABI.

Continuing our series on ABI Stability with a third installment, we focus on the mangling component and address some past mistakes.

Following last week's episode on the big picture of ABI Stability, we focus on two categories of decisions that need to happen to get there: data layout and metadata.

We clear up some of the misconceptions around what ABI stability means, how we'll get there and why it's important.

This week we dive into some of the recent proposals, including SE-0180, SE-0181, SE-0182, SE-0183

We dissect the newly open sourced part of Swift tooling that helps us port our apps to the latest Swift version.

A month after WWDC, we share our thoughts on the announcements and events from the week.

Taking a break from Swift itself, we shine the spotlight on the open source community and highlight some lesser-known open source Swift projects that we think are interesting!

Exploring the many different ways in which the Swift compiler is tested.

The state of error handling in Swift and a brief history on how we got here, as well as comparisons to Objective-C.

Part two of our discussion on the new features and improvements in Swift 4! There were so many great things to discuss, we needed two episodes!

We discuss some of the new features and improvements in Swift 4!

We share our hopes & expectations for the Swift language at WWDC 2017.

We debate if Swift evolution is pulling its weight, and if it's possible for Swift to remain "open" without the cost.

A brief overview of the complex topic of memory ownership revisions currently underway.

We cover 3 recent Swift Evolution proposals and the new Swift Compatibility Test Suite.

We go in way over our heads into Swift's String Manifesto.

We unpack the recent SE proposals on serialization & encoding.

There has been a ton of debate on the Swift Evolution mailing lists about access control in Swift. We share our thoughts on the situation.

This week we celebrate the release of Swift 3.1 and the large set of improvements to SwiftPM that happened just under the wire.

Continuing from episode 4's take on Objective-C Bridging, in this episode we look at Objective-C interoperability.

There's been a constant push and pull on ObjC bridging since Swift 1.x, trying to seek a balance but always swaying in the other direction.

The up (and down) sides of striving for source compatibility across Swift versions. Let's rearrange some deck chairs!

The tumultuous tales of the community getting SourceKit compiling on Linux.

A retrospective on one year of open source Swift.

Welcome to Swift Unwrapped!

A weekly, 30-minute show about Swift the language hosted by JP Simard & Jesse Squires

Copyright 2021 Spec Network, Inc.