While some RubyMotion developers prefer to keep all their app built in code, there is still many out there that enjoy using Interface Builder and Storyboards. With the importance of properly managing scroll views with Auto Layout, its my pleasure to give you tips and details on how to make scroll views and Auto Layout easy every time.

Understanding how to properly structure the views and constraints to build a truly flexible and responsive scroll view in iOS is important for all iOS developers. Use these tips and instructions to make it easy to use scroll views with Auto Layout every time.

Showing off cool techniques and fancy gems and pods is always fun but sometimes we need to look at the fundamental skills we need to see a project successfully through from start to finish and into maintenance. Managing your environment variables properly is one of those things. For an added bonus as well there is a handy tip at the end about certificates too.

Talking technology, thats what we've been fantasising about for many many years, and now it's here! AVSpeechSynthesizer allows us to very easily get our iPhones to talk. Learn how to do it then come up with creative ways to take advantage of it.

The previous two episodes have covered how you can begin controlling the camera on iOS devices at a level not possible with higher level APIs. When you're wanting to just get the job done though this can be tedious, especially with the large amount of fairly boilerplate code. Sitting in the middle of the two extremes is the amazing motion-capture gem by Devon Blandin (a.k.a. @dblandin). Learn how to use the great too to create your own custom camera.

Continuing on from where we left off in part 1 (Episode 69) where we were displaying the camera input on screen, we're now going to work with gesture recognisers, the Photos framework, and the still image output to capture the image data and save it off to the phones photo library.

After some requests for more detail on how to control the camera it's time to take a look at AVFoundation. By using an AVCaptureSession and the correct inputs and outputs for it, we can create a totally custom camera. Over the course of the next few episodes we'll be building a working custom camera app.

Over the course of this two-part episode, we're going to take a look at how I would build an application using ProMotion, MotionKit, and Sugarcube, a frequently requested topic. Going through the normal task management app creation you'll learn how to integrate these gems together to make a ad-hoc framework for you to work with. Add in some CDQ and RMQ and you have a pretty much fully featured framework. This two-part episode is filled with quick-tips and is recorded as an unedited episode so that you can see how I work.

Over the course of this two-part episode, we're going to take a look at how I would build an application using ProMotion, MotionKit, and Sugarcube, a frequently requested topic. Going through the normal task management app creation you'll learn how to integrate these gems together to make a ad-hoc framework for you to work with. Add in some CDQ and RMQ and you have a pretty much fully featured framework. This two-part episode is filled with quick-tips and is recorded as an unedited episode so that you can see how I work.

When you start doing RubyMotion work or even if you've been doing it for a while and want to switch things up with your process you might be a little confused at which gems to use, both individually and together to create your own mini "framework". That's what this episode is here to solve. After a request on Twitter for this I've done a "live" episode (off-the-cuff would be a better term), where I walk you through the different sets of gems out there you can use for developing your applications.

We've built default cells, styled cells, custom cells, and yet we still can't tap on them. It's time to change that as we take a look at how to handle tapping a row, accessory view, and how to navigate to another screen.

Table views are a fundamental part of iOS development. It's common place to see them in many different apps to list data, or sometimes they're used in creative ways to achieve an interesting way of interacting with content. No matter how you plan to use them though, you'll still need to understand the basics first, and that's exactly what this episode aims to teach you.

MotionKit is much more than an easy way to do Auto-Layout, but it's APIs for Auto-Layout provide a concise way to work with the layout system. Take a brief introduction to MotionKit before we dive deeper into how to use it both for your general styling need and for Auto-Layout.

During the previous episodes looking into Auto-Layout we've had to specify each constraint individually. By using the Visual Format Language (VFL) we can instead use a specially formatted string in combination with a new method for creating multiple constraints at once.

Auto Layout is based on using mathematical equations to solve what the frame of a view should be in a given context. Constraints are the code representation of these equations. Learn about how to apply the math to work out which constraints to use.

