Paul-Hudson on blog.iankulin.com

SwiftUI provides

Wed, 07 Dec 2022 00:00:00 +0000

A few hours after I speculated about pausing work on the tickets app because outputting the tickets was too far out of my expertise, a helpful instance of the Baader–Meinhof phenomenon threw up some help in the form of this tweet from @FloWritesCode. It turns out this was an addition in iOS16 announced at WWDC that makes this straightforward.

As soon as I googled around about it I also found good solutions that wrapped the old code to provide similar functionality. So that’s a lesson for me about not assuming something’s hard before I’ve spent some time investigating it. I took that lesson and applied it to rendering to a PDF, and of course, @twostraws has a code example for that from three days ago!

Obviously I’m going to have some fiddling around to lay it out and so on, and I still need to figure out the share behaviour (which I’m expecting to be straightforward) but it feels like SwiftUI is just going to help me express my intents in code. I’m really enjoying this language, framework and community!

You Can Take Big Steps When You Feel Safe

Wed, 09 Nov 2022 00:00:00 +0000

Day 58 of #100Days feels like complex topics are being dropped in pretty fast. We tackle one:many data relationships and how to set them up in CoreData, using CoreData constraints and setting a merge policy to manage conflicts, and even the underscore to access the actual property inside a wrapped property struct (needed for dynamic filtering in a view).

I’ve mentioned before that I think Paul Hudson is an excellent teacher, and an example of this is that even though this was a day with a lot of challenging material, I’m not worried. I followed the discussion and tried the code, and more importantly I’m anticipating these new skills will be practiced in the next app, and probably shortly after I’ll be writing an app using them.

When learners feel safe and supported, they are comfortable taking bigger risks. This has the effect of growing their Zone of Proximal Development and allows faster learning.

Some of the complexity around CoreData relates to it’s pre-SwiftUI age - it has a lot of power, and does a lot for the developer but is full of non-intuitive bits. The rest of the complexity is really just related to it’s job - any object graph persistence that’s going to allow us to think of, and work with, our data as native objects is going to have to expose some of the complexity of what’s happening underneath in order to provide the flexibility needed. What’s not so evident in this implementation is Swifts progressive disclosure of complexity. It’s easy to imagine a modern rewrite of a more Swift-like object persistence framework being less scary.

Since CoreData is using SQLite underneath, an interesting question is what the same code would look like if you pulled in an SQLite library and handled things manually - to approach the same functionality - ie not refetching when a view is recreated if the data hasn’t changed, lazy list building etc. My guess is: a lot more complex.

Top Four Reasons why @TwoStraws is a Good Teacher

Tue, 01 Nov 2022 00:00:00 +0000

Good Questions

At various points in the 100 Days of SwiftUI course, you get asked sets of questions to check you’ve understood the preceding material. They’re usually presented as two different statements, one of which is true, and the other false. It’s actually a really good technique - the student feels like they’ve got a couple of opportunities to figure it out, plus they are forced to read both statements and think about them. Paul does a similar thing in the Unwrapped app - there, the questions are often presented as “Is this valid Swift code” and the user needs to scan through it all looking for mistakes. It’s checking your understanding, and making you a thoughtful debugger!

Zone of Proximal Development

You know how if something is too easy, it’s not engaging? It’s why you don’t choose Snap when you sit down to play cards. It’s so far below your skill level your brain is not interested in it. There’s a similar problem at the other end - if I ask you do try something that’s so hard for you that you’ll never be able to achieve it, you want want to do it again. For good learning to take place, it’s important to pitch the difficulty of activities just ever so slightly in advance of what the student can comfortably do. This is the zone where the most learning takes place in the shortest amount of time.

Learning in Context

Logically, you could teach iOS development with a semester of pure Swift teaching before you got to your first app. Probably there are courses that do that, but if you want to engage your learners do it with as much real life context and hands-on activity as possible. #100Days is all about this.

Beginner Mind

In the videos/lessons, Paul often anticipates how the learner might expect something to work, or how they might tackle a problem, before explaining the problem with that thinking or showing a better way of doing things. This is a great trait of a teacher. Often it’s difficult for experts (which Paul undoubtedly is) to recall how things looked to them as they were learning. Anticipating the state of mind of the learner, and moving them from that point is both comforting for the learner, and avoids confusion.

Currency

As soon as you start googling problems and reading blog posts or StackOverflow answers, it becomes apparent that the rapid development of Swift and SwiftUI has a downside - a lot of the helpful information put out there is out of date. Like everyone, I’m amazed at the work Paul puts in to producing his massive amount of content, and then keeping it up to date. If there’s a Hacking With Swift result in a search you’ve made, that’s the one to click on.

Sean != Erica

Sun, 04 Sep 2022 00:00:00 +0000

When Swift was newer, there was a bunch of podcasts about it - in early episodes of Fireside Swift the existence of a Swift Podcast Network is often mentioned, but now it’s more of an established language there’s a bit less current content to listen to, and what there is, is less focused on learning Swift and more about what’s happening in the community.

Being firmly in the camp of needing to learn more about the language, I’ve listen to a number of older podcasts, or even current ones (such as Fireside) but their older episodes. It is sort of an odd experience traveling on several slightly out of sync timelines, but quite a joy to see what happens to predictions - like the occasion when Paul Hudson predicts that an “Xcode lite” on iPad is unlikely to be able to write apps until a more swift like framework for developing interfaces exists.

One of the podcasts I’m working through by every episode is Paul’s Swift Over Coffee. The first season he was paired up with Sean Allen, but I’ve just started the second season with Erica Sadun. When I first came across Sean it took me a while to warm to his enthusiastic voice, but what I loved about him was he was never reluctant to ask Paul to explain something - usually something I needed explained as well. The dynamic of an expert (and expert teacher) co-hosting with a relative newbie was a great combination for me.

