Archive for February 11, 2020

Tuesday, February 11, 2020

Google Maps at 15

Lauren Goode (tweet):

Jen Fitzpatrick leads the Google Maps team, and also happens to be one of the earliest Googlers. She first joined the company as a software coding intern in 1999, and worked on Google’s search, advertising, and news products before finding her way to Maps. Fitzpatrick sat down with WIRED ahead of the app’s 15th birthday to talk about the evolution of digital maps, how she plans to keep advertising from being as confusing on maps as it is in search, and a future in which Google Maps is more than just a driving app.


I think we had a hypothesis going into the AR-based walking navigation effort that it would be most helpful for people when they were in very unfamiliar settings, in a travel kind of scenario. And I think we’ve seen that to be the case.


I think you’ll see Google Maps evolve to be an application that’s much, much better at getting you from here or there no matter what mode of transportation you’re using, even if you’re chaining together multiple modes of transportation.

Alexandra Erin:

If you find yourself using AirBNB, here’s what I would suggest, based on the past ~5 years of scammer stories:

1. Plug the address into Google Maps first.
2. Compare Street View pictures of the property to the interior photos.
3. Verify the hosts exist.

Eric Young:

Apple Maps vs Google Maps in an emergency

Los Angeles county already received the Apple Maps revamp that supposedly made it on par or better than Google Maps

This can have deadly consequences for anyone relying on Apple Maps during an emergency


More About SwiftUI

Apple (via Tony Arnold):

You’ll start by adding a macOS target to your project, and then reusing the shared data you created for the iOS app. With all of the assets in place, you’ll create SwiftUI views to display list and detail views on macOS.

Follow the steps to build this project, or download the finished project to explore on your own.

Chris Eidhof:

After a few months spent delving into SwiftUI, we decided to write a short book: it’s called Thinking in SwiftUI. Since SwiftUI is still in its early days, the book focuses on the concepts behind the framework that we believe are essential to understand. It is not a reference for SwiftUI’s platform-specific APIs, but rather a guide to honing your intuition about how SwiftUI works.

Nikita Prokopov (Hacker News):

First, the general approach SwiftUI is taking (reactive declarative data-driven UI framework) is really solid and considered state-of-the-art as of the current day of the year. No complaints here, great job, we all needed that, thank you Apple for releasing it. No, seriously. It’s a great tool and I’m looking forward to using it.

But, a few things I noticed in SwiftUI concern me. I think they could illustrate points in the UI framework design that future systems could handle better. Without further ado, let’s start with the biggest problem in API design: commas!

Will Townsend:

Today I’ll explain how to create your own Button Styles, and hopefully show you the difference between ButtonStyle and PrimitiveButtonStyle, and why you’d use one or the others.

Scott James Remnant (via Joshua Emmons):

One of the first things presented about SwiftUI is that its views choose their own sizes, and that once chosen, those choices cannot be overridden. This is such a simple statement that it would be easy to move on quickly to get to the good stuff.

This would be a mistake, because this simple statement fundamentally changes everything you know about layout.


This doesn’t contradict what we’ve just learned about chosen sizes not being able to be overridden, it actually demonstrates another key principle we haven’t learned yet: a view receives a proposed size from its parent before it chooses its own size.

Alexander Grebenyuk:

SwiftUI no longer uses Auto Layout, gone all of the cruft introduced over the years. SwiftUI has a completely new layout system designed from the ground up to make it easy to write adaptive cross-platform apps. […] I can’t be more excited to dig deep into the SwiftUI layout system to see what it has to offer.

Ole Begemann:

SwiftUI’s layout algorithm may be simple on the surface, but the way the built-in views and view modifiers interact is tremendously complex (and largely undocumented).


After spending some time testing the limits of alignment guides, I arrived at the conclusion that they do work. However, there’s confusion about what we expect from them. This confusion comes from not realizing there’s a whole set of implicit alignment guides in effect. When we ignore them, things do not go our way.


In this short article, we are going to explore several aspects of View equality. We’ll see what happens when we make a view conform to Equatable, and what is the purpose of EquatableView and the .equatable() modifier.


If you’ve been using SwiftUI for a while now, you probably hit the problem where you find yourself trying to update the state of a view from inside its body. Usually, Xcode complains during runtime. When it does, you are forced to put your update inside a DispatchQueue closure (not feeling too good about yourself) but you carry on anyway. Does this sound familiar? In this article, we’ll discuss why it sometimes is perfectly fine to apply that technique, but some other times, it’s a no-no (leading to CPU spikes or app crashes).

Jared Sorge:

In my last post I talked about some of the struggles I’m having getting up to speed with SwiftUI. Let’s dive in to a couple of examples.

Rob Whitaker:

Apple has taken the chance to re-think how some of their accessibility tools work for developers, and they’ve baked in accessibility right from the very beginning. Apple’s accessibility teams have been an integral part of some of the decisions that have shaped SwiftUI. You can see this throughout your SwiftUI code.

Mattt Thompson:

It’s hard to overstate how much of a game-changer Xcode Previews are for iOS development, and we couldn’t be happier to incorporate them into our workflow.

Kishikawa Katsumi:

I published SwiftUI online playground.

You can try SwiftUI and see the rendering results insanely easily.😊


I tried to replicate my app’s GUI using SwiftUI. Couldn’t get the basic layout right: standard controls do not size themselves correctly. Also, popup buttons do not draw their menu correctly. SwiftUI is plain broken on macOS.

I continue to hear about problems like this.

Wooji Juice:

If you want to make a Mac app, there are 4 primary APIs you could be using, in a sorta 2x2 grid: AppKit, UIKit (w/Catalyst), SwiftUI-in-AppKit, SwiftUI-in-UIKit. It’s a complex mess of what each does/doesn’t support — figuring out which to use for any given UI is trial & error

I’ve been trying to make one relatively simple bit of UI (in a standalone testbed app) for days. Every time I think I’m on a roll, I bump into a different wall of missing functionality. I try different implementations. I try different designs that don’t need same features.

It’s not even like you can say “Screw it, I’ll do everything old-school pure native AppKit and get access to everything”, cuz you’ll still be missing some things (e.g. SF Symbols aren’t supported, even tho they are all available on Mac since Catalyst apps can use them).


Rejecting and Accepting an Appfigures Client

Vojtech Rinik:

I’ve always wanted to build a desktop app that would let me access my most important data quickly. Like those old dashboard widgets used to.

I finally got around to it, and started with Appfigures, my favorite service to track App Store sales.


We noticed that your app offers a subscription with a mechanism other than the in-app purchase API.

Can anyone explain to me, how did they let the official Appfigures app into the App Store? It’s the same thing, and I’m pretty sure they don’t have IAPs. It’s just a dumb viewer of the data.

Vojtech Rinik:

Right after the rejection, I submitted an appeal. I didn’t expect much. I heard the stories. Once your app gets rejected, there’s nothing you can do, I thought. Especially if you’re small and irrelevant.


To my surprise, I got a reply to my appeal. (At this point, I wasn’t expecting one.) Just two days later I received a response, which basically said “Yup, we checked again, you’re fine, actually.”

Unbelievable, I thought. The best part? This heart warming message at the end: “Thank you for your commitment to Mac app development.”