Rob Tiffany » Wireless

The Meek Shall in Inherit the Smartphone World

Rob Tiffany — Sun, 15 Apr 2012 04:24:30 +0000

Like the PC’s domination over Macs in decades past, low-cost devices for the masses will win the global smartphone war. It won’t even be close.

Most of the world population has to buy their device first, without the luxury of carrier subsidies. This means devices with a lower hardware and software BOM cost will have the advantage over ones that absolutely depend on carrier subsidies for their very survival. I’m not talking smartphones that are cheaper because they lack the features and functionality of higher-end device. If you step back and look across most of today’s smartphone platforms like the iPhone, Android, Blackberry, Windows Phone, Symbian, and Bada, you’ll notice that they all have similar functionality. They all make calls and have email, an HTML5 web browser, SMS, MMS, touch, keyboards, APIs to build apps, 2G/3G/4G data networks, digital still/video cameras, web services, calendars, app stores, contacts, push notifications, music, maps, yada yada. Will there be variations in quality? Sure, but that’s the case with all products people buy.

It’s easy to forget that most of the world is still using feature phones because they meet minimum communications requirements and because they are inexpensive to buy. These billions of folks are moving to smartphones, but don’t make the mistake in believing that they are capable of purchasing the most envied phone in the affluent country you live in. For wealthy nations that currently live in a smartphone reality distortion field, this might be hard to understand. Remember, the populations of the combined affluent countries make up just 1/7th of the total world population. Even most folks in that group of ~1 billion people couldn’t afford the $850 unsubsidized cost of a certain smartphone that comes to mind.

Oh and by the way, the tablet market will shake-out the same way as it matures.

It’s the way of things in technology. Remember, once the IBM BIOS was reverse-engineered, we had the Attack of the Clones in the 1980s that democratized the personal computer market. Prices plunged, and Bill Gates’ vision of a computer on every desk was largely realized. The same thing is already beginning to play out for smartphones around the world in developing and not-so-developing countries. Players in the mobile and wireless space who are moving to where the kicked football will be in this emerging reality, rather than where it is today, are the ones who will benefit in the long run.

It won’t even be close.

-Rob

The Current State and Trends of the Mobile Internet

Rob Tiffany — Mon, 31 Oct 2011 17:53:22 +0000

Since 90% of the world’s population has mobile network coverage, lets take a look at how they’re using it, where they’re using it, and what we should expect from the future…

Interesting stuff!
-Rob

Sync Framework v4 is now Open Source, and ready to Connect any Device to SQL Server and SQL Azure

Rob Tiffany — Sun, 11 Sep 2011 20:54:27 +0000

The profound effects of the Consumerization of IT (CoIT) is blurring the lines between consumers and the enterprise. The fact that virtually every type of mobile device is now a candidate to make employees productive means that cross-platform, enabling technologies are a must. Luckily, Microsoft has brought the power to synchronize data with either SQL Server on-premise or SQL Azure in the cloud to the world of mobility. If you’ve ever synched the music on your iPhone with iTunes, the calendar on your Android device with Gmail, or the Outlook email on your Windows Phone with Exchange, then you understand the importance of sync. In my experience architecting and building enterprise mobile apps for the world’s largest organizations over the last decade, data sync has always been a critical ingredient.

The new Sync Framework Toolkit found on MSDN builds on the existing Sync Framework 2.1′s ability to create disconnected applications, making it easier to expose data for synchronization to apps running on any client platform. Where Sync Framework 2.1 required clients to be based on Windows, this free toolkit allows other Microsoft platforms to be used for offline clients such as Silverlight, Windows Phone 7, Windows Mobile, Windows Embedded Handheld, and new Windows Slates. Additionally, non-Microsoft platforms such as iPhones, iPads, Android phones and tablets, Blackberries and browsers supporting HTML5 are all first-class sync citizens. The secret is that we no longer require the installation of the Sync Framework runtime on client devices. When coupled with use of an open protocol like OData for data transport, no platform or programming language is prevented from synchronizing data with our on-premise and cloud databases. When the data arrives on your device, you can serialize it as JSON, or insert it into SQL Server Compact or SQLite depending on your platform preferences.

