It’s the final episode of Mobile Couch, so Jake MacMullin returns to the couch, and they discuss how they got started as developers, as well as how they feel about starting new projects.

Ben takes Jelly on a journey through his favourite points from the book Pragmatic Programming: From Journeyman to Master, which details points that you’ll want to learn if you want to be a better developer. Along the way they discuss everything from philosophy to buying dishwashers, and maybe even a little actual code here and there.

Jelly recounts his experience with interviewing for a developer position within a big tech company. He and Ben reveal a little insight into what the process is like, what you should know going in, and what you can take from the process to apply to the interviews at your own company.

Ben and Jelly run through a quick and dirty primary of Git, one of the most popular version control systems around today. Starting from the very basics, they run through all the things you need to know to use it in your day to day work, why you should be using some method of version control, and the clients they use to make things nice and easy to manage.

Once again, the Apple developer community has been host to scandal! Not a pair to leave this opportunity behind, Ben and Jelly discuss how developers can learn from this, looking at the mistakes that were made, how to avoid them, and what you need to remember when things go bad.

With Ben in London, Casey Liss rejoins Jelly on the couch to talk about leaving .Net behind for a career in the Apple ecosystem, his experience with RxSwift, and wrapping your brain around new things. Meanwhile, Jelly reflects on his recent GIFwrapped update and his approach when migrating it from Objective-C to Swift.

How do you lay out your views? Ben and Jelly look over the different methods available on both iOS and Android, and compare their experiences with each. Together they uncover some of the oddities that can pop up in various circumstances, how to get around them, and which approach rules them all.

User notifications have had a big makeover in iOS 10, so Ben and Jelly walk through how notifications work on iOS. Along the way, they highlight some of the newer features available in the new framework, look at when you might choose local notifications over remote notifications, and discuss the two new extension points to use for customising notifications.

If you’re lucky, you’ll never need to work on an app that has to manage files, but just in case you ever do, Jelly’s got you covered with a basic overview of file management on iOS. He walks Ben through the basics, covering coordination of access to files between processes, reading parts of files, and displaying a localised version of a file path.

Dependency injection is a simple programming technique with a bit of a scary name, but it turns out that it’s excellent for highlighting the connections between classes within an app. Ben walks Jelly through the basics of using dependency injection, why singletons are bad, and places you might already be using this techique without even knowing it.

Jelly’s had a bit of a computer disaster (which he totally got from Ben), so they talk a little bit about mitigating disasters as both users and developers. Then they cover off a little bit of follow-up about monetising Messages apps, before discussing the fun and horrors of migrating your codebase to iOS 10.

Since the announcement in the WWDC keynote, Ben has been working on a couple of Messages apps, so he and Jelly go through all the ins and outs. Together they look at the super-easy Sticker pack apps, the more complex implementation details for custom apps, and even a few gotchas you might run into while developing.

With WWDC done and dusted for another year, Ben and Jelly discuss their experiences queueing for the keynote, attending side conferences, and getting the most out of the week. They then turn their attention to an quick overview some of the key things that Apple introduced for developers with iOS 10, including Siri and Messages Apps, and finally they pine for the thing they still wish they’d seen: improvements to Radar.

In the lead up to WWDC, Ben and Jelly take an early look at some of the changes coming to the Swift language this year with version 3, which like one of the biggest releases so far. With widespread changes in the wording of method names, improvements to how C APIs are handled, and a Swift version of Foundation, it’s going to be a big change to both your code, and how you read it.

Ben and Jelly turn their minds to this year’s WWDC, and spend some time talking about what they expect to come out of this year’s conference, as well as what they’re actually hoping for (there’s a difference!), including better stability in tooling and more transparency with errors.

What is good code, and how does one achieve it? Ben and Jelly spend some time working through a small project while considering the flaws, edge cases and potential shortcuts, in an effort to come up with ways to weed out bad code, while also improving the end result.

Both Ben and Jelly have worked from home for many years, so they explore the benefits and disadvantages of remote working. Together, they discuss the things you need to do to ensure stuff actually gets done, what your team can do to help you succeed, and why you’d even consider this in the first place.

Jelly walks Ben through the ins and outs of implementing In-App Purchases in your “freemium” or “paymium” apps. IAPs are deceptively annoying to get right, but Jelly covers everything, including you need to do in iTunes Connect, how the StoreKit framework works, and finally, how you validate the receipt to prevent piracy.

Many developers work with things like views and view controllers, but might not have any idea about how these things all fit together. Ben introduces Jelly to the Model-View-Controller pattern, and explains what each part of this concept is and how they come together to make an app work.

In any given project, you’ll find that there are a number of different “hats” that you have to wear, such as making the hard decisions, being a user, writing code, or designing assets. Ben and Jelly take look at some of them, discussing not only how they come into play, but also how some of the common misconceptions about them.

Giovanni Lodi (@mokagio) joins the couch to teach Ben and Jelly about the automation of tasks, and especially about the automation of the build and deploy process for iOS apps. Together, they look at the various Fastlane tools and what they each do, why you would automate these parts of your process, and how to recognise when something should be automated.

Jelly’s been using JetBrain’s AppCode to get some work done in the last few weeks, and he and Ben go over the overall experience. Together, they discuss some of AppCode’s best features: inspections, the incredible level of customisation it provides, and best of all, Swift refactoring. It wasn’t all happy though, and Jelly also spends some time unloading on Ben about the issues he faced, how he dealt with it, and what JetBrain’s support is like.

This past week, Ben attended the Apple TV Tech Talks in Sydney. Meanwhile, Jelly didn’t get the opportunity, so Ben covers of a lot of the major points he learned on the day, covering concepts like the “Focus Engine”, and discussing talks like the one given by the App Store Review team (a.k.a. the best talk ever). It turns out there’s a whole lot of stuff that can be easily missed when creating apps for tvOS, and if you missed the tech talks, you’ll want to listen to the end!

