Posted on

These are not the Androids you are looking for- iOS on the other hand…

With iOS and Android in mind, have you ever wondered which one is the more superior one out of the two?  Of course you have- it is almost 2014 and where would you be without that handy piece of technology that could not function without the ingenuity of either iOS or Android.

Superiority aside, I was initially concerned more with the development side of mobile apps.  While the software that makes our favorite apps accessible is intriguing, to say the least, the development side has always been the most fascinating to me.  In order gain some insight on this, I decided to read up on the topic.

During my search, I came across an article, Android vs. iOS Development: Fight!, written by Jon Evans on Nov. 16, 2013.  First of all, I found out that the author is a rather awesome individual- Evans is an author, journalist, adventure traveler, and software engineer.  He also happens to have a decade of experience as a software developer and has even built numerous Android and iOS apps.

To begin with the development of mobile apps, Evans recommends that in order to be productive, use an integrated development environment, or IDE. 

Apple’s is Xcode, which is, by and large, a joy to work with, according to Evans.  It is slick, fast, helpful without being intrusive, and it keeps getting better at papering over the complex and paranoid certificate/profile machinery which Apple imposes on developers to retain its titanium-fisted control over iOS apps and devices.  The debugger works seamlessly, and the simulator is fast and responsive.

For Android, Evans declares that he current state-of-the-art IDE is Eclipse: customized with Android plug-ins and it is embarrassingly bad.  It is rather slow, clunky, counterintuitive when not outright baffling, poorly laid out, needlessly complex- it is simply just a mess.  He goes on to say that its debugger is so clumsy that he finds himself doing log-file debugging most of the time, whereas the XCode debugger is his iOS go-to bug-hunt tool.

Evans continues by mentioning that beneath the sleek, seamless exterior of Xcode and Objective-C lurk the Lovecraftian horrors of 1970s programming. Although he is merly making an amusing joke here, the point is well taken.  In regards to the configuration of iOS, he states that as far as macros and header files go- projects, targets, schemes, and build configurations or an appallingly-intimidating list of build settings.  They are much like the grim despair of encountering a baffling linker error!

Android on the other hand has a single manifest file and Eclipse builds your app in its entirety (usually) every time you save any file.  Evans prefers more clarity in the error messages you get when your app is not working because you have not configured its permissions correctly, but that is a minor cavil.  By and large, Android app configuration is simple and elegant.

Next, Evans covered the overall aspect of design and which software was better to use.  With regards to Apple’s iOS, its Interface Builder is a very sleek way to put simple good-looking user interfaces together quickly.  The trouble is, as Evans explains, the more he actually used Interface Builder, the less he liked it.  It is basically another layer of configuration complexity- it is excellent for simple things, but as time goes by and apps evolve, those simple things tend to get complex and messy.  He also feels that the multi-screen Storyboards Apple added about a year ago does not really help.

Now, Android theoretically has a comparable visual tool, the less said about it the better.  In practice you wind up writing XML files which provide layout guidelines, as opposed to rules, so that apps are rendered well on the entire vast panoply of devices and screen sizes out there.  Meanwhile, Android provides an icon pack for developers to use, whereas iOS developers have to go with third parties like Icons8, or create their own.

Overall, Evans feels that it is a closer contest than one might think- although he concedes that this is pretty idiosyncratic.  In the end, however, two things give iOS the edge.  First, it is still much simpler: three screen sizes (including iPad) and two screen densities, as opposed to the mass of complexity which is Android.  Second, the default iOS visual elements are much more visually attractive than Android’s.

What is really phenomenal, is that both iOS and Android make an enormous library of software available to their developers and, according to Evans, those libraries are fairly similar: there are APIs for phone functions and features, network access functions, a panoply of View objects including a powerful WebView which essentially functions as a full-fledged browser.  Most of the work, meanwhile, is done in controllers: very roughly, an iOS ViewController is equivalent to an Android Activity.

Evans exclaims that what iOS has, which Android does not, is an extra set of frameworks and features and a generally cleaner, better designed system.  Another metric, albeit a flawed one: lines of code.  These apps are very nearly functional identical, but the iOS one has 1596 lines of custom code, including header files, compared to 2109 lines of Java code and XML for Android. That’s a full 32% more.

Finally, the topic that is more than likely on everyone’s mind at the moment: the internet!  These days, many, if not most, apps are conduits to Internet APIs more than they are standalone programs.  This is important enough that it’s worth looking at separately.  Both iOS and Android provide quite a bit of tools and APIs for this.  Evans says that they both also provide very similar WebViews, which are basically full-fledged browser windows that you can plug into your app anywhere.

Network connections basically have to run in the background, so as not to block the main thread of the app, and multithreading is rather hard.  Android provides an AsyncTask class for things like this, which is verbose but works well, and a very easy way to determine whether you are currently online (which is rather nice, I might add).  However, iOS provides equivalent facilities, but they are all pretty low-level and unsatisfying.

So, according to every meticulous detail Evans went over, the winner over which is more superior- iOS!  Android has its advantages, but overall, it remains significantly easier to write good iOS apps than good Android apps.  Combine that with the fact that iOS users tend to be wealthier–and arguably more influential–and it still makes sense for most startups who want to make a splash to go iOS-first, Android-later. Evans declared that the new Android Studio IDE could conceivably close some of that gap…but not all of it.

As an Apple user myself, I agree with the conclusion Evans finally got to.  While what he had to say eventually added up, I think he took too long to make his point!  His article was full of techno-babble and a bit to verbose for my personal liking, but to each their own I guess.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s