Video #354: The Point-Free Way: Live

Episode: Video #354 Date: Feb 9, 2026 Access: Members Only 🔒 URL: https://www.pointfree.co/episodes/ep354-the-point-free-way-live

Description

We celebrate 8 years of Point-Free with a live stream! We take our brand new “Point-Free Way” skill documents for a spin by building a Flashcards app powered by SQLiteData, and we give a sneak peek at “Composable Architecture 2.0,” a reimagining of our popular library.

Video

Cloudflare Stream video ID: 0a59be32deb15dd039c0bf17645b5b73 Local file: video_354_the-point-free-way-live.mp4 *(download with --video 354)*

References

Transcript

— 0:00

Okay, we’re live and my video is all stretched out. Let’s fix that real quick. Stephen

— 0:16

It happens. Brandon

— 0:18

All right. Okay. There, that’s a little bit better. and so can everyone hear us? That’s a couple of seconds to light, so we’ll just wait a moment in the chat. Can we confirm? Can. I think yes. Okay. All right. Brandon

— 0:40

So let’s do it. This is Point-Free Live. We are here to talk about the official release of the “Point-Free Way”. We’re here to give a demo of it. and Stephen, you’re gonna give everyone a little preview of Compostable Architecture 2.0 or TCA 2.0. We’re gonna answer tons of questions along the way, and we are going to give away. Brandon

— 1:07

Eight free subscriptions for eight years of Point-Free. it’s kinda hard to believe we’ve been doing this for eight years, but it’s still very fun. We still have a lot of stuff we wanna do, and we’re just gonna keep on doing it as long as we get support from our viewers. and in fact, we recently even got a very generous sponsorship from somebody who it was just out of the blue and it was amazing to see. Brandon

— 1:32

And so we may even just give out a few extra yearly subscriptions to people because of the kindness of this person to just, sponsor us, out of the blue as a very welcome thing. So we are gonna now get into it. and I think I’m gonna start with, going into screen share. Oh, yep. My screen share’s a little frozen. The Point-Free Way Demo Brandon

— 1:58

Another peek behind the scenes of what we get. So let’s get into it. There we go. Now hopefully everyone can see the real thing. So yeah, the “Point-Free Way” is something we teased for a while. Released in a little private alpha. Released a little beta. People have been testing it and posting a lot of feedback in Slack and today. Brandon

— 2:21

We officially flip the switch on and it’s just ready to go. So people can now download this tool and start using the “Point-Free Way”. And it’s just installs these little skill documents that are handcrafted by us. We, work on these a little bit every day. Every time we get a little feedback from someone or we find a common anti-pattern or problem in the community that we see people are doing, we try to encode the fixes directly into the documents so it can just keep on evolving. Brandon

— 2:49

and we wanna just give a demo of it. So what I’m gonna do is hop over to my terminal and even before getting into I, we wanna show one quick thing, which is this is the pfw tool that you’ll install via brew , and then that installs all the documents. I, we just wanna say that there are some really fun, cool things in this tool that we built, because this is the first major CLI tool we’ve had to maintain, and we’re gonna talk about this stuff in episodes and blog posts and stuff in the future. Brandon

— 3:21

But for testing CLI tools, we cannot find a lot of information out there of like, how do you kinda load up a CLI tool, hit it with some arguments and see what happens. And so we leveraged our snapshot testing library to do inline snapshot testing so that you can actually invoke the CLI tool saying Install with the tool and you just see the output that standard out would give you. And there’s just really fun stuff here. Like you’ve got the idea of doing an install and it shows you get a challenge for authentication. You wait for the browser redirect, it saves the token, it logs in successfully and it installs the skills. Brandon

— 4:02

That’s everything that would’ve been spit out by standard out when running this tool. And then we also have an in-memory version of the file system so that we can see that files are even installed in the file system along with symlinks even. So you get to see that really all of the skill documents are installed in the home, .pfw directory and then linked symlinked to Codex, Claude, or whatever. Brandon

— 4:27

In fact, the symlink thing is something that came from, a member of the community. Ibrahim PR’d this because we were at first just copying files all over the place and he was like, why don’t you just install in one place and then send link it. Alright. So there’s a lot of fun stuff here that we will get into someday in the future, but for now, I just wanna give a quick demo of the “Point-Free Way”. Brandon

— 4:48

And so I’ve got pfw install ed and so I can do pfw install ed to grab all the documents and there it goes. They just installed it all into Codex. we typically use Codex. We’re gonna start with that. now technically for this livestream, I want to use a slightly newer version of these documents that we haven’t yet released. Brandon

— 5:07

And so I, gotta make command that just only works for us to make local PFW. Alright, so there’s a few little updates that I’m gonna make use when I do this, but everyone will get this soon enough. And so I’m going to show off. Building super quickly in the “Point-Free Way”, a flashcards app. All right. Brandon

— 5:31

And I’ve got, I’m in, in my terminal. I’m here right now. I’ve got all the PFW skills installed, and I can go into Codex and I’m gonna not allow it to make rights at the beginning, but I’ll give that right access later. And so right from the beginning you can do dollar sign. Oh wait, it’s not saying my documents. Brandon

— 5:53

Let’s see what’s over in Codex. Brandon

— 6:00

Oh, there’s nothing here. Okay. So pfw install . All right. this is always fun. So Stephen

— 6:15

It does, Brandon

— 6:16

yeah. So it’s saying it installed, it did not install. should I just run it from. I’m on this version. Let’s go check over in PFW itself. Oh, the entire. Let’s, all right, let’s start over. Let’s get rid of that. Brandon

— 6:40

pfw install skills. Oh, try. All right. Let’s do a force. There we go. There is that. And now over in Codex, there’s that. Maybe actually my, my make local PFW messed something up. Stephen

— 7:01

Tech demos. Brandon

— 7:02

Yeah. But now I think we’re looking good. We got it there. that, that’s in, oh, that’s just that directory. Okay. Brandon

— 7:13

So now, sorry about that. Let’s start, let’s get back into Codex. There we go. So now I’ve got everything here, PFW dash, and here’s a skill for basically all of our libraries and a couple of other additional skills. So what I’m gonna do here is just very quickly go through building a basic flashcards app. Brandon

— 7:31

And the first thing I wanna show isn’t even related to any of our libraries. It’s, we can actually ask Codex to create a swift package for us, for the core of our app, and then integrate it into an existing Xcode project. And I’m not gonna waste everyone’s time like writing, prompts completely from scratch. Brandon

— 7:52

So I’m gonna pay something in that I previously made, and I’m just gonna tell it to add an SPM package to this Xcode project and add a library to it so that we can put all of our code in that library and then link it all together. And we have a special pfw dash SPM skill that just tells it exactly how to do this kind of stuff. Brandon

— 8:13

And it’s finding that skill right now. And while it’s doing its thing, the reason we would want to do this is because we get to do more of our work in a file format system that’s far friendlier to things like Codex and Claude. It’s just basic files, the it doesn’t need to worry about project files and stuff like that. Brandon

— 8:39

And it’s really easy to then add dependencies. It knows how to edit a package, do swift and so it can kinda do all that for you instead of poking around this project’s pbxproj file, which is a kind of a mess. so I’m gonna let it do some things. Let’s see. Did it ever mention that it found our. So I don’t see it mentioning it found our skill, so let’s see what it does. Stephen

— 9:08

it does say the read a skill at the beginning. Brandon

— 9:10

It did, yeah. Stephen

— 9:13

Yeah. One thing to note is that we have found, when in doubt you can always explicitly mention the skill and that’ll Brandon

— 9:20

Yeah. Stephen

— 9:20

Usually give it enough of a kick. Brandon

— 9:22

Yeah. I think, the dream is that you get to just prompt and it finds the correct skill, but the reality is not quite that simple. Brandon

— 9:31

so if you know that a skill should be used, you should just go and do that. But yeah, I can tell already this is actually not correct. So let’s check if it’s made any, let’s just, all So what I’m gonna do, I’m gonna start over. I’m gonna tell it, Hey, use $pfw-spm . Stephen

— 9:55

While that goes, we could do a question or two about pfw . Brandon

— 10:00

Yep. Stephen

— 10:08

now, ericbdev asked if pfw is compatible with non-Apple platforms like Linux and it is, we have a test, suite for that and even ci and we don’t personally use Linux. So if there’s anything wrong with that, please submit some bug reports. But ideally it should work. Brandon

— 10:30

Man, I, I gotta tell you, it, it is not liking something about these skills. So it, we got ’em all here. There it is. Stephen

— 10:51

Did you run the local again? Brandon

— 10:54

I did, Stephen

— 10:55

Okay. Brandon

— 10:59

Yeah, it’s going, Stephen

— 11:00

everything did work really well yesterday on the practice run. Brandon

— 11:03

Yeah. It’s this, all this stuff is, it’s like herding cats. It’s just a constant battle. I, yeah. I don’t really like what it’s doing. It’s never once even said it’s using the, I’m gonna stop it. let’s just ask it. Brandon

— 11:23

What is $pfw-spm ? Brandon

— 11:31

Totally fair question. All right. yes. So let’s use $pfw-spm to add a project. Brandon

— 11:58

All right. Now it, Stephen

— 11:59

and we could, Brandon

— 12:00

yeah. So finally it is saying, I’m preparing to execute commands using $pfw-spm , so I have more confidence now. Stephen

— 12:07

Alright. Brandon

— 12:11

Yeah. Feel free to throw in some questions. All right. actually, so first, our first interesting thing here is as recognized that the best way of integrating an Xcode project and local SPM packages is via a workspace. And so we’re gonna get a workspace created for us with our Xcode project that is already sitting here and with a newly creative flash, flashcards package, which has not yet been created. Brandon

— 12:33

So we’re gonna let it go do its thing. It’s created our workspace now. It has correctly Stephen

— 12:40

probably been. I was gonna just say it’s probably been years since we covered how we like to organize projects and this is the latest iteration of that. And we have to show more about it soon. Brandon

— 12:50

Yeah. Stephen

— 12:51

But, Brandon

— 12:51

and so next, it’s now figured out it’s gonna create a package. Brandon

— 12:55

it’s gonna have flashcard library sitting there for us. And so we are gonna take that and once we see it, do this correctly, we’ll give it the keys to the computer and let it do whatever it wants for better or worse. And now that it’s got a package, it’s got a workspace, it is now gonna link a flashcards library into the Xcode project. Brandon

