Asynchronous Programming with C++

Asynchronous programming is a common pattern that vastly simplifies multithreaded programming. The idea is that a thread calls a function to be executed on a background thread. The call to the function returns immediately on the calling thread, and the function continues executing on the background thread. When the function is complete, the calling thread can get the results. A large percentage of multithreaded programming can be done using the asynchronous programming pattern. If the asynchronous programming pattern can be used in a situation, it is good practice to go ahead and use the pattern instead of creating a custom multithreaded implementation. A custom multithreaded implementation will be harder for other programmers to understand, and potentially more error prone. This article will provide a sample program illustrating asynchronous programming in modern C++.

In the sample program, there is a class called BackgroundWorker. BackgroundWorker has just two methods: DoWork() and DoWorkAsync(). DoWork() is a function that simulates a CPU intensive long running task. It generates millions of random numbers and sums them. DoWorkAsync() calls DoWork() on a background thread. Multiple DoWorkAsync() calls are made one after the other so they are executed in parallel on separate threads. The results of each DoWork() (i.e. the sum of the random numbers) is then retrieved and reported. The sample program is completely useless, but it illustrates running multiple execution threads of a function in parallel and then getting the results when they complete.

With C++ 11, the standard added the ability to do cross platform multithreaded programming with just C++. You no longer need to make operating system specific threading API calls to get the job done. The C++ standard added std::async() in the header for the purpose of calling a function asynchronously. The function can be any callable object in C++. That means a pointer to a function, a pointer to a member function, a functor, a lambda expression, or a std::function template instance. std::async() will return a std::future of the callable object which represents the execution return value when the background thread is finished. This return value is retrieved by calling get() on the future. If the background thread is still executing the function when get() is called, then get() will block until the function is done or throws an exception.

Here is the source code for the C++ command prompt program.

BackgroundWorker.h


#pragma once
#include 
#include 
#include 
#include 


/**	@class BackgroundWorker
*	Use to simulate a long running function through use of summing
*	random number generation. DoWork does this work synchronously.
*	DoWorkAsyn will call DoWork asynchronously. */
class BackgroundWorker {

public:
    BackgroundWorker();

    /**	Simulate doing long running calculation by summing randomly
    *	generated integers.
    *	@param[in] iRepeats  Number of random numbers to sum.
    *	@param[in,out] fAverage  As output, the average of all the random numbers.
    *	@param[in] callBack  Function callback called when processing is done.
    *		The long long parameter is the return value of this method.
    *	@returns sum of random numbers.
    *	@throws runtime_error if a certain random number is chosen a certain
    *		number of times. This is to simulate exception handling. */
    long long DoWork(long iRepeats, float& fAverage, std::function callBack);

    /**	Essentially calls DoWork() asynchronously.
    *	@param[in] iRepeats  Number of random numbers to sum.
    *	@param[in,out] fAverage  As output, the average of all the random numbers.
    *	@param[in] callBack  Function callback called when processing is done.
    *		The long long parameter is the return value of this method.
    *	@returns future of DoWork().
    *	@throws runtime_error if a certain random number is chosen a certain
    *		number of times. This is to simulate exception handling. */
    std::future DoWorkAsync(long iRepeats, float& fAverage, std::function callBack);

}; // end class BackgroundWorker

BackgroundWorker.cpp


#include "BackgroundWorker.h"
#include 
#include 
#include 

using namespace std;


BackgroundWorker::BackgroundWorker() {
}


long long BackgroundWorker::DoWork(long iRepeats, float& fAverage, std::function callBack) {

    cout << "Entering DoWork with repeats " << iRepeats << " on thread id " << std::this_thread::get_id() << endl;

    long long llSum = 0; // This is the return value of the sum of random numbers.
    fAverage = 0.0f;

    if (iRepeats < 0) {
        callBack(llSum);
        return llSum;
    }

    std::shared_ptr spRndEngine; /**< Mersenne twister random number engine. */
    std::shared_ptr spRndDistribution; /**< Int distribution. */

    // This is used to generate a seed for the random number generator. Time is no
    // longer recommended to use as a seed.
    random_device theSeed;

    // Use the seed in instantiating the random number engine.
    // Note the use of the () operator on the theSeed.
    spRndEngine = make_shared(theSeed());

    // Set up a uniform distribution of ints from 0 to 99.
    spRndDistribution = make_shared(0, 99);

    int iBadNumberHitCountLimit = iRepeats / 100 + static_cast(iRepeats*0.00003f);
    int iBadNumberHitCount = 0;

    for (long i = 0; i != iRepeats; ++i) {
        // This call uses the random engine in the random distribution to
        // create a random number from 0 to 99.
        int iRandomNumber = (*spRndDistribution)(*spRndEngine);

        // Simulate something going wrong by throwing an exception if a certain number
        // is hit a certain number of times. 66 is the bad number.
        if (iRandomNumber == 66) {
            iBadNumberHitCount++;
            if (iBadNumberHitCount >= iBadNumberHitCountLimit) {
                // Simulate some type of exception occuring.
                stringstream ss;
                ss << "Bad value processed. Number of repeats is " << iRepeats << endl;
                throw runtime_error(ss.str());
            }
        }

        llSum += iRandomNumber;
    }

    cout << "Exiting DoWork with repeats " << iRepeats << " on thread id " << std::this_thread::get_id() << endl;

    fAverage = static_cast(llSum) / iRepeats;
    callBack(llSum);
    return llSum;
}


std::future BackgroundWorker::DoWorkAsync(long iRepeats, float& fAverage, std::function callBack) {

    // Note the return value of this method is a future with return type of the function DoWork.
    // Note the use of std::ref() to pass fAverage by reference.
    // Note how address of member function is passed.
    // Note how the pointer to instance of class is passed after member function to call (e.g. this)
    // Pasing this is only required when passing a member function.
    // launch::async assures it is launched on another thread asynchronously.
    return async(launch::async, &BackgroundWorker::DoWork, this, iRepeats, std::ref(fAverage), callBack);
}

CPlusPlusAsyncCPApp.cpp


// CPlusPlusAsyncCPApp.cpp : This file contains the 'main' function. Program execution begins and ends there.
#include 
#include 
#include 
#include "BackgroundWorker.h"

using namespace std;


