Issue 34 – 26th April 2016


Future Apple Watch Apps Must Be Native

In addition to the announcements of new beta versions of iOS , tvOS , watchOS and OS X this week, this other announcement caught my eye. As of June 1st, all new watchOS applications that are submitted to the App Store, must now be native apps built with WatchOS 2 SDK or later. I suspect that for most people this might not be an issue but if you do have an Apple Watch app up on the store and it’s not already native, you’ve got a couple of months to get things switched over. Maybe this is a precursor to more Apple Watch announcements in June?



I Quit My Full-time Job and Built an iOS Game

There is no getting away from it. Making enough money on the App Store to make a full-time living is hard but it may not be impossible. In this post,@amirrajan recounts his story and revenues from the development of ‘A Dark Room’ an off-beat, ascii-based, RPG-style, experience-driven game and it’s prequel ‘The Ensign’. It’s an interesting read about the ups and downs of indie development on the App Store and has some good lessons learnt toward the end of the post.



Designing an Alternative to the Hamburger Menu

Love it or hate it, the hamburger pattern is a pretty common design pattern in iOS applications but it is not without its issues. Inefficient, non-discoverable and non-glanceable, app designers continue to search for design alternatives to three lines of the hamburger icon. In this article, one such designer, @_scottjensen , takes a look at an alternative approach, an approach based around the ever-present tab-bar. It’s an interesting idea.


The Trouble with Manager Objects

Ok, I admit, I’m definitely guilty of this sometimes. In this article, @sandofsky provides us with a great reminder to think about the names we give our controller classes as the names of our controllers can often be a symptom of other underlying issues such as massive view controller syndrome.



Swift Strings

Having had a bit more free time in the last couple of weeks, I managed to post a new article on the website that took a detailed look at Strings in Swift. I was also pleasantly surprised (and grateful) when none other than Mr Swift himself @clattner_llvm picked up on the article and was kind enough to share it on Twitter. Definitely not something I was expecting! Anyway, having weathered the inevitable traffic spike that brought, it looks like a number of people have found the article useful which is really great to hear. All I’ve got to do now is hope that it doesn’t all change too much with Swift 3.0!


Mutability and Foundation Value Types

I don’t normally link to the various proposals of the Swift Evolution mailing list, partly because it moves so quickly, partly because the sheer volume of conversations and partly because there are already great ways of keeping track of the goings on on the mailing lists through summaries like the Swift Weekly Brief that @jesse_squires puts together. For this proposal though I thought I’d make an exception.

In it, Tony Parker proposes a re-alignment between the mutability behaviour of the types in the Swift Language and in the Foundation Framework to create a new set of foundation value types that wrap their corresponding reference types in the Foundation Framework. It’s one to keep an eye on as it may have some pretty big (and positive) implications for the Foundation Framework going forwards.



Functors, Applicatives, and Monads in Plain English

When it comes down to it, my brain is still more comfortable thinking in an object-oriented fashion than it is thinking in a functional one and I’m pretty sure I’m not alone. If this sounds familiar, this article from @xenadu02 is probably one for you. In it, Russ Bishop strips back some of the terminology mysticism that you’ll hear some of the functional advocates banding around to take a look at some of the key functional programming concepts in plain english terms. It’s a great article and one I’d definitely recommend finding some time to read if you’re just starting out with functional programming in Swift.


Upgrade your TableViews with Loading State

UITableView is the workhorse of many iOS applications. In this article, @nickoneill builds on a presentation by @Javi and looks at using enumerations as a way of keeping track of a UITableView’s state thereby allowing you to present alternative information or messages when there is either no data or data has failed to load. It’s an interesting idea.


NSNotifications with userInfo in Swift 2.2

Some see NSNotificationCenter as a code smell whilst for others it provides a useful mechanism for passing information around their app. Whatever your views, you can’t completely escape using it and in this article, @iachievedit has written a great article on how to use NSNotificationCenter and the userInfo property in Swift 2.2.



App Store Review Guideline History

I’ve no idea why I didn’t know about this service before. As you know, having a good understanding of the App Store Review Guidelines, is critical if you’re app is going to have a smooth ride from Xcode to App-Store and part of that task is having a clear understanding of the latest set of rules. This service from the team at @gokarumi helps with that problem by keeping track of new issues of the App Store Review Guidelines and highlighting changes to those guidelines should they occur. It’s a useful service and helps reduce the amount of digging through the guidelines you have to do yourself.


How to Show the Duration of Builds in Xcode

Another one that falls into the category of ‘I didn’t know you could do this!” for me. Want to know how long your Xcode builds are taking then this quick tip from @tonyarnold is for you.



GPUImage 2

For a long time, GPUImage has been one of the most useful open-source Objective-C libraries for applying GPU-accelerated filters and other effects to images, movies and live camera video. With GPUImage 2, it’s author @bradlarson has set about re-writing the library in Swift, an exercise that has not only cut the size of the code-base by almost two-thirds but also seems to have been a much easier process. Whether that is a case of having already learnt about any pitfalls first time around proves to be seen but Brad has kindly documented his experiences in this associated blog post .


Easy Animation

Adding animation to your application can not only improve the overall polish of your application but forms a significant part of the experience your users receive. This library from @icanzilb helps simplify the process by providing some extensions to UIKit to make it a little easier to get these animations running without the need to import a bunch of bloated frameworks.



I’m a big fan of Reveal for understanding your apps view hierarchy but this library from @shaps provides similar run-time capabilities for free. Written in Swift, Peek requires a single line in your AppDelegate to get started and provides a easy way for you to check the runtime information of your user interface elements such as buttons, views and fonts with just a a couple of taps.


转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » Issue 34 – 26th April 2016

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址