Author at Infinum

How to Prepare Your Mobile App for the New iPhone X

Vedran Burojevic — Thu, 05 Oct 2017 13:45:00 +0000

Apple revealed the new iPhone X on their last September event, which comes with a bold new design. The device is no longer rectangular. Instead, it features rounded corners, edge-to-edge display, and a notch on top of the screen which holds the TrueDepth camera system for the new Face ID. It also lacks the iconic home button, which is now replaced by a virtual home indicator.

The question is how will current apps behave on the new iPhone X, and how can you adjust your apps for it?

iPhone X starts shipping early November, so it’s time to roll up your sleeves and get your hands dirty. Apps that aren’t adjusted for the new iPhone X will run in compatibility mode, letterboxed with slightly rounded corners.

Getting started

You’ll, of course, need to use Xcode 9 and build your app with iOS 11 SDK. It’s possible that you still use launch images instead of launch storyboard, so you’ll need to migrate to launch storyboard or add one for new iPhone X dimensions. Otherwise, iPhone X will still run the app in letterboxed mode. I recommend using the storyboard approach since you won’t have to worry about future device sizes.

Auto Layout

If you use Auto Layout correctly, chances are your app will be in a pretty good shape with a smaller amount of work. A problem arises if your app has a lot of custom controls (especially in the bottom portion of the screen, since it’s covered now by the virtual indicator), or if you calculate layout manually.

Safe Area

Safe area helps you place your views within the always visible portion of the screen. It’s guaranteed not to be covered by navigation bars, tab bars, toolbars, and other ancestors that can be a part of a view controller’s view.

Safe Area Layout Guides

Safe Area Layout guides are the building blocks when it comes to adjusting your app for the new iPhone X. Apple introduced topLayoutGuide and bottomLayoutGuide in iOS 7 SDK which allowed you to constrain your views to the status bar, navigation bar or tab bar. Now in iOS 11 SDK and Xcode 9, you should use new Safe Area Layout Guides instead. You can also access them through code via safeAreaLayoutGuide property on your view.

The important thing to know is that safe area layout guides are backward compatible up to iOS 9. This means you should drop the support for iOS 8 if you want to adjust your app nicely for iPhone X.

Another important thing to keep in mind is that you can add safe areas to multiple views in your hierarchy. This is useful when you need to constrain some view to edges of the screen, but it’s subviews elements to safe area layout guides.

Migrating Storyboards and Xibs

When you open a xib or storyboard in Xcode 9, there is an option to use Safe Area Layout Guides. Once selected, top and bottom layout guides, as well as leading and trailing edges will automatically be replaced with safe area layout guides. You should take some time to go through your xibs and storyboards, and adjust every one of them. Don’t forget to perform a smoke test after each adjusted screen, to see if everything looks good.

Native components

If your app uses native components such as UITableView, UINavigationBar or UITabBar, their layout will automatically be adjusted for the iPhone X so you have one less thing to worry about.

Table view

Table views still cover screen edge-to-edge, and the virtual home indicator is placed above it (and it passes taps to table view). However, cells are constrained to safe area layout guides. This means that in a landscape, for example, cell content will be constrained to the area where rounded corners begin. There’s a new property insetsContentViewsToSafeArea to modify this behaviour.

Search bar

In iOS 11, the search bar is now included in the navigation bar to best use the area where the search bar is usually displayed.
The following snippet shows how should you present search bar now, and how was it done before.

let searchController = UISearchController(searchResultsController: nil)
self.navigationItem.searchController = searchController
searchController.isActive = true

General tips

Bottom controls

Don’t place controls at the bottom of the screen. If your app uses custom bottom UI controls, they should be constrained to bottom safe area layout guide, while their superviews can be constrained to the edge of the screen.

Swipe Up Gestures

You shouldn’t use swipe up gestures from the bottom of the screen, this area is now reserved for the virtual home button indicator. You can give your gesture priority, but this is not recommended according to Apple’s guidelines.

Virtual home indicator

You can modify the home indicator behavior to autohide if the user doesn’t touch the screen for some time, but you should only do it in specific cases such as viewing photos or videos in full-screen. When a user taps the screen again virtual home indicator will reappear.