Erica is a giant in the Swift community, and she has a deep understanding and an wide knowledge of Swift topics, so she’s going to be great. In the first episode she and Paul riffed on a heap of interesting topics with great enthusiasm and clear enjoyment, but I did miss Sean asking for explanations!

Uwrap App

Thu, 25 Aug 2022 00:00:00 +0000

Part of the @twostraws programmatic universe is his Swift learning app, Unwrap that I’ve included in my learning goals. It presents little snippets of learning with a 60 second video, and in a written version, then tests the user to check their understanding. It is slightly gamified - you get points for answers, but it’s not clear to me how that works beyond the satisfying haptics when your score runs up at the end of a section.

The tests so far (I’m up to Functions) have been code examples along with a “true or false” question for the set - often “This code is valid Swift”, but sometimes things like “This code prints four messages”. At first, I didn’t love the tests as they often didn’t test the thing I’d just learned. For example in the unit about for loops, the hidden error in some code might have been an undeclared variable being used. But the effect of this has been to make me look at each example carefully to look for errors - in the process I’ve learned the Swift syntax well (which I would otherwise have relied on Xcode to help me with), and sharpened my ability to spot errors (that I would otherwise have relied on the compiler to help me with).

The screen shots here are from my SE2 iPhone - so on a sensible sized device the code may be a little easier to read (no it does not to landscape on the phone). I do value having it on the phone though - it’s perfect for making good use of tiny bites of time through the day which would be Swift learning free otherwise.

Even if you’re not following one of Paul’s Hacking with Swift courses, the Unwrap app is a great way to polish your Swift knowledge.

Playgrounds are good

Mon, 22 Aug 2022 00:00:00 +0000

A couple of times (Protocols & Named Loops) in the past few days I’ve needed to write and run a couple of tiny C or C++ snippets, and I’ve acutely felt the lack of Swift Playgrounds for it. It occurred to me that Playgrounds has been instrumental in my enjoyment of learning Swift - it’s just a bit magic to grab the closest device and noodle out an idea or to make sure I’ve understood a new concept.

In a conversation between Chris Lattner and Paul Hudson I’ve listened to recently, they discuss the value of Playgrounds and the excellent Swift book in bringing the community along from Objective C. I could not agree more about the value of these two.

As an alternative, I downloaded C Language app for the iPad. This seems like a reasonable editor that uses an online compiler - it worked for my purpose although it wasn’t real snappy.

A couple of alternatives in the app store mentioned the ability to compile offline - which didn’t make sense to me until I pressed build on this one and realised it was using a server somewhere to do that work. So this may well not be the best one for AUD5.

I was amazed to find heaps of online compilers for things which would have done the job just as well. I’ve bookmarked this one which does all sorts of languages including C and Swift.

Unwrap

Sun, 31 Jul 2022 00:00:00 +0000

Unwrap is the Paul Hudson app for Swift learning. It’s good for using those three minute gaps in life to digest a concept. I’ve incorporated it into my goals, as some days its the only progress I make.

Swift Over Coffee

Fri, 22 Jul 2022 00:00:00 +0000

One of the iOS development podcasts in my current rotation is “Swift Over Coffee”, it’s blurb is:

Swift over Coffee is a podcast that helps you keep your Swift skills up to date the easy way, hosted by Paul Hudson and Erica Sadun. Each episode has news, our picks of the week, plus an open ballot where you can share your views on important topics.

And that is about how it goes. In Season One, it’s actually Paul and Sean Allen at the mic, they chat about news and topics related to Swift and iOS development, and each week there’s a Twitter question that people have chipped in on and the hosts go over these different views in some detail.

There’s only two seasons - in 2019 and 2020, but still there’s lots of good content for a beginning developer like me.

Passing Data

Wed, 20 Jul 2022 00:00:00 +0000

Sean Allen has come to my notice a couple of times, once where he was mentioned as freelance contractor who is a great contributor to the community (I think perhaps that was on Swiftcoders Podcast), and I’ve also bumped into him as co-host (with Paul Hudson) of the early episodes of the “Swift over Coffee” podcast.

This video I watched last night is a compilation of the first few videos of Sean’s SwiftUI course, and it’s pretty great. In particular he does a great job of explaining how to start to refactor child views out and call them, and how all the stacks go together to make a pretty interface. What he does not do is vist/explain any of the Swift language fundamentals. If you don’t already know what a struc is, and the Swift flavour of them, it may be a challenging place to start.

In the last couple of tutorials he starts on the way the views are called, and how we can pass values into them. This is great marketing for me - it’s exactly where I’m up to in my journey - I’m perplexed about the structure of a SwiftUI app (where’s main?!) and the engine that’s watching when the UI needs updated and building the views. For example, I want to write a little hello world that just prints the time on the screen. I got this far:

struct ContentView: View {
 let today = Date.now
 var body: some View {
 Text(today, style:.time)
 }
}

But then a minute later when it needs changed what happens? In traditional programming there would be a loop in main where I could check the minutes have changed, and force the redraw of the label.

I feel this is the thing that’s going to be explained clearly in the next few videos of Sean’s course, which is cunningly behind the paywall. I’m very tempted, although my learning is already spread over two proper courses plus a shotgun blast of other reading, podcasts and self created programming tasks.

I did have one moment of confusion when Sean passes down an @State variable to a child view and said the variable in the child view needed to be made @Binding. One of the top comments points this out as being unneeded and Sean agrees.