John Sundell

John Sundell is awesome. Other stuff he’s done: Plot: Write type safe HTML/RSS/XML in Swift https://github.com/JohnSundell/Plot Ink: Converts markdown to HTML https://github.com/JohnSundell/Ink Swift by Sundell blog https://www.swiftbysundell.com/ Podcast https://www.swiftbysundell.com/podcast I really love these lightweight, JavaScript free websites he’s helping create in Swift. It’s such a better experience loading and reading than other blogs - the inlined sponsor/ads even look nice and don’t feel overwhelming or annoying (I usually read them!).

It's not slow by any stretch of the word compared to the rest of the web. A clean reload transfers only 300kb of data that uncompresses to 670kb. Of that 223kb(570kb uncompressed) are fonts which are heavily cached and change rarely if ever. DOMContentLoaded fires after 80ms. Subsequent loads are completely cached. In an age where the average website is multi megabyte https://swiftbysundell.com/ is a refreshing and excellent demonstration of how good the web can be.

Mine are mostly iOS specific, but here are a few of my favorites: - Swift by Sundell (https://www.swiftbysundell.com/subscribe/) - Indie Watch (https://indie.watch/) - Swiftlee Weekly (https://www.avanderlee.com/)

A very good and recent website for learning about Swift do not have a single line of JS :) https://www.swiftbysundell.com Some people still do care! Admittedly not a lot though.

Sure. Hacking with Swift [0] is great, CS193P [1] is very good (previous years were UIKit, now it's SwiftUI). Ray Wenderlich [2] and Swift by Sundell [3] are also good resources. The OG was NSHipster [4], but they haven't published much recently (some articles may be a bit outdated). For SwiftUI specifically, Swift with Majid [5] is a godsend and has amazing content. Finally, for learning good Swift language practices, the Swift book [6] is very friendly. Edit: forgot https://www.objc.io, definitely one of the best [0]: https://www.hackingwithswift.com [1]: https://cs193p.sites.stanford.edu [2]: https://www.raywenderlich.com [3]: https://www.swiftbysundell.com [4]: https://nshipster.com [5]: https://swiftwithmajid.com [6]: https://docs.swift.org/swift-book/

Thanks! A few sites that I've found really helpful in building this include: - Hacking With Swift (https://www.hackingwithswift.com/) - Swift by Sundell (https://www.swiftbysundell.com/) - Swift with Majid (https://swiftwithmajid.com/) - The SwiftUI Lab (https://swiftui-lab.com/) - The Lost Moa blog (https://lostmoa.com/blog) The community has been great, too — there are countless other little blog posts, tweets, and conversations that have helped me get this off the ground. :)

Like this idea in theory. The author's site (built with Publish) seems slow to me. Cause unknown. Would like to see more examples. https://swiftbysundell.com/

Here are my favourites: https://www.natashatherobot.com https://www.swiftbysundell.com http://whatsnewinswift.com https://rambo.codes And sporadically, I'll write a few myself: http://blog.chrishannah.me/category/swift-tips/

> I want emojis in my code. Then you will enjoy swift [1]! [1] Emoji driven development: https://www.swiftbysundell.com/special/emoji-driven-development-in-swi…

I've played around with actors in Swift for shared mutable state, which enforces async access patterns. https://www.swiftbysundell.com/articles/swift-actors/

Property Wrappers seem pretty neat, I wasn't aware of that new feature. Thanks for mentioning it. https://www.swiftbysundell.com/articles/property-wrappers-in-swift/

After leaving Apple, Chris Lattner (designer of Swift) ended up at Google for a while and there was an attempt to make Swift a first class language for Tensorflow. An interesting podcast on the topic from 2019: https://www.swiftbysundell.com/podcast/58/ Since then he has moved on to SiFive and S4TF has been shutdown. See HN discussion https://news.ycombinator.com/item?id=26117453

He was also recently interviewed on a podcast here: https://swiftbysundell.com/podcast/71/.

SwiftUI is an attempt to stop the spread of people coding for things like React and instead focus in a Apple only SDK so they accomplish their goals of developer lock in. Knowing why Apple is doing this is important to understand why this will never happen. Apparently the feature they are using is function builders (1) and its already working on the current versions of Swift. So at least now, nothing is preventing other people to try to replicate in a open source manner those features. By the way, there are some projects on Github that already implements the same functionalities. Don't wait for Apple to open source this kind of stuff, because one way to enforce lock in, is through API. And Apple is far away from being a benevolent big other as some people might naively assume. 1 - https://www.swiftbysundell.com/articles/the-swift-51-features-that-pow…

Well, I'm coming from the Javascript side, where people use promises a lot for async, but it's almost impossible to trace execution in the debugger. It's usually immediately obvious to me that many exceptions and failure modes have been missed, but I find it difficult to reason about large promise chains and I usually have no idea where I would add more error handling. It tends towards a big ball of spaghetti. Then if something does fail (wifi blips out without a retry, who knows) the page just hangs with no indication of what went wrong. Contrast this with Unix-style synchronous blocking code piping data between threads with no shared state. Since every step of execution happens in a single thread, blocking until a pipe returns data, it's trivial to step through the code. Async/await really becomes a problem in Javascript though because they made it a language keyword in Node.js. So you never know if you are dealing with a sync function or async function. Eventually the entire program has async in front of everything and ends up being written just exactly like sync blocking (but with superfluous syntactic sugar everywhere). So I question what was really gained there. IMHO it just doubles the workload in the mind since now we have to juggle both types of functions and explore those permutations. That's the last thing we need when we're trying to brainstorm a solution from a large possible search space. I'm also looking at this from a one-shot functional programming…