override func prefersHomeIndicatorAutoHidden() -> Bool {
    return true
}

Larger navigation bars

Navigation bar got an update as well in iOS 11. They can now be way taller with larger title fonts. This behavior is disabled by default, but you can enable it if needed.

navigationItem.largeTitleDisplayMode = .automatic

I hope this post helps you in adjusting your app for the new iPhone X!
If you found something interesting while adjusting your app, feel free to share it in the comments below!

More info

The post How to Prepare Your Mobile App for the New iPhone X appeared first on Infinum.

Becoming an iOS Developer Swiftly

Vedran Burojevic — Wed, 23 Nov 2016 17:05:00 +0000

So you want to learn the programming language everyone’s talking about, but don’t know where to look? We’ll give you a few pointers to kick-start you on your way to becoming a great Swift developer!

It doesn’t matter whether you’re already an experienced Objective-C developer or completely new to iOS development, you’ll still run into trouble choosing the right learning resources. There are already a lot of them available for learning Swift. To save you time, we’re here to recommend a few good ones!

Why start with Swift?

If you’re just starting out with iOS development, you’re probably wondering whether to go with Objective-C and then move to Swift or skip Objective-C altogether.

Objective-C is 33 years old, and it served us well so far (and still does). On the other hand, Swift has been around for only 2 years, but it’s steadily gaining momentum. Without a doubt, Apple will keep supporting Objective-C for some time, as most of Apple’s apps are still written in it. Nevertheless, it’s clear Apple is putting its money on Swift. It’s the future of both iOS and macOS, and Swift 3 was just released with a lot of improvements!

Swift is a brand new programming language for iOS, macOS, watchOS and tvOS. It has the best of C and Objective-C languages, but adds a lot of new modern features like flow control, data structures, and functions, with high-level constructs like objects, protocols, closures, and generics. It also brings type safety to help developers write less error-prone code.

If you are just starting out with iOS development, it makes sense to start with Swift. The iOS community moved away from Objective-C, and every new blog post, video tutorial, code example, and framework is referencing Swift. It’s a clear sign Swift is now mature and ready to be used in production.

First steps

I wrote an article on how to become an iOS developer, so if you’re completely new to this, you could head out and read that one first. Since Swift didn’t exist then, it was written with Objective-C in mind. Nonetheless, it contains all the information you need to start with iOS development.

Resources

Books

There are quite a few books already available for Swift. The ones that stood out for me come from the Big Nerd Ranch. Their books are beginner-friendly, so you’ll have no trouble starting out. At the time of writing this article new Big Nerd Ranch books updated for Swift 3 and iOS 10 SDK are only available for preorder.

To learn the language, I recommend Swift Programming: The Big Nerd Ranch Guide, which will help you learn basic Swift features and even some advanced concepts. It will also give you a taste of the iOS SDK. By the end, you’ll even be able to write a simple app.

When you feel comfortable with Swift, it’s time to move on! The next step is iOS SDK, and that means learning the basic usage of Apple’s framework for creating iOS apps. You can learn by reading iOS Programming: The Big Nerd Ranch Guide, in which they cover everything from creating an actual Xcode project to controlling animations and persisting data with the Core Data framework.

Also, there’s an official book by Apple, The Swift Programming Language, which offers an in-depth tour of the language and its features. I’d strongly recommend going through it!

If you’ve read all of the above and want to explore more, Advanced Swift is the book for you. You can examine some high-level (like programming with generics and protocols), as well as low-level topics (for example, wrapping a C library and string internals).

Videos

Not into books? That’s alright, we feel you. Luckily, Stanford University has a fantastic course called Developing iOS 10 Apps with Swift. It’s the most popular video course for iOS development aimed at beginners. If you prefer videos, I strongly recommend starting out with that one!

Videos from Ray Wenderlich’s team are also worth checking out. They cover a wide array of topics, including some great Swift courses.

You could also skim through some sessions by Apple’s engineers. Apple holds a WWDC conference each year and has development-related talks about new SDKs and general tips concerning iOS development. They are usually advanced-level topics, so I’d recommend watching them after you feel comfortable with Swift.

Online courses

