Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.
The Challenges of Mobile Development4:21 with Heath Hodgert
In this video we'll review what we'll cover in this course along with a discussion of the challenges of mobile development.
- iOS -- Apple's mobile operating system for iPhone and iPad devices.
- Android -- An open source operating system used for smartphones and tablets
- IDE -- Integrated development environment
- API -- Application programming interface
- Objective-C -- Object oriented language used by iOS
- Swift -- A general purpose programming language developed by Apple for iOS
- Java -- A general purpose programming language which is used for Android development
- C# -- A general purpose object oriented programming language developed by Microsoft
Cross Platform Development Choices:
- Native is the most straightforward way to build an app but you need to understand each platform and the language it uses as well as the platform specific IDE.
- Xamarin give us native performance and controls using a single IDE and language. There are also many ways to reuse your code across platforms.
- Xamarin.Forms is a framework using Xamarin to build cross platform apps that implements many of the native controls in a platform agnostic way so we can build the interface once and it will work on all platforms. Since Xamarin.Forms uses XAML and databinding we can get a huge about of code reuse with this solution.
- Hybrid solutions like Cordova/PhoneGap using a small native app with a webview that displays HTML. The hybrid solution is very appealing and can be quickly developed but it fails on performance, maintainability, and end product quality. There are dozens of good articles on this subject.
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
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.
You need to sign up for Treehouse in order to download course files.Sign up