Ole Begemann

I do and he says exactly the same thing. >...the goal was really to build something that you could write firmware in or that you could do scripting in, that you could write mobile apps or server apps or low-level systems code, and have it be great at all of those, not just some terrible compromise. Taken from https://oleb.net/2019/chris-lattner-swift-origins/ to save listing to the whole interview Feel free to actually listen to the episode as well, and also read/listen the sections on how Swift is a complete Objective-C replacement without the bad C parts.

We don’t lack for wonderful writers in the Apple ecosystem. Along with objc.io I’d heartily suggest: https://oleb.net (Ole Begemann) https://www.mikeash.com/pyblog/ (Mike Ash)

Here is a great article about strings in Swift: http://oleb.net/blog/2014/07/swift-strings/ Short story: “number of characters” and “nth character” are more complicated questions than you might think when you deal with full Unicode text.

For iOS/Mac development, Ole Begemann's http://oleb.net/ is invaluable, especially for the monthly link roundups.

> Swift’s string implementation goes to heroic efforts to be as Unicode-correct as possible. […] This is great for correctness, but it comes at a price, mostly in terms of unfamiliarity; if you’re used to manipulating strings with integer indices in other languages, Swift’s design will seem unwieldy at first, leaving you wondering. > It’s not that other languages don’t have Unicode-correct APIs at all — most do. For instance, NSString has the enumerateSubstrings method that can be used to walk through a string by grapheme clusters. But defaults matter; Swift’s priority is to do the correct thing by default. > Strings in Swift are very different than their counterparts in almost all other mainstream programming languages. When you’re used to strings effectively being arrays of code units, it’ll take a while to switch your mindset to Swift’s approach of prioritizing Unicode correctness over simplicity. > Ultimately, we think Swift makes the right choice. Unicode text is much more complicated than what those other languages pretend it is. In the long run, the time savings from avoided bugs you’d otherwise have written will probably outweigh the time it takes to unlearn integer indexing. — https://oleb.net/blog/2017/11/swift-4-strings/

The problem is that RSS doesn't really have a concept of "deleted". In general feeds just contain the newest items. Items not on the feed are generally considered old, not deleted. You can play with heuristics like "This feed is usually sorted by published date and these entries I saw previously should still be here but are missing, maybe they were deleted" but not even have published or updated dates and they aren't always accurate. This gets even more complicated with WebSub which allows hubs go remove entries they have already seen. So now you need to not do deletion on those requests, and if you turn down your poll rate for feeds with WebSub (which Feedly does IIRC) you might not even fetch the full feed to notice that items are missing for weeks. The one thing that would actually be reliable here is probably Atom's pagnation and archiving extensions which you can follow to get a view of all of the items in the feed and prune missing ones. However you probably don't want to do this every fetch (otherwise it kinda defeats the point of pagnation). Maybe you could combine this with other heuristics to come up with a decent system. But I'm not even sure these have ordering guarantees so I'm not sure if you are going to fetch potentially unlimited pages just to check if an item was deleted. If we did want to solve this problem the best option would probably be to add a tombstone element to the feed to explicitly remove items. TL;DR as far as I am aware neither RSS or…

Here's what Chris Lattner said about Kotlin this past June: "Lattner: Swift and Kotlin evolved at about the same point in time with the same contemporary languages around them. And so the surface-level syntax does look very similar. … But if you go one level down below the syntax, the semantics are quite different. Kotlin is very reference semantics, it’s a thin layer on top of Java, and so it perpetuates through a lot of the Javaisms in its model. "If we had done an analog to that for Objective-C it would be like, everything is an NSObject and it’s objc_msgSend everywhere, just with parentheses instead of square brackets. And a lot of people would have been happy with that for sure, but that wouldn’t have gotten us the functional features, that wouldn’t have gotten us value semantics, that wouldn’t have gotten us a lot of the safety things that are happening [in Swift]. "I think that Kotlin is a great language. I really mean that. Kotlin is a great language, and they’re doing great things. They’re just under a different set of constraints." https://oleb.net/blog/2017/06/chris-lattner-wwdc-swift-panel/