— 13:20

And that does require a little bit of dabbling with the pbxproject , but that it can do safely. So just basically three lines changed and we now have our workspace that can open up. We’re ready to do all of our work in here and just forget that we even have an app target other than the entry point launching everything. Brandon

— 13:39

And this is also good because, SPM packages support things that unfortunately, xco does not yet support things like traits and stuff like that. All right, so we’ve got the basics of our pro projects set up and the $pfw-spm` did that for us, although it took some prodding. So I’m gonna pop, paste in our next prompt, which is. Brandon

— 14:01

In this library, we are going to use the SQLite data scale to create a ta, table for flashcard decks. So you have a title for the deck, a table for the flashcard. So you got question and answer database connection, migrate the database and update the entry point to prepare a database connection. this, it should get for us. Brandon

— 14:24

And so it’s recognized that it might also need to use structure queries, which it would in order to apply the, table macro and, all that jazz. Brandon

— 14:35

Oh, and I’m gonna, Stephen

— 14:36

we’ve had, Brandon

— 14:37

yep. Stephen

— 14:39

Yeah, we’ve had some chat and some Q&A about, all the kind of Xcode, 26.3. Fresh off the presses. Yeah. here’s one of them. basically our past demos. We’ve used it in Xcode, we did Codex in our latest series, and you’re using Codex now. And the question is basically, does Xcode 26.3 change things? Stephen

— 15:05

Why are you still using Codex from the command line? Brandon

— 15:09

Yeah, I’ll, I, yeah, I’ll give my impression of it. And then Stephen, you give your impression. because it is hof the presses, we’ve only. I messed with it a little bit, but I, it feels like still the xcode like assistant thing just isn’t quite baked. Brandon

— 15:23

You, you have to poke it even harder to find the skills and you don’t get some of the nice things like I showed a minute ago, like a dollar sign or a slash to start listing skills. and so at least it, it, can find the skills, but it’s still a little bit rough. So honestly, we’ve just enjoyed having a separate window to interact with things and. Brandon

— 15:45

And not have everything baked into like just one single Xcode window. But, if people like that, then, that’s totally fine too. now real quick, it, just showed some stuff, which I accepted it, recognized that it’s gonna need some of our dependencies and so it, it put those in the flashcards library dependencies started rolling in into Xcode. Brandon

— 16:07

So that’s all looking pretty good right there. Next, it wants to create some table STRs and it wants to integrate migrations. it figures out how to do these, very nuanced migrations. Even the naming the fact that you need primary key, not no on conflict, replace default and even foreign keys and all that is baked into these skilled docs. Brandon

— 16:31

And so we’re gonna let it go with that. And then final, and it added it to schema Swift. And then finally it updates the entry point to import dependencies, import flashcards, and bootstrap the database. All right, so now it’s, I think it’s doing better now. So I’m gonna give it approval to start making rights so we can just kinda let it do its thing and let’s give it a build. Brandon

— 16:55

I’m probably pretty sure the, access control on this is not correct and I don’t need a build for my phone. it tends to not get access control correctly. So let’s, let’s check out. Yeah, it did not, so I’m just gonna go make that public. All right. So we are on our way and let’s get it to build a feature for us, an actual view. Brandon

— 17:22

and I’ll paste in and what we’re gonna do is have it create a decks view that just lists out all the decks and the, view should display the title of each deck along with a count of how many cards are in each deck and sorted by the title. This is a pretty big ask. I am, because of being tempted by the live demo gods a moment ago, I am going to go ahead and give it the skill that says, use SQLite data and let’s, let it do its thing now, hopefully. Brandon

— 17:55

All right. And it’s also using structured queries, which is good and knows it needs to use a fetch. All that is correct. Exploring a selection in order to join with count aggregations. It’s looking at aggregations in group buy. Brandon

— 18:17

It’s even doing identifiable. ‘cause I know it’ll be integrated into a four each and then it did its thing. and let’s take a look at the view. it created a selection for holding a deck as well as how many cards are in it did the identifiable thing and, alright, it did this, this will probably compile, but there is a slight improvement to this. Brandon

— 18:38

So it, but it did take all the decks and join the flashcards into it. It did the order and it selected the deck along with account. And that’s all good. And this actually is compiling, so that’s great. technically we typically prefer that you put the order. Before the join, if you don’t need to order by anything in the join. Brandon

— 18:59

that, that’s just, a little bit better. And then, and it’s technically actually a bug in structure queries that this even compiles. technically there should be two tables here that you have to, ignore one of ’em. But so technically this would not have been correct code once we fixed that, but this also compiles. Brandon

— 19:18

All right. And so now what I wanna do is tell. Code X to create an Xcode preview seed, three decks for math, science, and history. And then add a couple of fun realistic questions and answers for each of those cards. And we also have a skill or a reference and a skill about Xcode previews because there is very specific logic for that and it, and did it correctly. Brandon

— 19:42

and the preview’s even starting to go. So let’s, let it go and we can, while the preview’s loading, we see it created a deck and it gives it a very explicit, UUID because it needs to reference that ID throughout. whereas the other ID does not really matter ‘cause we’re not referencing it from a foreign key. Brandon

— 20:02

And then it loads up the flash decks preview. Oh. And also it bootstrapped the database and all that. And we say we’ve got three decks with three cards each. Okay. So now we’re gonna tell Codex to make it so that we can create new decks. From this view, we would like a little button we could press up here, enter a new name for the deck and have it insert. Brandon

— 20:25

But on top of that, so it’s gotta know how to insert into the database, but also we want the changes to be animated. All right, so I’m not gonna explicitly mention sq light data skill here. Hopefully it’s seen this enough. it also, while this is going, we can see it gave us even a suggestion of whether we wanted to extract out all these seeds to a reusable, function. Brandon

— 20:51

So we could use it throughout all of our previews. And that’s also something baked into the scale. so here we go. It’s exploring inserts. Exploring inserts, which is nice. it’s understanding. Stephen

— 21:09

I can put up a question. Brandon

— 21:10

Yeah. Yeah. Throw up Stephen

— 21:10

a question. no. You can also narrate how it’s going. Brandon

— 21:13

no. It’s, this is boring stuff. Stephen

— 21:18

Ryan Kassler asked, about kinda the scale loading, the explicit loading that you’ve been doing, and he asked whether we suggest loading all skills or just a subset in that skills can take up a bunch of tokens in the context window. Stephen

— 21:33

I think what we found is that most of our skills are pretty low on the token scale of things, especially in Codex. We’re not sure about Claude. Yeah, I think mention, mention the, skills that you’re definitely using is always a good idea, especially if the tool is not spitting out the results you want. Stephen

— 21:54

But yeah, I don’t think you need to load everything all at once. Brandon

— 21:58

Yeah, I agree. And yeah, and I, we took a lot of time to try to make the actual core Skill MD as short and to the point, the most essential things. And then you use like progressive disclosure to reference out to other documents so that if you’re working in an existing app and you don’t need migrations, like none of that. Brandon

— 22:19

‘cause the migration reference is actually quite long ‘cause there’s a lot of nuance there. But none of that will get loaded unless you actually do something that needs a migration. So we’ve spent a lot of time doing that so that you don’t have to be scared to load skills, but you still might as well just load the skills that you think will be used. Brandon

— 22:37

alright. It did I think a pretty good job of this. although actually maybe. It threw in. let’s see. Whoops. Brandon

— 22:57

All right. It’s got a syntax error somewhere, but I don’t see it. Did it insert a, you Stephen

— 23:06

might wanna move the order back up. Join? Brandon

— 23:10

Yeah, Stephen

— 23:12

just in case. Brandon

— 23:16

oh. The animation. It didn’t insert to come after this too. So close. So close. All right. But we fixed the syntax error and this will work. I get the preview running and now we will hit add and we can add something for, Spanish. Brandon

— 23:39

Hit save. Animated at the end. And let’s add something in the middle, geography? No, that’s the, that’ll be at the front. Alright. I’m just gonna put ends. I’m having trouble thinking. But yeah. Animated right into the middle. So it figured out the animation and if we see what it did a very reasonable thing of pres presenting the alert and, doing its thing. Brandon

— 24:03

It even extracted save deck into a little helper. which this is some guidance we give in our modern SwiftUI, modern SwiftUI skill. And then also it figured out the error reporting, the upsert, how to interact, even add at a database. dependency. So they could do those rights. It’s all looking good. Brandon

— 24:25

So let’s, keep on rolling. And now we’re gonna ask it to create the screen that allows you to play a deck of cards. So you’ll be able to go through all the cards, answer, you’ll be able to see the question, show the answer, go to the next card, and when you get to the very end, dismiss the whole thing. Brandon

— 24:42

All right? And so this is also not gonna be too difficult for, to do ‘cause there’s not really that much interaction with sq LI data other than just loading the cards. But what will be interesting is starting to do some navigation after this, but, all right, so it did, it very fast. we got our deck here. Brandon

— 25:02

Oh, and let’s also tell it to add a preview for this. it did not add a preview, so we’ll have it, add a preview and we’ll ask it to share the seeds. Between our other view, so we shouldn’t create all new seeds all over again. while it’s doing that, yeah, it gets access control, not quite right. Brandon

— 25:22

So I’ll fix that and it may also just bring it right back. Alright, so here we go. it’s found that it can extract out seed database for previews into a little helper and starting to use that everywhere. I think we’re all good to go. I think this is compiling and I’m gonna run the preview. It is compiling. Brandon

— 25:55

All right. And now, yeah, we can go through the show, answer next card, show, answer next card. And then this finish should dismiss, once we’ve got navigation. And speaking of, let’s throw in some navigation. And now I think people are understanding how this is going, so I may go a little bit fast, but here I’m just telling it to. Brandon

— 26:14

Now it’s time to navigate to this when you tap on a deck in the root. So let’s go. Let it do that, and we’ll see a button appear to say selected deck. And then we’ve got a sheet to go to, a selected deck. And this is compiling. Get the preview going. Brandon

— 26:44

All right, so now when I tap on history, I get the game, I can go through everything and then hit finish and it dismisses. And I think in the, I think people are understand how this works, I think, I, we had it so that next week create a screen that allows you to actually edit decks and create cards and remove them and stuff. Brandon

— 27:04

But I’m gonna breeze past that. And instead what I’m gonna ask it to do, I’m gonna go a little off script and hope it does okay. I’m gonna say that I’m looking at this and I see two different pieces of state controlling this, navigation. I’m gonna ask it to refactor. So use swift navigation to refactor the Boolean and optional driving state in the flashcard deck view to just a single piece of state. Brandon

— 27:34

And fingers crossed it will recognize this as an enum and all that jazz. but even more importantly, it’s got to actually do quite a bit more work. ‘cause it’s gotta add case paths. So it, has to know that if you wanna drive navigation with enums, it needs case paths. And now it’s seen the case path skill. Brandon

— 27:55

it also is gonna reference the $pfw-spm skill to know how to do this properly. ‘cause what we found is it tends to add the arguments and package at SWIFT in the wrong order and it messes up your package at Swift. So it recognized it needs case paths, it needs swift navigation. Now it’s gonna refactor our screen. Brandon

— 28:21

All right. And it actually did do that quite well. We now have a destination enum, that’s Case Pathable. It’s got a play and a new deck case and navigation is being driven off one single piece of state. So now you can just do things like destination equal play destination equal new deck. I do think, however, this is not gonna compile ’cause it went a little too far. Brandon

— 28:47

But let’s, build and see what, goes wrong or maybe it’ll surprise me. Brandon

— 29:03

Yeah. Stephen

— 29:04

We’ve had a few questions about PFW. Brandon

— 29:07

Yep. Go for it. Stephen

— 29:08

I might breeze through them rather than put them on screen. Stephen

— 29:13

There’s one that just asked if Xcode code X is compatible with the Xcode CLO agent, there’s a separate Xcode clot agent if that is what you use. And there’s another question about the default being code X, that was an earlier version of, PFW. Stephen

— 29:30

The latest should just default to whatever directory you said finds, or else it’ll prompt you to specify tool explicitly. Brandon

— 29:36

Yep. All right. So what it did wrong here is it previously was holding the, the state to drive navigation as a full-blown deck. so it was not doing it with just an id, it had a full-blown deck. Brandon

— 29:52

And that was working great because, it’s identifiable. And so then this would work great, and you would just have a deck and then you would pluck out the id. And so for some reason it switched to just an ID when it made that refactor. Unfortunately, alternatively you could keep the ID here and then use the version of sheet item that allows you to specify an id. Brandon

— 30:16

This is something we added in swift navigation, but yeah, so it tripped on that a little bit, but let’s, I think it will compile now. or there’s something else. Oh, okay. So it’s probably, yeah. So there is now just something small in here broken that we have to guess. oh, you know what it is? It’s the fact that, that flashcard deck is not, no, it, is identifiable. Stephen

— 30:51

Identifiable. Brandon

— 30:53

yeah. It should be identifiable. Yeah, it is identifiable. So then you just do your classic comment out and Stephen

— 31:02

Yeah, Brandon

— 31:03

bring stuff back. Brandon

— 31:07

Oh, you know what it is? It, yeah. It’s just that. Now we gotta provide the full deck instead of the id. All right, let’s get this going. And the last thing we’re gonna do is I’m gonna just queue up a couple of changes to do so that we can close out on a high note, but, alright, so we got it here and we’ve got that, this is one form of destination, and then this is one form of destination. Brandon

— 31:40

and let’s see. All right, there it goes. All right. So yeah. So we get one piece of state driving two destinations. The final thing we’re gonna do is we’re gonna tell it to start synchronizing this haptic iCloud. We are gonna also tell, let’s just watch it do that. and then I. Because it’s gonna do some fun stuff for us. Brandon

— 32:03

And in fact, let’s, I’m gonna bring up this so that we can see it, do some stuff. ’cause it, it is gonna know that it needs to do some work with entitlements and it found our reference to iCloud to understand how this all goes down. It understands, it needs background modes with remote notifications and the info p list. Brandon

— 32:24

and it will search to see if you have, if you currently have entitlements. And if you don’t, it will create it for you. Brandon

— 32:32

And it even looks for your bundle identifier so it knows what container to set up in iCloud. Brandon

— 32:41

And it’s figured out it needs a default sync engine. So there goes, it wrote to RP list to add background modes. This is so you can get notifications from iCloud and figure out to set up a sync engine and prepare defenses, and it created code signing entitlements for us with a iCloud container. That is our bundle id. Brandon

— 33:02

All right, so now our app is now synchronizing to iCloud, just like that. And then I’m gonna throw on top of this that add, it’s not another this time since I’m skipping some stuff. But add a swipe action, to each, row of the dex list that says share. And when tapped initiates an iCloud share that can be sent to another iCloud user. Brandon

— 33:30

Again, this has a number of steps to get right, but it knows about all of ’em from that iCloud reference. Brandon

— 33:40

And it knows about cloud sharing views, it knows that it needs to import cloud kit. And it’s also gonna know hopefully that there’s something to do with the info p list also. So it has added the syn engine to our view because we need that in order to call the share method. It’s showing a sheet, from the view and it knows that CK sharing supported has to be added to the info P list. Brandon

— 34:08

And so now all of that is set up and I’m not gonna run the simulator ‘cause it’s just too much to get that going. But if I go back to our Dex view and get the preview running. Brandon

— 34:25

We will see that. We can now swipe, there’s a share. I tap it. We see this is a emulation of the share sheet in a, on a real device. It would show the actual iCloud share sheet and so we can emulate that. Yeah. Now we wanna share it. And so technically this has been shared. All right. I like, let’s do one final thing. Brandon

— 34:44

Let’s let it write a very advanced query to now separate all of our decks in the list to shared versus private. So now it needs to query for the actual iCloud metadata behind these records to separate private from shared. So let’s see how it’s doing. It knows it needs to join SyncMetadata . It knows it needs to update the configuration of our database to attach the metadatabase. Brandon

— 35:09

These are all things we’ve covered in our episodes, and these are all things worth knowing. but now it does all that for us and it writes a very complex query for us. It gets it so close. However it needs, when we do yet another join on here, we need to further join to dollar sign two ‘cause that’s sync metadata, not dollar sign one, zero or dollar sign one. Brandon

— 35:33

Hopefully we’ll improve all these things and get it to be a little bit smarter. But that does compile and now we have made it so that we have shared and private. A little bit of work could be done to not show that, but that’s not the interesting thing. The interesting thing is that if I share it and I peak below, history has now been shared and so it moved up into the shared list. Brandon

— 35:58

And if I unshare it. Then history goes down to the private. And so this is how things would work in the app if we ran on our device and actually shared with iCloud users. But we don’t need to do any of that. It all just works in the preview. And our skill documents can slowly lead us to that point if we need to, or actually quickly lead us to that point. Brandon

— 36:22

But we do need to do a couple of fixes along the way. so that is this demo. I think it’s. Pretty cool. I think, that, the scale documents are doing a lot of work for us to nudge Codex along, and there’s of course, more improvements we can do. But that’s, also the fun thing about this, is that we are gonna be constantly making improvements to this. Brandon

— 36:45

And all you have to do is pfw install and you get all those updates. You could do it every morning if you want. And then also, if you’re in our Slack, anytime we make changes to either the pfw tool or the skill files at all posts in Slack. So you’ll always be able to see that something is when something is updated. Brandon

— 37:03

But maybe we could do a couple of questions before I, I stop screen sharing in case there’s something to talk about here. Stephen

— 37:11

Yeah. Let me pull them up again. Stephen

— 37:16

There are a bunch about PFW that we could discuss. Brandon

— 37:25

Oh yeah. I see someone. Yeah, there’s a Point-Free slack. It’s go to Point-Free.co/slack. I’ll just post in chat. I don’t know what I’m talking about. Point-Free.co/slack invite. yeah, hopefully that links, Stephen

— 37:47

We got, one question about how are the skills at writing relevant tests for the code that it implements? we have some test related skills, and as Brian just mentioned, we’re gonna be constantly expanding them. we found that it uses a lot of signal from your current code base. Stephen

— 38:05

And so if you have a test or two written, it does a very good job of, adding more tests and then using our skills to know what to do when it comes to snapshot testing, macro testing, and that kind of thing. Brandon

— 38:17

Yeah. and we, yeah, we got a lot more skills coming up, actually more tools coming up around testing. Brandon

— 38:24

and then we will update our skill documents to properly use those tools. Things that we haven’t, there’s PRS out there that are public for people to see, but things we haven’t really talked about yet Stephen

— 38:37

and a couple questions about whether or not this code sample will be available along with the prompts and Sure. I think we’ll try to make that work. Brandon

— 38:49

Yeah. Yeah. We also, we think this little demo is also gonna be what we use, soon for A-A-T-C-A plus SQLite data demo. Because what, it’s very similar to some of the demos we’ve done before. Brandon

— 39:01

Reminders. You get reminders, listener reminders. Here you get. Flashcard decks and flashcards. We also did scorekeepers. You get games and players. It’s all very similar. But one fun thing we can do with flashcards that we couldn’t do with those is we’re gonna be able to explore single table inheritance slash enum tables to have the idea of flashcards that have an asset that could either be text, image, video, or sound, and have it all embedded in like a type safe and schema safe way. Brandon

— 39:28

and that’s gonna be really fun to see. So we’ll, be able to explore some of that. Stephen

— 39:34

There’s another testing question about if we test the PFW skills, and how they evolve. Brandon

— 39:40

Yeah. Stephen

— 39:41

we haven’t figured out if that’s really possible to do, especially with how much of a black box all these different tools are. it would be cool if it is possible, so if anyone out there is experimenting with that, you can reach out. Brandon

— 39:57

Cool. All right. I’m gonna switch us back over to. The talking heads. And then what we can do is, maybe give out a couple of subscriptions. I don’t know if people, actually, we didn’t even mention this, but on the YouTube page, and if you’re watching from our website Point-Free to co slash live, there’s a link for this, raffle giveaway we’re doing. Brandon

— 40:25

y’all should enter your names and that we’ve already got a num, a number of, one. So what I’m gonna ask is for someone to throw out a random number between one and 150 and one, that’s how many people are on the list right now. And then that will be who we get. So let’s, oh, someone just got added again. Brandon

— 40:44

So 1 52 0 0 0 1 50. All right. One 50. one six. All right. Alright, here we go. 42. That’s a good number. There we go. I like that. 42. All right. Eric Batista, I got your, Eric, are you in the slack right now or in the chat right now? Say hi. If so, if not, we’ll get in touch with you. so let’s see. Brandon

— 41:10

I’ll make a, I’ll make a note of that actually. I’ll just write it down. Alright. All right. All, all right, let’s see that. All right, I’m just gonna look at a random number now. So someone said 1 52. Okay. So let’s see. 1 52 is Jacob. Clayton. Okay. Jake. Is Jacob Clayton in the, in this chat right now? Brandon

— 41:39

We’ll see in a couple of seconds. all right, and then I’m gonna do one more. Right now we, actually we got, alright, so now we’re up to 213. So gimme one more number between zero and two or one and two. 13. That 87 I saw. 87 was the first one I saw. So here we go. We got buoy, bow, no, buoy. If you and I, know I’m butchering your name, sorry about that. Brandon

— 42:09

But, if you’re in the slack, say hi. All right. No more numbers. we’re good right now. We’re gonna do more numbers later. We got three, we’ll do eight and then a couple of extra. okay. all right, Stephen, I think you’re up to start showing people about proposal architecture 2.0. Stephen

— 42:33

Yeah, let’s do it. Stephen

— 42:35

I have started streaming, so if you wanna hop off, hopefully it’ll just take over. Brandon

— 42:41

Okay. And you’re recording too? Stephen

— 42:43

I am. Brandon

— 42:44

Okay. Composable Architecture 2.0 Stephen

— 42:52

Okay. It looks like we are live. all right. Composable Architecture 2.0, something we’ve been teasing for a while now, and it’s something we’ve been building for even longer. I have an expert project here, with a TCA 26 demo, a lovingly named after the latest suite of OSS and tools. Stephen

— 43:17

And it has, some preview packages below that. I’m gonna not lift the curtain behind. TCA A two has a few kind of major goals. one goal was to basically address every single major pain point that we are aware of and that come up from our users. another goal is to simplify as many concepts as possible. Stephen

— 43:42

We definitely simplified CA 1.0 over the course of many releases, but we believe that there are many improvements that we can make and many more simplifications. And then relatedly, we just want to double down on the direction of TCA and make building features as much like building SwiftUI views as possible. Stephen

— 44:02

You should be able to just use, really friendly components and modifiers and just describe how a feature should work in isolation in a very testable fashion. And In here I have Codex, and I actually have it loaded up with a new version of the composable architecture skill. this is already being worked on for 2.0 and it even has, various, explanations on how to migrate from 1.02, 2.0. Stephen

— 44:33

I think we had a question earlier about whether or not 2.0 will be backwards compatible, and we are going to strive to do it and make sure that the last version of 1.0, if it builds without any deprecation warnings, ideally it should work and when you point to 2.0, but in the case that you want to adopt new functionality that only comes with 2.0, these migration guides are still gonna be very helpful. Stephen

— 45:00

And so what does a feature look like in 2.0? I am going to just tell the scale that I want to create our prototypical counter feature. Brandon

— 45:14

So Stephen, so there is a report of a little bit of a audio off thing. I thought we tested this, but, maybe move the mic just a little bit closer. Okay. and it sounds, it also sounds like people are saying there’s a left versus right thing going on, but I’m not sure we’ll be able to do much to fix that right now. Stephen

— 45:35

we did flip the screen a little bit between our versions, but Brandon

— 45:41

Yeah, you could just double check. Stephen

— 45:43

Yeah. My OBS is looking Okay. And is audio better with the mic closer? Brandon

— 45:51

Yeah, we’ll see it. It may be, yeah, so yeah, I think we can get, they’re saying it’s not that big of a deal, but yeah, maybe Yeah, with the mic closer maybe would be a little better. Stephen

— 46:01

All right. And as it always is with tech demos, I wasn’t in the demo projects, so let’s boot up Codex again. Stephen

— 46:12

And let’s create a counter feature. Brandon

— 46:18

Yeah, they say closer mic is helping. Stephen

— 46:20

Okay, great. Stephen

— 46:24

All right. And we’ll see how Codex does. usually it generates a very similar feature that you would generate in 1.0, with a few small changes, but we think they’re significant. Stephen

— 46:46

All right. It created the view. I am going to proceed, Stephen

— 47:02

and it created a feature and that also looks good to me, so I am going to proceed. And I’m also going to give, oh, it’s making some changes as well to the app entry point, hoisting the store out to state so it always gets rendered correctly. That looks good to me too. And then let’s give things a little more, still bumping, but import TCA two. Stephen

— 47:31

And then let’s give approvals so it just doesn’t keep prompting me. All right. Seems to have stabilized. I’m gonna hop over it. Created a new counter file with a counter feature, and this looks very, close to TCA 1.0. probably the biggest change that you might see is that there is no mention of reducer whatsoever. Stephen

— 47:56

we now are using a macro call feature instead of reducer. we return some feature. And we introduce instead of the reduce kind of reducer, we have the update feature, which gets handed some state that it can mutate and can switch over a given user action. the reducer kind of, term of art, was something that we thought really worked well with TCA 1.0. Stephen

— 48:24

but that was when TCA was literally just a composed reduced function. And TCA two has a lot more bells and whistles. It no longer feels appropriate to call these things reducers ’cause they are capable of so much more. And so we felt like it was time to finally ditch that prior art. the other significant but small changes, you no longer have to mark state as observable. Stephen

— 48:49

you now get that behavior for free. And so it’s just one less step that you have to take and remember when building features. All right. Let’s see. We have the basics. So maybe let’s explore a big change in TCA two, which is how bindings work. I am going to paste in a prompt where I’m gonna refactor the counter feature to use a step in the view. Stephen

— 49:21

And I’m also gonna just prod it a bit to say it can remove any unused actions. Okay. And that, Brandon

— 49:29

oh, let’s go in just a, few tiny things. Oh, yeah, just, yeah. Someone’s, this is something I, I haven’t really thought about, but someone’s asking how can people keep their con coding conventions, but allow a, codex to write the code. Brandon

— 49:43

‘cause if someone wants feature to be on a separate line from the struct, I think, I don’t know, hopefully Swift format has enough customization that you could just run format on your code base, but I just, I don’t know. If there’s any way to service that from like our skill documents, like I’m sure it’s gonna be heavily influenced by what we put in our skill documents. Brandon

— 50:05

So yeah, Stephen

— 50:06

people with more experience with this may have good tips. I think you might be able to use an agent’s file that kind of double down on patterns that you want, so various spacing, et cetera. But if anyone has any other ideas, please let us know in the chat. All right. I am going to get the preview going, or no, I didn’t create a preview. Stephen

— 50:31

So create a preview for the counter. Brandon

— 50:38

There’s also a little question here about, improvements to isolated stores because that was something teased in and that is, yeah, something that TCA 2.0 will greatly improve. we’re still working out the details, but it hopefully it’s even to the point of passing dependencies down to the isolated store and everything, and that is a major goal of 2.0. Stephen

— 50:59

Yeah. Not demoing that this time, but maybe next time. All right. We have a very bare bones feature now. It’s really just state of account, no user actions and a completely empty body, and yet we are able to do, derive a bindable store and bind to that count. And if I increment or decrement in the preview, it does seem to work. Stephen

— 51:22

Now this is something that might even seem scary, and throwing all of the tenants of the proposal architecture just in into the trash. Because the view is just in unfettered fashion, mutating state inside of the store. And we’ve always said that is a bad thing. However, all these mutations are still going through this feature. Stephen

— 51:47

all those changes are being observed. They can be intercepted, inspected, and to show that I am going to ask Codex to add some debug printing. Stephen

— 52:06

Okay? if you remember from 1.0, you would have to enhance the reducer, by maybe even wrapping it in a combined reducers in order to call dot print changes on the reducer. we’ve simplified things. One less thing that you have to remember as long as you remember that you can do this in SwiftUI. Stephen

— 52:24

You can also do this in TCA. And so let’s open up, get the canvas and we will see that we’ve already gotten one debug thing, printing, which is that the counter feature mounted. We’ll talk more about that soon. And then if I were to increment, we’ll see that we got a binding event and we got another binding event. Stephen

— 52:45

And so everything is still, intro, respectable, detectable. Whenever a change is made through one of these bindings, you still have the ability to track how it entered the system, which is really important. And Brandon

— 53:00

so while we may have relaxed a couple of things in 2.0, we still have like our north star of what it is that we want to be able to accomplish with the library, which is like complete introspection of the system, like infinite debug ability and printing. Brandon

— 53:16

And so we’re still gonna always have that, but we’re just trying to peel away the layers. Stephen

— 53:21

Yeah. And it might seem scary that you can mutate all the state inside of a feature by just binding to it. But there are changes that we’re making that, that we’ll demo soon to show that, may not be a bad thing. Stephen

— 53:35

there are still ways to encapsulate things. but before we get there, I want to make things a little more complex. We’re gonna add over set button to the counter and see how things go. Stephen

— 53:59

All right. And it expanded with a new user action. It threw an update into the body. We have now explicit logic to zero out the state, and sure enough, it all works. we see that the counter feature, send a reset button, tap action, and yeah, so basically bindings and then user actions can live side by side in harmony. Stephen

— 54:22

just say this, they did in 1.0. However, one of the huge things here is you no longer have to remember to do a whole bunch of steps. one of the complaints in t say that we hear pretty often is that, you go in here, you needed to conform this to bind action. You needed to add a case for the binding with a binding action on our own action, or no on our own state. Stephen

— 54:50

And then critically, you would also need to remember to add in a binding reducer here. And this step in particular was just a step that people kept forgetting about. And now you just don’t have to ever do any of these steps. Everything will just work with bindings out of the box. But let’s continue. I am gonna add a moderately complex effect to this feature. Stephen

— 55:18

By telling Codex Set. Let’s add a timer button that toggles a timer and that timer will increment this count by one each second. Stephen

— 55:30

Okay? And it has spit out a ton of code, but I think it looks good to me. The preview is loading. It is all building. And so here we see it added new state for whether or not the timer’s on it. Added a timer button for toggling that timer. It introduced, a new thing called a feature store, which we can get to in a little bit. Stephen

— 55:53

But crucially, it found the On Mount Reducer modifier, which. Is linked to this mount event. And so basically on mount can be passed in an id. It’s like SwiftUI task modifier. You can either have it start just at mount time or you can specify some bit of state that when it detects a change to, we’ll tear down this work and then start it up again. Stephen

— 56:20

And so here we are handed a store. out of the bat we can check is the timer on, and if it is, we can just loop over sleep every second. And then you may have noticed we didn’t even add in a timer tick action or anything like that. We have the A, the access to modify store state directly in this closure. Stephen

— 56:43

And this basically goes through the same system as the bindings. And that just makes it very easy to set things like is loading and to true and falls directly in effect without having additional ping pong actions for every step of the. But let’s take it for a spin. I am going to start the timer. We’ll see that it flipped to stop timer. Stephen

— 57:05

The timer is ticking in both the preview and in the console. We can stop the timer and yeah, it all works. And so this is kinda eliminating a huge pain point, that users have brought up, which is, you need to introduce on a peer actions in your domain and you need to remember to send them from the view. Stephen

— 57:27

And, it’s just a lot of extra work and coordinating between, your features domain and the view in SwiftUI. And now it all just gets squashed into a single area. But even more critically, this unlocks something that is just not possible in TCA 1.0, which is you can now deep link into, some kind of effect. Stephen

— 57:50

And so we can just say, is timer on? We want to start it at true. You’ll see that the preview just automatically started with the timer going. Brandon

— 58:00

Yeah, and this is a huge thing, and if anyone’s ever dabbled with elm and things like that, they have this whole separate concept known as subscriptions that allow you to basically map effects from state changes. Brandon

— 58:13

And this kind of just subsumes all that. And you still just get one package, but it can do that. and so if you imagine you had a navigation stack with a, and you, deep link, like three levels deep, but the middle layer, you wanted to start an effect, you wouldn’t be able to do that typically because there was no on a peer on that middle layer. Brandon

— 58:33

If you, drill in three levels deep, the middle on appears don’t call only the, leaf one. And so here you get the ability to have effects driven by state. and it all just works. Yep. Stephen

— 58:47

All right. And something that I did just blow past was that we had this feature store here, and what that allows us to do is we can specify store state directly in this reduce. Stephen

— 58:59

previously state was only accessible inside of update functions. sometimes you could key path in so you could do an on change of, and then a key path to that state. but now we just give unfettered access to state directly in the body of the feature, and that actually unlocks functionality that previously was done in, this draft poll request that we never merged for what we called a reducer reader. Stephen

— 59:26

And that was just a way to open up a scope, to another builder. And so you get some nesting, but you do get the state and the action and then you can use those in order to specify whether or not something happens in the reducer. And Basically we don’t need that complexity anymore. We just simply give access to the store using this property wrapper. Stephen

— 59:52

but I think this new complex feature gives us an opportunity to explore another property wrapper, which we’re excited about. And that is the ability to introduce some local feature state to a view. this is state that lives on the feature level. It’s not in state, and you can really only access it locally to the counter. Stephen

— 1:00:15

And so let’s say we don’t care about showing start and stop timer. The view doesn’t need to know that the timer is going, it’s just encapsulated inside of the feature. And then we actually get right access to it right inside of this update, and we can toggle it. And then because we don’t, require this to be stated, it can be any observable thing and future state is observable, we can just specify the ID is timer on. Stephen

— 1:00:48

We can check it here. And then finally in the view we can just say, we want to toggle the timer because the view just doesn’t have access to that state anymore and we think that’s a good thing. And then finally, we still have the ability to delink in this case because we can actually seed that feature state with the value of true. Stephen

— 1:01:18

Okay. Let’s see. We are building. Stephen

— 1:01:25

And it still works exactly as before, but this state is fully encapsulated in the feature. And this has just been another thing that people keep bringing up. How do you encapsulate features and prevent parents features from seeing it and prevent views from seeing it. And people have all of these lint rules in their repos in order to try to enforce internal versus external and view state. Stephen

— 1:01:48

And we just think that, this is a, nice way of approaching it. And another thing that is going to be familiar to people who already write SwiftUI code is just instead of composing views with local at state, you compose features with local at feature state. Brandon

— 1:02:06

Yeah. And I think you already mentioned, but maybe I was, I may have been distracted in the chat, but, the on Mount plus feature state alleviates one of the main reasons to do reducer readers, which is being able to customize dependencies for different features because now you could have a little feature state for is the user logged in and use that piece of state to figure out, oh, should I override with this API client or this API client? Brandon

— 1:02:35

Or you could just have a button that just switches all of your dependencies to their mock versions so that you can just run in the simulator with everything mocked out. yeah, the reducer reader just isn’t needed anymore. Stephen

— 1:02:47

Yeah, and the way that you use feature state, feature store with ID also applies for dependencies. Stephen

— 1:02:54

as long as the dependency is observable, you could just feed it in here and that could also drive whether or not, like the life cycle of this work is tied to a specific state. Another thing is, this is like a hidden effect, like effects. It can still be spun up the same way as before you can do a run except now it gets handled a store. Stephen

— 1:03:15

but these helpers just deep link you into effects that are auto canceling and everything. Okay. I think that covers a lot of the nice big kind of leaf feature features that we’re adding to TCA two. but let’s take a look at how navigation has changed. I am going to ask Codex to add a parent feature that can display this counter in a sheet. Brandon

— 1:03:46

All right, while that’s going, there have been a number of questions about, TCA on Android and Skip and stuff like that. And so one of the big things, and I maybe Stephen, you already mentioned this, but one of the big things also about TCA 26 or 2.0 26 is just a, fun name. It’s not the final name, but 2.0 is, our ability to finally wipe the slate clean with respect to combine. Brandon

— 1:04:10

we are using every tool in the toolbox in modern swift concurrency in order to squash thread hops, make everything. As synchronous as possible, while still giving people the, the idea of like main actor stores versus, background actor stores and all that kind of stuff. And yeah, modern swift concurrency has come a long way that allows us to finally embrace it over a combine. Brandon

— 1:04:35

And so that would be a gigantic step, of course, to being used on Android and other platforms. Stephen

— 1:04:41

Yeah, that is our goal. It should be cross platform available for everything. All right. It did implement a counter, or apparent to the counter feature in a new file. And so let’s take a look. this will look similar to how TA 1.0 looks, but there are a few key changes and we’re pretty excited about it. Stephen

— 1:05:04

first. State is now just simply an optional, if you’re using TCA 1.0, you need to always remember to say that you’re presenting the counter. And then also the counter action is just embedded directly in a case. You no longer have to remember, oh, this is that presentation action. and so little simplifications things that you and your team don’t have to learn or remember to do. Stephen

— 1:05:28

that’s all very nice. And then it implemented the body where, again, this looks much like the reduce would look, but the key change here is an if let, you also don’t need to remember to do that projected value that presents was doing. And so now everything is more balanced. It’s just easier to remember how to do things. Stephen

— 1:05:48

but let’s take a look. Alright, it presented. If I open up the console, we’ll see that still keeping track of all this stuff in the leaf counter feature. Oh, and importantly, now that this is an optional feature, we can show that when it gets dismissed, the counter dismounts and it detects that, and that’s actually something that we can hook into. Stephen

— 1:06:15

if I go into the counter, this is a thing that is much more difficult to do in TCA 1.0 or just more of a pain. we can now say on dismount we want to perform some work, and this can be async work or anything. It gets handed the last piece of state. And so we could pretend that we are tracking analytics with that last piece of state. Stephen

— 1:06:43

And now if I head back over to the parent Stephen

— 1:06:48

and present, and that’s Brandon

— 1:06:48

an async context that, people can use. Stephen

— 1:06:51

Yeah, I’ll increment a few times. I will dismiss. And we’ll see that. I printed out the full state, which included that count. And this is from the observable state, which basically allows value types to be observed over time. but let’s make it a little cleaner and we’ll just do dot count here. Stephen

— 1:07:18

Okay, so this is looking pretty cool, but while we have, some navigation here, I want to show something that we think is a nice improvement to which is, again, complaint, very similar to forgetting to add in, the binding reducer. there’s a complaint that if you forget this, you’ll be in your view and you just won’t understand why the feature isn’t working. Stephen

— 1:07:44

And so if I comment that out. Stephen

— 1:07:51

And I present it, it did present the feature, but it knows that it’s completely inert because there was no scope store that it, it found, and we’ll be cleaning up these messages to be a little bit better in the future. But, this gives you an instant view into what isn’t actually integrated back in the feature level. Stephen

— 1:08:10

So if I had written this from scratch and Codex hadn’t thrown in the alet for me, then I would’ve given like instant notification that, oh, I forgot to hook up the feature. Brandon

— 1:08:22

Yeah. And, one thing I, mentioned, I meant to mention with the, on dismount is, that tool also serves a gigantic need that people have asked for because people often try to send on disappear actions. Stephen

— 1:08:34

Yeah. Brandon

— 1:08:35

And you can’t do that because on Disappear sent when a feature state is nailed out, that’s how SwiftUI state-driven navigation works. And if state is nailed out, there’s then no way to invoke a reducer or feature update because there is no state to update and so it just goes into a black hole. Brandon

— 1:08:54

and so now you do get that one last moment of something has been a feature, has been fully, dismissed and time to do a little bit of work. Stephen

— 1:09:03

Yep. Alright, so this is just very basic presentation and we saw some improvements, but let’s do another kind of position. I’m going to ask Codex to refactor the parent feature and display a list of counters instead of a sheet. Stephen

— 1:09:22

And TCA 1.0 there is a four each reducer operator, and it operates on this identified array type that we introduced. And it also, operates with this identified action. So whenever you need a list of features displayed, there’s just a whole lot of steps and new types that you need to know about. Stephen

— 1:09:45

And so let’s see how things have changed. Stephen

— 1:09:54

Okay. It is cooking and I think it’s looking pretty good. the parent feature now just has a plain old array of counters. this should work with any random access collection that is range replaceable. So you could still use identified array if you want, but you don’t have to. You can now just not have to worry about new concepts. Stephen

— 1:10:16

And then it embedded the action for the counter state identity and a specific counteraction as well. And then it did some nice, glue code for adding a counter button. And then, yeah, we just for each, over that counter state and that counter’s action. And let’s see if it works. Okay. Add it in a timer. it looks like it’s not displaying everything because everything is a little too big. Stephen

— 1:10:46

So let’s go over to the counter and just. Maybe get rid of that padding at the very least. Stephen

— 1:10:56

Let’s see if the count shows up. If not, I will. Okay. Slightly better. we can increment, decrement can toggle a timer. It’s counting up. We can add another counter toggle more. And yeah, so this is just another example of us trying to simplify surface area, reduce concepts, make it more familiar to people that know SwiftUI. Stephen

— 1:11:22

but right now I don’t have the ability to remove any counters. And so let’s ask Codex to refactor the list so that rows can be deleted. Stephen

— 1:11:43

And it found some swift GI info. It’s exploring edit actions, which is a way to edit rows in a list. Stephen

— 1:11:57

Okay. if I scroll down, we’ll see that it made just a small change, which was instead of for reaching over a scope, it’s not for reaching over a binding to a scope and we’re allowed to specify edit actions and then just render the counter view. But this binding, using the same binding infrastructure that we are using in a stepper basically now allows, things to be written directly by the, for each. Stephen

— 1:12:28

And so hopefully we’re in building order. Looks like it is not for the four each. So let’s take a look. Stephen

— 1:12:44

If I go into the counter, it is marked as identifiable, so I think that should be working. Let’s just comment. I wonder if it’s just this overload that we’re missing. Stephen

— 1:13:01

Yeah. When you bind to something, you need to bind to the binding, and so without that it was getting confused. With a binding to a store, that’s something we should be able to address. Stephen

— 1:13:14

Okay. But we can now add a counter and we could toggle the timer and we can swipe and delete. And yeah, everything works. You don’t have to introduce new domain actions for deleting or reordering. it all works using the same binding infrastructure, and so that’s even more simplifications made to your user code. Stephen

— 1:13:38

All right, I think we’re getting close to the end of the tour, but I would like to refactor the parent once more and we’re just gonna show the counters in a navigation stack instead of a list. Brandon

— 1:13:52

I’m gonna throw a couple of questions up real quick. Oh, wait, one disappeared. okay, nevermind. Stephen

— 1:14:05

If there are any questions that came up, this might be the more complicated refactor. Brandon

— 1:14:09

Okay, so then, so there’s been a lot of questions about the migration path and the release schedule. So I’ll just kinda say out loud, I respond to a few of ’em, but essentially release is very TBD, but we would love to basically release a toy repo of TCA 2.0 that is untethered from TCA 1.0 right now, just so people could poke at it and play around with these features and give us feedback on them. Brandon

— 1:14:35

Then someday after that would come more of a, like a beta period where it’s in the actual TCA repo. It is built off of what 1.0 is, and that would be like the 2.0 and the migration guide is a little bit up in the air too. a lot of this we would love to be super backwards compatible. Brandon

— 1:14:58

We’ll have a final one x release that. Deprecates a bunch of stuff gets you on a lot of newer tools and just opens up the doors for 2.0 and then a final 2.0 and then a 2.0 release of possibly breaking changes that you have to go in and fix. And then there’s also the idea of like, how much could we even support the idea of you being able to depend on two versions of TCA temporarily in order to slowly migrate something we have not explored? Brandon

— 1:15:28

And then finally, what, kind of AI skills can we, throw into PFW to help convert existing features? those are all things that are on the docket for us to explore and look at. Stephen

— 1:15:42

Absolutely. but here we are. It did a pretty good job. The PFW skills told it to create a feature enum for the path, even though we only have a single feature in there right now. Stephen

— 1:15:55

It’s a navigation stack, so typically you have more than one kinda screen on there and it will just continue to expand this territory. And then in the future, it did a very minor refactor, which is, it introduced some root state for the root view. And it changed this from being counter state to be the path state. Stephen

— 1:16:14

But just like for each, it’s just using a plain old array. It’s using the exact same kind of action, which is just an id, action pair for the path. And then down in the body, it has thrown a scope in there. There’s an unnecessary group that could probably be improved in the PFW docs, but just like with the previous list of counters, I use this exact same for each. Stephen

— 1:16:42

It’s just going through the parent pass body instead and. Okay, back in TCA 1.0, you have to reach for a completely different set of tools for stack navigation than you would for lists. And here it’s just unified into a single thing. You don’t need to know about Stack state or stack actions. Those are things that we had to introduce and concepts that you need to know about. Stephen

— 1:17:03

And then we had an overload for a very specific stack feature or, stack reducer at the time. But down in the, body of the view, this is just using the vanilla navigation stack with a scoped binding, and then it has the root screen, which is the counter. And then we’re just using the vanilla navigation destination right now. Stephen

— 1:17:26

Every time you use an enum @Feature , it generates this thing called a store enumeration, which you can switch over directly and then just pluck out a store per feature and then render the screen. And let’s take it for a spin. I’m going to add a counter and I push one on the stack. Can add a few more. Stephen

— 1:17:48

We can open up the console, get a timer going, push a few more counters on the stack, a few more timers, we’ll see that all these effects are still running in the background. And then if I tap here and then go all the way back to the root, we’ll see, we track some analytics for a bunch of different screens and we got a bunch of dismount events and all of those effects were just torn down and Brandon

— 1:18:17

yeah. Brandon

— 1:18:18

Alright. So Stephen

— 1:18:18

yeah, Brandon

— 1:18:19

overall, an overall question, is just how, do a lot of these new tools interact with things like testing and with things like, like reacting to, so the implicit binding action. How would you react to changes in the binding. Stephen

— 1:18:39

Yeah, it, the question is, it depends and the, test store is a feature that we are still evolving, but the idea is, if these modifications are happening in flight with an action, so basically let’s head over to the counter. Stephen

— 1:19:01

If we were to have this spin up on an effect. Instead, if we weren’t using on mount, we would be handed a store. And in here, if we did a store modification where we wanted to, take the count and then immediately add it, add one or let’s just say we had some, is loading state that we wanna flip to true here. Stephen

— 1:19:25

And then we wanna defer to the end of the effect that we want to modify is loading back to false. the act of doing a test or assertion here would be that you send in the timer button tapped action and then in here you assert exhaustively against the state. not only will it do is timer on to be true, but you would also get the ability to say is loading is equal to true. Stephen

— 1:20:03

Basically, any modification that happens before an await or a suspension point will be bundled up in here. And then for any modifications that happen just over time like this kind of thing, assuming you are controlling things with a clock, you would just be able to do a store doer. we might be changing how these APIs look, but you would just say, is loading equals false. Stephen

— 1:20:33

After doing some logic in here that would get into the false state and Brandon

— 1:20:40

Yeah. So yeah, so the overall thing is all this stuff is still gonna be testable. The, test may look a little bit different, but it’s just gonna be us expanding. The role of the reducer to not include, or, former, RIP reducer update function to not only include the synchronous stuff happening directly in the update, but then also the stuff happening in the effect. Brandon

— 1:21:08

We’re gonna consider that all a part of the same world. And, and the reason we’re able to do that is because with modern swift concurrency, we’re able to squash a whole bunch of thread hops. And now I think also in our test store right now, we don’t even have a single test yield. We’re able to get everything lining up correctly and so we’ll be, and then with regards to reacting to some of these implicit things like binding actions, the on change in reducers now works regardless of action being sent. Brandon

— 1:21:39

It’s not tied to actions anymore. What it is, it actually does now observe changes to that piece of state. And so you can even observe child. State changes, shared state changes, feature state changes, anything you do on change of, you can get into and observe its changes. Stephen

— 1:21:58

Yeah. If we wanted to observe the change to this store count, could be modified outside of this update action. Stephen

— 1:22:07

It could be modified and apparent and this will still execute. And that is also a big, feature improvement from 1.0 and 1.0. Having to remember that this only observes what happens in here definitely is a, bit of a Gotcha. Then one other thing that is, is quietly happening in this demo is that I actually never turned off main actor isolation. Stephen

— 1:22:30

And as it stands, all of these tools are, workable both in non-isolated and main actor isolated modes, and currently it’s very difficult to work with TCA 1.0 in main actor isolation. Stephen

— 1:22:50

I think that Brandon

— 1:22:51

hey Stephen

— 1:22:51

is it for TCA 2.0 this time. I dunno if there’s any other questions that came up that I should explore. Yeah, I can in the demo. Brandon

— 1:23:00

Yeah, I can. It’s, YouTube keeps flipping around all the Q&As all over the place, so I’m scanning to try to find them or maybe can I sort these? No. Brandon

— 1:23:10

Okay. let’s see. I’ve answered a bunch in the chat. there’s a lot of stuff about, like TCA and the “Point-Free Way” skill docs and yeah, you mentioned it at the beginning, but for anyone who didn’t hear, you’re working off of a, like a little private skill, that we’ve been working on honed in specifically for this. Stephen

— 1:23:35

Yeah. Brandon

— 1:23:39

Yeah, mostly questions about migrations, which of course is the big thing that we’ll be spending a lot of time on. and so we will see how that all pans out. It’s probably gonna be a combination of a last one, do x release to nudge you in the direction a breaking 2.0, change an AI skill document to help with the migration. Brandon

— 1:24:01

And maybe some way, possibly, it would, it’s gonna require some research, but possibly of being able to run two at the same time so you can, work your way through it. but there’s even a lot of things like the isolated stores, a lot of new tools that may even just kinda to help with, that. Brandon

— 1:24:18

’cause you can more easily cut off a feature like in the middle and then decide on either side, which version of TCA you wanna be using. Stephen

— 1:24:30

a lot of ideas on how to make migrating from 1.0 to two point. Less painful. but yeah, there are just certain changes that we can’t backport, but hopefully bare bones, vanilla stuff, and even stuff like, binding reducer, bindable action. Stephen

— 1:24:52

We can make work in the new system just be heavily deprecated. And so that could be like a pre-release version of 2.0 where you get access to all these deprecated APIs that technically work, but there are better ways to do things. Brandon

— 1:25:07

Yeah. here’s a question, about, and I just posted it. how does TCA separate architecture layers presentation domain application when comparing to other architectures like clean architecture and others? Brandon

— 1:25:26

I, it’s. So our viewpoint of this is that, TCA is a library. It’s like an actual thing. You can Swift package put in or add it to your Xcode and then use the tools. Whereas what we see from a lot of other like blog posts and stuff like that is just a loose set of guidelines of here’s how you can do things. Brandon

— 1:25:49

Here’s how you name things, throw a protocol here, throw a. object over here. it’s far looser of an idea. So it’s really hard to compare the two because one is set in stone in that you can actually add it as a dependency. And the other one is kinda off to the whims of whoever wrote that blog post and who knows how they feel about that blog post three years after they wrote it. Brandon

— 1:26:12

it’s just out there. so it’s hard to compare directly, but in the topics of presentation and domain and layers, we’ve already seen a lot of that in just this tiny little demo here. All the tools are there for presentation, for domain modeling, we want every tool to work with structs and enums above classes. Brandon

— 1:26:33

We want you to be able to use value types where value types make sense. We want dependencies to be controllable and handle, easily easy to handle. And, we just feel like we got all the tools for those things. And so you can, e you know, embrace those layers, as you see fit. Stephen

— 1:26:52

Yeah. A hundred percent agree. the mindset that I mentioned at the beginning was we, want building feature code to feel like building SwiftUI. And so it’s more about the APIs and the library than anything else. the tools are provided and you can use them, but you can also circumvent them the same way that you can circumvent SwiftUI tools that it provides. Stephen

— 1:27:14

it’s really up to you how you wanted to do things on your team. We’re not prescribing every little thing, we’re just providing tools that hopefully make building features a lot easier. Brandon

— 1:27:25

Yeah. There was a good question here about, about how with log changes we were seeing mutations happening even without actions being sent. Brandon

— 1:27:36

And so asking are there still actions out there? They’re just not a part of your own types and, that is the case. Those binding actions and mounting actions and dismounting and stuff like that are, is like a bit of a secret world of. Of action. so when that, when it looked like we were editing state right in the store, that actually is not what’s happening. Brandon

— 1:27:57

It, really is sending an action and that’s what gives us the full introspection. we don’t wanna lose that. so Stephen

— 1:28:05

yeah. under the hood, TCA is completely rewritten. when you’re building up bodies of these features, they’re like long living, now living in a tree. and whenever you send in these events, whether they’re user actions that are defined in the domain like this, or kind of system level actions, library actions like modifications, mounting, dismounting, those all just get fed through that same tree every time. Stephen

— 1:28:34

and so yeah, we’ve just looked to SwiftUI for a lot of this design, both because we think it makes the library more approachable and familiar, but also there, there’s just a lot of good things to pull from SwiftUI and, yeah. under the hood, it is written in a way that we’re, even seeing right now that the benchmarks, have improved performance from 1.0 and we hope to push it even further before release. Stephen

— 1:29:00

But hopefully everything, once you do upgrade will be even faster than before, Giveaways and conclusion Brandon

— 1:29:07

All right. So I, let’s do another, let’s do a few more giveaways. And Stephen, you could look for a question, a couple questions to answer. And so I’m gonna, so we’re up to now 287. Pick a random, someone, throw out a couple of random numbers between one and 287. Brandon

— 1:29:33

One. Okay, fine. One, we got a, Raphael, sorry. a Nun Schwer. Rafael Nun. Schwer. if you’re in the chat you should say hello, but. We’ll, we’re gonna give you one. All right. And then I see a 200, let’s hop down to 200. We got Sonia, Viv, Ziv. So Sonia, if you’re in the chat, you should say hello. Brandon

— 1:30:03

It feels like none of these people are in the chat, should we require that they be in chat to be able to redeem? all right, then I see a 34. Let’s hop over to 34. We got Paul Colton. All right, Paul’s in the chat. Should say hello. And then I see a, let’s see, I see a two 70. here we go. We got two 70. Brandon

— 1:30:31

This is a Miguel, no last name. So Miguel, if you’re in, and let’s see, that is, we’re up to seven. All right, so let’s do one more and then we’ll actually do a couple more. alright, we got a 2 1 2, that’s the area code of my phone number, so I like that number. also, I think this is not a real name so I won’t even say it out loud. Brandon

— 1:30:55

I think this is someone who wants to protect their privacy. Alright. So that’s eight for eight years. But, alright. Alright. let’s pause the numbers for one moment. but yeah, as we said recently, we actually, someone as has recently agreed to sponsor us, in a way. And then that’s of course like very welcome. Brandon

— 1:31:17

And we, it was out of the blue and we felt very grateful for that. So we’re, I think we should pay it forward and we will give out just a few more, of these, oh, you know what, let’s also, we should go to, I’m gonna start streaming. Stephen

— 1:31:32

Okay. Brandon

— 1:31:32

So we go to, Stephen

— 1:31:33

let me hop on. Brandon

— 1:31:36

all Yeah, that actually, that’s a good I do to pick someone from the chat. Brandon

— 1:31:41

In order to make that fair though, I need to, wait, let’s wait till it catches up. Brandon

— 1:31:54

Okay. All right, so we’re back. all right, so someone mentioned to pick some people from the chat who are still here. I like that idea, but I wanna make it fair to, to, so I’m gonna close my eyes and then where my mouse lands, whoever’s chatted recently. So if I’m gonna scroll up and back down, and then pause. Brandon

— 1:32:16

Here we go. We’ve got the human bagel. Alright, I guess the problem with this, is that I don’t have these people’s contact information. So human bagel, I don’t know what to do about that. let’s see if I go to their profile. Bagel man. Yeah, I got nothing on this person, If you could email me and prove to me that you are indeed the human bagel, I will give you a subscription. But I think that’s the end of, that experiment. I’m not gonna do that anymore. So let’s go back to, random numbers. let’s see. I’m gonna look up here. We had a random number of 51. Brandon

— 1:32:57

That’s a pretty good random number. so we’ve got, Christian, no last name. So do that and let’s do two more. we got a 1 96. I hope I’m getting a good spread on this. We got 1 96, we got resis. Alright. And then, all right, I see a 100. And there we go. We got, what? Oh, you know what, Uhuh? No, this person entered four times, so I’m not taking that one. Brandon

— 1:33:40

I see a 1 65. Okay. We got a Paolo, no last name, but I got their email. All right. All right, so let’s start with that and let’s do some, let’s do some questions to round things out. you got anything for us, Stephen? Stephen

— 1:33:56

there were questions about performance and how we measure it, and even with against SwiftUI and the performance is just its own thing. Stephen

— 1:34:09

Like we have benchmarks written where we benchmark against TCA 1.0, but. Because TCA is always gonna be additive to SwiftUI, there’s just really no way to compare, like performance. You’re really comparing the performance of, an absorbable object, which is the store versus, something like at state. Stephen

— 1:34:28

And so ho hopefully TCA doesn’t introduce that much more complexity to the built-in tools, but we, haven’t benchmarked those yet. And as Brandon mentioned before, with things like isolated stores being easier to use. You should be able to improve the performance when you hit problems with larger, features that are composed together. Stephen

— 1:34:50

there was a question about Linux and we haven’t explored it, but all the tools built as is so far, they don’t rely and combine as you mentioned, and so hopefully they do all just work on Linux and Android and everything else. Brandon

— 1:35:03

I saw a question, I threw it up about Swift Drive previews working worse in SPM modules than the main app target. Brandon

— 1:35:10

That has not been our impression. it’s actually been the opposite. However, I will say with the caveat that the less things you’re building in your SPM module, the better previews are gonna do. So if you are building like Firebase, if you’ve had to link Firebase in order to build your. Your SPM module, the previews are probably gonna really struggle with that and the more things are in there. Brandon

— 1:35:34

So that’s a really good reason to try to split out little feature modules and then further, for any dependencies that they have on API, clients, analytics clients or whatever, to use, some kind of abstraction in front of them. So you, that you don’t need like the actual full live version of those dependencies. Brandon

— 1:35:53

You can just have a little bit of a mock or a preview version of it. Stephen

— 1:36:01

there is a question about effects in TCA 2.0 that I can put up. Stephen

— 1:36:09

Or you just put up one. Brandon

— 1:36:10

Oh, yeah. Let me just answer that one real quick. sorry. yeah. Should we now be using Xcode workspace with the SPM project or the older Xcode project With the SPM project? Yeah. At some point in Xcode pre 26, it broke a trick. Brandon

— 1:36:24

We showed in older episodes, if you could take an Xcode project, you could drag and drop the SPM. module in it and go from there. And instead, it strongly prefers you to have an Xcode project and add it like in the package settings, dependency settings, link it like as a local SPM module. But what happens if you do that is you can no longer run the tests in the SPM module from Xcode. Brandon

— 1:36:51

So you’re in Xcode working on your features, and you wanna then run the test for one of those modules in SPM and it’s just not accessible whatsoever, because it’s such a fully separate little SPM package. And so the fixed all that is one main root workspace. Throw in your Xcode project, throw in all your local SPM, packages, and then when you’re running in that workspace, you get to run app targets. Brandon

— 1:37:15

SPM Libraries, SPM tests, everything. Stephen

— 1:37:20

And so far it seems to be working pretty well, but, these tools can break between Xcode releases and we just gotta hope that this, continues to work. I will put up a question about tca two effects. a lot of these things are, a work in progress, but one big change in 2.0 is, effects before you could merge them, map them, concatenate them. Stephen

— 1:37:48

effects are maybe more built into the system now. whenever you have a feature spinoff and effect, it lives locally to that feature, and we think this is a good thing. an improvement where effects lifecycle are tied to the on mount, on dismount, lifecycle of the feature. And so you no longer need to be mapping and pulling back these effects in order to merge them into the parent. Stephen

— 1:38:18

ideally the effects are encapsulated in the feature and parents just don’t need to worry or need to know how to spin up effects in the child. But yeah, still work in progress and when we do have a preview release, we’ll be looking for feedback on any limitations. Brandon

— 1:38:36

Yeah, I just threw up one is TCA 2.0 a solution for massive state in a big app. Brandon

— 1:38:43

and what I think this is referenced, I don’t know exactly what this is referencing, but I, there no library, no anything is the solution for massive blank. we used to call things like massive view controller, then we had a massive view model. Now someone can go out there and cheekily say massive reducer. Brandon

— 1:39:04

you can do massive anything. All right? You can have massive view, you can have massive model, you can have massive tests. Anything could be massive. It is only up to your discipline to decide to where to cut things off and how to, draw boundaries and make things simpler. So DCA and no library out there is the solution for any kind of massive thing. Brandon

— 1:39:22

‘cause anything can be made massive. So if there’s a, if there’s a library X, Y, z out there, inevitably there will be massive X, Y, Z. It just, it won’t always happen. Stephen

— 1:39:35

All right. There’s a question. YouTube keeps jumping around. Brandon

— 1:39:42

Yeah. Stephen

— 1:39:42

But there was a question about how someone new to the compostable architecture could write features. and we always provide plenty of copious documentation and demos and everything, but as we saw during my demo, you can use our 0.3 way skill document. Stephen

— 1:39:58

You can just say, I wanna use the compostable architecture skill. I wanna build a feature for this kind of thing. And it will know about all the structure and, help you write it. So you don’t even need to be intimately familiar with how to structure a feature, what macros to apply. ideally if you have the “Point-Free Way” docs, you can just get up and running by telling it what you wanna build, and then it knows what to do with TCA. Brandon

— 1:40:25

Yeah. I got a, good one here. Have we ever. Consider curating or pr pruning old videos. especially where it may not reflect like current best practices or even the modern APIs. And that is a good idea. And I think we definitely should have some kind of archival section and then even some of the stuff that is just a little bit crusty, but the core of it is still great material. Brandon

— 1:40:48

I remastered version of it. Like I feel like the algebraic data type stuff is all really fun stuff, but maybe it could just be get a little sprucing up at some point. so that is something we have considered and we would like to make better. I’ve got a fun question here I could throw up unless you get one, Stephen. Stephen

— 1:41:09

Yeah, go for it. Brandon

— 1:41:10

Okay. We got, outside of working on Point-Free, what might we find Brandon and Stephen doing? You wanna take that? Stephen

— 1:41:20

Yeah. I like to, cook, hang out with the, our, dog and yeah, go on walks. I’m enjoying being outside of the city. we met in Brooklyn, Brandon and I, but we both have left the, city and gone to other pastors, and so getting a lot more fresh air and, nature. Brandon

— 1:41:45

Yeah. Yeah. I’m in, in Texas now. I was in New York for a long time, but I had to move out and I’m originally from Texas, if, in case anyone doesn’t know that. but I lived in New York for 23 years and yeah. And, now I’m, yeah, just, I’m trying to adapt again out from being outside the city and, yeah, and honestly, my, my wife and I are expecting our first kids, so you can expect in a couple of weeks for me to be very absent and Stephen will be the face of Point-Free. Brandon

— 1:42:19

But, so yeah, it looks, say we had a couple of Texas people in the chat too, and Stephen, you come to Texas pretty often too, although we haven’t met yet in, in Texas. Stephen

— 1:42:31

Yeah. My partner, her family, lives in Texas. She grew up there We’re there every year or so. Brandon

— 1:42:38

Yep. all right. And then I’m seeing, oh, hey, this is a good one. Brandon

— 1:42:43

Oh man, I couldn’t have written a better question myself. Maybe I paid this person a prompt. But, prompt us with this, do you notice a number of Point-Free subscribers going down since the a AI hype? And, yeah. It’s, no secret that AI really puts educational material like our stuff in a bit of a bind, and then even doubly so for us, because we do so much open source work, and AI also puts that in quite of a bind. Brandon

— 1:43:11

but at the end of the day. We want to continue doing this. we really enjoy it. And so what we have found is, unfortunately our, usage of the open source, like if we look at our graphs and GitHub and stuff like that, see how many people are cloning. It is, it’s like this basically, it’s a, it is a really an up, and if you look at our subscribers, it’s like a, this. Brandon

— 1:43:37

It is a stagnant, slightly downhill, downhill hill. So that is unfortunate. It just, it really means we’re, we, spend so much time with our open source work, we wanna keep on doing it, but at the end of the day, like fewer and fewer people are supporting us to do it. And it is just extremely important for us to have support. Brandon

— 1:43:57

And we had mentioned this kind of sponsorship we got recently and that helps a ton. We’re not gonna publicly say who this is ‘cause we haven’t even talked to them about this, but it’s like just Yeah. If people, all our supporters out there were internally grateful and if you work at a company that doesn’t have a team subscription, you should definitely consider getting a team subscription. Brandon

— 1:44:15

It’s, it’s a drop in the bucket for most things and it’s a whole team can get a subscription for less than what, like it cost to send a single person to a conference. we’re gonna keep on doing what we do, but it is, yeah, a little annoying to, To spend as much time as we do on our open source and on answering questions and being out there and yeah. Brandon

— 1:44:36

Seeing, things slide. Stephen

— 1:44:40

Yeah. We’re not gonna shame any large corporations, but there are a bunch out there that we know are using our tools and benefiting from our open source and we would just hope that they would put a drop in the bucket, get a team subscription and help fund those tools, so that we can continue to build them. Brandon

— 1:44:59

Yeah. I think we could do just like one or two more questions. let’s see. Just scanning around. I saw it. It, yeah, it’s jumping all over the place. But I saw something about a wasm and that, yeah, along with us wanting to support Android windows and stuff like that in TCA and really across as many of us, our libraries as possible. Brandon

— 1:45:25

Wasm would certainly be one of those. It’d be really fun. wasm comes with the added, difficulty of a, standard default was map is gigantic, measured in megabytes. And the way you get a very slim binary for Wasm is using embedded Swift. And embedded Swift is just a super, super thin, swift, you don’t even have existentials. Brandon

— 1:45:50

It’s, pretty bare bones. So that’s a big hurdle. Stephen

— 1:45:57

It’d be fun to tackle and maybe we will do episodes on it at the very least, but our libraries very heavily depend on things like existentials and, even keypads don’t exist on embedded swift. And could be very difficult to get something like the disposable architecture, working in embedded swift, but it doesn’t mean we won’t try. Brandon

— 1:46:19

Yep. I just threw up a question that dovetails with, our previous little spiel about. You know how Point-Free has been going, but also a couple other people I’ve asked this is, yeah, we, put into the skills that the skills intended for the person who installed it. the, so the idea is for larger teams, how can you store it at the repo level rather than the home directory level? Brandon

— 1:46:42

we would love if we could support that use case. we’re just not sure exactly how it would look. at the very least though, we would love if the team had a team subscription and then we would love to then support that. Yes, the team could install it at the repo level, and then that would even allow things like, CI actions to maybe do a review pass and, stuff like that, using the skills. Brandon

— 1:47:04

We would love to do that. But as we mentioned ago, we’ve got a lot of this happening with open source and a lot of this happening with subscribers and so it’s just, it’s really tough when AI’s like sucking up everything and putting us in a bind of how do we support ourselves? How do we, spend time doing these things? Stephen

— 1:47:31

Yeah, question about if we’ve considered adding sponsorships to our repos as well, and we’ve talked a little bit about other various funding mechanisms and we just find that subscriptions are the easiest way to just have one single simple way to, fund what we do. diluting it in a bunch of different places. Stephen

— 1:47:56

We feel like that might send the wrong messaging. and, we do need to maybe update the marketing on our webpage a bit. We, do a fair amount of consulting with various companies and that is another way to, to help fund us. We should make that more widely known. Yeah. But yeah, even if your team doesn’t necessarily watch every episode, or maybe not every member of the team is interested in, watching Point-Free episodes, but if they are still using our open source and the company wants to support it, getting subscriptions for the whole team does help. Brandon

— 1:48:38

here’s a good, one. Do we or plan on covering testing today, particularly cloud kit? we don’t unfortunately plan on talking about that today, but that is exactly what this week’s episode on 0.3 was about as well as last weeks’s. And you should definitely watch those ’cause we actually show how to write a test against an app that has cloud kit and iCloud sharing and show how all the data is flowing. Brandon

— 1:49:04

And you can, that actually, that query we did a moment ago that separated the shared records from the private records. We write a test to show that separation. all right. Maybe we do one, someone mentioned, Point-Free merch. I think that would be fun. We just, we haven’t Yeah. Spent any time doing it, but that would be fun. Brandon

— 1:49:27

and then, oh yeah, there’s some mentions about the kind of entry point tutorial for 2.0. We absolutely will do that. It won’t assume, anything about TCA knowledge in general. We like to do just a kinda fun from scratch, episode, and we absolutely will be doing that. Stephen

— 1:49:52

we’ve been live for a while. I don’t know if there’s any more questions that we wanna get at the backend. we could also mention that the “Point-Free Way” is available to all subscribers now. Brandon

— 1:50:07

yep. Stephen

— 1:50:08

Our alpha period is now a beta, If you have a subscription, you can install the “Point-Free Way”, right now. Brandon

— 1:50:15

Yep. And give feedback in the slack. There, there is a slack Point-Free.co/slack-invite. Maybe we should just make that slash Slack, but, but also, yeah, feel free to email us or anything. And yeah, I’ve got some people I’ll reach out to with some free subscriptions. Thanks to everyone for being a part of the community and watching us for the past two hours. Brandon

— 1:50:41

I think we maxed out like 450 people, which is really fun. And we’re still at 319 somehow. And, we have tons of stuff that we are preparing for. We’ve got a new episode series coming soon, and we’ve got, yeah, just a, lot of fun stuff, but I think that could do it for now. Stephen

— 1:51:02

Great. Brandon

— 1:51:03

All right. Stephen

— 1:51:04

Till next time, Brandon

— 1:51:05

Till next time. All right. See you. References The Point-Free Way Brandon Williams & Stephen Celis A collection of AI skill documents curated by yours truly, and designed to guide you toward clear, composable, and testable application architecture. /the-way SQLiteData Brandon Williams & Stephen Celis A fast, lightweight replacement for SwiftData, powered by SQL. https://github.com/pointfreeco/sqlite-data Composable Architecture Brandon Williams & Stephen Celis • May 4, 2020 The Composable Architecture is a library for building applications in a consistent and understandable way, with composition, testing and ergonomics in mind. http://github.com/pointfreeco/swift-composable-architecture Downloads Sample code 0354-pfw-live Point-Free A hub for advanced Swift programming. Brought to you by Brandon Williams and Stephen Celis . Content Become a member The Point-Free Way Beta previews Gifts Videos Collections Free clips Blog More About Us Community Slack Mastodon Twitter BlueSky GitHub Contact Us Privacy Policy © 2026 Point-Free, Inc. All rights are reserved for the videos and transcripts on this site. All other content is licensed under CC BY-NC-SA 4.0 , and the underlying source code to run this site is licensed under the MIT License .