Mobile Couch

With Ben off attending Google I/O, Jake and Jelly talk art exhibitions, storyboards, Jelly’s struggle with sync, and prepping for WWDC.

Jake kicks things off by talking a little about features he’s recently discovered in Storyboards, such as the ability to mark constraints and constants in storyboards as “installed”. He’s slightly ashamed, since he’s realise that these features have been around for a while now, but never the less, it just makes him love them more.

To make him feel worse, Jelly tosses out a new feature Jake’s never heard of: the ability to provide image assets based on device and size class. He also agrees that storyboards are the logical choice for visual layout design (WHAT?); things like autolayout constraints make more sense in a visual format than in code.

Jelly then spins the discussion off to talk about his issues with sync in GIFwrapped: a year and a half into working on the app, he’s still having issues. In response to an announcement from Dropbox that they’re moving to a new version of their API, he’s working on a new structure for the GIFwrapped library, part of which means writing his own Dropbox client directly on top of the HTTP API.

This leads to the question of which is better: notifications, protocols (like delegates), or blocks. Jelly first asks Jake’s opinion, then proceeds to describe his rationale for the use of each one.

Jake wants to spend a little time talking about how to prep for WWDC, which is happening next week, so he spends a little time explaining what he’s been doing to get ready: re-watching last year’s sessions, filing radars, and preparing sample projects to take to labs.

• James Turrell: A Retrospective
• iOS Core SDK (Dropbox)
• AltConf 2015
• Layers Conference
• ReactiveCocoa Developers Conference 2015
• Paged Collection View (GitHub)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

With the videos from the final NSConference out to watch for free, the couch discuss some favourites, as well as conferences in general. Plus, a brief look at presenting alternate view controllers, such as onboarding screens and login dialogs.

After a brief (and ridiculous) discussion about what WWDC might have in store this year, Ben reveals that he has a list of his favourite videos from NSConference 7, and the couch spends some time discussing each one for a few minutes.

Somewhere in the middle, they get sidetracked by a discussion of conferences, both first and third party, and Jelly’s one lament, which is that there isn’t more opportunities for conferences in Australia, while so many happen in America or Europe.

With NSConference covered, Jake poses a couple of questions for Ben and Jelly to answer: how do you handle showing an onboarding sequence on first load, and how can you do something similar with login screens, showing a login modal over another modal if the user isn’t logged in?

• Cocoa and Robots - Taylan Pince (Vimeo)
• The Last Job - Kyle Richter (Vimeo)
• Humans Need Not Apply - CGPGrey (YouTube)
• iOS App Marketing For Small Developers - Marco Arment (Vimeo)
• Expert of Nothing - Jessie Char (Vimeo)
• Layers Conference
• AltConf 2015
• The Modern Password And You - Joel Parsons (Vimeo)
• SpriteKit with Crayons - Rob Rhyne (Vimeo)
• Somewhere Between Tomorrowland and Frontierland - Daniel Steinberg on Vimeo
• Feedback Driven Development - Paul Kafasis (Vimeo)
• Topical 6: Minimum Viable Product

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Jake has his watch in hand, so after going back over some unit testing follow-up, and with a single weekend’s experience, the couch looks at first impressions, the various delays that people are struggling with, and handling multiple asynchronous tasks with dispatch groups.

Jelly segues seamlessly into follow-up, and talks about how he spent some time since the previous episode creating unit tests for one of his open source projects. He struggled a little with getting started, but feels like the endeavour was worthwhile (it found bugs!). He’s still wary about full test-driven development though.

Pre-ordered watches have started arriving, including Jake’s, and so the couch discusses the pre-order experience, Apple’s offer of expedited orders to random developers, and the watch labs that were offered prior to the launch for on-device testing of Apps prior to day one release.

This leads to both Jake and Jelly giving their first impressions, including the delay that they experienced with waiting for Jake’s glance to load it’s data, and the fact that there’s a large gap between the experience of first-party and third-party apps.

Jelly uses this as an opportunity to cover what gives him the inspiration for his apps, and how being the first in the store doesn’t prevent someone from coming along with a better implementation and succeeding.

