Ideas for fixing unconnected computing

I traveled quite a bit recently and got exposed to a negative aspect of current technology: Things work well if you have a solid internet connection with no traffic limits and are plugged into a power outlet. Otherwise, things do not work well at all. This blog post describes the problems that arise and suggests solutions.

Managing data traffic  #

Cell phones are quite good at conserving traffic, laptops much less so. This becomes a problem when your laptop has a mobile connection (e.g., via tethering or in a hotel with data caps). I once accidentally started iTunes in such a situation and immediately used up my daily allowance of traffic. Similarly, mobile email is frugal with traffic (only the current folder is updated, attachments are only downloaded on demand, etc.), desktop email is usually not.

How can this be handled better? I’d like to see three traffic modes for all operating systems: “full”, “restricted”, “minimal”:

• In full traffic mode, all data transfers are allowed and happen immediately and automatically.
• In restricted traffic mode, you are asked to confirm data transfers beyond a given limit (e.g. a few hundred KB). Apps also try to consume less data (e.g. they don’t periodically access servers, anymore; only when the user asks for it).
• In minimal traffic mode, as little as possible would be downloaded. For example, web browsers would never download high-resolution images or custom fonts. These are reductions that hurt, but still give you bare minimum services.

The currently active mode can be chosen automatically, in most cases (but manual override must be possible). Location seems an interesting criterion:

• At home, I have broadband and can use full traffic mode.
• Abroad, I’m roaming and every byte counts. I need minimal traffic mode.
• At a hotel, I have daily data caps and restricted traffic mode is appropriate.

Note that being connected via Wi-Fi does not necessarily mean that traffic is unlimited. Which mode to use could also be configured per network (cellular per carrier, Wi-Fi per WLAN).

Lastly, the same file is often downloaded multiple times. For example, the same image by several web browsers and by a Twitter client. Several apps could share a cache and traffic could be saved.

Syncing while offline  #

Automatically syncing one’s data via the internet has made operating multiple devices much easier. A few examples:

• With the IMAP procotol, one’s emails stay on the server and you have the same data on every device.
• With Dropbox and similar technologies, folders with files are synced across devices.
• Most browsers sync bookmarks, these days.
• Syncing photos makes cell phones even more convenient as cameras.

Alas, syncing doesn’t work if one is not connected. It would be nice if we could have peer syncing: create a WLAN and let the devices sync with each other, instead of with a server on the internet. Even in a broadband setting, it would help if one could peer-sync large downloads such as apps, OS upgrades, etc.

Handling intermittent connectivity  #

It is interesting to see how much apps and protocols are designed around continuous connectivity: Usually a task is aborted if there is a time-out. If connectivity is intermittent, one has to start from scratch every time one is connected. Therefore, the task will never finish if one cannot transmit all of the data in a single session, even if it could be done in multiple sessions. Additionally, you often have to re-try manually.

Again, some kind of queue seems useful: tasks requiring connectivity would be added to it and worked on incrementally, whenever there is a connection.

Additionally, I’d love to have a way to tell my device that I’m about to go offline for a longer time. It could then immediately download emails, web pages in reading lists, contacts, events, files, etc., without waiting for an app to start or a periodic timer to go off.

Managing power consumption  #

Operating systems (Windows 8, OS X, Android) are becoming increasingly adept at saving battery power: network requests are batched, apps put to sleep in the background, etc.

On desktop operating systems, I feel that I should get a warning if an app uses an exceptional amount of processing time. This is bad if you are running on battery power. But even if you are plugged in, you want such a warning, because processing-intensive apps can run for a long time without being noticed, while consuming considerable amounts of power.

When it comes to tethering, I like a feature that Apple has added to the upcoming OS X Yosemite: In your laptop’s Wi-Fi menu, you can see your tethered iPhone’s battery life and signal strength. Thus, there is no need to take one’s phone out of one’s pocket to check those stats.

A few tips for mobile computing  #

These are a few random things that I find useful when I’m mobile:

• Dropbox: My battery lasts longer if Dropbox doesn’t run. I then start it periodically, whenever I want to sync.
• git is excellent for working offline, because you can sync selectively and get unlimited undo.
• If I need complete control over mobile traffic, I only use my phone and don’t tether. That means that I won’t have the surprise downloads that can happen on desktop operating systems.
• BitTorrent Sync looks like a way to sync data between peers, but I haven’t tested it, yet. I’m curious to know whether it works even if you are completely offline.

Conclusion  #

Whenever I am mulling over the problem of unconnected computing, I keep coming back to the aforementioned task queue – an operating system service similar to a printer queue, to which apps post tasks that depend on being connected to the internet. Such a queue would have several advantages:

• Optimized operation under intermittent connectivity: The queue helps with finishing tasks in small steps, whenever there is connectivity and however long it lasts.
• Asynchronous workflow: You can always start a task, independently of whether you are currently online or not. If you are offline, finishing the task is simply delayed until you are online again.
• Activities that are currently hidden inside apps become visible and can be controlled. You can reorder and cancel them and you can request to be notified when one of them is finished.

Controlling traffic via the previously mentioned modes would work well together with the queue: If a task is too expensive for the current mode, you can pause it temporarily, until conditions become more favorable.

Further reading: The website of the “Offline First!” project (by the team behind Hoodie) describes many interesting ideas for improving the offline operation of apps (especially of web-based apps, but also of native apps).