Ben’s been working on a side-project over his break, and wants to actually flesh it out into something complete and polished. There are a few things he’s not sure about, however, so he gets Jelly’s advice. Should you consider the monetisation of an app for version 1.0? How finished does an app need to be to be placed in the hands of testers? How do you get past the ever-growing list of bugs and get to the point where you can release?

Russell Ivanovic jumps on the couch to chat about what makes code good or bad, and how the perception of code changes over the years. They look at how they’ve learned to approach both their own and other people’s code, helping others learn and grow their skills, and most importantly, whether code style is important or not.

Ben and Jelly take a look back at the things they’ve learned over the past year with their approach to work as well as with the technical side of development. They reflect on what’s changed for them, and look forward to next year to consider things they’d like to approach and try in the future.

Christmas came early this year as Apple followed through on their promise to open-source the Swift language. Ben and Jelly take a look at all the things that have been included in this somewhat unprecedented release (it may even blow your mind) and look at what this might mean for the future, both for the platforms Swift now extends to, and for its predecessor, Objective-C.

After talking about dealing with — supporting — clients, Jelly thinks it’s worth touching on supporting the users of your app. He and Ben talk about his experiences with GIFwrapped and get into why it’s important to be positive, how to improve your app to get in front of support requests, and why support can be part of your marketing strategy.

If you deal with clients, you’ll discover that there’s a lot of ins and outs to working with them on a project. Ben and Jelly talk about how they deal with clients, from the refining the app idea, through scoping and quoting, to communication and running the project. Along the way, they cover finding the email sweet spot, dealing with clients who want everything, and coming up with your hourly or daily rate.

In response to a topic suggestion, Jelly draws on his recent experiences with GIFwrapped to discuss ways to ensure an app’s architecture is loosely-coupled, thereby making it easier to extend and maintain it’s functionality. He and Ben go into several important techniques that they use in the apps they write, and back each up with examples to show the benefits of approaching your code in these ways.

A new version of iOS means new features, and this year brings a handful of big ones, slide over, split view, picture in picture and 3D Touch. Ben and Jelly takes a good long look at each of these new features, talk about how to go about implementing them, and investigate some of the things you’ll need to remember to create the best experience possible.

For the past few weeks, Jelly has been refactoring the core components of his app, so he feels like he needs to talk it out with Ben. The two look at their experiences with refactoring code and talk about the best ways to approach it, what it’s place is within your regular workflow, and most importantly, how to know when you’re finished. Along the way, they explore the basics of extreme programming, the problems with building up technical debt, and the longevity of Swift and Objective-C. Keyboard Shortcuts: Command + Shift + J: Highlight current file in Project Navigator Command + Shift + /: Menu Search

Ben and Jelly cover some tips and tricks they use to get through their work day, from basics like keyboard shortcuts to bash scripts for automating build numbers. Xcode Open Quickly: Command + Shift + O Fold/unfold Everything: Command + Option + Shift + Left/Right Search for Method: Control + 6 Open Quickly in Assistant: Option + Enter (from Open Quickly) Close Assistant: Command + Enter Close Left Sidebar: Command + 0 Close Right Sidebar: Command + Option + 0 Edit in Scope: Control + Command + E Show Variable Type (Swift): Option + Click AppCode/Android Studio Search for Action: Command + Shift + A

After dealing with some follow-up about privacy policies, as well as mentioning a couple more methods for handling blocks within blocks, Ben introduces Jelly to the basics of functional programming. Together they walk through their approaches to the handling of a parsed JSON structure, as Ben explains several functions, such as filter, map, reduce and flatMap, as well as the underlying approach and how it can benefit your code.

Jelly has been implementing some more analytics in GIFwrapped over the last few weeks, so he and Ben take a look at the various aspects of tracking your user’s behaviours. Tracking your users has obvious privacy implications, and it’s not just Apple enforcing them. Australia’s privacy laws require that you don’t capture information that could reasonably identify someone. With that in mind, analytics are extremely useful for learning how people use your app, and using this knowledge to try and improve it. Jelly explains a little about what he’s been starting to track and why he thinks it’s useful. With the why and what out of the way, they begin talking about the how: discussing a handful of analytics services, including Apple’s Testflight, Answers, Google Analytics and Snowplow. The two examine the pros and cons of each service, discussing the core features and their experiences with each.

Jelly and Ben start the show by covering some quick follow-up about CocoaPods and Carthage, which blurs the lines between their differences. This leads into a quick discussion about how CocoaPods is now being supported by a bunch of companies with libraries, such as Google, Twitter and Hockey. Ben then puts forward the problem of “blockception”, the effect that blocks within blocks have of excessively indenting your code, making it more difficult to read and harder to maintain. There are some native ways of dealing with the issue, but they’re still not ideal, so he has taken a look at some ways of solving the issue. The first of these is PromiseKit, a third-party library that wraps asynchronous calls in Cocoa with versions that use promises. This allows you to keep all your blocks at the same level of scope, which has the additional benefit of ensuring that each block only captures the variables that they actually need, making memory management a little easier. Another is ReactiveCocoa, a well-known implementation of reactive programming for Cocoa. This follows a very similar approach to PromiseKit (except with “streams” instead of “promises”), but is a much larger implementation, as it covers more than just the idea of multiple asynchronous calls. Finally, there’s Rx, which is a C# library from Microsoft, but it’s also been brought to Java, Swift and Android. It’s a lighter weight implementation of reactive programming, and also has the benefit of being cross-platform, which means you can keep your approach conceptually similar between the different platforms you support.