int main() {

    try {
        // Get the start time.
        using std::chrono::system_clock;
        auto tStart = system_clock::now();

        cout << "Starting program on thread id " << this_thread::get_id() << endl;

        unsigned int uiNumberOfCalls = 4; // This is the number of parallel, asynchronous calls
        // to DoWork to make.
        int iBaseRepeats = 10000000; // Base number of random numbers to sum.

        BackgroundWorker bw;

        // Set up vector of futures.
        vector vFutures;

        // Set up vector of averages of random number. This holds the fAverage output
        // parameter to DoWorkAsync.
        vector vfAverages;
        vfAverages.resize(uiNumberOfCalls);

        /**	Define the callback function for the asynchronous call. Note how the
        *	lambda signature matches the callback signature.
        *
        *	Note, this callback is actually running on the thread that calls it.
        *	To invoke something on the main thread, would need to post a message
        *	via OS call (e.g. PostMessage).
        *	@param[in] llSumm This will be the sum of random numbers. */
        function TheCallBack = [](long long llSumm) -> void {
            cout << "Entering callback on thread id " << std::this_thread::get_id() << endl;
            cout << "Callback is passed sum of " << llSumm << endl;
        };

        // Call DoWorkAsync uiNumberOfCalls in parallel.
        for (int i = 0; i != uiNumberOfCalls; ++i) {
            // Note how the number of repeats is incremented for each call. This is so the calls can be
            // distinguished.
            vFutures.push_back(
                bw.DoWorkAsync(iBaseRepeats + i, vfAverages[i], TheCallBack)
            );
        }

        // Note, instead of using a callback to know when the DoWork is complete,
        // you could also poll the future with the Is_ready() method. If true,
        // then the execution thread has finished. Is_ready() does not block.
        // Is_ready() is experimental. You can also use wait_for(0) to check if 
        // the future is ready. wait_for() with a non-zero duration will block
        // for up to that duration waiting for the future to be ready. get() will
        // return the return value of DoWork. If an exception is thrown
        // by DoWork, it will be transferred to this main thread at the time
        // of calling get(). get() does block until the executing thread is done
        // or an exception is thrown.
        for (int i = 0; i != uiNumberOfCalls; ++i) {
            long long llSum = vFutures[i].get();
            cout << "Returned with sum " << llSum << " and average " << vfAverages[i] << " for number of repeats " << iBaseRepeats + i << " on thread id " << this_thread::get_id() << endl;
        }

        // Get the end time and output the duration.
        auto tEnd = system_clock::now();
        auto durationRun(tEnd - tStart);
        using std::chrono::duration;
        cout << "Run duration: " << duration(durationRun).count() << " milliseconds" << endl;

        cout << "Ending program on thread id " << this_thread::get_id() << endl;
    }
    catch (exception & e) {
        cout << "Exception caught! Message: " << e.what() << endl;
    }
} // end main

The C++ code above is nicely commented. Reading those comments should explain most of the functioning. The C++ program illustrates features you would probably want to use in a real world program. For example, it shows how to pass a parameter by reference so you can use an output parameter in an asynchronous function (see fAverage parameter in DoWork() and DoWorkAsync() methods).

Exception handling is also illustrated. The DoWork() method can throw an exception if a specific random number is called a specific number of times. The exception does not happen on most runs. You have to run the program multiple times to see the difference between when DoWork() completes successfully on all threads, or when one of the threads throws and exception. If one of the threads throws an exception, the exception is percolated back to the main calling thread. It is important to understand that if an exception is thrown, it does not happen at the call to DoWorkAsync(). The call to DoWorkAsync() simply returns immediately a future to the method. The call to get() on the returned future is when the exception will percolated back to the main calling thread. Putting a try-catch around the future::get() is how you would catch exceptions thrown by the asynchronous function.

It is important to understand that when get() is called on the future, if the asynchronous method is not done executing, it will block the calling thread until it is done. When it is done, you will either get the return value of the asynchronous method, or an exception will be thrown if the asynchronous method throws an exception. get() blocking may be unacceptable in some situations. If this was running on the main UI thread for example, blocking could be unacceptable. You could call wait_for(0) to see if the future is ready. The 0 passed will cause wait_for() to return immediately. Unfortunately, this amounts to polling, and polling can be awkward to orchestrate while also keeping the UI responsive.

This example also illustrates passing a callback std::function to the asynchronous method. When DoWork() is done, the callback function is called by DoWork(), passing the return value to the callback function. You do not need this callback function if you are fine with just using future::get(). I wanted to also show the option of the asynchronous method calling a callback when done. Though not shown in this example, you could post a message on the message queue in the callback function. This will trigger an event when processing is done. This will allow your UI to know right away when processing is done without polling or blocking. Since the callback is called by DoWork(), the callback runs on the background thread that DoWork() is running on. This means you will not be able to access UI controls from the callback; thus the reason the callback will need to post a message to cause something to happen on the UI.

Here is an example of the program’s output when all the threads succeed:

Starting program on thread id 13304
Entering DoWork with repeats 10000000 on thread id 10868
Entering DoWork with repeats 10000001 on thread id 14528
Entering DoWork with repeats 10000002 on thread id 9752
Entering DoWork with repeats 10000003 on thread id 1036
Exiting DoWork with repeats 10000001 on thread id 14528
Entering callback on thread id 14528
Callback is passed sum of 495023730
Exiting DoWork with repeats 10000000 on thread id 10868
Entering callback on thread id 10868
Callback is passed sum of 494943204
Returned with sum 494943204 and average 49.4943 for number of repeats 10000000 on thread id 13304
Returned with sum 495023730 and average 49.5024 for number of repeats 10000001 on thread id 13304
Exiting DoWork with repeats 10000002 on thread id 9752
Entering callback on thread id 9752
Callback is passed sum of 494986882
Returned with sum 494986882 and average 49.4987 for number of repeats 10000002 on thread id 13304
Exiting DoWork with repeats 10000003 on thread id 1036
Entering callback on thread id 1036
Callback is passed sum of 495006297
Returned with sum 495006297 and average 49.5006 for number of repeats 10000003 on thread id 13304
Run duration: 281.249 milliseconds
Ending program on thread id 13304

As can be seen from this output, four DoWork() invocations occur one after the other, all on different threads. This gets all four threads working in parallel. As the DoWork(s) complete, you see the trace of exiting DoWork and entering the callback. Since the callback is called by DoWork, the callback and DoWork run on the same thread. This is evident by the thread id reported. The statements beginning with “Returned with sum …” come from the main function on the main program thread. The finishing of the threads does not necessarily happen in the order the threads were launched. It is random the order the threads complete. But the reporting back on the main thread following the future::get() call will always be in the order the threads were launched. This is because future::get() blocks until the thread either finishes or throws an exception. This is not as bad as it might seem because, while it is blocking on the main thread waiting for the first thread to finish, all the other threads are running in the background. The time it takes to call future::get() on all four threads is roughly the time it takes for the longest running thread.

Here is an example when one of the threads throws an exception:

Starting program on thread id 10668
Entering DoWork with repeats 10000000 on thread id 2044
Entering DoWork with repeats 10000001 on thread id 11016
Entering DoWork with repeats 10000002 on thread id 5932
Entering DoWork with repeats 10000003 on thread id 13068
Exiting DoWork with repeats 10000001 on thread id 11016
Entering callback on thread id 11016
Callback is passed sum of 494945635
Exiting DoWork with repeats 10000003 on thread id 13068
Entering callback on thread id 13068
Callback is passed sum of 494999070
Exiting DoWork with repeats 10000000 on thread id 2044
Entering callback on thread id 2044
Callback is passed sum of 495124183
Returned with sum 495124183 and average 49.5124 for number of repeats 10000000 on thread id 10668
Returned with sum 494945635 and average 49.4946 for number of repeats 10000001 on thread id 10668
Exception caught! Message: Bad value processed. Number of repeats is 10000002

As can be seen, the third thread throws an exception. The exception is percolated to the main thread when future::get() is called on the third thread. The main()’s try..catch catches this exception, and thus you see the “Exception caught!” message. Once the exception is caught, the programs terminates, and you never get the results back from the fourth thread.

Well that concludes this tour of asynchronous programming in C++. A lot of your multi-threaded programming can fit into the asynchronous pattern nicely. When it can, using the asynchronous pattern saves coding time, saves time for other programmers to understand your code, and potentially saves time to debug errors. Happy coding!

Copyright © 2020 by Jeffery Lewis. All rights reserved.
Published by WalletCard.org.

Why Microsoft’s Mobile Strategy is Unclear