Some websites like Code School give you a chance to learn Swift directly from your web browser. The cool thing is that you don’t have to be on macOS! Their courses cover more common uses of the UIKit framework and how to use it with Swift.

Another great resource is Hacking with Swift, a set of tutorials which lead you from beginner-level topics, to more advanced ones in 39 hands-on projects! It also has an awesome introduction to Swift programming language.

Blogs

The iOS community is constantly evolving. Reading blog posts by other developers is an excellent way to learn new techniques and gain insight into how others solve problems. Quite a few of these blogs are related to Swift, and you could learn heaps from following them.

Some blogs I’d recommend:

Natasha The Robot
Ayaka Nonaka
That Thing In Swift
Bart Jacobs
Objc.io Issues and their brand new Swift Talks

Newsletters

There are also popular iOS weekly newsletters like iOS Dev Weekly and our own iOS Cocoa Treats in which you can find great blog posts, libraries, videos and tools related to iOS and Swift development.

And more…

These two links are the holy grail of iOS development resources. They contain tons of resources which you can use to learn Swift and the iOS SDK!

What about Objective-C?

It’s still a good idea to learn fundamentals of Objective-C. If you just started out with iOS development, you might think there is no need for it or no time to learn both languages, but it’ll pay off. You should know Objective-C because sooner or later you will stumble upon it. It’s highly unlikely you’ll only work in Swift during your professional career. Older projects are written in Objective-C and they have to be maintained. Once you are acquainted with the iOS SDK, it’s much easier to switch from Swift to Objective-C and vice-versa.

Since Objective-C has been around for quite some time, you can find a lot of answers to your iOS development related problems online. Stack Overflow is always a good starting point.

What next?

Ok, so you wrapped up this article, and now you have everything you need to become the next big name in iOS development.
Bookmark this post for future reference, fire up your Xcode and good luck! ?

The post Becoming an iOS Developer Swiftly appeared first on Infinum.

Top 10 iOS Swift Libraries Every iOS Developer Should Know About

Vedran Burojevic — Thu, 10 Dec 2015 10:19:00 +0000

Swift is gaining popularity each day. If you’re starting a new project, chances are that you’ll decide to write it in Swift. To make the transition easier for you and save you the time you would spend writing certain components for your app, here are 10 libraries that we think every iOS developer should know about!

Just like we mentioned in our Top 5 iOS libraries every iOS developer should know about article, GitHub and Bitbucket are great places to find open source iOS libraries. Tools like CocoaPods and Carthage can help you speed up installing and maintaining libraries you use in your projects, and in that way make project dependency management easy for you.

1. Alamofire

When you want to abstract away and simplify networking in your app, Alamofire is the way to go. Alamofire is a HTTP networking library, built on top of NSURLSession and the Foundation URL Loading System. It nicely wraps networking mechanisms in an elegant and simple Swift interface.

// Making a GET request

Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])
         .responseJSON { response in
             print(response.request)  // original URL request
             print(response.response) // URL response
             print(response.data)     // server data
             print(response.result)   // result of response serialization

             if let JSON = response.result.value {
                 print("JSON: \(JSON)")
             }
         }

2. SwiftyJSON

Explicit types in Swift make sure that we don’t make mistakes in our code and cause bugs because of them. But sometimes it is rather painful to deal with it, especially when working with JSON. Luckily, SwiftyJSON is here to help us deal with JSON data in Swift in a more readable way. Optional unwrapping is handled automatically for you as well!

// Typical JSON handling

if let statusesArray = try? NSJSONSerialization.JSONObjectWithData(data, options: .AllowFragments) as? [[String: AnyObject]],
    let user = statusesArray[0]["user"] as? [String: AnyObject],
    let username = user["name"] as? String {
    // Finally we got the username
}

// With SwiftyJSON

let json = JSON(data: dataFromNetworking)
if let userName = json[0]["user"]["name"].string {
  //Now you got your value
}

SwiftyJSON also plays very nice with Alamofire.

Alamofire.request(.GET, url).validate().responseJSON { response in
    switch response.result {
    case .Success:
        if let value = response.result.value {
          let json = JSON(value)
          print("JSON: \(json)")
        }
    case .Failure(let error):
        print(error)
    }
}

