Talking Mobile // Tablet // Web Development

© Rakka on Flickr

In the world of Android smartphones, the ecosystem moves swiftly. It wasn’t long ago Android device owners were salivating over Cupcakes and Donuts (Android versions 1.5 and 1.6 respectively). In the span of roughly six months, Android has gone through two major revisions; Android 2.0 (Eclair) and Android 2.2 (Frozen Yogurt or Froyo).

Prior to Google I/O this past May, details of what exactly would be included in the final release were sparse. Early testers reported various improvements including a noticeable boost in speed. Yet development was in full swing and it was hard to figure out just when exactly Android 2.2 would be deemed ready for mass consumption.

At the I/O conference, Google made it’s official announcement to the world and answered many of the questions that had arisen about the latest version of their mobile OS. In addition to a slew of new APIs and developer features, Android 2.2 would come with a number of improvements for front-end users. It boasts a JIT compiler, wifi and USB tethering capabilities, support for Flash, as well as several other improvements and updates.

Taking the prize for the most noticeable, yet invisible feature is the JIT compiler which brings a 2-5x performance boost systemwide. JIT stands for “just in time.” In other words, Froyo is able to do a bit of analysis on the code it’s about to run and make some optimizations to how it handles that code. All that magic happens on the fly and works regardless of the app or which OS version it was targeted to run on. Developers don’t need to change a thing. Animations are less jerky, games run with a higher framerate, and because the device doesn’t have to work as hard, it uses less power thus extending battery life. The bottom line is the JIT compiler makes Android better all over.

Tethering refers to the ability to connect your laptop or desktop to your mobile phone and use the phone’s data connection as the machine’s Internet connection. Froyo includes two types of tethering; USB and wifi. With USB tethering, you connect the device to your computer using a USB cable. This of course means you’re limited to a single connection. Multiple devices can be connected via the wifi hotspot option which essentially turns your handset into a Mifi.

Mention tethering to an iPhone user and they’re likely to launch into an invective-filled tirade against AT&T. Last year, the carrier promised tethering capabilities, but failed to deliver. Since then, Apple and AT&T have gone on to announce tethering a second time along with the cost, $20 per month. Thus, it came as a shock to Android fans when Google announced it was including tethering in Froyo; for free. Not only do Android users get a useful feature, they have another thing they can hold over their iPhone carrying compadres.

As much as people love to hate Flash, it does have it’s uses. Namely, video on the web. Changes are certainly in progress right now with the emergence of HTML5, but it’s hard to deny that Flash is still used quite liberally on the web. With Froyo, Android is able to run a mobile version of Flash and comes as a welcome addition to the speedy browser. It was no doubt made possible by the performance boosts included in Froyo. This is likely the same reason, it won’t be backported to earlier versions of Android.

Flash performs moderately well on Android. Admittedly, video playback performance suffers from low framerates. However, things like simple games or site menus run smoothly. Users are given the option to turn Flash on all the time or to selectively choose components on a page to load. At least now users have the choice of whether or not they want to experience Flash content or not. It’s better than seeing gaping holes in web pages.

As previously mentioned, Froyo also includes a number of minor improvements. Exchange and enterprise control of devices are better supported and the gallery and camera apps have been completely rewritten. Developers will be happy to see several API’s were improved and many new options were added. Notably, developers can enable their apps to be installed on the device’s removable media. This helps to free up internal storage on the device. Overall, the Android experience in Froyo is much more polished and if the pace of development is maintained, it won’t be long before it is the best smartphone OS on the market.

© Dekuwa on Flickr

The biggest negative of Froyo is that it leaves much of the original crop of Android phones behind. Owners of the G1, MyTouch 3G, Hero, and Moment will be forced to root their phones or buy a new device to experience the latest in Android goodness. While it is tempting to bash Google for this, it is not right to do so. Those devices contain obsolete hardware and are simply not equipped to run Froyo. If Android is to move forward, it will need to have hardware to support it. With carrier subsidies working the way they do, two years seems like the maximum life span of a smartphone.

