Stanford University.

Okay, well, welcome to CS193P, Stanford CS193P.

This is Developing Applications for iOS, winter

of 2017. Today we're going to talk a little bit about what

this class is about, and the prerequisites you need.

Then I'm, really fast, gonna go over iOS and what's in it.

And then, I'm gonna dive into a big, long demo.

And this demo is gonna really quickly let you see what it's

like to develop an application for iOS, so you can decide,

is this for me, or not? So, what are you gonna learn?

Well you're gonna learn to build cool apps, all right,

that's, that's what we're here for. Why are these apps in iOS

cool? Well for a number of reasons, okay?

One is they're in your back pocket,

you can pull them out and show your friends on your phone,

a lot of them are networked so there're kind of social

apps and a lot of that can be a lot of fun.

Also if you decide to turn your app into a product it's

really easy to get it out to customers via the app store.

You don't have to wrap it in a box and

put it on a shelf somewhere anymore. You can get it out

there real quick. And also you're going to see,

today even, it's really easy to build pretty complex

app pretty quickly. So you get a lot of instant gratification

from building iOS apps. For those of you in

computer science there's also this huge benefit, you're

gonna get to see a real life object-oriented programming

system. And not just object-oriented programming,

but we're going to use databases in this class, and

graphics, and multimedia, multi-threading, animation,

networking, all these things. And

you're going to see it in a real world environment.

So you take a lot of classes on these subjects

and sometimes you get maybe a little disconnected from

what's this like in the real world, well,

you're gonna get to see it all in action here. Prerequisites,

just boiling it down really easily. The prerequisite for

the class is object-oriented programming.

You have to know object-oriented programming,

I'm not gonna teach that in the class, I completely and

utterly assume it. And not only do you have to know it,

you have to have some experience doing it.

So that's why here at Stanford CS106 A and

B are a hard prerequisite. You have to have taken those two,

those are object-oriented programming classes. And

then I just want to make sure you have some programming

experience, so either you've done something outside

of school, or you've taken CS107 or CS108 or CS110.

CS108 is a particularly great prerequisite,

that's object-oriented programming.

So if you have a chance to take CS108 and

you haven't taken it yet, yeah, maybe taken it, and

then take this class the next time it's offered, all right?

So let's dive through what's in iOS really quickly here.

I've divided it here into four layers.

These layers are roughly close to the hardware.

And then up close to the user. So that bottom layer close to

the hardware, that's actually a Unix operating system, okay?

Just like macOS, iOS is a Unix operating system at

the bottom. None of these APIs are object oriented or

anything, they're basically C, okay? For

the Unix pretty much written in C, these API's are in C.

We're gonna do no work at that level in this class, okay?

This is an object-oriented programming only class,

so we're not gonna be doing anything there.

So there's another layer right on top of that called core

services. Sometimes people refer to this as foundation,

but there's other things in this lever, layer,

besides foundation. And this is an object oriented layer

on top of those things that were lower down. Okay, so

now you can do networking, file system, things like that,

using object oriented API. But this is still non UI layer,

right? It's still kinda closer to the hardware. So I'll

definitely be teaching you a lot of stuff at this layer,

'cause you just need it to do the things you're gonna do.

Now, there's another layer here, the media layer here I

call it. This is a huge layer, which has 3D graphics, and

audio playback and recording, image processing, video,

all that stuff. Unfortunately I'm not gonna have a lot of

time to spend here, even though it's a huge part of

what an iOS device does. iOS devices all pretty much have

iPods in them, video iPods if you wanna think about it.

And so there's a lot here. Unfortunately I can't cover it

all. Because I'm gonna spend most of my time up here,

which is the Cocoa Touch layer.

This is where buttons and text fields and things are, but

also much more powerful objects like maps.

There's an object in Cocoa Touch which is a map object,

it's pretty much the entire Maps application on

an iOS device, that you can drop right into a rectangle

in your app. With almost no work.

So, very powerful object to this layer. This is where

we're gonna spend the vast majority of our time,

building user interface apps at this layer.

That's a rough overview. Trying to explain all

of iOS in two minutes is pretty much impossible, but

that's kind of what we're doing in this class. We're

gonna use all these components to get our work done.

Top level there, Xcode 8, is gonna be...

everything we do is gonna be in Xcode 8.

The debugger, the editor, everything, building,

it's all in Xcode 8. There's a little app, Instruments,

that goes along with it, for performance and stuff, but

pretty much it's all Xcode 8. Two, I'm gonna teach you

a new programming language. So if you're computer science

people, you know that learning different programming

languages, really valuable skill.

Not because you're necessarily gonna use all of them,

some you might or might not use. But just the process of