After touching on some Core Data follow-up, Jake proposes that the couch talk about Frameworks. Apple’s Cocoa includes a lot of things, and arguably more than most other first-party SDK, but there’s alway a need for additional frameworks to solve common issues. He starts by laying out a few different pieces of the framework puzzle, from how to discover them, how to actually get the code, and how to implement it in your own projects. One solution for managing these third-party dependencies is to use Git’s submodules. Jelly mentions that this is how he manages and maintains the external libraries he maintains alongside his code. Another is Cocoapods, which solves all three aspects of finding and using libraries, including finding of projects, and the actual integration with your Xcode project. Finally, the cool kid on the block right now is Carthage, which only deals with the building and preparation of the dependency tree, whereas discovery and the actual integration is dealt with by the developer.

Following-up from the last episode, Jelly tries to recover from his failed attempts to explain why he believes that opening up Radar isn’t the solution to all of Apple’s issues with bug reporting. This causes Jake to note that part of the problem with Radar is that Apple, as an organisation, seems to care a lot less than Google about reported bugs in general. That’s not to say that the engineers themselves don’t care, which becomes obvious when you do hear from them directly, whether in labs at WWDC or through avenues outside Radar, such as Twitter or Apple’s developer forum. Jelly’s about to release an new version of GIFwrapped, so he’s been thinking about things like deadlines and code freeze and how developers handle those things. So he asks Ben and Jake a few questions about how they approach an app release. Jake feels like the best approach is to develop iteratively, and aim for regular, short release cycles (like Facebook’s two week cycle). Jelly takes issue with that, explaining that as a single developer, or even a small team, it’s very difficult to aim for that kind of model. Ben then brings up automation, explaining that part of moving to a regular release cycle requires a change in thinking. Jake also explains that perhaps larger features need to be broken down into smaller pieces, making it easier to stick to regular release schedules.

In the wake of WWDC, the couch discuss their favourite sessions and lab experiences, and some of the answers to the questions they had following the keynote. Ben and Jake start by sharing some of their highlights from the labs at WWDC. They both explain some of the issues they took to the engineers, and the responses they got in talking them talking over. This leads into a discussion about Radar, especially in contrast with Google’s more open bug reporting tool. Everyone agrees that there are giant holes in Apple’s tool, and Jelly’s actually convinced we might see something change next year. Jake mentions at this point that he’s excited about the current focus from Apple on education, even in things as small as being able to run apps on device without having to be a paid developer. Jelly is quick to point out that there’s a lot of evidence that Apple has being thinking about education for at least a couple of years now. From here, Jelly asks Ben and Jake to name their favourite sessions from the conference. Ben’s is the session on protocol-oriented programming, while Jelly really liked the session on the new system font, and the thought that has gone into typography on the platform. Jake, who also liked Ben’s pick, settles for one about new features in playgrounds. Moving along, Jake talks a little about his experiences playing with CloudKit and CloudKit JS, coming to the conclusion that it’s still missing some crucial features, such as its lack of shared data and it’s lack of ability to run scheduled tasks. Jelly then brings up Bitcode, which is something that Apple really hasn’t explained very much at all. Jelly cites an article he’s read which explains both what Bitcode is, and some of the reasons Apple might be interested in it. Ben’s not convinced that it’s going to work as expected, however, since it just seems too magical. Finally, Jelly brings up to odd occurrence of a couple of presenters who made a big deal about using first-party frameworks, most notably Core Data. This leads to a conversation about Core Data vs. Realm and what they actually are and why you would choose something other than Core Data for data storage.

The WWDC 2015 keynote has come and gone, but Eddy Cue’s dance moves will forever haunt us. Jake and Ben call in from San Francisco to talk about developer-y things that got announced during the keynote and the Platforms State of the Union, while Jelly, who watched from his lounge room, fills in the gaps on some of the new APIs and kits. Starting with the keynote, the couch quickly cover the general feeling of the presentation, the highlight of which was the inclusion of two female VPs presenting things on stage. Not to mention the brief inclusion of an app that Ben wrote in one of the videos shown as part of the presentation. Moving into development stuff, Jelly breaks down the addition of Search APIs which use NSUserActivity, and content indexed from the internet, to create indexable content that appears in the home screen search. This builds on a new feature from last year, and along with “universal links”, allows for easier access to content within apps. Another new feature is App Thinning, which is actually a handful of smaller features related to shrinking the size of your app’s install footprint. It includes things like splitting up assets that are specific to devices, separating out 32 and 64 bit code, and assets that are able to be downloaded as needed. This has some interesting and potentially crazy implications, and Ben and Jake aren’t sure that they’re that keen on the idea. CloudKit is also getting a huge addition with the release of a Javascript API for building web-based apps that run on CloudKit. Ben’s not convinced that this is any better than the competitor platforms, and Jake is concerned about how serious Apple are about the web, but Jelly has taken the approach that this is perfect for newcomers, and that its architecture highlights Apple’s preference for native apps. Everyone other than Jake has been expecting native apps for Apple Watch, which are also coming along with watchOS 2. This is a very simple change with a lot of implications, where the extension is simply moved to the watch itself. This leads the couch to question whether the watch was released too early. The release also adds custom complications, which allow you to show simple, time-based information on the watch face. It comes with a new feature called “Time Travel” which allows you to see the information as it changes over time, allowing you to see weather in the future, or the stock price as it varies over the day. Jake reveals that he’s using a new MacBook at this point, and his battery is running low. This prompts Jelly to quickly move on to new Xcode features, including the new Stack View, which lets you create simple, linearly-arranged sets of views, Storyboard references, which let you create properly modular Storyboard structures. After Jake disappears, Ben and Jelly continue on to talk about the new testing features in Xcode. The first of which is UI testing, which appears to be based on UIAutomation. The second is code coverage, which Ben had feared would be too overwhelming, but appears to have been implemented in a very useful way that doesn’t appear unless you actually want it to. And finally, they cover the highlights of the upcoming Swift 2.0, including the guard keyword, the try/catch error-handling system, the availability features, and finally the announcement that Swift 2.0 will be open-source. This causes them to reconsider Objective-C’s eventual demise, which seems more obvious now than it has been in the past.

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.

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?

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?

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.

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.

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.

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.

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.

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.

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.