A companion piece to this idea (previously at Oleb’s “making illegal states unrepresentable: https://oleb.net/blog/2018/03/making-illegal-states-unrepresentable/) is “parse, don’t validate”: https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/ A third piece / concept I often circle back to is a lot more subtle and difficult to grok: “Names are not type safety” (https://lexi-lambda.github.io/blog/2020/11/01/names-are-not-type-safet…

> I think many also find its syntax more approachable compared to that of Rust. Chris Lattner (of LLVM fame) did design the language with the goal of hiding complexity until it is needed. > The concept of progressive disclosure in Swift, where you can start with something very simple and then learn complexity as you go, was totally driven by making it teachable. I personally spent a lot of time trying to make sure that the introduction to Swift could just be print("Hello World"). No semicolons, no \ns, none of that public static void main stuff. Making it simple and approachable was a strong goal, and not in a weird way where in a teaching environment there is this “Swift Prime” language that’s similar but different. https://oleb.net/blog/2017/06/chris-lattner-wwdc-swift-panel/

The web (HTTP + HTML + JS) intentionally fits the definition of a REST API. https://oleb.net/2018/rest/ In particular: > The central idea behind HATEOAS is that RESTful servers and clients shouldn’t rely on a hardcoded interface (that they agreed upon through a separate channel). Instead, the server is supposed to send the set of URIs representing possible state transitions with each response, from which the client can select the one it wants to transition to. This is exactly how web browsers work

There are at least a couple of ways of indicating that an entry should be deleted in RSS and Atom, but they don't seem to be well-supported. This blog post mentions a couple: https://oleb.net/blog/2015/11/rss-feed-item-deletions/ I vaguely recall that Microsoft also had some proposed mechanism, but I can no longer find any trace of it. I doubt anything supports it.

I’ll tack on a couple sources to this: http://pointfree.co - high quality content, emphasizing functional programming. https://oleb.net/blog/ - blog of Ole Begemann, co author of Advanced Swift (good resource itself) https://appventure.me - Benedikt Terhechte’s topical guides to Swift features https://andybargh.com/blog/ Andy Bargh’s topical articles

Call it a database if you wish. In fact it is probably sqlite running behind the scenes. It is a relational model, a different way of organizing things compared to the hierarchical model of the filesystem. There is probably enough literature about that to fill your ebook library ;) I suppose that the "library" model is what most people prefer since most modern media apps use that in some form or another. Or maybe it is because of Steve Jobs reality distortion field ( https://oleb.net/blog/2012/06/steve-jobs-on-the-file-system/ ). Still, I hate all these apps attempting to hide the filesystem from me.

Here's more info about how the iPhone 6+ scales pixels in various situations if anyone's curious: http://oleb.net/blog/2014/11/iphone-6-plus-screen/

Seeing there are no blogs listed for iOS dev, here are my favorites: https://www.mikeash.com/pyblog/ http://nshipster.com/ http://natashatherobot.com/ http://oleb.net/blog/ Also I have a blog: http://koreyhinton.com/blog

It's a big company, and there will certainly be diversity in experiences. But he's not the first person to talk about such situations: http://oleb.net/blog/2014/09/work-habits-at-apple/ (https://news.ycombinator.com/item?id=8389238) It does happen.

Apple is at least providing some tools to help with this - for instance, you can specify a storyboard whose initial view controller will then be used as the app’s launch screen; this avoids the problem of separate launch images for all screen sizes, resolutions and orientations their app supported. http://oleb.net/blog/2014/08/replacing-launch-images-with-storyboards/ I seem to recall Marco Arment took a bit of pride in having 100% procedurally generated graphics with overcast, so that he didn't have to create/ship any bitmapped images whatsoever.

I've already seen a high level post about how Dropbox does cross-platform development [1], but I think they don't go in details about the kind of issues one might face going with that approach. [1] http://oleb.net/blog/2014/05/how-dropbox-uses-cplusplus-cross-platform…

Ole Begemann recently wrote about the changes in the context of selling apps through the App Store: http://oleb.net/blog/2014/07/eu-vat-changes-2015/ Apple sells all apps through its Luxemburg subsidiary, meaning Luxemburg's low 15% VAT rate applied. On the buyer side, am I right to assume that as a VAT-registered company/freelancer I will be able to deduct VAT paid on apps purchased through the App Store?

Some info about the VAT changes can be found here - http://oleb.net/blog/2014/07/eu-vat-changes-2015/

Apparently launch images in different sizes will go away and will be replaced by storyboards with auto layout http://oleb.net/blog/2014/08/replacing-launch-images-with-storyboards/

When I wanted to code a foundation of reusable code for different devices I would either do it like Dropbox and use C++ as the most common layer http://oleb.net/blog/2014/05/how-dropbox-uses-cplusplus-cross-platform… or use Javascript (which I can also use for web pages) for the program logic like described here http://www.skyscanner.net/blogs/developing-mobile-cross-platform-libra… Also interesting http://kivy.org allows you to use Python for iOS, Android, OS X and Windows. I would not bet on Swift and cross compiling it today... too bleeding edge. But interesting project... hope it matures. Good luck!

It seems Apple has reduced the scope of the NDA this year. http://oleb.net/blog/2014/06/apple-lifted-beta-nda/

There was a blog post about this http://oleb.net/blog/2014/06/apple-lifted-beta-nda/ Further, Apple agrees that You will not be bound by the foregoing confidentiality terms with regard to technical information about pre-release Apple Software and services disclosed by Apple at WWDC (Apple’s Worldwide Developers Conference), except that You may not post screen shots, write public reviews or redistribute any pre-release Apple Software or services.

There's stuff here about a UIRemoteWebViewController: http://oleb.net/blog/2012/10/more-on-remote-view-controllers/ https://github.com/nst/iOS-Runtime-Headers/blob/master/Frameworks/UIKi… https://github.com/nst/iOS-Runtime-Headers/blob/master/Frameworks/UIKi…

They might be able to handle it with a remote view controller. An existing iOS technology that allows for a view controller that fronts an out-of-process application. This is used for the mail composer and facebook sharing. See: http://oleb.net/blog/2012/10/remote-view-controllers-in-ios-6/ (I suspect there are some constraints on how a remote view controller can be used, and they'd have to do some additional work to shunt in NSURLProtocol and all.)

iOS has support for something called XPC. IIRC, it's how the mail composer, etc is invoked by apps (behind the scenes). I'd be very surprised if the API isn't made public in the next version of iOS, which would help facilitate some of these things - it would at least allow easier app-to-app integration. More info: http://oleb.net/blog/2012/10/remote-view-controllers-in-ios-6/

XPC[1][2] is a private framework in iOS. I am hoping it will be made accessible before iOS 8 (unlikely). [1] http://oleb.net/blog/2012/10/remote-view-controllers-in-ios-6/ [2] https://developer.apple.com/library/mac/documentation/MacOSX/Conceptua…

They might be moving towards some kind of XPC service so you can talk to a JIT through a Mach port. Speculation is my own, derived from: http://oleb.net/blog/2012/10/remote-view-controllers-in-ios-6/

This website actually crashes my macbook pro. No really. I have this bug (verified by genius tech) http://oleb.net/blog/2012/05/15-inch-mbp-mid-2010-crashing-to-black-sc… which I haven't given to them for repair yet. The Product button's visual transition repeatedly crashes my box. Otherwise, looks pretty cool :)