3. ObjectMapper

If you’ve ever written an app which downloads information via an API, you’ve probably spent a lot of time writing a code to map a response to your objects. ObjectMapper helps you convert a JSON response into your model object, and vice versa. In other words, it helps you map JSON to objects, and objects back to JSON. Nested objects are supported as well.

// Temperature class that conforms to Mappable protocol

struct Temperature: Mappable {
    var celsius: Double?
    var fahrenheit: Double?

    init?(_ map: Map) {

    }

    mutating func mapping(map: Map) {
        celsius     <- map["celsius"]
        fahrenheit  <- map["fahrenheit"]
    }
}

It’s also worth to mention AlamofireObjectMapper, an Alamofire extension which converts JSON response data into Swift objects when using ObjectMapper.

4. Quick

Quick is a behavior-driven development framework for Swift, inspired by RSpec, Specta, and Ginkgo. Quick comes with Nimble, which is a matcher framework for your tests.

// Documentation directory spec

class TableOfContentsSpec: QuickSpec {
  override func spec() {
    describe("the ’Documentation’ directory") {
      it("has everything you need to get started") {
        let sections = Directory("Documentation").sections
        expect(sections).to(contain("Organized Tests with Quick Examples and Example Groups"))
        expect(sections).to(contain("Installing Quick"))
      }

      context("if it doesn’t have what you’re looking for") {
        it("needs to be updated") {
          let you = You(awesome: true)
          expect{you.submittedAnIssue}.toEventually(beTruthy())
        }
      }
    }
  }
}

5. Eureka

Eureka helps you write dynamic table-view forms in a simple and elegant way. It consists of rows, sections and forms. If your app contains a lot of forms, Eureka proves to be a real time-saver.

// Creating a form

class CustomCellsController : FormViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        form +++ Section("Custom cells")
                    <<< WeekDayRow(){
                        $0.value = [.Monday, .Wednesday, .Friday]
                    }
                    <<< TextFloatLabelRow() {
                        $0.title = "Float Label Row, type something to see.."
                    }
    }
}

6. RxSwift

RxSwift is a Swift framework for Functional Reactive Programming. To be more specific, RxSwift is a Swift version of Rx and its goal is to enable easy composition of asynchronous operations and event/data streams. KVO observing, async operations and delegates are all unified under abstraction of sequence, which makes RxSwift such a powerful framework. If you’ve ever worked with ReactiveCocoa, you are familiar with the concept.

// Combine first and last name sequences, and bind the resulting string to label

combineLatest(firstName.rx_text, lastName.rx_text) { $0 + " " + $1 }
            .map { "Greeting \($0)" }
            .bindTo(greetingLabel.rx_text)

7. SnapKit

SnapKit is an Auto Layout library that simplifies writing auto layout in code with a minimal amount of code needed without losing readability. It is type safe by design to help you avoid programming errors while coding your user interface.

// Resizing and centering subview in its superview

let box = UIView()
let container = UIView()

container.addSubview(box)

box.snp_makeConstraints { (make) -> Void in
    make.size.equalTo(50)
    make.center.equalTo(container)
}

8. Spring

Spring is an animation library that helps you create animations both in code or directly in Storyboard. You can create animations in Storyboard using runtime attributes (set through IBInspectable properties). Spring has grown into a fully developed animation library that supports quite a number of already written animations, transitions, and properties.

// Usage with code

layer.animation = "wobble"
layer.animate()

9. Kingfisher

Kingfisher is a lightweight library for downloading and caching images from the web. Downloading and caching is done asynchronously. Downloaded images are cached in both memory and disk, which could improve your app experience quite a lot.

// Basic example of downloading and caching an image

imageView.kf_setImageWithURL(NSURL(string: "http://your_image_url.png")!)

10. CoreStore

CoreStore is a wrapper library for Core Data. Its goal is to provide type safety and elegance of Swift when interacting with Core Data. CoreStore’s API provides all common methods to effectively interact with your database.

// Storing a person entity

CoreStore.beginAsynchronous { (transaction) -> Void in
    let person = transaction.create(Into(MyPersonEntity))
    person.name = "John Smith"
    person.age = 42

    transaction.commit { (result) -> Void in
        switch result {
            case .Success(let hasChanges): print("success!")
            case .Failure(let error): print(error)
        }
    }
}