Moving along, Jake talks about an issue he had this week with implementing multiple API calls for displaying data in a today extension. After trying a few solutions (including NSOperationQueue), and then he discovered dispatch groups, so after he covers how he implemented them, the couch discuss why you would choose them over an operation queue.

This spawns a conversation about APIs and how Jake’s implementation is covering up a potential issue with the API he’s using. Is it better to use a potential complex API endpoint that doesn’t provide the data in the format you need, or stick a server between the app and the API to parse out just the bits you need?

Also, did you know Jake got an Apple Watch?

• Topical 8: Employment
• Using Dispatch Groups to Wait for Multiple Web Services (Command Shift)
• Today (App Extension Programming Guide)
• widgetPerformUpdateWithCompletionHandler: (iOS Developer Library)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Leading with follow-up, Jake touches on his experiences with developing a WatchKit after having talked to David, how he’s fetching the content for his glance, and how the Swings analogy made him rethink the way he was trying to lay out his views (and thus making his efforts more successful).

After getting nostalgic about a listener-submitted Codewarrior mug, Jake talks a little about the various Steve Jobs biographies he’s read, before touching on some assert related feedback.

This leads Ben to pose the question about whether you should leave asserts on, or remove them for release code. The couch discusses where people use asserts, and in what cases you might actually want to ship asserts rather than displaying an error.

Moving on, Jake asks if Ben has any opinions on testing, and this leads into a discussion about unit testing, and what exactly a unit test should cover. From the conversation expands to cover various other kinds of testing, like integration testing, and UI testing with UI automation.

As they start wrapping up, Jake mentions that the bit he likes about unit testing is that it makes him think about the structure of his code, which Jelly believes he already does. In fact, he believes that if you’re relying on testing to structure your thinking, you’re doing it wrong.

This prompts Ben to ask about how Jelly approaches his code, which Jelly answers by roughly describing his process when he built Static Tables. Laying out blank classes and methods to create a basic structure, fleshing them out, then writing an example app for testing.

Finally, Jake adds that Playgrounds are what got him started on unit testing in the first place. He loves the concept of code being executed as he’s writing it, but the lack of external frameworks lead him to trying out unit testing.

• Becoming Steve Jobs (Amazon)
• Becoming Steve Jobs (iTunes)
• Edge Cases 23: The Elevator Pitch for Design by Contract
• The Pragmatic Programmer
• Testing in Swift with Jeff Hui (Realm)
• KIF Framework (GitHub)
• Xamarin Test Cloud
• Big Code: Developer Infrastructure at Facebook's Scale (YouTube)
• Core Intuition 178: Hacking Things Together At Runtime

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Joining the couch this fortnight is Underscore, a.k.a. David Smith, host of Developing Perspective and independent developer extraordinaire. There’s so much to talk about, but the biggest topic is the Apple Watch, and specifically developing apps for it, which is something that David has some experience with.

To kick things off, Jelly asks David what drew him into developing in the first place. This leads to talking about why he keeps a large catalogue of apps, and how he achieves sustainability through diversity, while also providing him with the ability to satiate his short attention span.

Turning their attention to the Apple Watch, David explains why he’s focusing on developing for Apple’s new device, and how’s he’s managed to create apps he believes are compelling for a device he hasn’t yet been able to fully experience.

The couch then start talking about the actual development process in a bit more detail, discussing things like what methods are called at different points within the app’s lifecycle, and when you should be refreshing the data that’s shown in a glance.

At this point, Ben asks about how David has achieved animations on the Watch, and so David describes how you perform animations, from timers to more complex, image-based animations, like the bar graph in Pedometer++.

From there, they discuss measuring the experience of the app, and how it’s not always the obvious choice, as well as what the balance of complexity should be when it comes to building apps where there is very little as far as input mechanisms.

• David Smith's Website
• David Smith on Twitter
• As I Learn WatchKit (David Smith)
• WatchKit (Apple Developer)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

While Ben is at NSConference, Jake and Jelly compensate by talking about the new Macbook, Jake’s recent experience with converting a Swift 1.0 project to 1.2, and a couple of Haneke-related tricks they’ve learned recently.