At the October 2, 2019, Surface Event, Microsoft finally revealed to the world what they have been working on. Back in February 2018, I wrote a blog article explaining why Microsoft has the best long term mobile strategy despite the failure of their Windows 10 Mobile platform. Microsoft will be making phones again, but it is not what I thought. This article is an update to the original article given the latest information from the Surface Event.

First, I want to expand on a computing vision that the original blog article discussed. Back in 2015, when the first Windows 10 Mobile phones came out, Microsoft made a video showing the new Lumia 950 series phones. In the video, a man sets his phone on the table. On the table was a high definition TV, and a wireless keyboard and mouse. The phone presumably connects to the TV with Miracast, and the keyboard and mouse connect with Bluetooth. The Windows 10 Mobile device goes into Continuum mode where something very similar to Windows 10 desktop was presented on the TV. The man was then able to use his phone pretty much like a desktop computer and was shown running Office and searching the web like he was on Windows 10.

This was not a concept video. The Lumia 950 phones running Windows 10 Mobile could actually do this back in 2015. UWP apps that where engineered for various form factors could scale from phone to desktop beautifully. Though they retired Windows 10 Mobile, I was under the assumption this form factor agnostic vision would be refined with a new version of Windows based on Windows Core OS. This new version of Windows we now know is called Windows 10X.

Microsoft showed off their new Surface Duo phone at the event. This is essentially the dual screen Surface Andromeda that was leaked several years back. The big surprise is the Surface Duo is running Android. The Surface Andromeda had been initially developed to run an earlier version of Windows 10X. It seems Microsoft decided to switch to Android to increase the marketability of the Surface Duo. The Microsoft Store does not have anywhere near the apps in Google Play. If the Surface Duo ran Windows 10X, people would most likely still need either an Android or iOS phone for mobile app workflows. Microsoft is presuming only the most die hard Surface fans would buy a Surface Duo running Windows 10X due to limitations with apps. The mobile app landscape is slowing changing to be web based instead of native. This happened with PCs decades ago where web apps slowly replaced native programs. Native programs remain, and always will, but most work on the PC is done through the browser. This will be true for mobile in time. When that occurs, the OS platform will not be as relevant when it comes to app availability.

Prior to the Surface Event, I thought Microsoft was on track to make a pocket PC as their long-term mobile strategy. Is the dream of a pocket PC dead? Will we have to continue to live in a form factor fragmented computing world? The fragmented computing world of today has us using Windows on devices with screens 10 inches or above, but then when we go smaller, we have to switch devices, operating systems, accounts, and apps. This is expensive, time consuming, and more complicated. I think with Microsoft putting Android on the Surface Duo (instead of the initially intended Windows 10X), it makes the Windows pocket PC dream ambiguous, but does not rule it out for the long term.

The vision I have for the future is where each person of a household only has a single computing device. This single device would be in the form factor of a pocketable device. To use other form factors, the household would have a 2-in-1 lapdock and a dual monitor docking station for shared use. A 2-in-1 lapdock looks like a 2-in-1 laptop/tablet, but does not have the computing internals. It has monitor, keyboard, standard ports, power supply, and battery. You would use a USB-C or Thunderbolt cable to connect the pocket PC to the 2-in-1 lapdock. Connecting the pocket PC to the 2-in-1 lapdock would essentially enlarge the form factor of the pocket PC. The OS, accounts, settings, and installed apps would of course be identical. To get a full desktop experience, household members would plug their pocket PC into the docking station. Here you would get two large monitors, a full-size keyboard, and mouse. The docking station would also have ports for even more peripherals. Here, once again, the form factor is even more enlarged for maximum multitasking and productivity, but the computer itself has not changed. In this type of arrangement, apps would need to support multiple form factors. The UWP app development technology allows multiple form factor support.

I think the computing vision described above is simpler and more cost effective. In your household today, how many computing devices do you have? It would not be unusual to have 2 to 3 devices per person. Each person generally is managing multiple devices, multiple operating systems, multiple accounts, large form factor apps, small form factor apps, and the thousands of settings across multiple operating systems and apps of different form factors. This takes a lot of time and money to manage! There is also the time it takes to learn operating systems and apps. It typically takes me a few months of using an app to work out all the use cases and configuration permutations. During this break-in period, I am experimenting with settings, and fumbling with usage. This learning curve is real and costs time. The pocket PC vision promises a single computing device per person. You only have to set up, organize, and master a single device, but you can extend your form factor through these docking devices. I thought Microsoft was set to fulfill the pocket PC vision. With the Surface Duo running Android, things are unclear.

Microsoft may have a trick up their sleeve. I think they will provide support for UWP apps to run on Android and iOS. This will allow you to use the same app on Windows as you do on your Android and iOS device. This will help bring a unified app eco system closer to reality provided it incentivizes developers to develop UWP apps. But porting the UWP runtime and UWP apps to other platforms does not really complete the single device per person vision. You will still need a separate device for small form factor.

If you had a large “Columbo” style coat with an oversize interior pocket, the Surface Neo would fit into it. Could you consider the Surface Neo a pocket PC then? For people that didn’t see the Surface Event, the Surface Neo is the larger version of Surface Duo. The Surface Neo though runs Windows 10X. The Surface Neo is mobile, but just not pocketable in a standard pants pocket. I still think this is a pretty good accomplishment. You could get down to two devices per person. Right now, I’m not sold on the Surface Neo dual screen form factor. If I had my choice, I would want the guts of the Neo put into a Surface Go form factor. Todays Surface Go is mobile and can dock to larger monitors. My blog article goes in-depth about the capabilities and versatility of the Surface Go.

I am bothered by the fact Microsoft has a prototype of the Surface Duo running Windows 10X. Windows 10X was originally intended as the operating system for the Surface Duo. Would the Surface Duo running Windows 10X sell as a consumer phone? Probably not. But would the Surface Duo sell as an Enterprise pocket PC? I think that would slowly gain traction in the Enterprise market and then spread to the consumer market. I could see hospitals using a Windows 10X Surface Duo where users are moving around a lot, but then can dock at a shared docking station to get multi-tasking intensive work done. Microsoft can deliver something new here. Google and Apple are not able to delivery something like this in the near term. I think Microsoft should offer the Surface Duo with an Intel and Windows 10X variant to sell alongside with the ARM and Android version. Microsoft would not be really competing with phones. They would be offering a new type of device. Microsoft can bypass getting back into the phone race and beat everyone to market with a fully featured pocket PC. But will they do this? That unfortunately is unclear.

Copyright © 2019 by Jeffery Lewis. All rights reserved.
Published by WalletCard.org.

 

Surface Go Review: Delivers Far More than Expected

Surface Go shown with Type Cover and Surface Pen

The Surface Go was released August, 2018. I got mine for the holidays and have been using it for about five months. I have always considered the Surface line of hardware to be nice, but pricey. The Surface Go starts at $399. This significantly lower price point led me to look into the Surface Go as a travel computer. I would like to share my experiences with the Surface Go.

Configuration Design: It’s a Tablet and Laptop