The Sync Framework Toolkit provides all the features enabled by theSync Framework 4.0 October 2010 CTP. We are releasing the toolkit as source code samples on MSDN with the source code utilizing Sync Framework 2.1. Source code provides the flexibility to customize or extend the capabilities we have provided to suit your specific requirements. The client-side source code in the package is released under the Apache 2.0 license and the server-side source code under the MS-LPL license. The Sync Framework 2.1 is fully supported by Microsoft and the mobile-enabling source code is yours to use, build upon, and support for the apps you create.

Now some of you might be wondering why you would use a sync technology to move data rather than SOAP or REST web services. The reason has to do with performance and bandwidth efficiency. Using SOA, one would retrieve all the data needed to the device in order to see what has changed in SQL Server. The same goes for uploading data. Using the Sync Framework Toolkit, only the changes, or deltas, are transmitted over the air. The boosts performance and reduces bandwidth usage which saves time and money in a world of congested mobile data networks with capped mobile data plans. You also get a feature called batching, which breaks up the data sent over wireless networks into manageable pieces. This not only prevents you from blowing out your limited bandwidth, but it also keeps you from using too much RAM memory both on the server and your memory-constrained mobile device. When combined with conflict resolution and advanced filtering, I’m sold!

I think you’ll find the Sync Framework Toolkit to be an immensely valuable component of your MEAP solutions for the enterprise as well as the ones you build for consumers.

Keep Synching,

Rob

Performance and Memory Management Improvements with Windows Embedded Handheld

Rob Tiffany — Sun, 04 Sep 2011 15:49:39 +0000

A lot has changed since the launch of Windows Phone in the Fall of 2010. Microsoft now has a compelling phone platform that targets consumers inside and outside the office. One thing that that hasn’t changed is the widespread use of Windows Embedded Handheld to solve tough enterprise mobility problems. It should be no surprise that over 80% of enterprise handhelds shipped are running Windows Mobile or Windows Embedded Handheld. They include support for barcode scanning, RFID reading, rugged hardware, every type of wireless, full device encryption, complete over-the-air software distribution and device managment support, FIPS compliance, and both capacitive touch and stylus operation. On the application platform side of the equation, they have rich support for WinForm development using Visual Studio and the .NET Compact Framework, C++ and a full-featured database with built-in sync capabilities via SQL Server Compact. They can easily communicate with WCF SOAP and REST web services running on Windows Servers on-premise or with Azure in the cloud. Support for Merge Replication means faster time to market to get device synchronizing with SQL Server with almost no coding.

Since Windows Embedded Handheld uses an advanced version of the operating system kernel used by Windows Mobile 6.5.3, many of the techniques and best practices I’ve taugh customers and developers all over the world still apply. While it still uses the slotted memory model found in Windows CE 5 with 32 processes and 32 MB of memory per process, you’ll find that numerous enhancements and tuning has taken place to give your line of business apps more of what they need. I’m talking about more memory per process and improved performance. Therefore, I’d like you to sit back and watch the video of a presentation I delivered at Tech Ed in Los Angeles a couple of years ago so you can better learn what this mobile platform has to offer in the form of better memory management and improved performance:

A recent Gartner report recommends that organizations should stay with Windows Embedded Handheld as the best mobile platform for enterprise line of business needs. Great devices are available from OEMs like Intermec, Motorola, Psion, and Honeywell just to name a few. I hope this video helps you with any memory management or performance issues you may need to deal with in your enterprise mobile apps.

Best Regards,
Rob

Windows Phone 7 Line of Business App Dev :: Uploading Data back to Azure

Rob Tiffany — Wed, 04 May 2011 05:11:35 +0000

Looking back over the last 6 months of this series of articles, you’ve created wireless-efficient WCF REST + JSON Web Services in Azure to download data from SQL Azure tables to Windows Phone. You’ve maintained in-memory collections of objects in your own local NoSQL object cache. You’ve used LINQ to query those collections and bind results to various Silverlight UI elements. You’ve even serialized those collections to Isolated Storage using memory-efficient JSON. So what’s left to do?