The couch is back from holidays, so they take the opportunity to talk about things that they worked on over the short break, and what they like to do during downtime to keep themselves sharp. Having received some feedback about extensions from the previous episode, Jelly details how Target Membership can help developers build extensions into their apps while supporting iOS7. He explains how this works, and why it might not be such a great idea. Jake then touches on his recent experiences with Android’s “support libraries”, which allow developers to support new APIs on older systems. This leads to discussing methods of supporting older versions of iOS, which doesn’t have this ability, and Jelly explains how he prefers feature detection over system version detection. Jake also follows up on his argument about Today extensions, citing Drafts reinstatement as partial proof that he is correct. Jelly can’t handle someone else being right, so he asks Jake to explain Pcalc’s reinstatement, which Jake can’t do. He does believe, however, that recent rejections aren’t completely unsurprising, as Apple’s behaviour on this matter appear, to him at least, to follow some form of pattern. Moving along very quickly, Jelly asks the other two what development they did over their breaks. Ben details a side project he did as part of a Christmas gift for his wife, Jake explains how he learned a little about functional, and then Jelly explains that rather than working on GIFwrapped, he did some “comfort” coding in PHP. This leads them to discuss the low-reward jobs, like refactoring, that they sometimes do during downtime. Ben notes that Jake’s code is usually pretty good, and is commented, which takes them off down a path of discussing comments in code: when it’s good, when it’s bad and what the past practice for commenting your code might be. Getting back on track, Jelly talks about his approach to implementing low level things as a method of learning how they work. He explains how he goes about it, detailing his experience backwards-engineering NSScanner in PHP. As usual, Jake then spins the topic off onto Swift, explaining the inability to call UIAppearance’s appearanceWhenContainedIn: method in Swift. This leads to talking about Swift’s viability as a future-proof language, which in turn leads to discussing Swift as a server-side language.

The couch answer a question about where they go to learn about new things, Jelly discusses his experiences so far with implementing extensions and Jake gets frustrated by the recent discussion of app rejections. Starting with follow-up about GitHub’s Swift style guide, Jake discusses what he likes and doesn’t like about it, like the preference of structs over classes. He also takes the opportunity to mention a blog post about comparing Swift and Objective-C. Jelly mentions that he’s still using Objective-C, and this leads to a short discussion between he and Jake about their respective approaches to Swift: Jelly being a bit wary of it, and Jake being very gung ho. The couch then decide to answer a question about where they get their information, and they go on to list some of the sources they use for information, including podcasts, blogs and Cocoaheads. With follow-up out of the way, Jelly brings up the topic of iOS8’s extensions and discusses the problems and decisions he’s come across so far in trying to build them for GIFwrapped. When the discussion turns to Jake’s extension homework, he reveals that he’s more interested in debating the recent slew of extension-related rejections, or rather, pointing out something that he believes the internet has wrong. This kicks off a heated argument between he and Jelly, who believes that the issue has a much larger scope than what Jake is arguing. Eventually, Jake manages to get his point of view across, despite Jelly’s best efforts to restrain him, and the two try to turn the conversation to a more positive note, discussing the best way to deal with app rejection and how to approach the situation in your own apps, and whether this fight makes the platform better or worse.

Jelly’s done his homework, so the couch explores his solution to getting a scrollview to page with peeking content. They also weigh in on Watchkit, discussing the way it works and what the future implications might be. Like all the cool shows, this one starts with the intro, or at least it tries, as Jake leads everyone off track into discussion of podcasts (specifically Chat 10 Looks 3, Serial and Start Up), as well as their style and sound quality. Finally getting themselves into gear, Jelly starts the discussion with the results of the bet about getting a scrollview to “page” with content that peeks on either side of the frame. Jake explains the problem he had, and then Jelly explains how he tackled the issue, as well as what he did with his results. More follow-up about Swift brings discussion of a listener-submitted Swift style guide, and the oddities about the optional language syntax. This leads to Jake admitting that maybe he’s still not clear about a few things, like how type inference works… or how arrays work, for that matter. Jelly brings up the topic of Watchkit, which has been out for a few weeks now. Even though none of the three have actually done anything with the framework, they decide to weigh in with their first impressions. This inevitably becomes a discussion about the potential of WatchKit, and how the iPhone’s ecosystem was moved forward by “misuse” of API features. Ben asks Jelly, as a hold-out on Storyboards, what he thinks about the fact that Watchkit apps are storyboard only. This, of course, leads Jake to get all excited and start explaining how he implemented IB_DESIGNABLE with a class and has fallen in love with it. Taking all of this back to Watchkit, Jelly points out that the “storyboards only” approach — which he’s totally cool with, by the way — might be suggestive of where Apple is trying to go with app development overall.