The Surface Go is the smallest Surface device. It looks like a baby Surface Pro 6. The Surface Pro 6 and Surface Go are 2-in-1 configurations, which means they are a tablet and a laptop. The entire computer is essentially a tablet slab. When used without a keyboard, input is from the touch screen or pen. In this mode, these devices run Windows 10 in tablet mode. When the specially designed keyboard is attached, Windows 10 is used in desktop mode where keyboard, touchpad, and mouse input can be used along with touch and pen. The keyboard, or what Microsoft calls the Type Cover, is very nicely designed. It attaches to the tablet body with magnets. Power to the Type Cover is supplied by this special connection. You do not need to worry about charging the Type Cover. Taking the Type Cover on and off is very fast. Windows 10 detects when this happens and, provided you have the tablet mode setting to switch Windows 10 mode without asking, Windows 10 will go to desktop mode automatically when the Type Cover is attached, and go to tablet mode when the Type Cover is removed. The Type Cover also doubles as a very nice screen cover when you close the Type Cover on the screen, hence the name. Another cool design feature allows the Type Cover to be folded behind the screen. This is nice if you don’t have a place to put the Type Cover, and you want to use the device as a tablet. When you fold the Type Cover back behind the screen, Windows 10 will detect this and switch to tablet mode. A final nice design feature of the Type Cover is a secondary magnet that attaches the Type Cover to the tablet body. This will put the Type Cover at a raised angle for optimal typing comfort.

The Surface Pro 6 and Surface Go come with a high quality “kick stand”. The kick stand folds out from the tablet body. The kick stand has a wide range of motion. It can be adjusted to give a slight tilt when set on a table as a tablet, and then adjusted to holding the device more vertical when used like a laptop. It will stay in place in whatever position you leave it. When used as a laptop with the keyboard, the kick stand is required to hold the screen up. Some have wondered if the kick stand inhibits the “lapability” when used like a laptop. I have found that the Surface Go fits fine on my lap. The kick stand can be near the edge of my knees though, so people with smaller laps might have issues with the kick stand falling off your knees.

The Type Cover and kick stand, from strictly an ergonomic design perspective, has many advantages over an iPad. The iPad has no kick stand, so it must be held up with one hand when used as a tablet. Third party keyboards for the iPad use Bluetooth which will require the keyboard to be charged. I have found the Surface Go kick stand to be extremely useful. I also have found that switching between tablet mode and laptop mode to be very fast. My Surface Go sits in the kitchen as a tablet with the kick stand propping it up at the perfect viewing angle. The keyboard is nearby so can be quickly grabbed and attached if needed. This setup and central location have made my Surface Go very popular and well utilized.

Should You Get the Type Cover?

So, if you want to utilize the full potential of the Surface Go, I would get the Type Cover as an optional accessory. Most content creation activities are better suited using a keyboard. The more expensive Alcantara keyboard is backlit. This keyboard sells for $130, which I think is overpriced, but it does feel nice and the typing experience is good. Keep in mind, the keyboard for the Surface Go is smaller than a full-sized keyboard. The touchpad though is spacious. I got used to the smaller keyboard very quickly and now love typing on it. For a keyboard of this size, it is nice that it has dedicated Home, End, PgUp, and PgDn keys. Many keyboards on up to 14-inch laptops force you to hold down a function key to access these keys. One thing I don’t like about the keyboard is that it only has a Ctrl key on the left side. I have trained myself to use keyboard shortcuts extensively and have an invested muscle memory with right Ctrl key shortcuts. I’m still adapting to having just the one Ctrl key.

Though the Surface Go sells as a tablet without any of its optional accessories, the Surface Go is a full-fledged Windows 10 computer. Many applications for Windows 10, and even parts of the Windows 10 operating system, are not well suited for touch only. In these workflows, without the keyboard, you will be limited. Take Windows 10 File Explorer for example. I have yet to figure out how to select multiple files with only touch. With a keyboard, you hold down the shift or ctrl key along with mouse click to select multiple files. And it should go without saying that if you want to do a lot of typing, a keyboard is mandatory. So, I don’t consider the Type Cover optional. I understand why they sell them individually. The Type Cover could be used across different versions of the tablet. You may upgrade your tablet, but not your Type Cover. Keep in mind, if you have a Surface Pro Type Cover, it will not work with the Surface Go. It will be too big. So get the Type Cover, and I would splurge the extra $30 to get the backlit Alcantara version. The fabric feel on the Alcantara is super nice.

Should You Get the Surface Pen?

I think you should get the Surface Pen, even if you don’t expect to be doing much drawing or other types of pen-based work. There are times where UI elements on applications, and even web sites, will be too small on the Surface Go. It will be hard to select with a finger. An example of how a pen is much more precise than a finger is with highlighting text in an e-book. It is hard to nail the exact words using your finger, but it feels just like highlighting a real book using the Surface Pen. There are many applications, particularly web sites, that implement mouse enter, leave, and hover events. This simply will not work with touch. You cannot hover your finger over some control on a web site. This is very common on menus that drop down automatically when the mouse enters the menu, or menus that cascade as you move over sub-items. If you have the Type Cover with you, using the touchpad solves this problem. If you don’t have the Type Cover with you, then you will get frustrated with the web site unless you have the Surface Pen. The Surface Pen is held onto the side of the Surface Go by a strong magnate. I just leave it there for when it comes in handy. If I come across one of these web sites that forgets there is a world of touch out there, you can grab the Surface Pen to hover over the glass of the tablet. The pen can communicate proximity. This will act like mouse hover to the web site. An example of this kind of problematic web site is Internet Movie Database. Their menus on the desktop version of their web site will drop down when you touch them, but then once you release, they disappear. They are expecting a mouse to do this.

If you do a lot of conference calling, you may find the Surface Pen nice if you have to “whiteboard” something. And if you are an artist, there simply is nothing like the Surface Pen on the market right now. Windows 10 pen input with the Surface Pen takes in angle and 4096 levels of pressure which is communicated via Bluetooth. Applications must know how to read this information to leverage it. There are a growing number of artist applications that can utilize the pen input information to give realistic simulations of paint brushes and other drawing tools. I am not an artist, but I played around with some applications that fully utilize the Surface Pen. The Surface Pen experience is simply awesome. Even on a modestly priced computer like the Surface Go, there is no lag. It really feels like you are drawing on paper. So, get the Surface Pen. I think you will find it worth the $99 price.

General Impression of the Surface Go Experience

I got the 4 GB RAM and 64 GB storage model of the Surface Go. I thought I was going to use the Surface Go just for travel, so I didn’t want to pay extra. I didn’t expect it to become the dominate device of choice. When home, I use the Surface Go more than my laptop and phone combined. When at a hotel, I use the Surface Go more than my phone, and I have no need for the laptop. When away from wi-fi, then of course my phone becomes the dominate device.

The form factor of the Surface Go hits a unique sweet spot between a tablet and laptop. It is super portable. Without the Type Cover, it weighs just 1.15 pounds (522 g). With the Type Cover, it weighs 1.68 pounds (762 g). It is so small and light that you could throw it in a bag or backpack and not even notice you have it. But, you can still get work done on this thing. The screen is big enough to use browser-based web apps if you cannot find a Store app for what you want. The Surface Go is light enough as a tablet to make an e-reader for those digital books where you need something bigger for diagrams and tables.

The screen looks great. It is very sharp and can get bright. It is a 10-inch screen with 217 pixels per inch and 1500:1 contrast ratio. The 3:2 aspect ratio makes the screen taller when in landscape, which is great when in laptop mode, but also nice in tablet mode. I find I use tablet mode in landscape most of the time due to the 3:2 aspect ratio. I use portrait mode when doing immersive reading.