Oh yeah, I guess you might want to know how to upload an object full to data back to a WCF Web Service in Azure. In order to keep this article simple and to-the-point, I’m going to work with a basic Submarine object and show you how to fill it with data and upload it from a Windows Phone or Slate to a WCF REST + JSON Web Service. Let’s take a look at this object:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;

namespace Models
{
[DataContract()]
public class Submarine
{
[DataMember()]
public int Id { get; set; }
[DataMember()]
public string Name { get; set; }
}
}

It includes just an integer data type called Id, and a string called Name. As in previous articles before, its decorated with a [DataContract()] and two [DataMember()]s to allow .NET serialization to do its thing. So the next thing we need to do is create and populate this Submarine object with data, serialize it as JSON, and send it on its way using WebClient.

Below is the method and its callback that accomplishes this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using Microsoft.Phone.Controls;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Text;

private void AddSubmarine()
{
Uri uri = new Uri(“http://127.0.0.1:81/SubService.svc/AddSubmarine”);

Models.Submarine submarine = new Models.Submarine() { Id = 3, Name = “Seawolf” };
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Models.Submarine));
MemoryStream mem = new MemoryStream();
ser.WriteObject(mem, submarine);
string data = Encoding.UTF8.GetString(mem.ToArray(), 0, (int)mem.Length);

WebClient webClient = new WebClient();
webClient.UploadStringCompleted += new UploadStringCompletedEventHandler(webClient _UploadStringCompleted);
webClient.Headers["Content-type"] = “application/json”;
webClient.Encoding = Encoding.UTF8;
webClient.UploadStringAsync(uri, “POST”, data);

}

void webClient_UploadStringCompleted(object sender, UploadStringCompletedEventArgs e)
{
var x = e.Result;
}

As you can see above, I point the URI at a WCF Service called SubService.svc/AddSubmarine. How RESTful. Next, I create an instance of the Submarine object, give it an Id of 3 and the Name Seawolf. I then use the same DataContractJsonSerializer I’ve been using in all the other articles to serialize the Submarine object to a JSON representation. Using the MemoryStream, I write the JSON to a stream and then artfully turn it into a string. Last but not least, I instantiate a new WebClient object, create an event handler for a callback, and upload the stringified Submarine object to the WCF Service.

So where did I upload the Submarine object to?

It takes two to Mango, so let’s take a look. For starters, it goes without saying that every WCF Service starts with an Interface. This one is called ISubService.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;

namespace DataSync
{
[ServiceContract]
public interface ISubService
{
[OperationContract]
[WebInvoke(UriTemplate = "/AddSubmarine", BodyStyle = WebMessageBodyStyle.Bare, RequestFormat = WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json, Method = "POST")]
bool AddSubmarine(Models.Submarine sub);

}
}

Unlike previous articles where I had you download data with WebGet, this time I’m using WebInvoke to denote that a PUT, POST, or DELETE HTTP Verb is being used with our REST service. The UriTemplate gives you the RESTful /AddSubmarine, and I added the Method = “POST” for good measure. Keep in mind that you’ll need the exact same Submarine class on the server that you had on your Windows Phone to make all this work.

Let’s see what we get when we Implement this Interface:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.Diagnostics;
using Microsoft.WindowsAzure.ServiceRuntime;
using Microsoft.WindowsAzure.StorageClient;
using System.Configuration;
using System.Xml.Serialization;
using System.IO;

namespace DataSync
{
public class SubService : ISubService
{
public SubService()
{

}

public bool AddSubmarine(Models.Submarine submarine)
{
try
{
if (submarine != null)
{
//Do something with your Deserialized .NET Submarine Object
//… = submarine.Id //… = submarine.Name

return true;
}
else
{
return false;
}
}
catch
{
return false;
}
}

}
}

Here we end up with SubService.svc with the simple AddSubmarine method where you pass in a Submarine object as a parameter. What you do with this object, I’ll leave to you. Some might be tempted to INSERT it into SQL Azure. I’d prefer that you drop it into an Azure Queue and have a Worker Role do the INSERTing later so you can stay loosely-coupled. Just in case you need a refresher on a REST-based Web.config file, here’s one below:

To persist the traces to storage, update the DiagnosticsConnectionString setting with your storage credentials.
To avoid performance degradation, remember to disable tracing on production deployments.

–>

name=”AzureDiagnostics”>

contract=”DataSync.ISubService” />

–>

This Web.Config gives you the webHttpBinding you’re looking for to do a REST service. I even left you a spot to add your own database or Azure storage connection strings.

This article wraps up the Windows Phone 7 Line of Business App Dev series that I’ve been delivering to you since last September. Who knew I would make fun of OData or have you create your own NoSQL database to run on your phone along the way? I think I actually wrote the first article in this series from a hotel room in Nantes, France.

But have no fear, this isn’t the end.

In preparation for Tech Ed 2010 North America coming up on May 16th in Atlanta, I’ve been building the next-gen, super-fast, super-scalable Azure architecture designed for mobile devices roaming on wireless data networks. I’ve spent the last decade building the world’s largest and most scalable mobile infrastructures for Microsoft’s wonderful global customers. Now it’s time to make the jump from supporting enterprise-level scalability to the much bigger consumer-level scalability.

Yes, I’m talking millions of devices.

No, you won’t have to recreate Facebook’s servers, NoSQL, Memcache, or Hadoop infrastructure to make it happen. I’m going to show you how to make it happen with Azure in just two weeks so I’m looking forward to seeing everyone in Atlanta in two weeks.

Keep coding,

Rob

Top Ten Mobile Internet Trends

Rob Tiffany — Mon, 28 Feb 2011 20:32:32 +0000

Our friends at Kleiner Perkins have some great insights into where things are going with the Mobile Internet:

Top 10 Mobile Internet Trends (Feb 2011)

View more presentations from Kleiner Perkins Caufield & Byers

Mobile Web Facts and Best Practices

Rob Tiffany — Thu, 24 Feb 2011 02:50:47 +0000

It’s growing faster than the desktop web
Faster growth than desktop web during 1990’s
There’s been a 2000% increase in mobile websites since 2008
The mobile web is:

The mobile web is not:

The mobile web is glanceable info for people on the go
The desktop web is for people who aren’t going anywhere
The mobile web can reach half the planet
The desktop web reaches ~1 billion users
The mobile web browser is the #1 app used on most phones
The mobile web browser consumes 13% of user face time
The mobile web browser accounts for 50% of all phone data traffic
There are around 326,000 touchable mobile web sites
Most of the top mobile web sites focus on shopping, services, social and news
Retailers can increase consumer engagement by 85% by having mobile-specific website
But only 4.8% of U.S. retailers have a mobile website
9 out of 10 mobile shoppers use the mobile web while in-store
50% of users in-store mobile web activity is shopping related
51% of in-store mobile research has led to a purchase
Amazon took in > $1 billion via its mobile commerce site
Google says mobile shopping searches are up 3,000% over last 3 years
Most native device attributes will reach HTML5 by 2013, enabling UX that rivals native apps
- Geo-location 2010
- Camera 2011
- Motion detection 2011
- Calendar 2012
- Contacts 2012
- SMS2012
- Files 2013

Today’s mobile web is XHTML Basic 1.1Second Edition
- W3C recommendation in November 2010
- http://www.w3.org/TR/2010/REC-xhtml-basic-20101123/
- Supersedes XHTML-MP 1.2 from Open Mobile Alliance (OMA)
- Similar to HTML 4.01
- Not WAP
Yes, it’s XML
- XML parsing rules enforced
- Every tag name and attribute must be in lowercase
- All attributes must have a value
- Every tag must be closed
You must have a document type definition (DTD)
- Your markup must stick to the definition
You need an XML namespace for your document
You need a mime type
- @Response.AddHeader(“Content-Type”, “application/xhtml+xml”);
There are no frames, no framesets and no iframes
No Java applets
No Flash
No image maps
Simple tables
- Not for layout (Use CSS)
- No table nesting (Tables within tables)
- No thead
- No tbody
- No tfoot