Jake wants the world to know about the one thing he managed to predict correctly for the Apple Event: the inclusion of hardware other than the Apple Watch. This leads to talking about the new Macbook as a development machine, despite the slower compile times as compared to a Macbook Pro.

This starts to lead into a discussion about Swift 1.2, which apparently has far improved compile times than the previous version. First of all, however, Jake lays some groundwork by detailing some bugs he fixed in an update for the app he talked about on the last episode, including the parental section accessibility issue and the solution he devised.

Jake then finally gets to the details of his migration of the app’s codebase to Swift 1.2, including the changes to the as operator, and the changes to @autoclosure. This procedure has made him question Swift’s simplicity, however, and he wonders if it will be a language that is easy for newcomers to pick up, or whether Objective-C might be the better choice.

The migration has also introduced him to forking an open source repository to contribute changes, and he details the changes he made for a page control alternative and how he made it compatible with Voiceover.

Finally allowed to talk about some of his work, Jelly takes the mention of Haneke as an opportunity to talk a little about custom fetchers, and Jake then talks about implementing custom formats with the caching library.

• How Apple Makes the Watch (Atomic Delights)
• The New Macbook (Apple)
• Building assert() in Swift, Part 1: Lazy Evaluation (Apple Developer Swift Blog)
• Jake's migration of HanekeSwift to Swift 1.2 (GitHub)
• Jake's VoiceOver additions to FXPageControl (GitHub)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Jelly’s had some wine, and a long day to boot, so after a failed first attempt at recording the episode, the couch talks developing for Android, goes into more detail about the value types discussion from the last episode, discusses the Blue and Black/White and Gold dress dilemma, and makes predictions for the “Spring Forward” event.

In the past week, the Australian media have been shocked to discover that you can send iMessages to people if you know their email address, much to Jake’s annoyance. Meanwhile, Jelly takes no stock in the mainstream media’s ability to report accurately on technology issues, citing people’s tendency to blame technology for things that are actually user error. This leads to a quick discussion of how old devices are treated and Ben’s inability to keep one charged off of the cable.

Ben then starts to give a bit of a primer for getting started with Android development, including which IDE to grab and how to get the emulator running. This is soon somewhat derailed as Jake begins to list features he likes in Android Studio, and the discussion devolves into a comparison between it and Xcode. Of course, it doesn’t take much to go from there to talking about Swift, and Ben ends up talking more about the video from Andy Matuschack mentioned on the last episode.

After Jelly does the intro at this point, and it’s revealed that this is the second attempt at recording the episode, Jelly brings up the topic of the Blue and Black/White and Gold dress that recently took the internet by storm. The couch first discusses the science behind the phenomenon, and then Jelly attempts to spin off onto accessibility, and how some users see your app differently.

This prompts Jake to talk about some accessibility weirdness he recently came across with working on a kids app: not only does the app read out instructions for accessing the parental features, but the gestures used become impossible with accessibility gestures turned on.

Having officially given up on the show at this point, Jake then turns the couch’s attention to the rumoured Apple car (the most mobile of devices), and specifically, the reasons he thinks that it’s an actual thing that Apple are working on. He then moves on to predictions for the imminent Apple event, including things that might be announced alongside the watch.

• The simple iMessage trick that lets you text almost any MP without knowing their mobile number (Sydney Morning Herald)
• Android for iOS Developers (Stripy Sock)
• Android Studio and SDK Tools
• Genymotion
• Using Hardware Acceleration (Android Developers)
• Xamarin Android Player
• Visual Studio Emulator for Android
• The Original Dress Photo
• Checkershadow Illusion (MIT)
• Apple Gears Up to Challenge Tesla in Electric Cars (Wall Street Journal)
• Jonathan Ive and the Future of Apple (The New Yorker)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Tonight! Ben uses a Word template, Jelly iterates a build number, and Jake watches half of a video.

Hot off the heels of the release of his book about Cocos2D, Ben gives the couch a quick walk through what it’s like to write a book, from what tech is used, having your work edited and your code reviewed, and what it’s like to deal with a publisher.