Many tech reviewers on the web have criticized the Surface Go for being under powered. It would seem that way if all you did is look at benchmarks and compared the Surface Go to much more expensive laptops. Microsoft has struck a nice balance between performance, size, weight, battery life, and price. If you currently have a laptop or desktop with a spinning hard drive, I believe you will find that the Surface Go will feel faster for most tasks. I have a 5400 RPM hard drive laptop, and my Surface Go feels faster all around. Booting is fast, coming out of hibernation and standby is fast, opening apps is fast, browsing is fast, and opening Office documents is significantly faster than my aging laptop. And I have the 64 GB eMMC drive, which is slower than the 128 GB SSD that is available on other configurations of the Surface Go. I suspect it will seem a bit faster with the 128 GB SSD model. The Intel Pentium Gold 4415Y processor with integrated Intel HD Graphics 615 does get the job done for most tasks. It will fall short for current high-end games, though you can do light gaming on the Surface Go. I suspect doing video editing might seem slower than a high-end laptop due to the slower processor. On most tasks, the Surface Go responds with very little lag, and scrolling of web pages is very smooth and responsive. Panning and zooming maps in Microsoft Maps is extremely smooth and enjoyable with the touch screen. The truth is, todays 8th generation Intel i5 and i7 laptops are extremely powerful. The Intel Pentium Gold 4415Y gets a 1941 single threaded Geekbench 4 processor score. The Intel Core i5-8265U, a popular 8th generation chip in laptops, gets a score of 4042. The multi-core scores respectively are 3815 and 12,184. The Intel HD Graphics 615 onboard the Surface Go gets an OpenCL score of 17,415. A populate integrated graphics chip on today’s laptops is an Intel UHD Graphics 620, which gets an OpenCL score of 23,435. A high end Nvidia GeForce GTX 1080 Ti gets a 215,390 score. These numbers may make you think twice about the Surface Go, but from hands on experience of day-to-day tasks performed on the Surface Go, I wouldn’t worry about the scores. You won’t be able to play high end games or edit large video files quickly, but you will be able to do a lot on the Surface Go for an entry price of $399. This video puts the Surface Go through extensive tests with audio production software. Audio production software can be very demanding on a computer, and the Surface Go proved capable of producing professional music. Sitting here now typing this blog article in Word, my Surface Go processor is only using 2% of its capacity according to Task Manager. I would not notice the difference if I had a much more expensive 8th generation Intel chip editing a Word document.

Regarding battery life, I seem to be getting about 7 hours of typical use. Microsoft rates it at 9 hours of video playback. I find 7 hours to be plenty. Battery life can vary all over the place depending on what you are doing. Surfing the web with repeated smooth scrolling is a pretty energy demanding task for any computer. So, if you are hitting web pages repeatedly, with rapid smooth scrolling, you can expect to get less than 7 hours. People think web surfing is light computing, but it is not given today’s information intense web sites and the rendering demands of smooth scrolling.

I have found the Surface Go to be a superior form factor over a laptop or phone in the following activities:

  • immersive reading a document or book with diagrams and tables
  • referencing recipes while cooking
  • watching movies or TV.
Surface Go is perfect for referencing recipes while cooking
Surface Go is perfect for referencing recipes while cooking

As mentioned earlier, the Surface Go is small and light enough to make a good e-reader. Where a 6-inch e-reader is too small for books with diagrams and tables, the Surface Go 10-inch screen in portrait mode is the perfect size and weight. A laptop is too cumbersome and bulky for immersive reading, and obviously a phone is way too small for complex documents. When cooking, the Surface Go in tablet mode propped on your kitchen counter is perfect for referencing a recipe. It is not too bulky to get in the way, and the touch screen is perfect if some scrolling is required. My wife gets a lot of recipes from the web, but has always printed the recipe when it came time to cook it. Putting a laptop on the kitchen counter just doesn’t work. The Surface Go is allowing to truly transition to digital recipes. Finally, watching movies or TV on the Surface Go is a great experience. The resolution, color accuracy, and headphone sound quality are very good. You can watch movies or TV on a phone, but on the Surface Go, it just looks way better due to the bigger screen. You could also do this on a laptop, but the weight of the laptop starts to encumber the experience. When watching movies or TV, the built-in kick stand is super handy. I consider watching movies or TV on the Surface Go with headphones to be a better experience than on my big screen TV provided you are watching alone.

Connecting Things to the Surface Go

The Surface Go is the first Surface product to have a USB-C port that includes DisplayPort output and power delivery. The Surface Go comes with a 24-watt adapter that connects to the proprietary Surface Connect port. If you don’t have your Surface Go adapter, you can use most USB-C chargers. The supplied adapter is rated at 15 V with 1.6 amps. Check your voltage and current of your USB charger. It should be a minimum 5 V with 3 amps (15 watts). Anything less than 15 watts will not be enough to charge while also using the Surface Go. The maximum power input to the USB-C on the Surface Go is reported to be rated at 45-watts. Most chargers though can communicate with the device being charged and step down their power delivery if the maximum adapter output exceeds the maximum device input. So, using a “smart” USB-C adapter over 45 watts is probably safe.

The USB-C power delivery is great when traveling. If you have a phone that also charges with USB-C, you only need to take one charger with you. You can leave the Surface Go adapter at home. If you have an iPhone, you can buy adaptors that output USB-C and USB-A. The USB-A can be used with a USB-A to Lighting cable to charge your iPhone, and a USB-C to USB-C cable can be used to charge your Surface Go.

The Surface Go can be docked to extend its connectivity. You have two choices on the port to use for docking. You can use the Surface Connect port on the Surface Go, or you can use the USB-C port. If you use the Surface Connect port, you would need to buy a Surface Dock. The Surface Dock will give you two Mini DisplayPorts, gigabit Ethernet, 4 USB A 3.0, and audio out. If you use the USB-C port, your connectivity will depend on the dongle or dock you use. Plugable makes a USB-C 4K Triple Display Docking Station with Charging Support. Using this dock with the Surface Go, you should be able to connect two 4K monitors at 60 Hz. Both the Surface Dock and the Plugable dock will also provide power delivery to the Surface Go through the single Surface Connect or USB-C connection. So, you don’t need to worry about the Surface Go running out of battery power while docked.

If you find you need extra storage, there is a microSD slot right under the kick stand. You can get up to 1 TB of extra storage. I recommend getting a UHS-I, speed class U3 card. This will give you the best speed for your money, but do not expect read and write speeds to be faster than the eMMC or SDD drive. Windows 10 allows you to move apps to a microSD card if you are running out of room on your main drive.

You can also wirelessly connect to monitors and digital audio using Miracast. Roku and nearly all smart TVs are equipped with Miracast though it may not be called that on the device. I’m able to wirelessly connect to my TV with 4K resolution as a second monitor. Photographs look amazing this way.

Windows 10 in S Mode

Windows 10 in S Mode is supposed to be for security and better performance. When in S Mode, you can only install apps from the Windows Store. Apps from the Store are vetted by Microsoft, so should not have viruses. Also, UWP apps from the store can be better controlled in terms of the resources the app can use. A lot of people complain that their Windows 10 computer gets slower and slower over time. This is not Windows 10 getting slower, this is your computer getting bogged down with Win32 programs running things in the background. S Mode is not faster. It is just less likely to get bogged down with legacy programs over time. If you take a new Surface Go and take it out of S Mode, it will not slow it down.

I tried to stay in S Mode. I lasted about 2 months, then I decided I needed to install a conferencing app from the web. I checked with Task Manager to make sure the Win32 conferencing app did not hog resources while it wasn’t loaded. It was well behaved. In that case, I was lucky because the Win32 app was well behaved. If you continually install badly behaved Win32 programs, over time your performance will degrade.

