Shape Shape point chapter-list Group Group Group Group Group Shape Copy 12 Shape Shape Copy 3 Shape Shape dropdown editor editor Combined Shape grid Shape Copy 4 Shape Copy 7 Shape language language Shape megaphone paperback Shape platform noun_419259-2 copy play-icon BS-Question-Rounded-Circle quotes noun_610406 stacked-books-1 stacked-books-2 Group Group Group Group Group Group Group Group Group Path

iOS Apprentice

$59.99 3.8/5 12 reviews · Write a Review
  • Platform iOS 13
  • Language Swift 5.1
  • Editor Xcode 11

In this iOS programming book for beginners, you'll learn how to build five complete iOS and Swift apps by following easy step-by-step tutorials.

Over 10,000 copies sold!

Developer Guide

Beginner

For Beginner Developers

For Complete Beginners!

If you’re completely new to Swift and iOS development (or need a brush-up), this is the series for you.

The iOS Apprentice is a series of epic-length tutorials for beginners where you’ll learn how to build four complete apps from scratch.

Each new app will be a little more advanced than the one before, and together they cover everything you need to know to make your own apps. By the end of the series you’ll be experienced enough to turn your ideas into real apps that you can sell on the App Store.

These tutorials have easy to follow step-by-step instructions, and consist of more than 1,100 pages and 500 illustrations! You also get full source code, image files, and other resources you can re-use for your own projects.

If you’re new to iOS and Swift, or to programming in general, learning how to write an app can seem incredibly overwhelming.

That’s why you need a guide that:

  • Shows you how to write an app step-by-step
  • With tons of illustrations and screenshots to make everything clear
  • In a fun and easygoing manner!

We’ll start at the very beginning. The first tutorial assumes absolutely zero programming knowledge but still shows you how to build an entire game from scratch.

The iOS Apprentice series doesn’t cover every single feature of iOS – it just focuses on the absolutely essential ones that you need to know.

Instead of just covering a list of features, the iOS Apprentice series does something much more important: it explains how all the different building blocks fit together and what is involved in building real apps.

You’re not going to create quick example programs that demonstrate how to accomplish a single feature. Instead, you’ll develop complete, fully-formed apps that are good enough to submit to the App Store!

Want to try a sample for free?

Sign up for the raywenderlich.com newsletter and you’ll receive the entire first section of the book to try out:

https://www.raywenderlich.com/newsletter

Table of Contents

Section I: Getting Started with SwiftUI

1.

Introduction

In this book, you're about to deep dive into the latest and greatest Swift and iOS best practices. Throughout this five-section book, you will build four iOS projects using both UIKit and SwiftUI. Good luck!

2.

The One-Button App

Take the first step of building a SwiftUI game by creating your iOS project, add some interactivity with a UIButton and learn all about the anatomy of an app.

3.

Slider & Labels

Bullseye is all about the slider, get sliding in this chapter by using the Slider control and learn all about different Swift data types.

4.

A Basic Working Game

In this chapter, you'll be well on your way to a working game. Learn all about generating random numbers and how best to improve your code afterward.

5.

Rounds & Score

A fully working Game: It's all about winning; in this chapter learn how best to score each game and introduce one more round functionality.

6.

Refactoring

At this point, you have created a fully functional game, wow! It's time to take a step back and look at best practices in the industry. It's time to clean up some code and make it more readable for the future!

7.

The New Look

Apps are known for their clean and simple UI. We will spice up the artwork in this chapter and make it look like a *real* game. We will also make improvements to landscape orientation.

8.

The Final App

To finish our game we will add some animations, an icon, and display name ready for the App Store!

Section II: Checklists

9.

List Views

It's time to start your next iOS project. Are you ready for the challenge? In this chapter, we will commence our next app using SwiftUI, Checklists. Prepare for NavigationView, Arrays, Loops and removing items from the list.

10.

A "Checkable" List

A Checklist app without being able to tick off the items? In this chapter, you will add the toggle for a Checklist item.

11.

The App Structure

You have eagerly made great progress on creating a TODO list app by adding the checked status. In this chapter, you will start adding more features and start thinking about iOS design patterns.

12.

Adding Items to the List

Your goal in this chapter is to start adding new items to your TODO list app. It also included learning about CRUD (Create, report, update and delete).

13.

Editing Checklist Items

Congratulations! You can now add new items to your TODO list app, in this chapter, it's time to start editing your list and changing the text.

14.

Saving & Loading

In this final chapter for your TODO list app, you will learn about data persistence. Right now all the items are hardcoded so it's time to persist and go!

Section III: Getting Started with UIkit

15.

UIKit & The One-Button App

You've built two apps using SwiftUI, yay!. In this chapter, you will start building Bullseye using UIKit, Apple's existing way of building UI for iOS apps.

16.

Sliders & Labels

Congratulations, you have a UIButton on the screen. It's time to start adding the UISlider which will be fundamental to the game.

17.

Outlets

You'll be well on your way of noticing the differences between building an app using SwiftUI and now UIKit. In this chapter you will deal with random numbers, adding rounds to the game and calculating the points scored.

18.

Polish

In this chapter, we will add some UIKit polish to the app and show an alert to the user.

19.

The New Look

Bullseye is looking great! The gameplay is now complete but it's time to make it look pretty. In this chapter, we will add some graphics and create an about screen to display the rules of the game.

20.

TableView

TableViews are fundamental in the UIKit toolbox. In this chapter, you will learn about data sources, delegates, and general TableView best practices. Be sure to take this knowledge in your future iOS career.