Froyo is a welcome addition to the Android world. It makes an already good mobile OS more mature. Perhaps this is the most important update yet as it brings Android on par with iOS. The competitors do 1-up each other in certain areas (Android is better at multitasking, iOS is a better music player for example), but the average person would be happy with either. The OTA update push to Nexus One’s has started and there are rumblings of a Droid update coming too. It shouldn’t be long before new devices start shipping with 2.2 on them. There is much excitement and innovation going on in the mobile space right now and it shows no signs of slowing down.

Every iPhone developer with an app in the Apple App Store has dealt with the frustration of code signing. Try searching for “iphone code signing error” on Google and you get almost a million results. The purpose of code signing is to tie developers, apps, and devices together in a tangled web in an attempt to prove you are actually yourself, your iPhone is in fact yours, and Apple has authorized you to run or submit your app.

Sounds like fun right?

The way to sign your app is to associate it with a provisioning profile. Creating a provisioning profile is beyond the scope of this post, but you can find more information here. You’ll need a current iPhone developer account to access the docs. Sorry.

So what is this post about then? Well, once you have a few iPhone apps under your belt you’ll find that you have a ton of profiles to manage. Development profiles to test your apps on your device. Ad-hoc profiles to send out beta versions to your testers, and Distribution profiles for submitting your apps to the App Store. They all live in the same place on your Mac and will have non-human readable names if you’ve followed the Apple documentation and dragged and dropped them into Xcode. This makes it a bit tough to know what profile goes with which app.

What are provisioning profiles?

The docs define provisioning profiles as “… a collection of digital entities that uniquely ties developers and devices to an authorized iPhone Development Team and enables a device to be used for testing. A Development Provisioning Profile must be installed on each device on which you wish to run your application code.” Translated this means you have to have a development profile to run your app on your device or a distribution profile to have the app accepted into the app store.

How XCode/iTunes uses them

I’m not going to cover how to sign your apps in this post either. But, rather explain how XCode uses them and how to organize them. Both XCode and iTunes use profiles. XCode to sign the apps and iTunes to install them. Whether you’re signing or installing profiles they live in the same place. Fire up Terminal.app and issue the following commands to find your profiles.

$ cd ~/Library/MobileDevice/Provisioning Profiles/
$ ls

Profile Installation Methods: Drag & Drop vs. Finder

Most of the Apple documentation tells you to drag and drop a profile into XCode to install it. This works but your profile is renamed along the lines of “0ED00060-C42C-4E3F-932F-30F22F79A14C.mobileprovision”. Good luck on knowing what file is.

I prefer move the profiles manually in Finder to avoid the automatic renaming. I like to name my files project.type.date.mobileprovision or trickiwiki.adhoc.03352010.mobileprovision.

What is Git?

Unless you’ve been out of software development for a few years you’ve probably heard of git. Git is distributed version control system for source code and when coupled with a website like GitHub it makes contributing to open source project easy. One of the great things about git is the ease of branching.

For info on how to use and configure git please refer to Scott Chacon’s Pro Git book & website

Creating a Git Repository

Now that git installed we can finally get to the meat of this post. So fire up Terminal.app and issue the following commands. But first move all of your provisioning files out of ~/Library/MobileDevice/Provisioning Profiles/

$ cd ~/Library/MobileDevice/Provisioning Profiles/
$ git init
$ touch README
$ git add README
$ git commit -m 'first commit'

You have created your git repository and added a blank file named README to it.

Using Git Branches

You new git repo comes with a pre-made branch named master. For our purposes we’ll leave this one alone. Run the following command any time to see the branches in your repo.

$ git branch

I like to create a branch for each app. To create a new branch run…

$ git branch app_name1
$ git checkout app_name1

You’ve just created a new git branch for app_name and moved into it. Now save your profiles for app_name1 in cd ~/Library/MobileDevice/Provisioning Profiles/ and run

$ git add .
$ git commit -m "Profiles for app_name1"