What’s your opinion?

You don’t agree with us? Some other library deserves a place in this top 10 list?
Leave a comment and let us know what you think!

The post Top 10 iOS Swift Libraries Every iOS Developer Should Know About appeared first on Infinum.

Top 5 iOS Libraries Every iOS Developer Should Know About

Vedran Burojevic — Wed, 29 Apr 2015 14:05:00 +0000

You probably know that using third-party libraries in your iOS projects can save you a lot of time and hassle. The question is, which libraries are worth using? Read on and find out!

Note: Looking for Swift libraries? Head over to Top 10 iOS Swift libraries every iOS developer should know about

Services like GitHub or Bitbucket are full of useful third-party libraries that can be easily integrated into your project by using tools like CocoaPods and Carthage. Here are 5 libraries that we use in every-day development and think every iOS developer should know about.

1. AFNetworking

When it comes to networking, this library makes every developer’s life a whole lot easier. AFNetworking is a light-weight and fast networking library that uses blocks and GCD (Grand Central Dispatch).

It is a great example of how an open-source project should be run, largely thanks to its creator Mattt Thompson, the founder and former writer on NSHipster. An amazing community of developers contributes to AFNetworking daily, making it the most popular third-party iOS library.

To see just how easy it is to use it, check out the code example below:

GET request

AFHTTPRequestOperationManager *manager = [AFHTTPRequestOperationManager manager];
[manager GET:@"http://example.com/resources.json" parameters:nil success:^(AFHTTPRequestOperation *operation, id responseObject) {
    NSLog(@"JSON: %@", responseObject);
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
    NSLog(@"Error: %@", error);
}];

POST request

AFHTTPRequestOperationManager *manager = [AFHTTPRequestOperationManager manager];
NSDictionary *parameters = @{@"foo": @"bar"};
[manager POST:@"http://example.com/resources.json" parameters:parameters success:^(AFHTTPRequestOperation *operation, id responseObject) {
    NSLog(@"JSON: %@", responseObject);
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
    NSLog(@"Error: %@", error);
}];

Swift alternative

Alamofire – also made by Mattt

2. JSONModel

If you are working on an app that requires communication with a remote server, chances are you’ll get a JSON response. This is where JSONModel comes to the rescue.

JSONModel is an open-source library that helps you with parsing and initializing your model classes with JSON response from the server. When it comes to applications with a more complex data model, JSONModel proves to be a real time-saver.

Initializing model from JSON response

JSONModelError *jsonModelError = nil;
PersonModel *personModel = [[PersonModel alloc] initWithDictionary:personDictionary error:&jsonModelError];

Swift alternative

ObjectMapper – this framework written in Swift simplifies the conversion of Model objects (Classes and Structs) to JSON and vice versa

3. MagicalRecord

The Core Data API is used by iOS developers to persist and query user data. While powerful, using its API can also be quite time-consuming and contain a lot of boilerplate code.

Luckily, you can help yourself by using a library called MagicalRecord, a wrapper around Core Data that simplifies managing your persistence storage. It was inspired by the ease of Ruby on Rails’ Active Record fetching and it allows you to:

Clean up your Core Data related code
Use simple, one-line fetches
Modify the NSFetchRequest when request optimizations are needed

Let’s see how we can put MagicalRecord to use:

Create an object

Person *person = [Person MR_createEntity];
person.name = @“Vedran”;
person.age = @23;

Retrieve all records for the NSManagedObject subclasses

NSArray *people = [Person MR_findAll];

Updating an entity

person.age = @28;

Delete single record

[person MR_deleteEntity];

Swift alternative

SugarRecord – a data management library designed to make working with CoreData and Realm simpler

4. SDWebImage

AFNetworking has a great category to load images from the web (UIImageView+AFNetworking), but there’s a library even more suited to this task.

SDWebImage specializes in image downloading and caching, and offers an extensive list of features:

A UIImageView category adding web image and cache management to the Cocoa Touch framework
An asynchronous image downloader
An asynchronous memory + disk image caching with automatic cache expiration handling
Animated GIF support
Background image decompression
Guarantees that the same URL won’t be downloaded several times
Guarantees that bogus URLs won’t be retried again and again
Guarantees that the main thread will never be blocked

Here is a basic example of usage:

Load remote image using blocks

[cell.imageView setImageWithURL:[NSURL URLWithString:@"http://www.domain.com/path/to/image.jpg"]
                placeholderImage:[UIImage imageNamed:@"placeholder.png"]
                       completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType) {… completion code here …}];

Swift alternative

Kingfisher – lightweight and pure Swift implemented library for downloading and caching images from the web

5. ReactiveCocoa

Objective-C framework inspired by functional programming. It provides methods to compose and transform streams of values. It functions by using signals (RACSignal) that capture present and future values. You can observe and update values by chaining, combining and reacting to signals.

A major advantage of ReactiveCocoa is that it provides a way to deal with asynchronous behaviors, including delegate methods, callback blocks, target-action mechanisms, notifications and KVO, simply by using signals.

Basic usage

Check if the email length is greater than 0, password length greater than 8, and enable the login button if both requirements are met.

RACSignal *formValid = [RACSignal
                            combineLatest:@[
                                            self.emailField.rac_textSignal,
                                            self.passwordField.rac_textSignal
                                            ]
                            reduce:^(NSString *email, NSString *password) {
                                return @([email length] > 0 && [password length] > 8);
                            }];

    RAC(self.loginButton.enabled) = formValid;

ReactiveCocoa has grown to be quite a big piece of library, and I recommend that you check its GitHub page to see everything it can do.

Swift alternative

ReactiveCocoa v3.0 will contain a brand new Swift API. You can learn more in this great blog post written by Scott Logic.

Honorable mentions

SVProgressHUD – Clean and easy-to-use HUD intended for displaying the progress of an ongoing task
BlocksKit – Objective-C framework which facilitates the use of blocks for many iOS native classes such as UIAlertView, UIWebView, UIActionSheet, NSArray, etc.
pop – An extensible animation engine for iOS and OS X
FormatterKit – Collection of well-crafted NSFormatter subclasses for things like units of information, distance and relative time intervals
Masonry – Light-weight layout framework which wraps AutoLayout with a nicer syntax
XLForm – The most flexible and powerful iOS library to create dynamic table-view forms
IDAlertController – iOS7-safe UIAlertController
FBAnnotationClustering – An iOS library for fast and easy clustering of map notifications (here’s a nice blog post about it)

The post Top 5 iOS Libraries Every iOS Developer Should Know About appeared first on Infinum.

Becoming an iOS Developer

Vedran Burojevic — Tue, 20 May 2014 06:31:00 +0000

When I first tried out my new iPhone, I was instantly curious about how everything worked on it. To satisfy my curiosity, I started learning iOS development. Do you want to become an iOS developer? Let me give you some tips I wish I knew when I first started!

What’s the deal with iOS development? Is it easy, hard or somewhere in between? I’ve been asked lots of times how I started with iOS development and what was the learning process of becoming an iOS app developer.

My answer has always been the same – it takes time, effort and patience to get over the learning curve. But first, you’ll need some advice about required tools and learning resources necessary to become a competent iOS developer.

This tutorial is a part of our ‘Becoming a developer’ series. You can check out our previous article on Becoming a Ruby on Rails developer.

Equip yourself

Unfortunately, there is no way to develop iOS apps on Windows. You’ll need OS X for this, which means you’ll need to buy either an iMac, Mac mini or a MacBook. If you’re used to working on PCs, this might be a little bit pricey, but it’s totally worth it.

Also, you don’t have to go with a top model Mac. A machine with an Intel-based processor and the Snow Leopard version of Mac OS X will be good enough, as this is the minimal requirement for Apple’s IDE called Xcode. Newest version, Xcode 5 requires OS X 10.8 (Mountain Lion). Older Macs that don’t support Mountain Lion still support Xcode 4, but is best to have the most recent version of Xcode available. Currently, the least expensive Mac is a Mac Mini, starting at $599. Of course, you can also buy a used Mac cheaper.

Different types of Mac computers

But I don’t want to work on a Mac

