[MUSIC]

Building mobile apps is an amazing field of software development,

because it's growing so quickly, and changing so rapidly.

While this may be exciting, it also introduces some challenges for

us as developers.

The first challenge we face is on which platform should our app be developed.

Currently iOS and Android are the best choices.

Although Windows and Linux should not be ignored.

We'll focus just on iOS and Android in this course.

If you choose iOS, then you'll need to use Xcode and

learn either Objective-C or Swift.

If you choose Android, you'll need to choose one of many IDEs and learn Java.

Taking these one at a time, it seems reasonable, but if we wanna

reach the largest number of users, we should develop for both iOS and Android.

The problem is, it will double our development cost to build the same app

on two very different platforms.

Using Xamarin we can build our app using Visual Studio, a powerful ID and C#.

Because we are using one language,

we can share a large portion of our code between platforms.

We will be discussing how this can be done throughout this course.

Even if we decided to develop for

one platform, the second challenge comes from fragmentation of devices.

As I said, mobile development is a quickly growing and

changing environment which caused an explosion of devices for both platforms.

iOS is less challenging because Apple aggressively pushes

updated operating systems and has relatively few form factors.

Also, because Apple pushes updates, we must build and

deploy our app every year or get left behind.

Android is another story altogether.

The individual device manufacturers decide which OS version to use and

don't need to update them.

So as developers, we must develop for many Android versions.

Also, device manufacturers can modify their versions of the OS for

their devices.

There are also no defined form factors for Android devices, so they range in size and

performance all across the spectrum.

Xamarin does not directly solve this problem, but having shared code and

an abstraction layer over API changes makes maintenance easier.

The third challenge is to develop our app so it looks and

responds well on either platform.

If we develop a native app for both platforms, we'll need an expert for

each to make sure they run effectively,

because both platforms use very different frameworks, libraries, and patterns.

Xamarin uses an obstruction layer

that smooths out many of the API fragmentation issues.

And to their credit, Xamarin has had support for

each operating system on the day it was released.

This course will cover the basics to start building an app with the Xamarin platform.

At the end of the course, you'll have a simple app and

the skills to make your own.

Now that we've discussed some of the challenges of mobile development,

we'll discuss how Xamarin works, so you know what happens behind the scenes.

Then we'll use a solution template to start our basic app.

Once we have the project created, we'll customize it for Android and iOS.

We'll also need to set up our development environments for iOS and Android.

Finally we'll re-factor our app to share code and discuss code sharing patterns.

As we learn the basics of Xamarin development,

we'll build a simple PC calculator app.

We all have been in the situation where we are asked to order pizzas for

a large party and we have to guess how many to buy.

We'll build our mobile app to help us calculate how many pizzas we'll need.

As you can see here, I have the IOS version in the app,

where I can enter the number of people and calculate the number of pizzas required.

Then I can call my local pizza parlor to place the order.

Since I'm using an emulator, it will not make a call, but

it shows a message to let me know it's working.