Ben rejoins the couch from London, and Jake discusses his beacon woes, some tips and tricks he’s picked up while developing with Swift, and the recent open-sourcing of .Net frameworks by Microsoft. Following up on the discussion from the last episode, the couch talks about a possible alternative for finding things near you without requiring location services: requesting postcodes, or using a geocoding service to search for locations. At the mention of London, Ben chimes in to talk about his experience trying to attend NSLondon. Jake and Jelly fill him in on the surprisingly official Cocoaheads that Jake presented at. This brings up a bet that they’ve made about whether it’s possible to have a paged collection view that shows peeks of the previous and next page. Jake believes it’s not possible without hacks, and Jelly thinks he can find a way. Getting back on topic, Jake expresses his frustration that the proposed idea doesn’t really solve his dilemma with ranging for beacons in the background, and this leads to an exploration of what the real problem is with the scenario: the message that users get to remind them about the monitoring of locations in the background that is presented without context, and even if the beacons haven’t triggered the app. Moving on to Swift, Jake weighs in on his thoughts about Swift and whether it is, in fact falling out of favour. With that in mind, he decides to share some things that he’s picked up in the past few weeks that might help others: how to concisely unwrap multiple optionals simultaneously, mutating arrays, dealing with implicitly returning single line closures, and detecting when collection view cells have been reused. Finally, the couch talks about Microsoft’s recent move to open-source .Net on Github, and what effect that could have on the Apple development community. Jake spends a lot of of the discussion dreaming about what it would be like if Apple open-sourced some of its core libraries, giving Jelly’s cynicism a good solid workout.

Craig Stanford, co-founder of Clipp, joins the couch to talk about start ups, onboarding and the little men who run the internet. Following up on his attempts to space out his table view cells, Jake explains how he solved his problem and why he wanted to space out his cells in the first place: a header view that contains branding and collapses when scrolled. This prompts concern from Craig, and Jake ends up defending his position. Before Jake can launch into asking questions, Jelly suggests actually introducing their guest, and gets Craig to explain what Clipp is, what it’s like in the world of start ups, as well as a bit of the story about how Clipp got started. When Craig starts talking about how excited beacons get him, and how he’d love to find a good way to use them in Clipp, Jake takes the opportunity to complain about the permissions dialogs iOS presents, which he feels give the wrong impression to users. Jelly uses this to steer the conversation away from beacons, and to discuss what the best context is for asking users for permission to access features. This leads to a discussion of onboarding and whether it’s good or bad. The couch then discusses an app that Jake is working on currently, and how he might solve his issues with permissions and onboarding. At this point, Jake turns the conversation a little by asking Craig what his point of view is on work hours. This spurs discussion about work ethic, what it means to work too hard, and eventually health. Jake and Jelly talk about how they’ve been trying to improve their health by walking more, and how to motivate yourself to do it. The idea of motivating users prompts a conversation about gameification and what that means. Jelly explains his opinion that gameification has a bad rap because we’ve taken the wrong lessons from games, and ends up going back to onboarding, using the first level of Super Mario as an example.

Jane Abernethy — part of the iOS development team at the Commonwealth Bank in Sydney — joins the couch to fill in for the globetrotting Ben, and to talk about her work, her team and IBDesignables. Also, follow up. Lots and lots of follow up. After attempting to convince Jake to use 1Password, Jelly talks about his internet troubles, and Jake follows up on his endeavours to get VDSL installed as mentioned in last week’s episode. Jane introduces herself and talks a little about how she got started as an iOS developer, which leads into a discussion of why each of the couch got into development in the first place, and what made the iPhone such an exciting device to make apps for. Jane talks about how it feels great that her mum uses the app she works on, but it’s frustrating that she hasn’t updated from iOS 6 yet, and the whole couch joins together in a chorus of sorrow about supporting older iOS versions. Delving into follow up, Jelly attempts to finalise the pronunciation of Haneke, and communicates the differences between the Objective C and Swift versions. Jake follows up on his previous follow up regarding gender diversity in tech by mentioning a Planet Money episode that discusses the history of the topic. This prompts much awkwardness, and then discussion of said awkwardness. Finally, Jelly follows up on the topic of today extensions, and how they communicate with their parent app. Returning to the topic of supporting older iOS versions, the couch talks about what versions it’s worth supporting with releases and what the 6% of users that aren’t using iOS 7 actually means. Jake mentions that it feels like this change to iOS 8 feels a lot harder to support alongside older version because of the sheer number of new features. Almost two-thirds of the way through the episode, Jake finally gets to ask Jane a few questions about her work, and what the differences between her current role at the Commonwealth Bank and her previous role at a digital advertising agency in Sydney are like. Jake also asks whether Jane’s team is looking at Swift at this point, and though they aren’t really, this prompts a discussion about IBDesignables with Interface Builder, which Jane has been exploring. Finally, Jake looks for a solution to a tableview that feels too cramped on the larger iPhone 6 plus, and Jelly tries to talk him out of detecting the device model with two lines of CGRect-based code. But will he listen? Tune in next time to find out!

Jelly is working on a big update for GIFwrapped, which prompts discussion with Ben and Jake about getting validation from shipping something cool, designing for single handed use, iOS8 extensions and rotation based on size classes. Jake retouches on the topic of diversity and gender equality in tech, mentioning the recently funded CODE documentary, and Annabel Crabb’s new book, The Wife Drought, which looks at both sides of the issues regarding flexible workplaces. Jelly talks about his recent experiences working on the next major GIFwrapped update, and how you need some form of validation to stay positive about a project, whether it be from implementing a cool little feature, having people see your well structured code, or from seeing a drop in crashes in the shipped product. The couch then talks about designing for multiple screen sizes, like using larger phones with one hand, and how app designers and developers can add little touches to allow users to perform tasks without having to move the phone around too much. Plus, dealing with landscape orientation on various devices and thinking about all the different size, and shape, screens. iOS8 shipped alongside a plethora of third-party keyboards and a new layout on the iPhone 6 plus landscape keyboard, and the couch spends some time discussing the downsides and decisions made about those keyboards; the first-load experience, additional buttons and the installation experience. Ben also talks about the limitations when creating extensions and how to pass data back and forth between your extension and your app. The new API for checking your version number in iOS8 doesn’t actually work for version prior to iOS8, and this prompts a discussion of versioning and migrations, how it works, and the best way to implement them in your app, from clearing caches between versions to migrating Core Data stores from one version to another. Ben talks about image feature detection, such as face and blink detection, in Core Image, and how to crop an image to show a person’s face, which is really easy and impresses Jake quite a bit. Jake then talks about taking that image and caching it with HanekeSwift, a generic, Swift implementation of the Haneke image cache. Finally, Jelly brings up his attempts to autorotate based on possible size classes, to only allow landscape mode on devices which use a regular size class in that orientation, and Jake pulls a solution out of one of the WWDC sessions from earlier this year.