CSS Mobile Profile
- Subset of CSS2
- Must specify units
Keep your short, description and < 20 characters
Stack everything in a single column
- No left/right horizontal scrolling
- Minimize up/down vertical scrolling
Include just the top 20% most important content from the desktop web
Use minimal, lightweight advertisements
Link to the desktop website
Use short URLs that fit on a single line and don’t disappear off the side of your phone
Accommodate different device dimensions
- Width = 100%
- Height = Auto
No hovering or mouse-overs needed for touch
Limit the need for text entry
- Use checkboxes
- Use drop-down combo boxes
- Use lists
- Use radio buttons
- Use pre-filled text
- Maintain reusable session data in a cookie
Each page must only provide a single function or idea
Use larger fonts because people can’t read small screens with high resolution
Use large touchable UI elements
- Fingertips are up to 80 pixels wide
- Touchable elements must be 40+ high/wide
- Touchable elements must be 20+ pixels apart
Navigation should be at the top of each page (Also use breadcrumbs for one-click access)
Just say no to background images
- Makes pages harder to read
- Increases page size
No pop-up windows
Don’t use absolute values for measurements
- You’ll get unexpected results on different mobile browsers
- Use ems
- Use percentages
Do not use images for:
- Icons for links or menus
- Buttons
- Visual separators
Do use small images:
- For maps
- For an article
- As a product logo
- If they are smaller than device screen
- As long as they are lightweight thumbnails
- Only when absolutely necessary
Click to call Call Rob
Click to email email rob
Access keys for fast access to list items
- For phones with keyboards
- Products

Server-side device capability databases
- Wireless universal resource file (WURFL)
- Device Atlas
- 51 Degrees (points to WURFL)
Client-side device capability detection
Detect modern DOM

function hasModernDOM()

{

// Check for support of DOM Level 1 functions

if (document.getElementById && document.getElementsByTagName)

return true;

return false;

}

Don’t assume…test for object existence

if (object)

{

// object available

}

Determine device orientation

if (window.orientation)

{

if (window.orientation == 90 || window.orientation == -90)

return “landscape”;

else return “portrait”;

}

Detect AJAX capabilities

if (window.XMLHttpRequest)

{

return new XMLHttpRequest();

} else try {

return new ActiveXObject(‘Msxml2.XMLHTTP’);

}catch(e) {

try {

return new ActiveXObject(“Microsoft.XMLHTTP”);

} catch (e) {

return null;

}

Viewport
- Prevent mobile browsers from displaying desktop-optimized markup
Internet Explorer Mobile adaptation
Blackberry adaptation

Minify XHTML, CSS and JavaScript
- Remove non-useful tags
- Remove comments
- Remove spaces
- Use YUI compressor to compress HTML
- Use jsmin to compress JavaScript
Use Yahoo YSlow to analyze website performance
Validate your site with W3C mobileOK Checker at http://validator.w3.org/mobile/
Some DOM thoughts
- Avoid large DOM frameworks like JQuery
- Most DOM frameworks lock you into Webkit
- DOM frameworks use extra system memory and JavaScript libraries and CSS take longer to download
- Keep small and uncomplex DOM for fast manipulation
Enable Web server compression (GZip/Deflate)
Cache for performance

//Timed caching for freshness since last request:

Response.AddHeader(“Cache-Control”, “max-age=3600″);

Response.OutputCache(3600);

//Request always goes to origin server for validation:

Response.AddHeader(“Cache-Control”, “no-cache”);

//Instructs caches not to store sensitive data:

Response.AddHeader(“Cache-Control”, “no-store”);

Conserve battery life
- No auto-refreshing
- Be smart about JavaScript usage
The scourge of Transcoders
- They are proxies that reformat desktop web pages
- They might add mobile operator navigation bar to each page
- They might inject advertising from unknown sources
- They might replace original graphics with smaller/low res images
- Maintain your page integrity:

Response.AddHeader(“Cache-Control”, “no-transform”)

Reduce number of linked resources
- Use only one JavaScript file
- Use only one CSS file
- Use only one Cookie
- Check for and eliminate duplicate scripts
No client-side redirecting
Empty strings can cause unnecessary HTTP requests to the server