21.

The Data Model

A TableView is no good without real data. It's time to create the data model that will hold the high score data.

22.

Navigation Controllers

UINavigationControllers are super important in an iOS app. In this chapter, you will learn about adding a NavigationController, which will help present the high scores view. You will also add the functionality to delete rows from the TableView.

23.

Edit High Score Screen

Now that you have the navigation flow sorted, it's time to implement the edit high score functionality. In this chapter, we will add a static TableViewCell and read the contents from the UITextField.

24.

Delegates & Protocols

You now have an edit high score screen but how do we get this data back to the high score screen? In this chapter, you will learn about Delegates and how best to use them.

25.

The Final App

Phew! You have successfully created Bullseye using UIKit. In this final chapter of this section you will learn about supporting different device sizes and add some beautiful animations.

Section IV: My Locations

26.

Swift Review

You have made great progress. You have built your first app using UIKit which is some achievement. Whilst we have been writing the apps using Swift, you will need some additional theory to level up your knowledge. In this chapter, we will go into details about some of the Swift language, such as Variables, Constants, Types, Methods & Functions, Loops, and Objects.

27.

Get Location Data

Are you ready for the final app challenge? In this chapter, you will commence the final app MyLocations. It's all about using the Core Location framework and displaying using MapKit.

28.

Use Location Data

You've learned about getting GPS coordinate information. Now it's time to deal with GPS errors, improving GPS results and testing on real devices to mimic real-world scenarios.

29.

Objects vs. Classes

This question will most likely crop up in your next iOS interview. It's time to put the toolbox down and learn some theory. Expect to learn about classes, inheritance, overriding methods and casting an object.

30.

The Tag Location Screen

n this chapter, you will be picking up the toolbox again and building our tag location screen. This involves building out some TableViewCells, displaying location info and adding a category picker.

31.

Adding Polish

Who doesn't love adding a bit of polish? It's time to start making it look more like an app ready for the App Store. We will improve the experience of the app and add a loading 'HUD'.

32.

Saving Locations

At this point, you have an app that obtains GPS coordinates and allows the user to tag the location. We're going to be deep-diving into Core Data, the object persistence framework for iOS apps.

33.

The Locations Tab

Now that you can persist the data to Core Data, we're going to explore displaying this data in the TableView. Learn about TableView sections, NSFetchedResults and add functionality to delete tagged locations.

34.

Maps

Showing a list of locations is great, but not very visually appealing. In this chapter, you will learn about MapKit, the awesome map view control giving in the iOS toolbox.

35.

Image Picker

UIKit comes with a built-in view controller, UIImagePickerController that lets users take new photos or select existing ones. In this chapter explore this controller and how best to display the image on the screen.

36.

Polishing the App

ou have made it this far! It's time to give MyLocations a complete makeover. Prepare your pixel paintbrush for this chapter and let's get your creative flair at the ready. In this chapter you will cover the map screen improvements by adding icons, polishing the main screen and adding some cool effects to the app.

Section V: Store Search

37.

Search Bar

One of the most common tasks for mobile apps is to talk to a server. In this final UIKit app you will build StoreSearch. In this chapter, you will build the first screens, add fake searches and create the data models.

38.

Custom Table Cells

Before your app can search the iTunes store for real, we need to make the app look visually appealing. In this chapter, you will cover custom table view cells and nibs. Learn a little more about using git and the debugger right inside Xcode.

39.

Networking

Networking you say? Start querying the iTunes web service by using HTTP requests. An introduction to JSON and best to convert them into data models and finally look at how best to sort results.

40.

Asynchronous Networking

Phew! You will rarely want to block the main thread with a network request. In this chapter, we will explore asynchronous networking and finally showing an activity indicated to let the user know something is loading.

41.

URLSession

The iOS toolbox and the Swift language has many tools for our disposal, including URLSession. In this chapter, we will explore URLSession and it's many benefits. Downloading the iTunes artwork and how best to merge your git changes.

42.

The Detail Pop-Up

In this chapter, we will create a detail pop-up view when a user taps a row in the TableView. We don't want to display too much information now, do we?

43.

Polish the Pop-Up

We're about to get the polish back out again. The detail pop-up view is working well but we can display the information better. Learn about dynamic types, gradients for the background and let's explore adding some more animations.

44.

Landscape

Users expect apps to work in both portrait and landscape. They also expect the app to look great in both orientations. In this chapter, we will learn about adding a completely different user interface for landscape vs. portrait.

45.

Refactoring

The final app is looking great. You should put your feet up and grab a coffee! Programming is all about building new pretty features but when you join an existing company with an existing code-base you have to learn about the best ways to refactor existing code. Let's go!

46.

Internationalization

So far our app works great in English. But if you want your app to go international you must support multiple languages and formats. In this chapter, you will explore adding support for a new language and look at regional settings.

47.

The iPad

Even though the app works _OK_ on the iPad, but it's not exactly optimized for the iPad. In this chapter, we're going to explore universal apps, the split view controller functionality, and dark mode support.

48.

Distributing the App

Are you ready to ship to the App Store? Finally, you will learn the key fundamentals on how to ship the app to the App Store, including the Apple Developer Program, beta testing using TestFlight and finally submitting to the App Store.

Meet the Team

Average Rating

3.8 /5

Leave a review for this product

12 reviews

iOS Apprentice

In this iOS programming book for beginners, you'll learn how to build five complete iOS and Swift apps by following easy step-by-step tutorials.

Over 10,000 copies sold!

Top