Jake deliberates on purchasing an unwanted iPhone 6 plus from a friend, while Ben talks about his first impressions and the bugs in the recently released iOS8, and Jelly gets shirty about the whole watch thing. An off-the-cuff comment from Jelly spurs a conversation about devices like the Microsoft Surface and a theoretical iPad Pro. This somehow devolves into a trip down memory lane, with Jake talking about his Psion handheld computer, and Jelly recounting his love for Snake on the Nokia 3310. A terrible first impression with the iPhone 6 has convinced Ben to try out an Android phone for a year. This leads to a discussion about the inherent bugginess of iOS8, especially on the new devices, and whether Apple has bitten off more than they could chew with this year’s releases. The couch then talks about the lock-in effect of being immersed within one company’s ecosystem, and whether that’s a deliberate move. Jake’s attempts to get Family Sharing set up spurs discussion about verifying people’s age and how and why Apple (or any tech company, really) would want to this. Finally, Jake manages to actually talk about something development related, using the current discussion surrounding the Apple Watch and it’s price factor to discuss emotional design, and how the emotions evoked by the design of your app affects it’s utility.

Ben is back, and the couch dives into the September Apple event to try and determine what the future of development is going to be like with bigger screens, extensions that live on your wrist and the idea of connected devices. Apple Pay is being rolled out in America first, but when can Australia expect to see it? More importantly, what sort of impact will it have, given that Google Wallet, it’s closest competitor, completely fizzled? The iPhone now has much larger screen sizes, with the iPhone 6 coming in a 4.7” and 5.5” models, meaning that app creators will be forced to rethink the location of buttons and use of gestures. This also means that layout related calculations will have different implications, with the 5.5” model using different size classes to the iPhones that have come before it. When discussion turns to the downsampling performed by the iPhone 6 plus, Jake takes the opportunity to bring up Auto Layout, and how to create proportional width constraints. Jelly counters with his own math based solution used to layout the collection view in GIFwrapped. The most frustrating thing, however, is Apple’s solution to declaring support for the larger devices: detecting the presence of correctly sized launch images (of which there are now 20), or the use of a launch screen xib. The couch discusses the purpose of these and whether the issues they’ve seen with getting apps working across all devices. Discussion then turns to the Apple Watch, and how this could be the launching point for a morse code resurgence. Jelly then turns the discussion to development, and with very little to go on, suggest the possibility that Apple Watch “apps” might end up as little more than extensions of apps on your iPhone. From there, discussion turns to the Taptic Engine and its future as a feedback mechanism. When combined with iBeacons and other methods of detecting the world around you, will the watch become a player in giving you the ability to interact with the world around you? Just to top off the episode, Jelly discusses his image caching adventures, discussing the pros and cons of three third-party image caching libraries: SDWebImage, Haneke and Path’s Fast Image Cache.

Jelly tries his hand at hardware mods, Jake buys a yellow Nokia to try out development for Windows Phone, and Ben gets married. Jake’s Windows Phone experience leads to a discussion about the differences between Apple and Microsoft’s approach with their development environments, which begs the question about what Apple’s plans regarding Objective-C vs. Swift are, leading Jake to confess that he’s concerned Swift might end up as a modern version of Cocoa Java. Following up on the episode with Basil Shkara, they then discuss how one defines success as an “indie” developer, and whether pitching apps to potential clients is one method of finding success. Now that the outcomes of Google and Apple’s diversity reports are known, and it turns out that everyone is pretty much as bad as each other, Jelly turns the discussion of diversity to solving the lack of diversity in the tech industry. How do we, as businesses and individuals, encourage people of different backgrounds to become developers? Finally, Jake interjects towards the end of the episode to discuss beacons and using context to improve app functionality in apps and devices. Because it’s tradition.

Basil Shkara - indie developer and creator of Bee - joins Ben and Jelly to discuss succeeding as an indie developer, marketing your app, and the scary world of SEO optimisation.

Ben, Jake and Jelly discuss access control, using target/selector style method calls, and avoiding retain cycles in Swift (with a recap on how to debug them with Heapshot Analysis). They then take a look at test-driven development, asynchronous tests, and learning on-the-job. Plus, Moodstocks’ new pricing structure, the competitive GIF app market, and the failures of voice command interfaces.

Jelly hasn’t had enough discussion of diversity yet, Jake discusses whether Apple should use a stick or a carrot to try to enforce accessible apps, and Ben explains how the Swift runtime works. Meanwhile, Jake talks about GovHack, a hackathon based around open data from services like data.gov.au. Plus, he and Ben have just shipped a new app for multiple platforms, and it spurs a discussion about the best method for targeting the various platforms. Not to be outdone, Jelly discusses his QA “experiment”, looking at the benefits of having other people provide feedback on your code, and the wide variety of approaches to developing apps.