Jake then begins to review some of the Testflight follow-up, prompting Jelly to vent about his plentiful issues that Testflight has caused over the previous week or so, such as build that don’t install and crashes that occur on launch. Jake then actually manages to touch on some bits that weren’t covered in the previous episode, as well as a new feature that launched since then.

Moving on, Jake brings up the new version of Swift, which has a bunch of bug fixes, improvements and new features, such as: less compiler crashes, single line unwrapping of multiple optionals and improvements to let.

While he’s on a roll, Jake also talks about video presentations he’s watched recently, including two that introduce React Native, an upcoming project from Facebook that changes the way you deal with native views in mobile apps, and another by Andy Matuschack on managing complexity in Swift.

• Cocos2D Game Development Essentials by Ben Trengrove (Amazon)
• @practicalswift's Tweet About Swift Compiler Crashes
• swift-compiler-crashes (GitHub)
• React
• Introducing React Native (Facebook)
• A Deep Dive into React Native (Facebook)
• Reveal
• AsyncDisplayKit
• Controlling Complexity in Swift by Andy Matuschak (Realm)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Jelly has wanted to talk about Testflight for a while, and he finally gets his chance, comparing Apple’s beta distribution tool with the previous methods, like Ad Hoc and Enterprise distribution.

After dealing with some follow-up backend services, Jelly brings up the topic of Apple’s Testflight, it’s new beta distribution tool. The couch discuss the previous methods for sending out builds, which involved provisioning profiles, UDIDs, and endless nightmares about testers not receiving builds immediately after getting the initial email.

Turning to Testflight’s limitations, the trio go through some of the larger issues that it has, mostly looking at it’s iOS 8 requirement and the need to go through review before distribution, as well as the limitations of iTunes Connect accounts, which are a requirement for internal testers.

• Stringing the Pieces Together (JellyStyle)
• Turbulence for TestFlight (Andy Drizen)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Russell Ivanovic (@rustyshelf) joins the couch to discuss back-end services for mobile apps, the differences between software-as-a-service and building your own web service, and go into why you might choose one over the other.

After several side tracks, including trying to figure out who has the higher Crossy Road score, and a whole bunch of French, Jake kicks things off by asking why you might want to integrate web services to begin with. Since everyone pretty much agrees on the answer (and that iCloud does not a good back-end make), they move onto discussing some of the services out there, like Parse and Azure, that allow you to create something with some amount of transparency.

Jelly feels left out, and begins to explain that his method of choice is to build a service from scratch, usually in (the abhorrently evil) PHP, and Russell chimes in to explain how the web services for Pocket Casts and Pocket Weather are built from scratch in Java and Ruby on Rails.

Jake doesn’t feel like this is an option for him, since he hasn’t kept on top of the advancements in this area, and he feels that it would take him too long to get things up and running. Using an example of generating scaled images using Cloudinary, he explains how he set a basic thumbnail creating service up for an app he’s building in around 20 minutes. After this, the discussion takes a quick turn to scaling: Jake doesn’t need it for this project, but it’s definitely something you need to consider.

Jelly hears Ben mention a bug, and after having Jake explain it (Azure having a dependency conflict), he launches into the biggest issue he’s had with a third-party service: when Giphy changed their API and broke GIFwrapped’s built-in search feature. This brings up the discussion of how to guard against issues with third-party systems: encapsulating all the third-party related code in a single class, or providing alternate solutions.

Finally, the couch discuss the process you would go through in choosing to use a third-party system, such as expertise, time, existing libraries, and the like. They go into the details of Jake’s situation — developing apps for clients — and weight up the potential benefits and issues in comparison with Jelly and Russell, who are building products.

• Russell Ivanovic (@rustyshelf) on Twitter
• Rusty Rants
• iCloud for Developers
• Azure
• Parse
• Azure Mobile Dev Camps for iOS
• Azure Mobile Dev Camps for Android and HTML apps
• Amazon Web Services (AWS)
• Pingdom
• Cloudinary
• Moodstocks
• moodstocksjs (GitHub)
• Pusher

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!