You’re probably thinking, why can’t I install OS X on my PC (in a virtual machine or build a Hackintosh)? This could get you started, but there are a lot of problems that can occur and I would recommend against it. If you want to be a professional developer, the best way is to have appropriate hardware which you know is stable and will always run smoothly.

Xcode IDE

After you’ve grabbed your new, shiny Mac, the next step is to download Xcode. Xcode is the official IDE (Integrated Development Environment) for iOS, which contains a complete development environment, including:

Compiler
Interface builder
Frameworks
Simulator
Full documentation reference library

Best of all, Apple provides this SDK completely free and it’s available on the Mac App Store. Want to see how awesome Xcode is and what it contains? You can check that out here.

With Xcode installed, you’ll be able to write and compile iPhone apps. But there’s a trick. If you’re not enrolled in the iOS developer program, you’ll only be able to compile your apps for the simulator. This is great, but not enough if you want to test more complicated apps that use a camera, gyroscope or other things available only on a real iOS device.

Xcode IDE

iOS Developer Program

Once you’ve created your first iOS app, you’ll want to test it on an actual device or publish it to the App Store to reveal your masterpiece to the world (and maybe earn a few bucks in the process). That means enrolling in the iOS Developer Program (which costs $99). It also grants you access to a large number of useful developer resources in the iOS Dev Center, official Apple developer forums and beta iOS and Xcode versions.

You can enroll and become a part of iOS developers community here.

About Objective-C

iOS apps are written in the Objective-C programming language. Objective-C is an object-oriented programming language based on C. That means that Objective-C is a superset of C and it takes everything from C, but also adds some extra functionality to it, such as Smalltalk-style messaging.

Object oriented programming is a programming paradigm that allows you to divide your application code into objects that have data fields and methods. These objects then interact with each other to implement specific behavior. Object oriented programming makes it easier to develop structured and maintainable code.

Diving into Objective-C

If you start looking for a book to start with, you’ll find a lot of them. Read the reviews and choose one for yourself or, for starters, follow my suggestion – read Programming in Objective-C by Stephen Kochan.

You can also start with another great book by The Big Nerd Ranch called Objective-C Programming: The Big Nerd Ranch Guide.

Also, you can learn more about Objective-C from Apple’s official library, or try it on Code School.

Cocoa Touch

After you have a basic understanding of Objective-C, it is time to use it in an iOS programming environment. While developing iOS apps, you will use Cocoa Touch, Apple’s UI (User Interface) framework that drives iOS apps. It’s a library with frameworks and APIs, containing everything from touchable buttons, custom maps, video and audio players to device notifications.

Learn more about iOS user interface

Creating your iOS app

There are two ways you can learn iOS app development: books or video tutorials. It’s best to use both.

Regarding books, a very fine choice is iOS Programming: The Big Nerd Ranch Guide 4th Edition. The latest edition contains all the important updates built into iOS 7 and Xcode 5.

When it comes to videos, the best choice are video tutorials from Stanford University. Lucky for you, Stanford’s lectures are available online for free. This course contains everything you need to learn the basics of iOS development, and, as you follow it, you’ll write your first very own application for iPhone.

After you are finished with these, you’ll feel completely confident to write you own apps.

Don’t forget about Apple’s official documentation!

Apple takes care of its developers, so it has created a fantastic online resource containing everything you’ll need if you get stuck with something while developing your app. It contains example code and tutorials so you can start with specific technologies and aspects of iOS apps.

Learn to use the official documentation right from the start. It’s a major plus if you master using it right at the beginning. It will make things easier for you in the future when you’ll work with new things that you haven’t encountered before.

What next?

The best way to extend your knowledge is to continue creating apps. You have an idea for an app, but you don’t know how to write it right from the start? That shouldn’t worry you; you’ll learn things along the way. There is a massive amount of resources on the Internet for iOS development and I’m sure you’ll find your way.

With every problem comes a solution, and with every solution your knowledge will grow and you’ll become more confident and a more competent iOS developer. If you persist with your project and complete the app, you’ll definitely learn a lot along the way. That means you will be ready for a new, more complicated project.

Other valuable iOS resources

The post Becoming an iOS Developer appeared first on Infinum.