Jelly talks about his new open-source library (and its terrible name), which leads into a discussion about the differences between table and collection views in iOS. Jake discusses his recent work with user testing, accessibility and the various ways that vision impaired users navigate their iDevices. The couch then talks about adaptive layout, what it could mean for future devices and why it has a different name to “responsive” design for the web. Finally, they touch on Google I/O and Android L’s new design direction, as well as the diversity amongst presenters during their keynote.

Swift: everyone’s excited about it, but that doesn’t mean it’s without oddities, shortfalls and issues. The couch attempts to cover as much of what they’ve learned so far about Apple’s new programming language, and in the mean time, discover that there are some things they simply cannot understand about this language.

Russell Ivanovic joins Jake and Jelly to discuss the fall out from this year’s WWDC: the things they’re excited about, the things that are going to change the ecosystem, and most importantly, the story of Rusty’s visit to Noosa with Google Now. 402: Introduction to Swift 403: Intermediate Swift 223: Prototyping: Fake It Till You Make It 211: Designing Intuitive User Experiences 226: What’s New in Table Views and Collection Views 235: Advanced Scrollviews and Touch Handling Techniques

Following up on the discussion about auto layout in the last episode, Jake and Jelly team up to compare it with manual frame management in a view from one of Jelly’s projects. Then come the WWDC predictions for language, frameworks, and even hardware as the couch attempts to peek into the future for what awaits us in the next couple of weeks.

It’s a rapid-fire episode, as the couch discusses follow-up about replacing Objective-C, C#’s async/await feature, supporting iOS 6 and 7’s UI, using Auto Layout to simplify UI layout math, the benefits of using Magical Record with Core Data, when to use Expedited Reviews, and variability in Beacon signal strength.

Instead of learning enough to talk about it himself, Jake probes Ash Furrow – author of Functional Reactive Programming on iOS – about functional programming, ReactiveCocoa, and the future of Objective-C. Meanwhile, Jelly sticks his head in occasionally to make terrible jokes, and Ben just simply doesn’t show up.

Creating an inclusive and flexible culture, whether it be through the way you speak, or simply by understanding the differences between people’s personal priorities. Follow-up about code-style leads into a discussion about code-folding, laying out your methods within a file, and the battle between useful features, extensibility and bloat in an IDE. Finally, WWDC tickets and whether the improvements have really made a difference.

The couch discusses about code styles and conventions: using tabs or spaces, casing in class names, and how to name consts. Along the way, Ben, Jake and Jelly touch on whether consistency is important for teams, judging people based on their style choices, and getting Xcode to enforce your own specific style.

Jake and Ben tell us all about their experiences using Bluetooth LE beacons as part of their most recent joint project: how beacons work, triangulating a user’s location by laying out a series of beacons, plus iOS7’s iBeacon API, and issues you’ll run into in real world usage. In the meantime, Jelly updates everyone on how GIFwrapped is doing, and we discuss a bunch of completely unrelated topics, like geoblocks, House of Cards and fake phone numbers.

Lessons learned from the launch of Jelly’s latest app, GIFwrapped: expedited reviews, asking for reviews within the update notes, helping users, enabling and setting up iAd, as well as disabling Ads for beta testers. Plus, ranting about how iAd isn’t as easy as it says on the box, the goto fail debacle, and replacing Objective-C.

Marc Edwards - designer and podcast co-host - claims a spot on the couch to share how Bjango got started building Mac and iOS apps, as well as some insight on Skala and its place in the world. We also talk about reducing the build-adjust-build cycle, the importance of having some technical knowledge when designing software, and wax lyrical about the future of user interfaces.

Feedback about asking for ratings prompts a discussion about when alert views should be used and when a different approach might be better; dealing with personally identifiable data within Australia, how and what you need to be doing when dealing with it; open-sourcing an entire app, why you would (or wouldn”t) want to do it (and how you should approach that decision); using Parse to quickly build cloud infrastructure for sophisticated apps; and layout-to-layout transitions in iOS7.

The benefits (and the costs) of open sourcing your code; using HockeyApp to track beta testers, why you might want to do such a thing (or not), and a discussion about the various methods of learning about how people use your apps; getting feedback, offering support, asking people to rate your app and where you draw the line; a quick discussion about AngularJS, a nifty little javascript library for creating web apps; and finally, some recommendations for books you might like to read.

Ben and Jelly travel to Kinglake, Victoria for NSCamp: a long weekend of coding and hacking for mobile devices. While they’re there, they do a special episode for the attendees, conducting lightning interviews with several of the developers in attendance; Sean Woodhouse from Itty Bitty Apps; Gerald Kim, who worked on the iPad app, Cook; Chris Miles, the man behind Reveal’s 3D view; and Armin Kroll, the organiser of NSCamp itself.

The effect that NDAs have on a project, do they help an app succeed, or are they unnecessary? Ben asks for some freelancing tips, which leads to a discussion of how to quote on work and what to do to find work as a freelancer. Jake introduces AFNetworking 2.0, and discusses one of the new features, URL sessions.

With Jelly’s need for a new Macbook Pro and the recent Apple event, now is as good a time as any to discuss the fallout, including new hardware and the consumer expectation of free software; Jake presents an idea for another app involving iBeacons; and Ben announces some news that gets the couch talking about making the choice to go freelance.

Jake’s excited about iBeacons, and so he discusses use cases, implementation and where to get actual beacons from; and we follow it up with a discussion about Core Data: what it is, what it’s useful for and some of the useful tools and add-ons that will help you manage your Core Data app.

Jake and Jelly are joined by Stuart Hall, co-founder of Discovr and creator of AppBot to discuss the story behind his Seven Minute Workout experiment, but not before they followup on health and NSURLCache (not to mention caching in general). They discuss the mindsets of people who buy apps when they”re dropped to free, adding in-app purchases to apps, and the differences between launching apps now, compared to the early days.