So, the imaginary client that we’re building this app for has come up with some ideas. We’ve reviewed their ideas and a lot of them require scrolling around content on screen. We’ve agreed to get back to them with an estimate of how long it’s going to take so we could go away and do some research into exactly how to scroll content around the screen. After some searching we come across scroll views. The name seems about right but how do they work?

As we progress through this course, we move from view controllers to the views they control. There is many different types of views in iOS, but we're going to take a more in depth look at some of the ones you'll use most often.

Continuing where we left off in part 1 of this episode, we will continue to build out the todo app we've been working on by using text fields and learning where all of our code belongs in a view controller as we look at the lifecycle of the view and view controller.

Its time to hit the ground running by building out functionality you see in real world applications. Over the course of this two part episode (too much awesome for one episode!) you're going to begin to learn the fundamentals of building real world iOS apps by learning all about how to use view controllers, the centrepiece in the MVC paradigm, as well as get an early introduction to buttons, textfields, status bars, and navigating screens.

Learning how views and view controllers work are possibly the most fundamental skill for iOS developers, so by the end of this episode you will know exactly what a view and a view controller is, how to create them and where to put them, about the hierarchy and composition of the windows and views on the screen, and the co-ordinate system that places and sizes them correctly.

To start off this course, you're going to do the number one way to get introduced to something in programming, create a "Hello World" application. During this episode you will learn about how a RubyMotion app starts up, how to run it on the simulator, and how to get some stuff onto the screen, all in preparation for diving in deeper during the next 2 episodes.

Welcome to the RubyMotion for Rails Developers course! This is a 12 episode course covering all you need to know to get started building working apps with RubyMotion. In the course you'll learn about Views and View Controllers, different forms of navigation, Auto Layout, table views, controls and inputs, and more. If you haven't already signed up, do so now to get a new episode of the course each week as well as enjoy the large number of existing video tutorials on RubyMotion.

The other day Colin Gray and I were tweeting back and forth on Twitter about why he’s not a fan of doing Auto Layout in Interface Builder, and with how excited I am about how stable Xcode 6 seems to be for doing Auto Layout I was surprised to hear this. He rose the very valid point that sharing and explaining to someone constraints in code between programmers is much easier than in Interface Builder.
This got me thinking about the amount I’ve covered Interface Builder recently and that many many people in the RubyMotion community try to avoid Storyboards at all costs. I’m worried many of you are missing out on a great tool though, especially for prototyping and working with designers, so this is why in today’s episode I’m going to show you how to take the constraints from auto layout and put them into a very nice separate layout class that’s kept away from everything else.

In this episode I’m going to show you how to use the new size classes feature in Xcode to create Storyboards that work for all devices, including iPads and the new massive iPhones. Now I’m covering Storyboards yet again, but for an incredibly good reason. Storyboards are becoming more and more powerful with each release of Xcode, and now with the introduction of size classes alongside the sudden need to handle many different screen sizes, Storyboards offer us something that when we try to replicate it in code, we end up with a horrible mess of if statements to do with which size class we fit into. This episode is going to be building on the knowledge obtained in episodes 40 and 41, so if you haven’t watched those, I suggest going back and watching them before you continue unless you already have a firm grasp on how to use Auto Layout and Interface Builder in Xcode.

In today’s episode we’re going to be taking a look at how to convert between Java Android code and RubyMotion Android code. The Android developer website has a great section dedicated to training for new developers, which I highly suggest running through, either using RubyMotion or Java. I’m actually going to do a live walkthrough of the first tutorial on this website, using RubyMotion instead of Java, so that I can show you what the process looks like.

The big announcement of RubyMotion's support for Android has finally reached public beta! Instead of creating my normal polished screencasts, I decided to go RAWRRRR!!! This is me playing around trying to get RubyMotion for Android set up, and at the end you can see me fighting with the Android emulator, showing exactly why I use a device for development, because it's faster and more stable. It's a bit longer than I would have liked, but if you're wondering about all the stuff you're doing with setting up, this is going to be the goto place to work that out. Eventually I'll update this as things change over time.

