Hacker News Reader

Comment by mncolinlee | Hacker News Reader

An important correction: Unlike iOS, Android does not come with a simulator. It has an emulator. That explains many of the differences in startup speed and performance. A simulator runs natively and does not have to emulate the ARM machine code on your x86 device. The Android emulator is theoretically more accurate and runs the entire Android OS, but the cost penalty is huge. Therefore, most Android developers test small changes initially on a device.

http://programmers.stackexchange.com/questions/134746/whats-...

View on HN

Excellent point. Running the x86 images in the emulator is much faster (and Google recently released x86 images w/ Google APIs in them).

Genymotion is a decent alternative to the 1st party emulator, it runs significantly faster.

Genymotion is as close to the speed of the iOS Simulator as you can get today.

However, Genymotion is x86-based, so ARM libraries you use in your app that are designed to run on an ARM device will not work in Genymotion on your computer. However, if your use of those is limited to just a few Activities in your Android app, you should be able to do a lot of things with Genymotion, and just tiptoe around trying out that Activity on your computer and instead use it on-device.

By the time you use special binary ARM libraries you should have figured out the difference between an emulator and a simulator and also maybe discovered the possibility to deploy to a real device.

> Therefore, most Android developers test small changes initially on a device.

That's also because deploying an APK on a test device (or several devices) is way easier than deploying an IPA on an iOS device.

As someone relatively new to iOS this past month or so, I was shocked by the number of hoops I have to jump through just to take a piece of code I've written and put it on a device that I own and is sitting right next to me[0].

Coming from Android development, I never thought twice about this - it's easy to push the APK to my phone as part of the build process, and I don't even have to plug my device in to do so.

[0] Including shelling out $99 for a certificate that gives me the permission to do so.

How is it easier than just pressing the build and run button on XCode?

I think the problem he is having is with how to get to that point. There is a lot of setup to get to the point of just being able to hit the build and run button in Xcode. Of course, once that work is out of the way it's super easy.

What setup work? Install Xcode from the App Store, and log in with your developer account? There is less involved than just downloading and unzipping the Android SDK

(ignoring the creating the developer account) - create certificate(s)

- create provisioning profile(s)

- hit refresh in Xcode and hope it pulls in the profiles you want to use (maybe only an issue if you're a member of multiple teams)

- modify build settings

once you've done that its simple but there is definitely a setup overhead with Xcode and devices

If you are not a member of multiple teams, this is all unnecessary.

The point is that the original comment is flat out false.

In my experience anything that Xcode promises to just work, just doesn't but yes they have at least improved provisioning.

The original point was that there are steps to go through, and creating a paid developer account is a non trivial step

There are steps to go through for android too. The original comment about deployment is false, and doesn't make any distinction about one time setup.

> That's also because deploying an APK on a test device (or several devices) is way easier than deploying an IPA on an iOS device.

False.

> it's easy to push the APK to my phone as part of the build process, and I don't even have to plug my device in to do so.

Also true of iOS.

If you want to make the case that enrolling in the developer program is a hassle, that's fine, but it's misleading to make it sound as though that is part of the build process.

Mucking around with provisioning profiles, schemes, and certificates is a part of iOS development that totally sucks.

True but has nothing to do with what was claimed.

You need to create a paid developer account on Android too.

No, you do not need any paid account in order to compile an APK and install it on any number of devices. I could paste a link to an APK right here, and if you were visiting it from your phone, you could install it directly from that downloaded file.

This works on any number of devices.

You need a Google Play Developer account in order to distribute through the Google Play store, but you can directly install an application on an unlimited number of devices for free without ever signing up for an account. This is not possible on iOS without jailbreaking every phone.

I'm not sure if it has changed since I last made an ios app a while back, but there was a fairly large amount of security certificate provisioning and the interface for it, at that time at least, was unintuitive.

It has changed. The certificate is created and provisioned to the device automatically by XCode.

They is the exact same amount of work involved with Android. iOS is actually significantly easier.

I would argue that debugging is also infinitely easier in the Android world, since plugging a phone into USB and authorizing ADB gives you full control to see everything on the phone. You can get full logs and debug control over the hardware. You can push and pull stack traces and files to and from the device with a single, three operand command line and obtaining hardware screenshots requires only a click in IDE.

Android also has a plethora of debug options hidden in a special device settings menu that can be hugely helpful for troubleshooting performance issues.

You do realize that all of those capabilities are available in XCode?

Uh. It's way harder to setup an android device for debugging. I just had to plug in my iphone and tap "use for development" at the prompt.

I'm porting an iOS app to android right now, and android is way behind on the development side of things.

Okay. I guess I mostly used iOS with the simulator and have less experience with their hardware interface. I just found the feature set for ADB to be pretty dang impressive. Most developers never touch even 10% of the the features even though some are very useful. I'd love to see a side-by-side comparison if someone has a link.

On the other hand, having iOS connect easily to a debugger disproves nothing I said.

"Obtaining hardware screenshots is just a click in the IDE"

I shouldn't need a computer attached to get screenshots for my app. Power + home button, or cmd+S in the simulator.

Even my users can easily send me screenshots, some of the time unprompted even.

After you setup the provisioning profiles correctly, get the build schemes right, etc etc. Oh and don't forget to send Apple your tax id!

I would highly recommend using Android Studio + Gradle over Eclipse. IntelliJ is a significantly better tool for writing and refactoring code than XCode. Some of the tight integrations between XCode and the phone are superior (especially around profiling), but overall I think IntelliJ is a much stronger tool. Even something as simple as doing layout is vastly better on Android. There is no choice between 'in code or in Interface Builder'. XML + the viewer in Android Studio is the best of both worlds.

I also think Relative Layouts accomplish 99% of what auto layout accomplishes in a much friendlier manner.

I didn't have to do any of that. Xcode creates provisioning profiles for you, and appcode created the schemes I needed. I think Xcode does a decent job as well.

And you only need a tax ID if you're trying to imminently release a paid application or an app with IAP. But we're discussing development, not release.

You can also use http://www.bluestacks.com for debugging/testing your applications.

Reply on news.ycombinator.com