More Xamarin talk, as the boys discuss its cross-platform benefits, the impressive IDE, and how it compares to native cross-platform development; Jake requests help with a problem he”s having with collection views in Xamarin; staying healthy when you spend so much time hunched over a keyboard, while also improving your workflow; and what the best practice is for caching downloaded data.

With his interest officially piqued, Jake is looking into Xamarin, and so the boys discuss making apps in alternative languages and the pros and cons attached to that. Afterwards, they share their origin stories, including Jake’s desire to be an actor, Jelly’s short-lived stint in theatre, Ben’s dream of being a pilot, and why freelance work is so dang addictive. Finally, they discuss the shortcomings of UICollectionView and what the best way of containing “hack” code is.

Casey Liss - co-host of the hugely popular ATP and Neutral podcasts - joins the couch to talk about being recognised by strangers, what the schedule is like doing a podcast while working a day job, and the difference between travelling to WWDC from Australia and from the East Coast of the US. Somewhere in-between, we find time to discuss Visual Studio vs. Xcode, writing and wrapping APIs, and the cross contamination of coding languages.

We answer questions about the best way to learn OpenGL, and what would we want to be working on if we worked Apple; we follow up on the status of our own recent App submissions and discuss the appeal system; and we discuss some of the differences between developing for Android and iOS.

Dealing with rejection and the app review process in general; how the review process works, review times, tricks for managing timing your app’s release and the difference between personal and enterprise developer accounts; and Ben gives an introduction to making mobile games by discussing some of the game engines that exist out there and reasons why you would choose one over the other.

An explanation of Objective C++; what ARC is and the gotchas you need to look out for when using it; reasons why now is a great time to get into making apps for iDevices; Jake talks about his experiences trying out Windows Azure, and looks at what sort of uses it’s designed for; and MoodStocks, an image recognition API you can use in your apps.

With WWDC over for another year, Ben and Jelly discuss some of the new technologies that you”ll be able to use with your apps and the sessions you should watch so you can make your apps shine on iOS7; and Jelly explains an app he recently discovered called Oyster, which is a tool for testing regular expressions and even writing the code to use them. 101: Platforms State of the Union 400: What’s New in Xcode 5 228: Hidden Gems in Cocoa and Cocoa Touch 204: What’s New with Multitasking 206: Getting Started with UIKit Dynamics 502: Introduction to Sprite Kit 210: Introducing Text Kit 220: Advanced Text Layouts and Effects with Text Kit 217: Exploring Scroll Views on iOS 7 218: Custom Transitions Using View Controllers

Following up on asking for reviews and how it makes users feel; a comparison of ways to pass messages back and forth between classes: delegates, notifications and blocks; some speculation on what additions iOS 7 will bring which we can implement in our apps; and a little overview of Reveal from Itty Bitty Apps.

One More Thing conference is over and Ben and Jelly give their in-depth recap, touching on interesting (and helpful!) talks from Amanda Rösler, Simeon Saëns, Dave Wiskus, Lex Friedman, Maggie Steciuk and Jaimee Newberry. Jake talks about his experiences with Mapbox and Tilemill, a set of services that allow you to easily use custom maps in your iOS applications.

The top 25 apps of all time, and what can be learned from them; skeuomorphic design vs. flat design, choosing the correct icons, and what good design really means when it comes to building your apps; guided access, the system feature that nobody knows about; a handy method for using vector icons in your app by utilising PDFs; and some tools to help you prototype and test your apps: Heatma.ps and Briefs 2.

Why you would go to WWDC (assuming you manage to get a ticket); a new plugin manager for Xcode, Alcatraz, is released; techniques for debugging your apps, including a discussion about profiling using Instruments and how it helps you track down issues. Also this week, we”re joined by Ben Trengrove, who is taking over hosting from Caleb.

The importance of user-testing apps and some techniques for testing with users; making apps accessible for vision-impared users; using plugins with Xcode; and the team behind CocoaPods releases CocoaDocs: a single source for open-source library documentation.

The Pebble smart watch and the development possibilities of Google Glass and Siri integration; Caleb”s plans for making money from his new free app, Cute Fruit; places for learning about new techniques and frameworks in the Objective-C frameworks; releasing open source projects and how CocoaPods is a great tool for discovering them; Jake gives a general overview of how to use bitmasks in your own projects.

Filing Radars for SDK bugs, the usefulness and importance of Open Radar, dynamically overlaying your app”s details directly on the icon, Caleb”s new app Cute Fruit and marketing your app through video, word of mouth and advertising. Plus an interview with Russell Ivanovic (@rustyshelf) of Shifty Jelly.

Developing with multiple versions of your app on your test devices, advertising your app and tracking the success of advertising (without having your app rejected), and setting up a server backend to add server functionality to your app, including persisting your Core Data storage in the cloud, sharing data via a simple API, and adding the ability to remotely update your app”s settings on user”s devices.

Follow-up on Hola! Unblocker, automating build numbers and Nimbus (with a short discussion about CocoaPods and whether it’s good or not), the pros and cons of using Storyboards in your app from prototyping to full-blown app, and how to approach version targeting with your app. Please note: there is some unfortunate noise and echo present in this episode. We apologise for this. Please know that we are doing our best to ensure that the show is the best quality that it can be.

Superbowl 101, Superbowl ads, the Apple TV, and content distribution. In more on-topic conversation, Jelly gets suggestions on how to deal with a new project, and Jake, Jelly and Caleb discuss useful third-party libraries, issue tracking and distributing test builds. If you”re not interested in hearing the casual banter about non-development topics, the boys start discussing the podcast itself and the development related topics at 0:23:44. This sort of behaviour where they blatantly disobey listener”s requests may or may not continue in the future. Stay tuned to find out!