Something a lot of beginners to RubyMotion realise quickly is that there is so many Objective-C resources out there that they need to understand some Objective-C first to use, so I've made a little guide for you all to learn those basic things!

In this episode, I’m going to continue showing you how you can take advantage of Interface Builder in your RubyMotion projects, using the IB gem.
In the previous episode, you learnt about the basics of Interface Builder, such as how to get views and view controllers in to a Storyboard, how to create constraints for Auto Layout, and how to use the IB gem and the UIStoryboard class to integrate the Storyboard with your RubyMotion code.
Now it’s time to start looking at one of the greatest features of Interface Builder, which is creating and visualising the entire workflow of your application in one central place.

RubyMotion developers seem to have a developed a strong opposition to using Interface Builder, the drag and drop interface editor in Xcode. In this episode I want to take a step back and take a look at whether that's actually a good thing or if we can use Interface Builder as just another tool in our toolbelt for iOS development (hint we can).

In today’s episode, we’re going to be talking about NSNotificationCenter. The name of NSNotificationCenter is incredibly deceiving, most conversations I’ve had about it with people that haven’t used it before are explaining that it’s not actually related to the notification centre in the iOS operating system, or to push notifications. NSNotificationCenter has been around since iOS 2, well before the notification centre in the operating system was created, and is instead a kind of publish and subscribe system.

A new validations feature was just announced with version 0.7 of RMQ! Lets take a walk through the new features and what we can do with them. We'll start by checking out the new general use validation utility, and follow that up with how we can use validation with our fields, including setting up event handlers on them.

In episode 36, I began creating a gem called better toolbar, test driving it towards where I wanted to go. In this episode, I'll take that further as I begin push towards a more complete API, once again, showing you how I test drive my RubyMotion code along the way. I've also got an awesome new title song.

A common request as a topic is to cover test driven development, and also how to make a gem. So in this episode I'll show you the way I like to do both of those. Both topics vary heavily depending on the exact work you're doing, but the workflow is always what gets people going.

Once your app starts doing more than a very basic set of tasks, you're going to need to add another layer of navigation. This is where the UITabBarController comes to the rescue! Yay! So in this episode we're going to take a look at how to set up a UITabBarController, and the how to customise it to suit the look of your application.

Today we're going to look at one of the essential building blocks of a lot of user interfaces, the toolbar. Watch and follow along as I show you through configuring the built in toolbar of a UINavigationController, and the how to use a UIToolbar like you would most any other view.

NSURLSession is an important, and relatively new class and set of APIs that give you a consistent way to get and post data both in the foreground and background. In this week's episode, we're going to roll our own API client for a basic RubyMotion app, using NSURLSession and the related classes.

In the previous episode we looked at CALayer and how easy it makes animating your views. We're going to expand on this by looking at a class I mentioned at the end of that episode called AVPlayerLayer, and it's buddy AVPlayer. Using these classes you can creating custom designed video players and animate them in the same ways that you can animate CALayer (because AVPlayerLayer is a subclass of CALayer), without making the video jump, it's all very smooth.

Working with UIKit and AppKit is common place when you're working with RubyMotion, but sometimes it's good to drop down a layer (or should I say CALayer), and interact with something else. CALayer is a great class to work with, especially when it comes to animating properties, because it does it all automatically for you. Watch this episode and see how to take advantage of this awesome class.

After popular request, here is a basics episode for using MotionKit with your table cells, including how to use autoresizing masks and the MotionKit DSL for Auto Layout in your table cells. A short episode filled with good tips.

Container controllers, such as UINavigationController or UITabBarController are the core navigation mechanism for many of our applications. The UIKit framework provides us with mechanisms and direction to create our own custom container controllers, which we'll be covering in this episode.

Sometimes you're applications will have a need for integrating some web content that needs to talk to your application. In this episode we'll be setting up a way for communication between the content in your UIWebViews and the rest of your application. This allows you to create some hybrid applications quite easily.

UIPickerView is a common sight in a lot of applications, it's an easy and familiar way to... well... pick things. Understanding the delegate and data source though can allow you to really understand what's possible and use it in more creative ways.