My recommendation is to just go ahead and take it out of S Mode. You do that via the Store. There is a link in your Settings that will take you to the place in the Store to take it out of S Mode. See below for more information.

Some Windows 10 Settings and Configurations Best Suited for a Surface Go

If you happen to have bought the 64 GB model, you will want to be careful about storage on your main drive. After I set up my 64 GB model, with Office, Netflix, and Sling installed, I had 40 GB left over. For major Windows 10 feature updates, you will typically need 6 to 11 GB of free working space to perform the update operation. Major feature updates happen twice a year: once in the Spring and once in the Fall. For the May 2019 (1903) update, Microsoft has announced you need 32 GB of disk space to store the operating system. This will include a new 7 GB reserve set aside to help with disk space availability for things like updates and temporary files.

Windows 10 will get maintenance updates usually on Tuesdays. These updates will start to accumulate on your main storage. I recommend turning on Storage sense to automatically purge unnecessary files on a regular schedule. Go to Settings > Storage > Storage sense, and set to on. Continue further by clicking “Change how we free up space automatically”. Here you can specify how often to run Storage sense and what type of files to free up. The scheduled Storage sense will not free up all type of files. You should run Disk Cleanup at least once a month to purge other files. You can run Disk Cleanup from the properties dialog of your drive by right clicking the drive in File Explorer and selecting Properties, and then click the Disk Cleanup button.

Aside from managing your storage, here are some other settings and configurations of interest:

  • Take out of Windows 10 in S Mode. Go to Settings > Update and Security > Activation for the link to the store for your free upgrade to Windows 10 Home edition.
  • Use OneDrive On-Demand. OneDrive On-Demand allows your files to only take up storage when accessed over the network. Right click OneDrive cloud icon in System Tray, select Settings, in settings dialog click Settings tab, then check “Save space and download files as you use them”. You can also control at a folder level to always keep select files on the local drive. In File Explorer, right click a folder, then select “Always keep on this device”. This way you can have some files networked, and others available for offline use.
  • Use Power Throttling. This will minimize background process CPU utilization. When device is on battery power, click the battery icon in the System Tray. Set the Power Mode slider to “Better battery”. When plugged in, repeat this process, but instead set the Power Mode slider to “Best performance”. There is no need to use power throttling when plugged in.
  • Lower display brightness when on battery. When on battery power, go to Settings > System > Display > Change brightness, to set brightness to about 50% or lower. This will have the greatest impact on how long the battery lasts. When plugged in, go ahead and set brightness to 100%. Windows 10 will remember the setting for each power mode.
  • Try Edge. Edge is already installed so you have a browser without taking up extra storage to install another one. If you feel you absolutely must have a different browser, I challenge you to just try Edge for two weeks. You will probably find your life will be pretty much the same. Edge is being rewritten to use the Chromium engine. This is the open source engine the Chrome browser is based on. When the new Edge is available (expected late 2019 or early 2020), it will be largely redundant to install Chrome.
  • Use Windows Defender. Remember when I was talking about badly behaved Win32 programs. Well it is my opinion that third party anti-virus programs are the worst offenders. If you don’t carefully monitory their settings, they will go off and do excessive and unnecessary processing like defragmenting your hard drive, and cleaning your registry. Windows Defender will keep you safe, will not get in your way, will not suck power out of your CPU and battery, and will not take up extra storage to install.
  • Automatically switch to tablet mode. Every time you attach or remove the Type Cover, you are not going to want to click a confirmation. Go to Settings > System > Tablet mode > When this device automatically switches tablet mode on or off, select “Don’t ask me and always switch”.
  • Make text bigger. You might find that text is too small on the Surface Go. Go to Settings > System > Display > Change the size of text, apps, and other items. It defaults to 150%. If you find things are too small, try 175%.
  • Set single click to open in File Explorer. When in tablet mode, double tapping to open something in File Explorer is very awkward. In File Explorer, File menu > change folder and search options > Folder Options dialog General tab > select Single click to open an item (point to select) radio button.
  • Make a Taskbar toolbar for the desktop. When in tablet mode, you will not have access to your desktop icons. You may have handy links to documents on your desktop. Right click the Taskbar, select Toolbars > “New toolbar…”. When the folder selection dialog opens, navigate to your user account folder, then select the Desktop folder. This will put a toolbar on your Taskbar called Desktop that will have shortcuts to your desktop icons that you can access when in tablet mode. If you change icons on your desktop, this toolbar will stay in sync automatically.

Which Surface Go Configuration Should You Buy?

I have the 64 GB storage model. I regret getting this version due to space being tight. Give yourself a little more breathing room and get the 128 GB SSD configuration. This will raise the price by $150, but I believe it will be worth it if you plan to use your Surface Go regularly.

Summary

Surface Go shown with backpack
Surface Go shown with backpack

I didn’t expect to use my Surface Go so much. I thought it was just going to be for traveling. I ended up loving the Surface Go. My wife also loves it. Microsoft’s execution of the device hits a magical sweet spot in terms of size, weight, performance, and price. The small size is perfect for single task content creation or media consumption. The small size also makes taking the Surface Go with you a no-brainer. Just throw it in your bag and you got a full computer in case you need one. I love traveling with my Surface Go, but I also love using it around the house. I didn’t expect to love using it at home. I wouldn’t say my laptop is collecting dust, but my laptop utilization has been cut down by about 80%. To me, the Surface Go is an extremely successful purchase because it is getting used and enjoyed extensively. I think how well a device is executed is determined over time by its utilization. I have used my Surface Go for five months, and my wife and I gravitate to it over the laptop and phone. That tells you the slower processor doesn’t really matter. There is no irritation from being slow. Microsoft got the things that matter right. The gorgeous display, fluid touch response, and ultra-portable size make the Surface Go a winner.

Copyright © 2019 by Jeffery Lewis. All rights reserved.
Published by WalletCard.org.

 

How I Solved My iPhone GPS Problems

I have recently purchased two new iPhone 8s; one for myself and one for my wife. By and large, the iPhone 8 works well except for one major flaw – the GPS doesn’t always work. GPS is by far my most beloved feature of a smartphone. When I was getting GPS failures, I was pretty upset.

So I tried everything on this article. All the suggested workarounds did nothing for both phones. I still could not get Apple Maps and Here WeGo to reliably navigate. After extensively testing both phones and in different locations, I came to realize bad GPS reception was causing the problem.

I used the app “GPS Diagnostic” to measure satellite signal strength. What I found is certain locations in my car have no GPS reception with the iPhone 8. What is interesting is that it matters if the car is running. If the car is not running, GPS works great everywhere in the car. Once the engine is started, GPS reception drops to nothing over much of the dash.

I managed to find a location on my dash where the iPhone 8 got decent GPS reception (thanks to “GPS Diagnostic”). I have used two hardware-based navigation systems and three smartphones in this same car, and in the location where the iPhone 8 will not work. All five of these devices had no GPS reception issues. This tells me that the iPhone 8 has bad RF noise rejection when it comes to GPS reception. This is seriously disappointing. My expectation for these high-end and expensive devices is that something as basic as GPS reception and its ability to reject RF noise, should be on the upper end of performance. Instead, the iPhone 8 has extremely poor performance. Apple, I’m not impressed. Please fix this.

Copyright © 2019 by Jeffery Lewis. All rights reserved.
Published by WalletCard.org.

 

