Learning iOS: Create your own app with Objective-C! by Tianyu Liu

Learning iOS: Create your own app with Objective-C! by Tianyu Liu


>>TIANYU LIU: Hey, how’s
it going everyone? And this is the iOS App
programming of objective c seminar. And my name is Tianyu Liu. I’m a Lowell junior right now,
concentrating in computer science. So in this seminar I’m
going to teach you guys a little bit about how to make an app. Yay, get excited for it.>>So before we even start diving
into the actual programming side, let’s just really quickly talk about
why might you want to build an iOS app? Why is iOS so awesome? So the first problem, the first
thing that is pretty awesome for us, especially as a CS50
student, is that iOS uses Objective C. Well, there’s
a new language called Swift, but we’re not going to
use that in this seminar. If you’re interested in Swift, there
is an independent seminar about that. But Objective C is basically
a superset of C. Meaning that everything you use in C can
be translated into Objective C very easily.>>As you might see later, that indeed
there are some very basic syntax, are basically exactly the same,
C and Objective C. So, since you have taken CS50
up this far, you already know Objective C, at least 40%. Also, Apple has a really
robust API for iOS. There are a lot of really crazy
things you can do with it. One of which is someone
actually created an iOS app for controlling cars, which
is pretty interesting. Probably a helicopter is more exciting. But that’s how powerful
the iOS API can be.>>And as you might have
figured out right now, the stack overflow is probably one of
the most important online resources available to you. And good news, for every
single problem you can possibly think of while building your
final project in Objective C, there is likely a stack overflow answer. It’s just awesome. In addition to that,
iOS is really a platform where you can reach a huge
audience with little effort. It’s not like Android, where
everything’s pretty fragmented.>>Everything iOS is unified. And as long as you create
an app for an iPhone, you can very easily port that to iPad,
iPad mini, or different iPhone sizes. These are all really convenient. And it’s just really good
for impressing your friends. You can just hold an iPhone
and tell your friend hey, this is the app I make. You can do that for any
desktop apps, which is nice.>>All right, now let’s actually get
into the language Objective C. So why don’t we start with
some really basic syntax. As I mentioned before Objective
C It’s basically a superset of C. So a lot of basic syntax are
actually exactly the same. Declaring a variable and
adding two variables together is exactly as we have done in Mario. Nothing new here.>>Similarly, the lodger for loop
and condition is also the same. You can do a for loop just as you
have did in a Mario [INAUDIBLE]. And you can do conditions
just as what you have been doing in your previous p sets. However, Objective C
is not completely C, and there is something that
is kind of weird about it.>>The first one being that when you are
doing C programming, you typically call include and then a library name. But in Objective C you call that import. Basically saying functionality,
just different names. And the strings are
actually a little bit weird. You can see that the first
thing that is kind of weird is that you have a pretty weird–
sorry– you have a pretty weird NS sign over here. And the second thing
that’s kind of weird is you have an at sign before
actually declaring the string. So the at sign basically signifies
that a string is not only a string, it is actually an object. We’re going to explain
that later so don’t panic if you don’t
understand what that means. And printing to console is a little bit
different because in C we call printf, but in Objective C we call [INAUDIBLE].>>You might be wondering what is that. That is basically printf,
just a different language. Exactly the same usage,
exactly the same functionality. Well it turns out that
Objective C actually has an ns prefix in almost
everything, every basic data type, nsstring, nsarray, nsdictionary. The reason being that ns
actually stands for Next Step, which is a company that
Steve Jobs has founded, which is a company where the
language Objective C is born. So this is basically tradition. I know it’s a little bit
weird, but it’s Apple.>>So something that is even weirder
than that is a function declaration. This is very different from what we
see in C, because here it actually doesn’t look like C anymore. What you have here– by the
way this is not a bullet point, this is a minus sign. You have a minus sign parenthesis
void and then the function name. Let’s just say if we
have hello world, then the return type would be void
because we return nothing.>>What gets really weird
is that when you’re having more than one parameter
passing into a same function that will be really weird as shown here. We have a method name,
called addInt to [INAUDIBLE] and we’re passing one parameter. But after that, we have
more method name call with. And after with we’re passing
the second parameter. This is actually a little bit weird,
but all these function declarations follow the same pattern as this.>>We have a minus sign to begin with. The minus sign could be a plus sign
sometimes based on what kind of method is it. Method is basically
another name for function. And we’re going to
explain that later when we’re talking about object
oriented programming. You first specify the return
type inside parentheses, after which comes the method name. You’re passing one parameter. And if you have more parameters
you need to extend the method name and basically write something more here.>>It could be anything you want. In our case it’s with. But you could say end, or or, or
abc full bar, whatever you want. And then after that you’re
passing parameter b. This is a really weird
convention but we are going to see why Apple wanted
to do that very quickly. So how do you call function? Calling a function in Objective
C is also different from C.>>Actually, calling a
function in Objective C is more like you’re talking to someone. Here we have self, which
is called an object. You’re basically telling the
object self to say “Hello World!” That is how to call the function. An object and a method name
combined with each other. And this is where the weird extension
for method name really comes into play.>>Let’s look at the second example. We just defined a method called
addInt with blah blah blah. So in this case when you are calling
that specific [? message ?] it’s going to look like self addInt:10 with:2. It sounds like English. Although the function
function declaration is weird, the point of Objective C’s
method declaration pattern, is that when you are calling
the function or method it will sound like actual English. So it’s very intuitive
once you get into it.>>Especially in this case,
where you can basically see that the function name is
sort of documenting itself. You don’t need any
more explanation to see what exactly is happening, what
exactly one parameter doing. Going beyond that, let’s talk a little
bit about object oriented programming. Object oriented programming is
one of the fundamental programming techniques or patterns that is
used by Objective C. Objective C is called Objective C, not
C, for a really good reason.>>So before we get into
Objective C syntax, Let’s really quickly look at
what exactly is an object. We’ve probably done something
like object before, which is called the struct when you are
implementing a tree or a linked list or [? try. ?] So, it’s
basically like a struct, but it’s much more powerful than that. An object has methods and properties. Methods are basically functions. Basically functions that a
specific to a certain object.>>And properties are basically the
field you specify in the struct. So for every single object
we have some property that has some variables which
are specific to the object. And we have some functions which
are also specific to the object. And the functions are called methods
and the variables are called properties. It’s just a fancy name. While you fact, every single view
you see while you open an iOS app, let’s just say Twitter or Facebook,
every single view you see is an object. And even the entire app is
an object to start with. Very interesting concept.>>And why do we want object
oriented programming? So you can imagine that when you
program it gets pretty complicated. Let’s just say when you’re
implementing chessboard, the logic is going to
be really complicated. You have 36 different
pieces, so that if you want to write logic for all
36 different pieces in chess, that’s going to be a lot of
different functions and variables. It’s a lot of trouble. And probably you’re going to write a
different method or different function for each of the piece to
exactly control what they do.>>But if you do object oriented
programming, all of these pieces can be abstracted into
one single object. And the object will have some common
properties, like what kind of piece is it? What color is it? How can it move? And in that way you have greatly
simplified the logic of it. So it’s just a really good way
to make complicated programs, and hierarchical relationship
within the program, very simple. As we’re going to see
why very quickly when we’re actually doing
programming– when we’re actually doing an S code
programming session later.>>Well in addition to that,
object oriented programming is just a lot of fun. You got to design your own object. You got to design what does
it look like by yourself. There is no right answer to it. And it’s totally interesting. So in object oriented programming,
two fundamental concepts will be class and instance. A class is basically
a template for object. And an instance is basically
one specific object.>>Let’s just say you’re making a cookie. In this case, every single
cookie you actually end up with is going to be an object. But the cookie plate you use to bake
all the cookies will be a class. A class is basically a template. And the instance will be one specific
object created out of that class.>>And an instance will be created
based on class declaration, as we will see in later slides. So let’s actually do a really
quick example [INAUDIBLE]. Let’s say we’re declaring
an object for a cat. The object should have–
the cat class should have some properties and methods. What kind of properties should the
class have– should the cat have?>>For instance, color,
age and breed, those will be variables that
are specific to each cat. And those are some things
that we use to describe a cat. What kind of method,
or what can a cat do? Some quick examples would be chase
mouse, eat fish or just meow. This is a really quick
example of cat class. And a really specific
cat object will be a cat where we specify the
color, the age and breed.>>In that case, our object is
no longer a class anymore. We copy the template from the class and
we specify each specific information to that specific object
to make it independent. And when you are calling
a method inside an object, you just call meow on the object,
which is the cat you just created.>>Probably you will print out
something like “Hello World! Meow.” Pretty cute. All right, let’s just
get into some details and see what exactly does that
translate into being iOS programming. So in iOS programming every single
class will be implemented in two files. One file is here, which
is called the interface. Another file is here, which
is called implementation.>>Typically the interface
will have extension.h as we have seen in C libraries. And implementation file is
going to have extension.n. It’s kind of weird. But .n means actually .c, there is no
fundamental difference between those two. So in this case, we can see that we’re
declaring interface, Cat : object. That is called inheritance. We’re basically inheriting the
cat class from the object class. So every property and method that was
previously defined in the object class will be automatically defined
in a cat class as well.>>In addition to that, we define color,
breed, and age, three variables. That actually looks like
something you have done before. It looks like struct. That is basically the syntax
for struct declaration, and that is totally correct. And since I mentioned before,
the difference a struct and an object, one of the
fundamental differences is that an object has method,
while a struct only has variables. So in addition to the properties or
variables we’ve created for the object, we specify some method.>>Let’s just say here we have
two methods, one is meow, another one is chase mouse. We probably want to be passing a
parameter based on our previous method declaration pattern. You probably want to be passing a mouse. And you’ll probably want
to return a bool signifying if your cat has successfully
caught the mouse or not.>>This is the interface, but we can
see that the interface actually doesn’t do anything. It just tells a program what exists–
what exists in the cat class. So in order for the
program to do something, we need to have implementation files. So here, the first thing we do is
obviously we import the interface. After we import the interface,
we define the method.>>Let’s just say here meow
would just print out “Hello World!” to the console. And after the implementation
file, we’re pretty much done. This is basically a class
declaration for one class. So now the question becomes,
how do you declare a variable? The way you use a class to create an
object in Objective C is written here.>>You first specify that
this is a cat pointer, because every object in Objective C
is finally implemented as a pointer. And you call the class, call them
as alloc, which is basically malloc, telling the operating system that you
need some memory space for this object. After that you have an object
already and you just initialize it. This is just convention. I know it’s is a little bit weird, but
this is actually how Apple does stuff.>>Assigning properties is
actually pretty straightforward. It’s very similar to
what you’re doing when you’re assigning some specific
field inside of struct. You just have the variable
name, the property name, and assign a specific value to it. And calling a method is very similar. The calling a method is
basically what I talk about for calling any method in Objective C.>>You’re passing an object, in
this case it’s going to be myCat, and you’re passing the method name. As if you’re talking to the object,
myCat, that you should meow. It’s pretty interesting. After that, there is one
more essential design pattern that we need to talk about
before getting to actual S code. That design pattern is called
event driven programming. This is also probably one of the most
fundamental ideas in iOS programming.>>So you probably don’t know what exactly
is the event driven programming, but it’s not really that scary. Well in fact, you have
already done that before. This is one of the lines you’ve probably
already written in the last [INAUDIBLE] of CS50,
google.maps.event.addListener(marker, “click”, function(){}):. By calling this line you are
essentially telling the computer that whenever the event called
“click” happens on the marker, use that function. >>This is very different from
what you do in mario.c. In mario.c you just run the program
once, it gives you an output, and you’re done. These are sort of like
one shot programs. Event driven programs
are very, very different. Let’s imagine, if Facebook is a one
shot program it’s not really good. You just go to Facebook
once and it’s done. It gives you some output
and you never got it back. You never got anything more.>>So here, especially
the pattern we use is event driven, so that
every function will be caught based on what
event has happened. For instance, if we have
a button and we specify that whenever that button is clicked,
call the function called “Hello World!” In that way we can really
manage the function logic flow in a highly flexible way. The user can do or call a function
that has already been called. It’s completely based on what users do.>>So we can see that this is
actually much better than mario.c. And good news is that it’s
actually not a new concept. You guys have already done
that in the last problem set. So in Objective C there are
three different diagrams for event driven programming. The first diagram is
called target action, where you bind a button
press with some function. Let’s just say, whenever you click
some button, you call some function. This is very simple target action.>>The second one is
actually the hardest one, it’s called delegation on protocol. We’re going to explain
that in great detail later. And the third way is notification. This is actually not
very important as far as we’re concerned, because the chance
that you’re going to use notification in your final project is pretty low. So we’re going to skip that part.>>And we’re going to dive
into delegation on protocol. So what exactly is a protocol? Or what exactly is a delegation? Let’s talk about protocol to start with. Protocols are nothing but events. But these events are given to
you by Apple to start with. For instance, I’m not
completely sure how many of you guys use Apple’s original
app mail or contact, but every time you scroll the
table and press the specific cell on the table, that is an event.>>And if you want to do
that event by yourself, it’s actually a little bit hard. So Apple has given that even to you
so that you can just directly use the event to do something on your own. Protocols are actually
really, really widely used in Objective C. Well in
fact, every single app has something caught app delegate. Inside of delicate is all of the
protocols for loading the app.>>Let’s just say there is
an event for app did load. So what should happen after you’ve
created an app, after you open the app, after you close the app, or after
you put the iPhone to sleep. These are all events that has
already been given to you. And originally inside these particles
there will be no implementation. Apple just told you that this function
will happen when some event happens, but what you do with that
function is completely up to you.>>Delegation is basically
telling the class that you should handle these protocols. It’s a little bit
confusing, but it will be much clearer when we do
the s codes in action. Delegation on protocol is actually a
highly robust mechanism in the sense that if we do delegation
to a specific class, we can essentially handle
all kinds of events using any class we have,
very convenient tool.>>So one quick example for
delegation on protocol will be what I just talked about. This protocol specifically is called
tableview [INAUDIBLE] select role at [? index ?] [? past. ?] So this an
event that would be caught when you actually tap on a specific
cell in your tableview, let’s just say in your mail
or in your contacts app.>>Inside a function there was
originally doing nothing. The function doesn’t
do anything by default. But you can specify
what the function does, given what you want out of your app. Very convenient tool. And with all that
being said, I basically cover some very basic syntax and
fundamental concept for Objective C programming, and we can do some s code. Much more exciting. So s code is actually a
little bit overwhelming when you open it for the first time.>>One quick note, so if you
want to do iOS development, I highly recommend you have a Mac. Because doing iOS development on
Windows is really, really hard. It’s doable, but it’s really hard. And you definitely do
not want to use g edit. So in s code we have
several different areas. When you first open up s code
you will see a navigation area, which basically shows you all the
files that is in your current project.>>You have a toolbar area, which
is basically managing views, or some little quick
tools about s code itself. And this is the actual editor area. This area is very similar g edit,
but much better than g edit. And in this right area, is
called the utility area. The area becomes really handy when
you’re creating interface or specifying some quick setups for your app.>>And the final area is the debugging. This area contains the console. So whenever you say printf,
or nslog in our case, all your results are
going to be printed here. All right? I guess we can really quickly do
an example for iOS programming. And let’s actually open up s code. So every time you open up s code, it’s
going to show up something like that. It’s going to ask you
what do you want to do? Do you want to start something
random, a playground, basically you can just test code without
actually committing to any app.>>Do you want to create a new project? Or do you want to continue
working on the existing project? In our case we’re going
to create a new project. So it’s really nice, s
code actually has already given you some templates
for creating objects. If you want to do a game, s code
actually has a game template for you, has page based applications,
tab based application. In this case, we’re going
to do something very simple, and we’re going to use a
single view application.>>After that just what you want to call
your product, and what’s your name, what’s your identifier, and
what language do you use. Here we do not want to
check using Core Data. Core Data is basically a databasing iOS. If you do Core Data, s
code is going to define a lot more complicated classes for you. So to keep everything simple, we’re
just going to do without Core Data right now.>>The problem we’re going to be
using is that– the problem we’re going to be creating is that we
basically want to import Mario from C to an iOS app. So let’s call that Mario-iOS. Of course you specify what you
want to put in your project. And there we go.>>So this is a little bit
overwhelming, but this is actually what we just saw on the slides. And the first area we see right now
is basically project configuration. So everything you want to do
project, what kind of device, let’s just say what kind of device
do you want your app to appear on? Is it iPhone, iPad or universal? So device orientation, all this stuff. Not very important,
but could be, but this is a place where you set up
your project if you actually want to deploy to the Apple store.>>All right, let’s look at
something that is inside our code. Let’s go through the file navigator. And these are all the files that already
came with the template, very nice. So when we click one of them
this is what it looks like. Very similar to g edit. But you can see that the
syntax highlighting is probably a little bit nicer. And it’s actually much more
powerful than g editing. And you can auto complete
a lot of things for you, as we will see very quickly.>>Let’s open the debugging area as well. All right, as we can see,
the console is right here. This is what you’re going to see where
you’re in printf or nsloging something. So without further ado, let’s actually
compile the app and see what happens. One essential feature for
s code, is that s code comes with an iPhone simulator. So you don’t need to have an
iPhone to try your project, s code can simulate that for
you, as we can see right now.>>It’s pretty nice. It’s taking a little
bit of time to compile and basically we have
an empty application, which actually does nothing. But it compiles. It’s pretty awesome. It’s much better than C, huh? All right, then let’s
try to add something. One file that is a little bit
weird here is called storyboard. This is actually a great,
awesome feature for s code. Because in s code, you can actually drag
and drop elements onto the interface and it will directly show up. Let’s try that. >>We drop a label here, “Hello World!!!” We can center that. Pretty cool. Now let’s run this stop simulation. Here we have “Hello World!!!” We didn’t even do any coding yet. What the heck is happening? This is how powerful
Interface Builder can be. Somebody even said that
you can probably just complete an app without writing
probably a thousand lines of code just by using the Interface Builder. But it’s probably not
the best way to do it.>>Now let’s actually get down to coding. So the structure for the file
is actually really interesting because, as you may see, there
is no main function anywhere. See? As we mentioned before,
you can see that this is an implementation file
for a specific class. But there is no main anywhere. So where is main? Actually, there is a main, but the
main is actually hidden from you. The main is here. That looks familiar.>>So basically what iOS
is doing inside main is that whenever main is
called, which is basically whenever the app is executed, it
creates a object called AppDelegate. As I mentioned before, the entire
app is actually an object by itself. So in this way, basically the
iOS app is telling the compiler that OK, I’m going to create
a product called AppDelegate, and that is going to be my app. So you need to go
through that AppDelegate and see what that guy’s doing. My job is done for me.>>And in AppDelegate you can see that
there are some really weird functions, well actually methods, that
Apple has already given you. What are these? These are actually just protocols
that I was talking about. So these are events that Apple
has given you to start with. There is nothing in some
of the functions right now, but if we want to initialize
something for our app before getting into displaying
any view, we do that here.>>You can just read the name and I guess
the event is actually really clear. So now main has created
an object for AppDelegate. And what AppDelegate is going to do
is actually also hidden from you. The AppDelegate is going to start
loading the ViewController stock. So it’s basically going to start
loading up all the views that you have and just render the view
based on the hierarchy.>>So in this case we only have
one view, which is here. So that is the only view
that’s going to be called. The ViewController logic is right here. This is the code that actually
controls the view we just saw. All right, let’s do something here. So viewDidLoad sounds like an event,
when in fact this is also a delegate, this is also a protocol.>>So whatever the view is loaded,
everything inside the function will be called. In this case we should see “Hello
Tianyu!” if we run the program. It’s getting a little bit slow
compiling storyboard files. Well indeed, we do see an output for it. It’s pretty cool. Now let’s actually do Mario. I’m going to define the
function very quickly. marioWithLevels: (int)level results. >>All right, this is actually the awesome
feature of s code auto completion. So when you write for and type enter,
it has already given up the template for you, which is pretty cool. That should look really
familiar to you guys. Sorry, that’s my fault. All right, cool. That logic should look really familiar
to you guys, especially just Mario.>>But we will now print out to
the console every single time, because we want to somehow keep
track of what we are printing. We’re going to use the
results somehow later, to display the print
out result to the user. So instead we’re just
nslogging everything, which we’re storing everything
into a function call result, but the logic is exactly the same. After we finish it, we
just print our results. >>And here instead of printing out my
name, we’re going to call a function. Let’s see what happens. Oops, obviously. We do have a nice
little pyramid out here. This is basically C, we’re just
manipulating where you call a function and how does a function look like. There’s nothing different. But this is actually
not very exciting here, because we’re not seeing
anything from the iPhone app.>>So if you actually have an iPhone app–
if you actually have Mario iOS right now, you’re not going
to see anything that has anything to do with Mario because
all those outputs into a console are hidden from a user. This is what you see,
which is “Hello World!!!” Not good. Now let’s try to make the user see
what exactly we’re printing out. So we don’t need to label anymore. Let’s try and figure out something
else that could be useful.>>There is actually one
element that is called text field, which could
be very helpful to us. It basically displays a region
of text that can be edited. So that looks really helpful. Now let’s drag it and drop it. Wow, we have a text view
in our view, really fancy. That’s a little bit too big. Let’s make it smaller. Put it into center. Make it smaller as well.>>Now we have a text view, which we could
be used to display our final result. But right now it’s
definitely not going to work because there is no– the
ViewController we just defined doesn’t know that
there is a text view out there. So we need to somehow
link the text view we just created with the class that
has already come with us.>>The way we do that is
actually really magical. So open up storyboard. There is a special [INAUDIBLE]
called [? assistant ?] [INAUDIBLE]. When you click that, it’s
going to open two files. One is a class and the other one
is a corresponding view for it. It’s very, very helpful. And let’s just goes through the .h file. Control, this is [INAUDIBLE] logic. Press Control and drag the
text view into the declaration. We’re going to call that outputView. Connect. So here we have declared a new
property for our ViewController class. And the new property
is just the text view we’ve created in the interface building. So in that way we could
access all the data and manipulate everything that is inside
the output view, which is awesome.>>So in our actual code,
let’s do something with it. So this time when we are like printing
out the final result for Mario, we’re in not logging anything. I mean we could keep
the logging statement. In addition to that, we
send the readout we just created to the output view, which
is a UI textview we just created. Now let’s see what happens. Wow. We have a pyramid in the app right now.>>So the user can see our output because
we have copied the output from our code to our interface. It’s pretty good. It’s actually not that
exciting because we can– All the app is doing is
showing a pyramid to you, and there’s nothing you can do about it. It’s not particularly exciting. So now let’s make a button
that will clear the views. Seems that a button will be helpful. Drag and drop. Button one. Button two. >>So when we click the left
button, the view should clear. There should be nothing on the screen. And when we click the
right button, Mario, the view is going to appear again. So this way we also do the
magic stuff, control and drag to the class declaration
in the assistant director– in the assistant viewer. In this case we are specifying
that that should be an action. clearMario. >>So here we have already created
an action called clearMario, which is the method that would be called
whenever we press the button clear. So in our actually code, let’s just
put the output text and the output view into nothing, and that way
it will appear to be clear. In addition to that, let’s create
another method called runMario. Oh sorry, that should not be a property. All right, that should
be an action as well. >>And when that function is
called, we just run Mario ten. Hopefully that will be fine. Does it compile? Yes. Now we have a view. We have an output. And let’s just see what happens. That’s gone. It’s back again. So here we have specified
what kind of function will be called when
we type in something, when we press a specific button. This is basically the
target action scheme for event driven
programming in Objective C.>>In addition to that,
it’s not very exciting because we can’t really change
how high the pyramid will be, so we probably want to somehow
get an input from the user and change the height of the
pyramid based on what they output. So we’re going to do that. So this time when we call runMario,
we do not just call Mario directly. This one’s title. >>Delegate. This is very interesting. What is a delegate? I’m going to put self here. And we’re going to see
what that means later. So here we have basically created a
specific instance called a UI alert view. A UI alert view is
basically what you will see every time something pops
up and asks you for input, like what will happen when you’re trying
to purchase something on an app store.>>In addition to that, after you
create it, we just show the alert. All right, let’s just quickly
test will that work or not. That’s very cool. Now let’s actually create an
input field for the UI alert. This is how we do that. And we should have an
input view for the alert. Very cool. Let’s just say 10.>>It’s not doing anything right
now because the call actually didn’t change for executing mario. So this has become a little
bit weird because whenever we press a button down, whenever we
press a button in the alert view, something should happen,
but it doesn’t happen. How do we catch that? How do we know that a user
has dismissed an alert view and already entered a number, because
right now nothing’s actually happening.>>Well, you might have guessed
it right, delegation. So in addition to all
these declarations, we need to add a new delegation to
it called UI alert view delegate. So that every single
interaction or event that we’re going to have
with the UI alert view is going to be handled
by our class as well.>>So in addition to that, will be
alert view click button at index. This is reached. So in that case we have
already– so we have found out a protocol that
will handle the event when we click the Done button
on the alert view. So every time we dismiss the
alert view, this should happen. Let me just test it very quickly. Well indeed, we have reached here.>>So here, what we won’t
actually get is actually get the– So we want to get out
the text that we have previously entered in the alert view. And based on text, we’re
going to display Mario. This very quickly turns out
if it actually works or not. So in that case, if we input,
let’s say, 10, we should see 10. >>Very good, we do have a number here. It’s pretty good. Now the last step will be– So the
last step we need to do right now is just a call Mario with
level based on the input that we have put into alert view. So we need to convert
this string into iOS. Static overflow is very awesome. And then we just call self
marioWithLevels value. Let’s see will that
actually work or not. >>We’re already given a pyramid. Let’s try to change the height. That actually works. It’s pretty cool. So that now you can just
input any value you want. Let’s just say four. That’s pretty awesome. So this is basically
a really quick example for how to create a project in s code
and how to really quickly wire up some really simple events and functions.>>So the source is going
to be put online later. So if you’re interested
in how iOS Mario works, I’m going to put exactly the same
projects onto the CS50 website later. We’re basically done with the
summer, and before we finish I just want to point you guys to
some really awesome resources that are available online.>>Obviously the Apple documentation
is going to be very helpful. But in addition to that, I especially
recommend four sources, code school, tree house, AppCoda and WWDC videos. Code school and tree house are
two online educating websites, which specifically focus
on software engineering. Especially for code school, they
have really good tutorial on iOS.>>That is a really quick example for it. They actually create a really cute–
look at that little cute iPhone dude over there, it’s pretty awesome. And the way they explain Objective
C syntax is perfectly clear. Tree house is the same. And AppCoda is a forum. It’s actually a blog that was run
by a really experienced Objective C programmer. And all those tutorials in AppCoda are
pretty short and easy to implement, highly recommended.>>And if you’re a developer,
definitely go check how the WWDC videos where you can
learn about the latest iOS programming techniques, APIs and libraries. So that is pretty much
it for the seminar. Thank you so much. And I hope you have fun
creating your own iOS app.

Leave a Reply

Your email address will not be published. Required fields are marked *