I have a special episode for you all today! This is a normal episode just like any other, where I'll walk you through the process of using motion-installr to get setup for ad-hoc deployment using the awesome Installr service. The twist is though that I also have a competition for you! Click the link in the show notes for details.

Many developers when they're given a design to implement that has multiple styles of text in one label or text view will struggle to work out a solution until they decide upon using HTML. That works, but it's inefficient and we have a better way built into Apple's frameworks. In this episode, I'll show you how you can use NSAttributedString to create basically any style of text that you want.

Sometimes we can't escape the reality of working with C-like code in RubyMotion, and at that point it's really important to understand how to use Pointers correctly. In this pairing session with Shaun, we worked through moving over some cool graphics code from MacRuby to RubyMotion and discovered a lot about pointers in RubyMotion.

MotionKit is the new kid on the block for us RubyMotion developers, providing us with a fantastic new way to handle our screen layouts. In this episode we take a look at some of the basics of creating a layout, adding styling and subviews, and laying them out on the screen using MotionKit's fantastic AutoLayout API.

Over the past few episodes, we've created the Tasker application, which we polished off in Episode 21. Now it's time to share it with our beta-testers. In this episode we explore how to set up your distribution certificates and provisioning profiles, and how to then get both TestFlight and HockeyApp set up to share your application around. This has been a highly requested topic from the RubyMotion community, and so I decided to show you how to use both TestFlight and HockeyApp instead of just one!

For the past 5 episodes, we've been building the Tasker application, and as of episode 20, it's basically ready to go except for a few more tweaks. So in this episode, we're going to clean things up by utilising MIMInputToolbar, TPKeyboardAvoiding, input views and input accessory views. This episode also looks a little into my process for splitting out views into reusable chunks. Many of you use Formotion, but this episode is going to give you a look at how easy it is to build custom forms just by utilising some simple pods and gems.

By using local notifications you can remind your users about your application, notify them with reminders, and use the notifications for all kinds of creative ways of enhancing the user experience and engagement with your application. In this episode we round off the functionality of our Tasker application by implementing local notifications to remind them of due tasks.

Dates are an important part of a lot of applications, and how you display them for their context can make a difference to how quickly users parse the information on screen. In this episode I walk you through getting the MHPrettyDate cocoapod set up in the Tasker application, and show you how to use NSCalendar and NSDateComponents to work with dates properly.

Both AutoLayout and the creation of custom UITableViewCell subclasses is extremely important when doing iOS development, so once you've finished watching this episode, I'd like you to take away the knowledge of "Why is AutoLayout important?", "Why create custom table view cells?", "How AutoLayout works", and finally "How to use AutoLayout when creating custom cells". You're going to learn these things while we take a look at our example RubyMotion application "Tasker", and there is some new parts to MotionInMotion in this episode where I change up the format a little, with a bit more "Why" than just how, as well as a challenge for you at the end to practice your skills.

RestKit is an amazing library for communicating efficiently and easily with RESTful services, like a Rails backend for your application. With a bit of setup, it's by far one of the best ways to keep your RubyMotion app in sync with your server. We're going to continue where we left off in Episode 16 with our Tasker application, and have RestKit keep our tasks saved to the server, and keep the server and Core Data store in sync. See the show notes for the Rails app I'm using with Tasker.

The MotionInMotion RubyMotion pairing sessions are focused on doing one-on-one training with developers who are new to RubyMotion, and recording them so other newcomers can learn from it. In this session we work through an error when working with cocoapods due to Command Line Tools not being setup, and then go through some of the basic concepts of iOS development like views, target-action, table views, and delegates & data sources. If you're not interested in the part at the beginning where we're fixing the error in cocoapods, skip ahead to 22m 20s in.

It's time to learn how to efficiently manage a Core Data backed UITableView by using NSFetchedResultsController. It's much simpler than you would think, and once it's done it's extremely easy to maintain. Your table views will be faster, your memory usage will go down, it's just a great time to be a table view!