seeing how language designers pick and choose their syntax

and, and the feature set, is really valuable.

So you'll get that I would think. It's a great language.

It was just invented in the last two or three years, so

it kind of incorporates the best of a lot of different

languages. So I'm gonna kind of blitzkrieg teach that to

you in the first couple weeks. Frameworks: That's essentially

things like the Cocoa Touch UIKit framework.

It's where all the buttons and stuff are.

Foundation is that, kind of,

mostly that core services layer.

But there's a lot of other ones like Core Data framework,

object-oriented database,

we'll be doing that in assignment five.

Also I talked about that map thing, that's in a framework

called MapKit. And there's also things in core motion,

like the accelerometer and the gyro in the device.

All those things, I'm gonna be teaching you many,

many of these frameworks as we go on. And

last, but definitely not least, and very,

very important, is the design strategy for

how to build apps, it's called MVC, model-view-controller.

How many people already know MVC, have,

have learned in a different class?

See, so maybe half of you. I will spend the first part of

Wednesday's lecture telling you about MVC and what it is.

We 100.0% have to use MVC when we develop apps for iOS.

There's really no other way to do it, if you do it any other

way, you're swimming so up stream against the current of

iOS, it's... You'll end up with a mess of an application,

okay, so we'll be going over that as well. This demo

that I'm gonna do, we're gonna build a calculator.

A calculator's great because it's got a fairly simple UI,

but it's got a little bit of guts on the inside,

the actual calculating part. So

it's just complicated enough to start showing you MVC and

a lot of language features and things like that. But not so

complicated that I can't do an entire calculator, basically,

in two lectures, okay, start to finish. All these topics up

here, you don't have to look at them now.

This is the slide to go look at after my lecture today and

say, hmm did I learn that, yeah,

I think I got that. So

it's kind of a summary of what I'm gonna do. Since I'm not

gonna get back to the slides from the end of my demo,

it's just gonna be the end of the lecture.

I'll tell you a little bit what's coming up.

On Wednesday, I'll be continuing this demo, but

not until after I give you this talk about MVC,

because what we're gonna do in the calculator is apply MVC

to it, on Wednesday. And your first

programming assignment will go out on Wednesday, which is

pretty much to replicate what I'm doing today and

on Wednesday, okay? And I'll give you a video of the demo,

so you'll see it, and you'll be able to watch it. And

then on Friday, we have an optional section.

So the Friday sections in this course,

you don't have to go to if you don't want to.

But a lot of times, they're very valuable.

Feature so if you have not used the debugger in Xcode 8

you really might wanna go to Friday's lecture.

The location and time of it will be posted on the class

forums hopefully tomorrow. I've asked for the room and

haven't quite got it yet so hopefully tomorrow. And

then don't forget next Monday is a holiday so we're not

meeting on Monday. Our next class after this Wednesday

will be next Wednesday. So let's hop into the demo...

I said we were gonna build a calculator, let me actually

show you a calculator. This is the MacOS calculator and

our calculator is gonna look very similar to this, right?

It has to display along the top, it has the keypad for

typing numbers in and it's got these operation buttons. And

then you can just multiply, times eight, you hit equals,

it does the operation,

that's pretty much what our calculator is gonna do.

It's not gonna look exactly like this. It's gonna have

a look that's a little more appropriate for a iOS device,

but it's generally this. And I promised that Xcode would be

your one-stop shop for doing all development, so

we're gonna spend our entire time here working in Xcode.

Now Xcode is an app that you just go to the Mac App Store,

and you download it. It's free.

When you first launch it, it's gonna put up this splash

screen like you see right here.

And all of your projects are going to start accumulating

here over on this right side where this gray area is. And

you can basically do three other things here. You can use

a playground, which I'll show the playgrounds on Wednesday,

it's kind of a little play area for iOS programming. You

can check a existing project out of a source control

management system which we're not gonna be doing.

Although we're probably have a Friday section

on doing a source code control. So we're gonna be

doing this option right here, create a new X code project.

And in fact, when I do demos in this course,

I almost always start from scratch.

Cuz I don't want you to have to like,

come up to speed on some code that I give you first, and

then, learn from there. So we try to start from scratch, and

see what we can do that way. So I'm gonna click on this,

to start a new app. It's asking, what kind

of app do we want to build, or what kind of project, and

here you can see, we can do Watch apps, Apple TV apps,

even Mac OS apps, but we're doing iOS, and in fact,

we're always going to choose this single view application

template. It's the simplest template, and

some of these other templates have code in there that I

actually want to show you how to write yourself instead of

having the template just make that code appear, all right?

So we're gonna do single view application.

Now it wants some particulars on our application,

most importantly at the top its name. Well,