Why Microsoft Still has a Strong Mobile Strategy

The title of this article seems absurd on the surface, especially since Microsoft just announced last October that Windows 10 Mobile will be discontinued. In addition to announcing they will be discontinuing Windows 10 Mobile, they announced they will not be making any devices for Windows 10 Mobile. And also, it is very clear that Microsoft has failed to capture market share on phone devices. Then how can Microsoft have a strong mobile strategy?

Microsoft has a strong mobile strategy based on their current and future road map of their Windows 10 operating system and application development technologies. This article will make a case that Microsoft has a strategy to converge the form factors of desktop, laptop, tablet, and phone into a single version of Windows 10, and that this positions them for a strong, long term future with mobile.

We should first review the general trends in computing to get some sense of where the future of computing is headed. The computing power of smartphones in the ten years they have been around has increased dramatically, all the while maintaining a pocketable form factor. The specifications of current flagship smartphones read like that of a laptop computer. Smartphones now have multi-core, high clock rate CPUs, and a lot of RAM. The Samsung A8 sports 6GB of RAM. The OnePlus 5 sports 8GB of RAM. Even though they have specifications like a laptop, are current smartphones as powerful as a laptop? Over the years, PCs have prioritized shear computing power without really constraining their power supply. Phones on the other hand, have put energy consumption as an important priority. When one limits the amount of energy a CPU can consume, that will impact how much computing power it can produce.

To try to answer the question if current flagship phones are approaching the power of a laptop, I downloaded from the Microsoft Store the AnTuTu benchmarking tool. AnTuTu is a respected benchmarking tool originally used for Android devices. It is now ported to iOS and Windows 10. AnTuTu is a native implementation for Android (as opposed to Java virtual machine implementation). I would assume it is a native implementation on iOS. In Windows 10 though, if developed in C#, it would be similar in performance to a Java virtual machine implementation. So, though AnTuTu is ported to these platforms, you cannot be sure computing power is compared equitably because of the unknown differences in the final native execution of the benchmarking tests. The benchmarking results have to be used to just broadly compare performance between different platforms and hardware.

If you look at the AnTuTu’s web site, the iPhone 8 Plus gets a total score of 217,385 (October 2017 results). The OnePlus 5 get a score of 181,047. The Samsung Note 8 get a score of 178,079. Running the benchmarking tool on my Windows 10,  Intel i3 computer with 6GB of RAM and Intel integrated graphics, I got a score of about 151,000. This is a six-year-old laptop mind you. Running it on my Windows 10, Intel i5 with 8GB of Ram and Intel integrated graphics, I got a score of about 192,000. This is a four-year-old laptop. Running on my son’s Windows 10, Intel i7 with 8GB of RAM, solid state drive, and Intel integrated graphics, I got a score of about 275,000.

As you can see, current flagship phones are getting pretty impressive benchmark scores when compared to an older laptop. These phones still have some ways to catch up when comparing to current day laptops. I suspect PCs with a dedicated graphics card would get even higher scores. None the less, this little comparison shows that a phone could be used for the processing duties typically used on a PC.

Not only have phones been getting more powerful, time using a phone as compared to time using a PC has increased dramatically. This has led to higher and higher expectations from phone apps. People are no longer expecting watered down phone apps, but apps with complete feature sets so most workflow scenarios can be carried out on the phone.

So now with powerful phones and powerful apps, there is one problem that phones have. Phones are too small. The phone form factor is its current limitation on what you can productively do on a phone. Without a full keyboard and reasonably sized screen, it doesn’t matter how powerful a phone is or how powerfully designed the apps are; you still are limited by the form factor. It becomes too awkward to have to zoom and pan documents, keep switching web pages and/or apps, and to type with your thumbs.

This is where Microsoft, Apple, and Google seem to agree that what needs to happen is convergence between the various form factors present today. That is, there needs to be some form of convergence between desktops, laptops, tablets, and phones. Convergence will allow continuity between phone apps and their operating systems with that of larger form factors typically found on desktops and laptops.

So now I’d like to talk about Microsoft’s strategy on this convergence and why I believe Microsoft is considerably ahead in this effort. Windows 10 Mobile may be on its sunset, but that doesn’t really matter. Microsoft is building Windows 10 in a way they don’t need a specific mobile version of Windows 10 to run on a small device like a phone. They have to retire Windows 10 Mobile because it is not cost effective to maintain if it no long has any distinguishing features from the upcoming Windows 10.

Microsoft has been working on this convergence since at least Windows 8. They managed to get Windows 10 and Windows 10 Mobile to share what they called at that time OneCore. They also got a type of monitor connection called Continuum that allows a Windows 10 Mobile phone to give a desktop like experience when connected to a larger monitor, keyboard, and mouse. HP sold a phone called the Elite X3 that really took to spirit how Windows 10 Mobile could be used like a desktop with the Continuum feature. The Elite X3 had a docking station to hook up to a large monitor, keyboard, and mouse. The Elite X3 also had what they called a lapdock. This is something that looks just like a laptop, but only has display and power. It has no computing capability or storage. When you hooked up the Elite X3 to either the docking station or lapdock, Universal Windows Platform (UWP) apps scale appropriately for the given monitor size. It does not look like just a phone app enlarged. I have a Lumia 950 Windows 10 Mobile phone that also has this Continuum capability. When you launch a UWP app on a larger monitor, it is very hard to tell you are not on regular Windows 10.

There are differences though between Windows 10 Mobile Continuum and the PC experience on Windows 10. For one, windows are not resizable with Continuum. The app window will fill an entire monitor. It seemed appropriate then to keep adding feature improvements to Continuum to bring it closer to a true desktop experience, but this would not be cost effective given Microsoft’s long-term plans.

Microsoft is working on a new Composable Shell (CShell). A shell control things like the start button, start tiles, taskbar, and window title bar with minimize, restore, and close controls. In other words, it is the binding UI framework that allows you to interact with Windows 10 and its programs. Windows 10 currently has a shell for desktop and tablet. Windows 10 Mobile also has a shell optimized for a phone size screen, touch interface, and the standard Windows 10 Mobile phone buttons. With the new CShell, it will be possible for a single device to take on multiple shells forms. Depending on the context of the display and input devices, Windows 10 with the new CShell will be able to be phone like on a small device, and PC like on a larger form factor. This is why they don’t need Windows 10 Mobile going forward. Windows 10 will be able to be phone like without the need for a separate mobile edition of Windows.

Microsoft has also just recently launched Windows 10 on ARM. ARM is the CPU architecture that nearly all phones run on. Windows 10 on ARM can run on the latest Qualcomm CPU and allows you to run older Win32 style applications. It allows you to run Win32 style applications using emulation similar to how x64 Windows can run x86 programs with the WOW architecture. Windows 10 on ARM also does not loose it connectivity when put to “sleep” (sleep is in quotes because I’m not sure if Windows 10 on ARM even calls it that). These laptops have continuous cellular connectivity through the Qualcomm cellular modem. So the “sleep” on the Windows 10 on ARM laptops is more like when you lock a phone; a lot of stuff is suspended, but connectivity stays up so communications can continue to arrive.