Now your profiles are safely stored in your project branch. Now to make a new project branch we need to move back to the master branch and issues the commands to make a new branch. So run the following…

$ git checkout master
$ git branch app_name2
$ git checkout app_name2

Move the profiles for app_name2 into ~/Library/MobileDevice/Provisioning Profiles/ and commit them into git.

$ git add .
$ git commit -m "Profiles for app_name2"

Did you notice that ~/Library/MobileDevice/Provisioning Profiles/ was empty when you put the profiles for app_name2 in there? That’s because the profiles for app_name1 are tucked into the branch for app_name1. To switch between branches just use the git checkout command.

$ git checkout app_name1
$ ls
app_name1.mobileprovision
$ git checkout app_name2
$ ls
app_name2.mobileprovision

Are you starting to get the idea?

What Branch Am I On?

Now that we have all of these branches how do you tell which one you’re working with. As I said before the command git branch will show you the branches

$ git branch
app_name1
* app_name2

The * indicates the active branch. But typing git branch over and over is annoying so I use some shell scripts from Jon Maddox to always show me which branch I’m on.

[proton:Provisioning Profiles[trickiwiki]$

In the example above the branch is shown as “[trickiwiki]“. Pretty sweet, huh?

Git Checkout Usage with XCode/iTunes

The one thing you need to remember when using this system to manage your profiles is XCode and iTunes are not very smart. They only check for profiles on startup. So you need to remember to checkout the correct branch before opening those apps. This took some getting used to until I made it part of my workflow.

For my introduction, I thought it’d be a good idea to discuss some of the tools I use to do web development for Recursive Awesome. Like a mechanic, a developer has a set of tools he or she relies upon on a regular basis. Writing software can be boring and tedious without the right tools. While most of these tools are focused towards web development with Ruby on Rails, but most are universal.

Hardware

15″ Macbook Pro

The foundation of any developer toolbox is the computer. I choose to use a laptop because I need the portability. Having a mobile development environment is huge. Anywhere I can sit down with my laptop for a few minutes can become a place I can program. A 13″ screen is too small. A 17″ is too big and unwieldy to whip out in more cramped spaces such as a packed coffee shop. The current crop of Macbook Pros are more than capable development machines with Core i5 or Core i7 machines rumored to be on the way later this year.

If you’ve spent any amount of time with Ruby, you know it’s kind of assumed you have a proper *nix terminal to run commands on. Windows + Cygwin just doesn’t cut it. Using Mac OS X provides me with the terminal I need and a flashy modern OS on top of it. If I need Windows, I can use either BootCamp or more likely a virtual machine.

XBrand 360 Degree Stand

If you’re going to be working on a laptop chances are you will find out very soon that the ergonomics aren’t ideal. Especially when seated at your typical office desk for 8 or 9 hours at a time. A stand will bring the laptop monitor up to a height where your neck and shoulders are in a better position. If you’e got an external monitor, it’s also nice to have both monitors at the same height. The stand I use is nothing special, but it has height adjustment, it swivels, and it was relatively cheap.

Apple Wireless Keyboard and Logitech VX Nano Mouse

Once you’ve got your laptop in a stand, the keyboard and trackpad become useless. Getting an external mouse and keyboard are virtually required. By using a wireless keyboard and mouse, I’m able to get my workstation set up very quickly. The only two things I plug in at the office are power and headphones.

The Apple Wireless Keyboard is compact and is easily tossed in my backpack. It is fairly good about battery life. Finally, it makes an easier transition from laptop keyboard to external keyboard when both are identical. This helps in productivity.

I use the Logitech VX Nano for no other reason than size. Both the mouse itself and the wireless dongle are tiny. I don’t have to worry about unplugging the adapter all the time; it is small enough to leave in. However, I do realize that with a Bluetooth mouse, I would have nothing to plug in. If I were in the market for a new mouse today, I would probably buy the Apple Magic Mouse.

Nexus One

Having owned a T-mobile G1 and become a fan of Android, I was 100% on top of the Google Nexus One when it was released. I’ll admit, for the entire time I owned my G1, I had iPhone envy. No so with the Neuxs One. Having owned one for several weeks now, I wouldn’t switch if given the chance. It’s definitely the nicest mobile phone I’ve ever had. While not really a developer, per se, the Nexus One keeps me connected. And I guess you could argue that there are apps for aiding in development such as the terminal/SSH client.

Software

TextMate

For Rails programming, there isn’t much better than TextMate. Sure, it’s been around since the beginning and hasn’t been updated since then. It still puts everything else to shame with it’s bundles and command shortcuts.

git

If you’re a developer and not using source control, you deserve a beating. These days distributed version control is all the rage and for very good reason. It rocks! Branching and merging in git is a dream. I recommend Vincent Driessen’s branching model to add some structure to your workflow.

Sequel Pro/Mesa SQLite

Any self-respecting geek knows their way around the command line. However, using it day to day to do repetitive tasks can be a drag. Enter Sequel Pro; a slick interface for dealing with a MySQL database. I believe it also supports Postgres. It does not support Sqlite3, yet (support is coming, just not for awhile). In that case, you’re going to want to try out MesaSQLite. It’s small, lightweight, and gets the job done which is more than Microsoft can say for most of their applications.

Safari

I used to be a huge fan of Firefox, until it started feeling more like it’s predecessor, Mozilla. Safari is fast a nimble, especially on Macs. Except for running thousands of plugins, Safari can do anything Firefox can do and most likely it’ll do it faster. If you’re a developer, make sure you turn on the Develop menu and familiarize yourself with the Web Inspector.

Firefox + Firebug + Yslow

Though you just saw me talk up Safari over Firefox, there is one tool I can’t replace in Safari and that’s YSlow. Yslow analyzes the page you are on for performance and gives you tips on how to improve it. The recommendations are those of the highly regarded Steve Souders (formerly of Yahoo, now at Google), so you know they are spot on.

Photoshop

Developers normally don’t do a lot of artistic work, but this geek does. I’ve tried using Gimp and even the Photoshop-like skins of Gimp, but none of them quite match the power of Photoshop. There is no substitute.

Virtualbox

Many Mac users will tell you to use VMWare Fusion or Parallels Desktop for Mac to do virtualization. The problem is those programs cost money. Why pay for something when you can get something equivalent for free. You may even be able to convert your existing Parallels or Fusion disk images to VirtualBox if you’re savvy enough to use Google.

Evernote

Last, but not least, is an application most developers probably wouldn’t consider part of their toolbox. I’ve come to rely quite heavily on Evernote though. Yes, you can take notes and tag them, and they sync up to a remote server. Yes, you can do cool things like scan documents or take captures of web pages with it. However, my most used feature in Evernote is not any of those; it is the checkbox widget. I am constantly building lists of things and adding checkboxes and turning them into todos.

Over the past few weeks, we here at Recursive Awesome were able to get our hands on the 2 mobile devices Palm is currently offering on the Verizon Network – The Palm Pre and Palm Pixi running their WebOS operating system.

Thanks to @albertmaruggi, @karenvzw and @rshidla

At the end of the day, I must say I am fairly impressed with their offerings.

It wasn’t difficult to give them back and return to my Nexus One, but they definitely do a fit a certain niche in the market and I’m a little surprised that the Palm WebOS sales have slumped as bad as they have.

On one hand you have a major carrier like Verizon doing a fairly good job of promoting the device, both in stores and in print advertising. I can’t go more than a day or so without seeing another Palm commercial, billboard or sign on a bus or at my local light-rail station stop. It would seem that there would be a lot more excitement over the device with it’s somewhat unique design, flip out keyboard, snappy interface, multi-touch (Android just got this in its latest release), and now supporting video capture and Flash. It seems like the time would be right for Palm to make a major move in to the market. Alas, though, that may not be the case.

What’s To Like

The first thing that struck me when using both of these devices was the performance. Despite their small size, they both felt very responsive and able to do multiple tasks at the same time without much lag. In comparison to some of the smaller Android devices and first generation iPhones, Palm has a very good start. They seem to have done their homework in optimization of  WebOS and keeping processes lightweight and execution times short during launch and usage.

Speaking of execution of apps, WebOS allows the user to run multiple application at the same time very easily. The Palm devices have a “flick” type of gesture support that you perform on the area below the screen. If you want to jump out of an application you swipe your finger (or thumb) vertically and you are presented with a scrolling list of applications that are running. You then can swipe side to side to select the application you would like to jump into. I found at first this a little different and cumbersome, as I was used to looking for an actual button to get out of an application (i.e. the home or close buttons on iPhone or Android). However, after playing with the phone for a hour or so, it actually became very easy to master and was a feature that I got very accustomed to and liked a lot. Interestingly , it seems that Palm agrees and realizes that it might take users some time to try out this swipe feature ( when you start up the phone for the first time, they force you through an entire tutorial and exercise on how to use this gesture feature ).

Another nifty feature is what Palm calls “Synergy”. It links together all of your contacts into one list, with calendars, and status updates pulled in from all of your various accounts (GMail, Yahoo, LinkedIn, Exchange, etc.).

I also personally like the fact that WebOS is built on top of the Linux operating system and all things being equal will support a company pushing the use of open source software over their own proprietary software and lock-in model.

What’s To Dislike

So, I’ve given a pretty good list of the likes, but what about some things that should be improved? Much of my dislikes revolve more around the hardware than the actual operating system itself. It might be because I’ve now gotten used to having a 3.7″ AMO-LED screen on my Nexus One, but it felt to me like the device was pretty cheap and not very sturdy. The screen seemed small and the device felt at times more like a toy than a true smartphone that would stand up to the test of time.

Another issue I had was with the keyboard. Neither of the Palm devices offer a virtual (on-screen) keyboard, so you are stuck using the physical keyboard on the device. While adequate I found the keys to be very small and difficult to use at times. They again felt cheap and found myself having to hunt for a number of different symbols and punctuation marks. Additionally, since the Palm Pre’s keyboard is hidden behind the screen, this requires you to pop the screen out vertically to access the keyboard. While this worked well, when the screen is open the device felt very top heavy and made using the keyboard not as nice as it could be, since I felt like the device was going to slip out my hands.

Finding and opening up the slot for the micro-USB plugin was not at all easy to use. Maybe over time the small plastic cover would be easier to open, but I found myself almost breaking the cover off trying to get access to charge and plug-in the phone.

Finally, and the most largest flaw with Palm (and probably the one that will ultimately prove to biggest hurdle) is getting application developers to create apps for this platform. At Recursive Awesome, we have done some work developing applications for these devices when it was first launched last summer, but since that time, none of our clients have been asking much at all about WebOS. If there are no applications being developed for the platform, end users certainly will suffer from lack of functionality of the device and certainly will start looking to other options of smartphones that they will purchase. While I have not seen any statistics on the true number of applications available, most think the number is in the few thousands, as opposed to the tens, or even more than one hundred thousand found on iPhone and Android.

Conclusion

So, who does this device work for? The prime target I see these devices working for are my parents generation. People that are not technology savvy users, that want a basic web experience with out all of the bells and whistles. I could see myself recommending this device to my mother or even grandmother for that matter. It still feels like a PDA however in some ways. Basic interface, somewhat intuitive to use (one you learn the gestures), and allows you to have all of your contacts and email in the palm of your hand.

In the end, it’s nothing really groundbreaking, but really an extension of some of the old palm devices I have owned in the past. That’s not to say that Palm is out of the game, but with the Windows Phone 7 coming out later this year, Palm will have a lot of competition on its hands. It already is a distant 4th on the smartphone circus behind iPhone, Android, Blackberry and without an injection of applications and buzz around the devices, 2010 might be the year that Palm is bought (or withers away in to the ether). Which is kind of too bad, since I do think that their WebOS, does provide some very useful and new ideas when it comes to interface design.