Grand Central Dispatch is one of the greatest (grandest even?) ways to do multithreaded applications in any language, which if you're doing any kind of processing or network communication, it's likely you will need to make your application use multiple threads too. In this episode we take a look at the main use cases for GCD and the simple code you need to write to run certain tasks in another thread by using queues and blocks.

There is more to Todd Werth's RubyMotionQuery (RMQ) than you might realise, it's filled with amazing tools to help you clean up your code and possibly do things you didn't know were possible. In this episode I have 5 Advanced RMQ tips to expand your knowledge of RMQ.

One of the great new accessibility features of iOS 7 was Dynamic Type. It's sad to say though that not enough applications are taking advantage of it, when it's so easy to setup, and can make a user's life a lot easier. In this episode you're going to learn just how easy it is to setup, and take advantage of it fully.

In this week's episode, we take a look at creating custom URL schemes for your application, so that other applications can open it, and how to open another application from your app. We are going to work with two applications, one for asking for authentication, and one to act as an authenticator, similar to how "Connect with Facebook" used to work before it was integrated into iOS.

In the past few episodes we’ve been taking a look at some of the gems available to make your development faster, your code cleaner and more ruby like, as well as generally make you a happier developer.
The series continues with this episode where I’m going to show you how to convert an existing view to use Teacup instead. I wanted to show you something a bit more complicated than the Zaggstar app we’ve been looking at in the previous two episodes, so we’re going to be taking a look at Blapp again, the application from the CDQ episode.
We’ll be converting the detail view for a post to use Teacup’s DSL instead, and to finish off, we’re going to improve things by using Teacup’s constraint helpers to setup AutoLayout.

In the last episode we had a look at how to create an app quickly using the power of ProMotion! In this episode we take a look at the integration of ProMotion and Formotion to create a full CRUD application in RubyMotion. I'll show you how to create an add and edit screen that Formotion makes easy for us, and at the end I show you how to setup deleting rows in a ProMotion table screen.

Sometimes you need to build something really quick, just to get an idea across. RubyMotion is fantastic for building iOS and OS X apps quickly, but with the help of gems like ProMotion, you can work twice as fast! That's why we're going to take a look at ProMotion. This will be the first in a series of episodes about the gems you have at your disposal and how you can use them all together to write beautiful code, quicker than usual.

Learning to use the camera is incredibly important. The camera can give your application a personal touch, or be a big feature to center your application around. I'll show you the basics of how to open the camera, and how to save photos (NSData comes back to play). You will also learn how to save photos to the camera roll. In the future we'll expand on these topics, but for now, let's get you taking photos by creating KeyHook, an application that helps you remember where you left your keys.

If CoreData is overkill for your application, you might be able to just write data out to the disk, or store it in NSUserDefaults. I'm going to show you how to do this in RubyMotion, and teach you how to encode and decode data which will help with storing any kind of data, not just your models.

CoreData is a difficult subject to learn, especially since you need to already have a fairly firm grasp on the knowledge of how to use the rest of Apple's frameworks. There is an easy way though! In this episode we take a look at how to get setup with, and use Ken Miller's CDQ and ruby-xcdm libraries in RubyMotion.

An in-depth look into how to do behaviour driven development when creating a RubyMotion application. I guide you through "hacking" the simulator to change settings from cucumber tests, and how to handle the usually complicated workflow of testing a location based application. There is a challenge for you at the end of this episode too!

A two part series that will teach you secret ways of Apple's take on MVC. I will show you how to talk to and create delegates, pass data around with data sources, give your objects a way to tell each other about changes with KVO, respond to events with target/action, and how to use all of these to properly structure your application and take full advantage of these tools.

A two part series that will teach you secret ways of Apple's take on MVC. I will show you how to talk to and create delegates, pass data around with data sources, give your objects a way to tell each other about changes with KVO, respond to events with target/action, and how to use all of these to properly structure your application and take full advantage of these tools.

The first episode of the MotionInMotion screencasts for RubyMotion! This first episode is all about using motion-layout and Auto Layout's Visual Format Language to use Auto Layout easily in your RubyMotion apps.