If you really think about all the building blocks Microsoft has, and the fact that todays phones are almost as powerful as a laptop, they are not far from being able to make a pocketable PC that is also a phone. If you take a Windows 10 on ARM laptop, add a telephony stack, add the new CShell, and then shrink it down to the size of a phone, you basically have a pocketable PC that is also a phone. They already know how to put a telephony stack on an ARM platform (e.g. what was already done on Windows 10 Mobile). The new CShell is the missing piece. To be fair though, it is a bit more complicated than that. Windows 10 still ships with a lot of accessory applications that use the older Win32 style of application. An example of this is File Explorer. Microsoft is working to port these accessory applications to Universal Windows Platform (UWP, to be explained in more detail further down). Having these accessory applications as UWP will complete the experience so they can be used on a small form factor.

What is not clear though is if such a pocketable PC is going to be able to run Win32 applications. This is where Microsoft is working on this thing called Windows Core OS. This will essentially modularize Windows 10 so that OEMs can pick and choose what modules they add to the deployed OS. On future devices with Windows 10, using the new Windows Core OS, the OEM can choose to not include Win32 support. The main reason to omit Win32 would be the resource demands Win32 support requires. For starters, Win32 support requires more storage space to install the OS. Also, Win32 support may not be as energy efficient given many scheduled tasks and services required of Win32. So there could be pocketable PCs that can run older Win32 application, and there could some that do not.

Microsoft has also a new development standard they introduced in 2015. It is called Universal Windows Platform (UWP). This development standard is modernized over the 20 some year old Win32 application standard. UWP is designed to write once, and deploy on many different form factors and device types. UWP apps can target Windows 10, Windows 10 Mobile, HoloLens, Xbox, IoT, and Surface Hub. UWP apps are more secure than Win32 applications, and have better transparency on the resources they are consuming. UWP apps also have better permission control for granting access to hardware resources such as sensors, and data such as contacts.

Unfortunately, there is the perception that UWP is just for mobile. This is very far from the truth. Microsoft is fully committed to UWP. The plan is to gradually retire Win32 and transition to UWP. New features are not being added to Win32. New features like inking and mapping are only being added to UWP. When Microsoft announced they were retiring Windows 10 Mobile, several companies soon there after announced they would be retiring their UWP apps. The reasoning being if there is no more Windows 10 Mobile, then why support their UWP app. UWP apps also run great on the desktop provided the app designer considered the desktop form factor in the UI design. I use many UWP apps on my laptop such as Edge, Mail, Calendar, People, Calculator, Maps, Sygic, AccuWeather, Sling, and Netflix, to name a few. I’m finding the UWP experience on the laptop form factor to be better than the equivalent web app. They load fast and interact fast. They also can run in the background to forward notifications and down load communications. And they are better to run on a laptop than a phone because the screen is bigger, and you have a full keyboard. In fact, since the UWP app on my Lumia 950 phone is essentially the same as the app on my laptop, the cognitive learning curve and usability is identical between the phone and laptop. I do not prefer a form factor just because I know how to use the program on that form factor better. They are identical. I pick a form factor to do something more on what is easier to use by nature of the form factor, and what form factor is currently accessible. If both the laptop and phone are both accessible (like when I’m home), I’m finding I am using the laptop form factor just because it is more productive on the larger screen and full keyboard. This is what starts to happen when the forces of platform convergence take shape. You don’t pick a platform just because that is where you have the app installed for a particular task. You pick a platform based on the most productive and accessible form factor. When a pocketable PC is available, and you have it connected to a lapdock or larger monitor, you will be able to do PC AND phone like tasks all in one experience. For example, you will be able to comfortably work on a document, AND text someone with SMS, or take a phone call. So app developers, please don’t think of UWP for just phone development. With the capabilities of convergence upon us, you have to think of UWP apps being used on multiple form factors; small and large.

So, is convergence really upon us? Microsoft is allegedly working on Project Andromeda, which has been associated with a Surface branded phone. Project Andromeda will be the first released versions of Windows 10 using Windows Core OS (e.g. the modular form of Windows 10). It will run on ARM using the Qualcomm Snapdragon 850 chip. I suspect Andromeda will have a CShell supporting a “phone” like experience, one for two small monitors, one supporting a tablet experience, and one supporting a laptop or desktop experience. The Andromeda device will have two phone size screens connected by a hinge. When the device is open, it will be a small tablet. The device will be able to fold in half, and when folded, will be pocketable. It will have a telephony stack, so will be able to do phone like things. When connected to a dock, it will use the desktop CShell and has the potential of replacing your PC. It is unclear if it will support Win32. Some sources are saying it will support Win32, but maybe not on the first release. This device sounds really great, but is it real? Microsoft has not made any formal announcements, but most reliable sources are expecting Andromeda to be released some time in 2018. And OEMs like Dell are on board with releasing their own version of an Andromeda like device in 2019. Convergence is coming!

Life with convergence will be simpler. I am really looking forward to this. Image having just one device for all your computing needs. You only have one device to purchase, configure, and maintain. You only have one device to purchase, install, and configure apps for. You only have one version of an app to learn how to use with one consistent experience. And sharing of data between platforms, like between a phone and desktop will be one less thing to have to set up. You will be able to do tasks for the best suited and accessible form factor. You won’t really have to think about how you have all your devices setup and configured to deal with all your workflow use cases and mobility needs. And with 5G coming in the near future, it is very likely users will just bypass WiFi for connectivity. 5G will have cellular connectivity forecasted in the gigabit speeds, which will be faster than what you can get with WiFi. So your one device will have the same connectivity where ever you go; away from home or at home. And only having one device is going to save you money. Think about how we purchase computing power today. We are paying a lot of money to have near similar computing power for three form factors (e.g. little phone, tablet, and desktop). Just as a basic estimate on what a family of three is paying for all this redundant computing power, say a family of three each has a laptop, tablet, and phone. Estimate $900 for a laptop that lasts four years. Estimate $600 for a tablet that lasts three years. Estimate a phone that costs $800 that lasts two years. Do the math. That comes to over $200 a month; or close to $2,500 a year; or $25,000 a decade! We need something simpler.

A pocketable PC is inevitable given the trends in computing power and miniaturization. What people are going to have to ask themselves, is what operating system are they going to want on this one device they own. Everyone has their own reasons, but let me share my thinking on this. Apple makes great devices. But that is their business model. They sell devices. When you go with Apple as your operating system, you can only choose between devices that Apple provides. I do not like having this limitation. I like for market competition to be able to make competing devices with different feature sets and price points. Android is a great operating system, but unfortunately, Android is an operating system for a throw away culture. OEMs love Android because it is free and they can modify it. Once they have provided maybe a few updates to a device, they have already moved on to the next great thing. They essentially abandon an older device, and the device will stop getting updates. This, in my opinion, is not acceptable. This one device is going to need updates in a world where hacking is common place. OEMs of Android device are not motivated to provided updates for the long term because it is not cost effective to keep maintaining these custom Android builds, and it allows them to differentiate OS features only available if you purchase a newer device. They want you to essentially throw away your old device and get a new one if you want it to be safe, and be able to run the latest stuff. These reasons are why I’m rooting for Windows 10 to be this one OS I will use for this one device. I think Microsoft can pull off this world of computing convergence.

So Microsoft has a strong mobile strategy because they have a strong strategy for computing convergence. We have to stop thinking that mobile means phone. Mobile just means small in size, connected with cellular, and can run on battery power. PCs of the future will be highly mobile and will be able to make phone calls. App developers will need to make apps that can deal with multiple form factors. Once we can all break this biased thinking that mobile means phone, we can enjoy and look forward to the world of computing convergence that is coming.

Copyright © 2018 by Jeffery Lewis. All rights reserved.
Published by WalletCard.org.