Musings – Page 3 – Andrew E. Scott

Can we talk about the back button?

I am one of those people who is not loyal to a particular smartphone platform. There are some people who say this, but truly, I switch between having an iOS based phone and an Android based phone every couple of years. I feel it is my professional obligation to ensure I am aware of the trends relating to smartphones in general, and so I switch.

I have recently switched to using the iPhone 12 Mini after using Android devices for the last couple of years. I love that Apple has added a smaller phone again to their current range, as I like to be able to fully use a phone one-handed as I walk along. It is great that this phone supports 5G. Unfortunately, I am also deeply missing having a back button on the device.

It is a little bizarre to me that I need to explain this, as I’ve come to realise that some people who have exclusively used Apple iOS devices for their entire lives don’t even realise that Android devices have a back button. This is an on-screen, virtual button (it used to be a physical button) that you can tap to take you to the previous screen you were on, and can keep tapping it until you get back to the home screen. It is conceptually the same as the back button in a web browser. Now, I am aware that some recent Android devices have started to do away with the back button also, but I am choosing to believe that this is just a short-lived fad.

The Android back button is just a simple user interface element, that it is only when it goes missing do I realise how much navigational heavy-lifting it provides. At any point, in any app, you know exactly where to tap to exit the screen you’ve ended up in. There is no need to figure it out based on visual cues that an app might choose to show. Just like in a word processor (or really any application that allows you to create things), you know you can always Undo, and it’s always the same mechanism. There’s not a different way to Undo a typo compared with an accidental deletion or a formatting glitch.

On the iPhone, the way to leave a given screen is up to the app and can be quite inconsistent. The emerging approach is to use the left-to-right swipe gesture, which is quite elegant, although there is no visual indicator that this will work so you need to be told about it, and also be prepared for it not to work at all. It would be great if it simply worked all the time, the way the Android back button does. So, this post is also a little bit of a plea for something like that to happen.

I suspect that people who are regular Android users don’t need to be convinced, so my audience is more iPhone users who don’t realise how inelegant the user experience is. Hence the rest of this post will be actual examples showing what I’m talking about using screenshots from my current iPhone device.

a screenshot of the Messages app on the iPhone

Above is a screen within the Messages app. It has a place on the screen in the top left corner with a “<” symbol so that we know that we can go back to the previous screen in the app by tapping this. We can also do a left-to-right swipe to achieve the same thing. So far, so good.

However, say we arrived at the Messages app by searching for the app rather than tapping on its icon in the home screen…

In this case, there is now also a little label “◀ Search”, that, if we tap on, takes us back to the search box. Tapping the “<” takes us to a different screen in the Messages app, and so does left-to-right swipe. So, it’s a little bit messier, but at least there’s a convention that the “going back” options are in the top-left corner, and left-to-right swipe does the same as “<“. Or maybe not.

a screenshot of the Photos app on the iPhone

This is a screen within the Photos app, displaying a cute pic of my parents’ dog. There is a “<” in the top-left corner to take us back to the photo Library within Photos. However, doing a left-to-right swipe doesn’t do the same thing. Instead, it scrolls to the photos immediately to the left of the displayed photo. So, the swipe gesture isn’t reliable, but is the position of the “going back” option in the top-left of the screen reliable?

a screenshot of the Safari app on the iPhone

Well, this screenshot is from the Safari app, where the “<” symbol is shown at the bottom-left. Although, this little bar of symbols disappears as we scroll through a page, and is shown only when we then scroll up. However, in this case the left-to-right swipe does perform the same action.

Now, tapping on the rightmost icon to show the open tabs…

This takes us to a visual display of the open tabs, but to exit this and return to the previous browser screen, we need to tap “Done” in the bottom-right corner. Additionally, left-to-right swipe doesn’t navigate us anywhere, and risks closing one of the open tabs if we’re not careful. We’ve now found exit prompts in three out of the four corners, but can we find an example of it in the top-right corner? Why, yes.

a screenshot of the App Store app on the iPhone

This is a screenshot from within the App Store app. If you are on the Search screen, and have searched for something of interest, but then change your mind, the only way to navigate back to the main Search screen is to tap “Cancel” in the top-right corner. Left-to-right swipe doesn’t do it either, unfortunately.

There are other examples we could look at where there is instead an “X” symbol or the word “Done” in the top-left corner, and the left-to-right swipe doesn’t work in these cases either. I hope you’ve gotten the idea.

There is no consistency around which corner the “no, I want to stop and go back to where I was before” symbol or word appears, or even what the symbol or word should be. Sometimes the left-to-right swipe works, sometimes it doesn’t, and sometimes it could scroll within the content or even delete it. There is actually an alternative that provides a single, consistent mechanism, and it’s called a back button.

Long ago, in 1987, Apple introduced something called HyperCard, which was software for the Apple Mac computers of the time. HyperCard was a huge thing and has influenced many aspects of computing we still use today, including web browsers. Instead of screens or pages, HyperCard displayed “cards”, and the cards were arranged into what it called “stacks” (although we would call them apps or web sites). Most relevant to our discussion, looking at the HyperCard user manual from 1987, there is this interesting snippet on page 5:

You can always go back: Another way to see the previous card is to press the Tilde key. Stacks in HyperCard often link to each other (a concept you’ll learn more about later). While the left arrow brings you to previous card in the stack you’re looking at, the Tilde key brings you to the last card you saw, no matter what stack it was in.

So, yes, Apple pioneered the concept of a back button. It is time to bring it back.

Diversification is the silver bullet

This post originally appeared over on Medium.

So, they say there are no silver bullets, but for dealing with uncertainty, diversification is as close as you can get. Instead of betting that the future will turn out one way, spread your bets across a diverse portfolio of likely possibilities.

I haven’t buried the lede, so there is going to be no surprise twist here, but I wanted to tease this out to show how widely applicable this concept is.

Company boards are made up of directors that need to make decisions about the future of the company. No-one knows the future for certain, so the background and experience of the decision-makers is critical for how good their decisions are. Instead of having every decision-maker with the same background and experience, having a spread of backgrounds and experiences improves the quality of the board. There are several pieces of research showing this, but one example reported in Forbes shows that, compared with individuals, a gender-diverse team makes better decisions 73% of the time, and teams that also have age and geographic diversity are better 87% of the time.

There is a danger that this seems completely obvious. Let’s just pause for a little and consider that it’s actually a little counter-intuitive. There is a proverb that has been around since the 16th century that too many cooks spoil the broth. Certainly, for a complicated task, an individual with deep expertise can often accomplish it better than a team. In fact, to underline that point, the same study reported in Forbes from before noted that diverse teams are more likely to struggle to put their decisions into action.

The difference is between complicated and uncertain. A complicated task can be made easier through the application of appropriate tools, skills and experience. Applying these things to an uncertain task doesn’t make it less uncertain. Producing a 7 day weather forecast is complicated. Getting it completely correct is uncertain.

This same logic applies in the world of venture capital. A VC firm will raise a fund to invest in a portfolio of startups, rather than just one. However, the same VC firm will typically seek out startups that each aim to win in a single market or technology area. Knowing which startup will become a unicorn is uncertain, so is best approached in a portfolio fashion. A VC fund of $50M could include something like a dozen startups, and there’s a well-known rule of thumb that only a third of startup investments will return more than their initial investment. (On the other hand, executing a startup is a complicated endeavour, and it benefits from simplifying and focussing where possible.)

Sometimes a VC firm develops an investment thesis for their fund, such as where they believe a particular technology or market should be the focus for their investments. Here’s a collection of over a dozen different VC investment theses, but a stark example is when Kleiner Perkins announced in 2008 that they would form a fund to invest in iPhone (and later iPad) app companiesdue to their belief in the potential of Apple’s iPhone. However, such VC firms still consider the winners in that space to be uncertain, and hence diversify their investments across multiple possible winners, e.g. Kleiner Perkins ended up investing in 25 companies. Similarly, investors in such a focussed fund (known as limited partners) are likely to diversify their investments across multiple VC funds, in order to mitigate the uncertainty that a particular investment thesis is wrong. An example here is Yale’s endowment fund, which historically invested in funds across VCs such as Andreessen Horowitz, Benchmark and Greylock Partners.

When it comes to corporate innovation, the lessons are the same. A particular corporate should take a portfolio approach to emerging opportunities. There might be some hypotheses that a corporation has developed about the opportunity sizes in particular markets, products or technologies. However, no one knows for sure how the future will turn out, so spreading risk across multiple opportunities is prudent.

The recent book from Geoffrey Moore called Zone to Win argues that a company can incubate only one major new business at a time, or risk spreading executive attention and corporate resources too thin. While there are examples of large companies like Amazon, Baidu, Apple, Google and Microsoft who are able to incubate multiple such initiatives at once, there are few companies at this scale.

However, when the expenditure and resources required to progress a new initiative are relatively small, and the likelihood of success of such an initiative is still very uncertain, it makes a lot of sense to spread the company’s investment across a number of these initiatives. Diversification may involve a range of possible time horizons, market segments, product areas, or technology domains. Spread the risk to increase the chance of overall success.

Whether it is the uncertainty relating to having relevant experience for board-level decisions, knowing which startups will hit home runs, or picking the right opportunities to explore within a corporate innovation function, the silver bullet is the same. Diversify across a variety of good options.

Patience is a virtue

This post is essentially a reposting of an article that I published on Medium a couple of months ago. I am giving the Medium platform a go, for topics that are more aligned with my professional life, but I don’t want to risk that the content disappears if Medium disappears. So, I’ll likely repost everything here a little afterwards.

I was speaking to an industry colleague in the innovation space, and commented to them that in corporate innovation, it was important to have patience. They blinked and restated what they thought I meant, that it was important to be tenacious. This revealed a surprising fact for me: that it wasn’t universally understood that patience is a virtue.

In the world of innovation, startups are often revered. The innovation that has come out of the international system of VC-backed tech startups is unarguable. Accordingly, in the land of corporate innovation in particular, it makes sense to seek to learn from the startup ecosystem, and apply their proven approaches into a corporate setting. Tools like design thinking, lean canvas, and the daily stand-up are examples of this.

However, innovation in a corporate environment requires a different approach to innovation in a startup, and not all of the startup lessons translate directly. Mark Searle from UC Berkley has recently made some insightful comments about that. I will add another — that the startup lesson about the the virtue of tenacity doesn’t translate directly either.

Before I go on, I’ll share some quick definitions so we’re all on the same page. Tenacity is the unwillingness to give up, even in the face of defeat. Patience is the acceptance that true success will take a while.

In my experience, it is the latter that better supports a culture of innovation within a corporate environment. That said, good innovators are not complacent, they do not accept the status quo, and they are driven to create a better world.

The reason that patience is a virtue in corporate innovation is due to corporate efficiency. Corporates are often set up so that the same idea isn’t funded in multiple places. In fact, there is usually a natural place for a particular idea to be explored, whether it’s in the IT group, marketing, or product development. If an idea fails, and most ideas do fail, it is unlikely that the same place will fund a similar idea again immediately. Effectively, a failed idea becomes taboo for a period of time.

How does this relate to patience? Well, getting the timing of an idea right is often a key part of success. However, since having an idea “too late” is a terrible outcome, people naturally err on the side of being “too early”. When a too-early idea fails, a successful corporate innovator will take the lessons from the failure, wait until the conditions are right, and then resurrect the idea. This time, the timing is likely to be better and the execution better informed. It requires an acceptance that true success can take a while, and often doesn’t come the first time.

Tenacity can be poisonous in this environment, with the unfortunate innovator continuing to push an idea within a company even after it has failed and become taboo. The reputation of both the idea and innovator can be harmed, and neither may end up working at the company in the future, depriving the company of real value.

However, in the startup ecosystem, tenacity is valued by the VCs who back startups run by tenacious people. A VC fund doesn’t live or die by the performance of a single startup, but VCs maximise their chances through knowing a startup will keep trying to find product-market fit while they keep funding it. They can then shift follow-on funding rounds towards startups that are performing better, and let the other startups run out of cash.

Many successful people from the startup ecosystem make their way into corporate innovation. They won’t have seen much patience within a startup; startups are all about urgency. Perhaps when they see patience, they associate it with lack of drive. However, corporate innovators have as much drive as innovators anywhere, and if one idea is paused, they will be progressing one of several other ideas. Corporate innovators often have many irons in the fire.

If you’re coming from a startup world into the corporate one, try to practice your patience. Sometimes the best strategy for helping an idea work out in the long term is to put it on ice for a while. When you thaw it out later, you may be surprised at how important your patience was for its success.

A conducting robot

I play the flute in The Essendon Symphony orchestra, and in the lead-up to our March concert, the conductor asked if I might borrow a robot from work. The concert was a celebration of comics, movies and pop culture, so the robot ended up conducting part of a Dr Who music number. For those interested, here’s how I got a robot to conduct an orchestra.

The robot in question is a version 5 NAO Robot, and is a type of programmable robot used in certain high schools and universities around the world. It is about 60cm (2 feet) high, and can walk, talk, respond to speech, identify faces, and move its limbs like a human. There are Python and C++ SDKs for writing software, or you can use (like I did) a visual programming tool called Choregraphe.

Different versions of NAO are supported by different versions of Choregraphe. Based on descriptions from the NAO documentation, I could tell I had V5, and hence I needed to download V2.1 of Choregraphe from the NAO software resources webpage.

It was easy enough to follow some of the NAO tutorials to learn how to use Choregraphe. The project that I wrote is available in a GitHub repo for general interest.

The project has blocks for conducting in 3/4 time (used in the project) and 4/4 time (not used in the project). It is set up to automatically start when the middle head sensor is touched, by using the launch trigger condition MiddleTactilTouched. After saying some amusing words, it conducts for 17 bars, controlled by the Counter box. At the same time, it is sensing for whether either of the other two head sensors are touched, and if they are, the Counter will stop the conducting. The robot will then say some more hilarious stuff, pause for a bit (for the real conductor to turn it around to face the audience), and then it will wave. Ta dah!

Learning how to use the tools and program the robot to do this sort of project took only a couple of days, so I can see how it could be useful in a highschool or university setting. The level of articulation in the joints is pretty amazing, and I look forward to this sort of technology becoming more widely available.

One issue: after getting the robot to conduct for a long period, it started to complain of over-heating, so I was comfortable with 17 bars, but I don’t think it could conduct a whole concert. But, not that the orchestra would want that!

Hacking the Alexa grammar

For Christmas, I got myself an Amazon Echo Dot (and I wasn’t the only one). For me, it’s been a fun and more convenient way to play music in our living room area, and I’ve been listening to more music as a result. I also had the idea that it would be nice to build some speech-driven interfaces to things.

It has been over a decade since I did speech recognition work. Speech recognition was used in one of the early projects that I did after I first left Uni, where I was part of a team that built a speech-driven personal assistant. It was a little ahead of its time, and never went anywhere.

Still, I thought I could put those slighty-rusty skills to use on the Echo, since Amazon provides a way to create Alexa skills (the name given to apps that run on the Echo behind the scenes). My idea was to use the Echo to provide a way to help the kids with maths, since they love to talk to “Alexa”.

Last week, my skill was published on Amazon’s list of Alexa skills. It allows someone to say “Alexa, tell me now if 1 plus 1 equals 2”, and will respond by saying that they’ve gotten this correct (or not). Unlike the basic Alexa functionality of doing maths, where someone might say “Alexa, what is 1 plus 1”, this skill forces the speaker to offer the answer and have it checked. This should be useful to anyone wanting to test their maths, and it supports addition, subtraction and multiplication. Basic users would probably use small numbers, but advanced users can use large numbers – the skill supports it all. Not negative numbers or zero, though!

Doing the coding behind this was straightforward; it was some simple Node.js code that runs on AWS Lambda. What was less straightforward was sorting out the grammar to use.

In speech recognition, the word “grammar” refers to the set of different phrases that an application can recognise at a point in time. A simple grammar is one that consists of just the phrases “yes” and “no”. A complex grammar might include every product for sale on Amazon itself and different ways to order them. The grammar is used by the speech recognition engine to improve its recognition, since it doesn’t need to always listen for every possible word in English, but only the specific words that are contained in the grammar.

To develop an Alexa skill, you need to hack together the basic Alexa grammar, together with an “invocation name”, and then the grammar that the skill itself can recognise. (Here, I’m using the word hack in its art-of-programming sense, not in the computer-intrusion sense.) Usually, the invocation name is a pronoun, e.g. “Dog Facts”, “Starbucks” or “GE Podcast Theatre”. However, it can be any set of words, and there is alternative dog fact skill that uses the invocation name “me a dog fact”.

This last one doesn’t seem to make sense until you remember that there is a grammar that comes before the invocation name. It starts with a “wake word” (one of “Alexa”, “Amazon” or “Echo”), then a variety of commands based around words like “tell”, “ask”, “start” or “open”. So, the invocation name gets added to this grammar, e.g. “Alexa, tell” + “me a dog fact” which makes a lot more sense.

Amazon publishes a list of constraints relating to invocation names. For my application, it would have been easiest to develop it using an invocation name like “Math Test” and then users would interact with it like “Alexa, ask Math Test to check if 1 plus 1 equals 2”. However, I wanted to see if I could do something that was easier for users.

Initially, I tried out the invocation name “me if”, which would produce nice interactions like “Alexa, tell me if 1 plus 1 equals 2”. However, using “if” violates one of Amazon’s constraints around invocation names, so I needed to find something else. That’s how I ended up with “me now” as my invocation name. Interactions become slightly longer, but still workable, like “Alexa, tell me now if 1 plus 1 equals 2”. To make this approach obvious to users, the skill is named “Tell Me Now”.

Now, I just need to get the kids to speak to Alexa about maths instead of music.

And remember, there’s no such thing as a bad idea

That is the cue – “remember, there’s no such thing as a bad idea” – for beginning the sport of suggesting ideas to my fellow brainstormers. However, instead of spurring me to reckless idea generation, it always stops me in my tracks while I re-evaluate the brainstorm facilitator. There is clearly such thing as a bad idea.

Playing in traffic while blindfolded.

Taste testing the contents of the laundry cupboard.

Stripping during a speech to parliament.

Assaulting an armed police officer.

It’s not hard to brainstorm them. So, why begin an exercise with people whose opinions you value by telling them such utter nonsense?

There are good intentions behind it, I admit. Even bad ideas may have the germ of a good idea hidden within them, and maybe one of the other brainstormers can bring that forth. Encouraging people to speak their ideas without thinking about their worth can improve the pace of the brainstorm session. Disruptive ideas can come from those outside of a field, because traditionally such ideas would have been considered “bad” by those inside the field.

On the other hand, perhaps merely being accepting of bad ideas is not going far enough. I’ve found that I can generate many more ideas of much greater variety if I focus on just generating bad ones.

Suggesting ideas in a language you don’t speak.

Brainstorming with just one person in the room.

Miming ideas to the other brainstormers.

Providing the same ideas as from the last brainstorm.

Overall, it is recognised that constraints enable creativity. The restricted forms of the haiku, sonnet or even limerick are able to result in enjoyable poetry. So, it’s understandable that coming up with “any idea, whether good or bad” will result in less creative ideas than coming up with “only bad ideas”.

Still, I don’t know why “only bad ideas” seems to work better for me than “only good ideas”. Maybe it’s simply that there are more bad ideas than good ones? Unfortunately, I can’t see a brainstorm session achieve a useful outcome if everyone involved is aiming for the worst ideas.

So, I’ve had an idea for how to harness the power of bad ideas in brainstorming. At the start of the session, the facilitator gives each brainstormer a note with either Good or Bad on it – which they keep secret from the other brainstormers – and this states the type of ideas they need to suggest. Maybe just a third of the brainstormers are given Bad, since their ideas will otherwise likely outnumber the Good ones.

This should help with improving the volume and diversity of ideas in brainstorms. In this case, the brainstorm facilitator will need to cue the start of the session with something like “Remember, I want to hear your ideas, even if they are bad.”

Tell me if this works for you, since I’m not sure if my idea for better brainstorming is a good or bad one.

Thinking of changes to traditional brainstorming.

Putting those thoughts out in public.

Child Wrangling

When I go on a long work trip, I often end up buying some books, because it is one of the rare times that I get to selfishly spend uninterrupted hours just reading. In September, I had a trip where I picked up a couple of parenting books.

My kids are getting bigger, and while at the moment I can get them to go where I need them to go by picking them up and taking them there, this is not sustainable. When we had babies, I read a bunch of books about how to get through that stage, but I hadn’t educated myself on parenting primary-school-age children. So, I picked two best-selling titles that seemed to have differing perspectives, and figured by reading both I would get a good coverage of the space. Now, by writing about them here, I am forced to understand them well enough to explain them.

<br /> The first book was 1-2-3 Magic by Thomas W Phelan. It is all about how to improve the behaviour of children 2-12yo through “effective discipline”, and is currently rated 4.7 out of 5 stars on Amazon (139 reviews). It is written by a child psychologist and is an easy read. I would say that this book has a basic assumption that children are happy and well behaved when they know what behaviour is required of them.

<br /> The second book was Calmer, Easier, Happier Parenting by Noel Janis-Norton. It is all about how to improve the behaviour of children 3-13yo through “five strategies” and is currently rated 4.5 out of 5 stars on Amazon (27 reviews). It is written by a child educator and is a comprehensive theory and practice for child-raising. This book has a basic assumption that children can work out what they are supposed to do, and will do the right things when they are supported appropriately and when doing the wrong things no longer works.

I seem to recall that I was a near-perfect child. So, my memories of how my own parents raised me should not be relied upon, and I find that I need to come up with things that suit my kids. Hopefully they will look back and think they were near-perfect as well.

Despite taking different approaches, the two books do agree on some aspects. There are five common strategies that I have noticed, and they seem reasonably sensible:

Don’t ignore bad behaviour.
Stay calm and don’t shout.
Always follow through.
Spend quality time with each child.
All caregivers in a house act consistently.

However, there is probably more that they disagree about than they agree, as you may guess from their differing assumptions about children’s behaviours. In addition to the above five common strategies, Phelan’s book proposes two fundamental techniques for achieving household happiness:

Impose time-outs for repeated bad behaviour.
Establish everyday routines.

Of course, the book has plenty more detail around how to do this. In particular the title of the book refers to counting instances of bad behaviour, and putting a child into time-out when the third count is reached.

On the other hand, Janis-Norton’s book has different fundamental techniques that support a range of parenting strategies:

Train children to want parental praise and recognition.
Teach them how to verbalise thoughts and emotions.

Hers is a very thorough book, going into numerous examples over its 400+ pages. However, it doesn’t include any examples of disciplining children – at least not in a traditional way. Looking on the Internet, it seems this sort of approach is also known as positive discipline, and there are other authors out there that promote it. Janis-Norton many times states that she knows it may seem unbelievable that this could work, but reassures the reader that it does.

I haven’t decided yet how to put any of this into practice, but I feel now better equipped with a bunch of parental tools that I hope will make life easier and more sustainable. And if I don’t have to pick up and move children any more, my back will be thankful.

Wrist Computers

At some point in the last century, a strange thing happened: people took something that they’d been happy to carry around in their pockets for centuries and started to wear it on their wrist. Why?

I have just bought myself a smartwatch, and it’s got me thinking about this. A smart watch is typically what a 1980s calculator watch would be if someone invented it today. Because that’s basically what 99% of them are. Not calculator watches, of course, but stick with me for a bit. Just as in the 1980s, the most computing power an ordinary person could carry around in their pocket was a calculator, so people tried to put a tiny version of it on their wrist. These days, the most computing power an ordinary person can carry around in their pocket is a smartphone, so people are trying to put a tiny version of it on their wrists.

That said, you may not be too surprised to hear that the smartwatch I bought was part of the 1% that aren’t like that. It is a Withings Activité Pop, which is an analog watch that happens to also talk to my smartphone using Bluetooth. Withings isn’t the only maker of this sort of smart watch, e.g. you can also get a Martian watch which takes a similar approach to being “smart”. I expect other watch makers will put chips in their watches and it will become pretty normal soon.

I am really loving my Withings smartwatch. It automatically updates the time when daylight savings changes or when I travel into a different timezone. It has a pedometer inside it, and shows me my progress towards my daily step target on a dial on the face. It also has a bunch of other features, and sometimes gets new ones that appear for free, like tracking swimming strokes. But most of all, it looks good, is light on my wrist, and has a battery life of over 8 months. While these as expected features of a normal watch, they are rather novel in a smartwatch.

As a result, smartwatches haven’t really taken off yet in the way that, say, FitBit fitness trackers have. Is the smartwatch market destined for greatness or niche-ness?

Perhaps the history of the pocket watch has some relevant lessons, for which I will be drawing heavily on Wikipedia. The wearable watch was a 16th century innovation, beginning as a clock-on-a-pendant with only an hour hand. Some 17th century improvements brought the glass-covered face and the minute hand, and they became regularly carried in (waist coat) pockets at this time. It took until late in the 18th century for the pocket watch to move beyond a pure luxury item.

Pocket watches continued to be the dominant form of watch, at least for men, until the late 19th century, when the “wristlet” (we know it better as the wrist watch) came along. The British Army began issuing them to servicemen in 1917, where synchronising the creeping barrage tactic between infantry and artillery was important, and pocket watches were impractical. Reading the time at a glance was probably the first “killer app”, and by 1930, the ratio of wrist to pocket watches was 50 to 1. Within a couple of decades, the pocket watch had been completed disrupted.

While it was more convenient to read the time on a wrist watch than a pocket watch, it was also was also awkward to wear a heavy thing on a wrist, and in terms of fashion, the wrist watch was considered more of a women’s fashion item. In the end, World War I forced the issue, eliminating the fashion consideration, and the convenience factor overcame the weight problem.

Coming back to the present, UK mobile operator O2 published a report called “All About You” in 2012 that noted 46% of respondents had dispensed with a watch in favour of using their smartphone to check the time. It seems the greater utility of a smartphone has led people to forgo their watches, even if it means that time has gone back into the pocket.

So, there’s an argument that if the smartwatch provided similar utility to the smartphone, people would again shift from the pocket to the wrist. My Withings watch doesn’t in any way substitute for my smartphone, and is really a smartphone accessory. However, something like a LG Urbane Second Edition watch runs Android and has an LTE connection for calls and texting, and is more powerful than even a smartphone of a few years ago. Speech recognition can make up for the lack of keyboard entry, and a Bluetooth headset can enable private conversations.

However, economically a smartphone is actually a games platform, and games dominate the revenues from apps on smartphones. Making the smartwatch a viable games platform may be required for it to replace smartphones. Even in the 1980s, there were attempts to create games for the wrist, but they weren’t enormously successful compared to the game & (pocket) watch versions. Admittedly, there are games for modern smartwatches. However, they drain the battery and aren’t the same calibre as smartphone games.

If we measure the period of the smartphone since 2002, when Nokia introduced Series60 handsets, it has been with us for 13 years. The pocket watch, from invention to disruption, lasted 400 years, but declined due to the rise of the wrist watch in the last 50 of those years. If the smartwatch disrupted the smartphone at the same speed, it would need less than 2 years.

All I can say is: watch this space.

Windows 10 on Raspberry Pi 2

I was one of those who ordered the Raspberry Pi 2, when it was announced back in February 2015, off the back of the claims that it would run Windows 10. Not the full desktop version of Windows 10 of course, but a version for simpler devices. Still, it impressed me that here was a $36 computer that could run the latest version of Microsoft Windows.

Unfortunately, while the Pi 2 became available back then, the required version of Windows was not. It’s only been in the last month that Microsoft launched Windows 10 IoT Core, so I’ve finally had a chance to try it out.

For those that also are interested in this option, I thought I’d note down my experiences on installing it, connecting to it and running software on it.

Installing Windows 10 IoT Core

There are some official instructions provided by Microsoft on how to do this. However, they require that you are running Windows 10 on a PC, and none of my computers have Windows 10 yet. I also didn’t want to use up the hard disk space that would be needed if I had set up a Windows 10 virtual machine. I was more interested in unofficial options.

What didn’t work:

Using the Python ffu2img tool to convert the official Windows 10 IoT SD card image to something that could be loaded onto the SD card with something like Win32 Disk Imager. The ffu2img developer admits that they are pretty sure that there’s something wrong.
Downloading the official Windows 10 Home edition ISO and using the version of DISM in the sources directory there to load the SD card image.

What did work:

I got the official Windows 10 IoT Core for Raspberry Pi 2 ISO from Microsoft, opened it, ran the installer, and it put the flash.ffu file in C:\Program Files (x86)\Microsoft IoT\FFU\RaspberryPi2\
Next, I got the Windows ADK for Windows 10 installer from Microsoft, and it loaded a suitable version of DISM into C:\Program Files (x86)\Windows Kits\10\Assessment and Deployment Kit\Deployment Tools\x86\DISM\
Then I formatted my SD card using SD Formatter
I copied the flash.ffu file into the DISM directory and used it (following the instructions on the Raspberry Pi forums) in an Administrator Command Prompt to copy it onto my SD card
I safely ejected the SD card, and popped into the Pi and it booted up fine.

Connecting to Windows 10 IoT Core

Once the Pi got going, I needed to tell it what language to use. I had plugged a decent quality USB keyboard in, but it was extremely finnicky: key presses were seemingly ignored. In the end, I plugged a USB mouse in and it was much more responsive to mouse clicks.

Windows 10 IoT is really designed to run a single GUI application. It boots into one that shows the hostname and IP address for the Pi, as well as displaying some simple tutorial instructions. It’s designed to connect to Visual Studio 2015, and allow a developer to push their application straight to the Pi. However, I don’t work with my Pi that way – I connect into it and configure/run it via a remote shell.

It’s possible to SSH straight into the Pi (as user Administrator, initially, until you set up some other users). You basically get a DOS prompt. Cool! What was less straightforward was getting files onto it.

What didn’t work:

SCP – I kept getting an “exec request failed on channel 0” error
Trying to get the Pi to download files using an Invoke-WebRequest via PowerShell running on the Pi. The version of PowerShell seems to be missing some modules.

What did work:

The Pi appears on the LAN as a Windows network share. You can use a Windows PC and put in \\192.168.1.10\c$ (or whatever your IP address is) and then login as minwinpc\Administrator with your password. Voila!
Similarly, on a mac, you can access it via the Finder using Go > Connect to Server smb://192.168.1.14/c$ (or whatever your IP address is). The Pi will also then appear under /Volumes/c$/
Once the share has been opened, it’s straightforward to copy files to and from the Pi.

Running Software on Windows IoT Core

As mentioned above, the standard way to get software running on Windows IoT is for Visual Studio to load it onto the Pi over the network. However, I’m more interested in running standard server apps that don’t rely on the Microsoft ecosystem, so I focussed my efforts on getting Node.js to run on the Pi.

Microsoft is doing some very cool stuff around supporting platforms like Node.js and even Python on Windows IoT. It’s still very much in its early days, but shows promise.

Here’s what I did:

I downloaded and installed the Node.js Tools for Windows IoT (v1.1) from GitHub. These were installed into C:\Program Files (x86)\Node.js (chakra)\
I copied the whole Node.js (chakra)\ installation directory over to the Pi into C:\Node.js\
I downloaded the ARM version of node.exe from the same GitHub page as above, which I copied over the top of the previous (Intel version of) node.exe in C:\Node.js\
Set up the APPDATA environment variable to be somewhere useful (it wasn’t set for me): set APPDATA=C:\Users\Public
Set up other useful environment variables for Node by running: C:\Node.js\nodevars.bat
Now commands like “npm install -s express” and “node test.js” work.

While I could run simple Hello World style programs with Node that wrote text out to the screen, I was unable to get working a slightly more advanced Node program that ran a basic webserver.

Conclusions

It was fun to see Windows 10 boot up on the Raspberry Pi. However, I was a little disappointed how limited it was, given how powerful a Pi is with the default Linux-based OS.

Microsoft’s approach to developing for the Raspberry Pi brings something new to the space, and may make the platform more accessible to developers who are already adept with Microsoft tools. Still, it would’ve been nice to see the basic image come with something immediately useful, if only the new Edge web browser (this would’ve make super-cheap Internet Explorer based kiosks really simple to create).

There’s the old saying that you should always wait for the third version of a Microsoft OS. I don’t know if we’ll need to wait that long for a compelling Microsoft OS on Raspberry Pi, but I am excited to see what Microsoft does with this in future.

Facebook Node SDK example

I’ve been writing some Node.js software to interact with Facebook recently. To do this, I just picked the first SDK listed in the Facebook developer’s page for Node.js. However, I couldn’t find a good example listing of how to use this SDK to iterate over multiple pages of results. So, this is a quick post that will hopefully serve as such an example.

The complete Node.js application can be downloaded from Github at https://github.com/aesidau/sbs-headlines, but I’ll walk through it step by step here. The application will list the first 1,000 news headlines from the SBS News page on Facebook. However, before any of this will work, you will need to get the fb and async modules, so start with something like:

npm install fb
npm install async

Also, I assume that you’ve set up a Facebook application over at https://developers.facebook.com/ and have its app id and app secret to hand. In fact, for this Node.js example, I am assuming that these values are stored in the environment variables FB_APP_ID and FB_APP_SECRET, respectively.

The first step in any Facebook API application is to use these app credentials to get an access token that can be used in later Facebook API calls. In this example, I’m going to get a basic access token that isn’t associated with a Facebook user, so will be able to obtain only public information. That’s all we need here, anyway.

// Acquire a new access token and callback to f when done (passing any error)
function acquireFacebookToken(f) {
  FB.napi('oauth/access_token', {
    client_id: process.env.FB_APP_ID,
    client_secret: process.env.FB_APP_SECRET,
    grant_type: 'client_credentials'
  }, function (err, result) {
    if (!err) {
      // Store the access token for later queries to use
      FB.setAccessToken(result.access_token);
    }
    if (f) f(err);
  }); // FB.napi('oauth/access_token'
}

This has been written as a function so we can call it later. Note that it uses a callback to indicate to the caller when the process has been completed, passing back any errors that came up.

So far, so obvious. Now that the access token is sorted, let’s look at what is required to iterate over a Facebook feed using the API.

I’m going to use the doUntil function in the async module. This enables iteration of functions that return results in callbacks. The other thing to note is that each call to the Facebook API will return a “paging” object that will contain a “next” attribute but only if there is another page of results to retrieve. This attribute can be parsed to construct the next Facebook API query to obtain the next page of results.

I have also included a test for if the access token has expired. This shouldn’t happen in a simple app where the access token was only just acquired. However, in many apps, the access token may have been acquired hours before. So, if this code is to be reused, it’s a good idea to deal with this case.

// Process the Facebook feed and callback to f when done (passing any error)
function processFacebookFeed(feed, f) {
  var params, totalResults, done;

  totalResults = []; // progressively store results here
  params = { // initial set of params to use in querying Facebook
    fields: 'message,name',
    limit: 100
  };
  done = false; // will be set to true to terminate loop
  async.doUntil(function(callback) {
    // body of the loop
    FB.napi(feed, params, function(err, result) {
      if (err) return callback(err);
      totalResults = totalResults.concat(result.data);
      if (!result.paging.next || totalResults.length >= 1000) {
        done = true;
      } else {
        params = URL.parse(result.paging.next, true).query;
      }
      callback();
    }); // FB.napi
  }, function() {
    // test for loop termination
    return done;
  }, function (err) {
    // completed looping
    if (err && err.type == 'OAuthException') {
      // the access token has expired since we acquired it, so get it again
      console.error('Need to reauthenticate with Facebook: %s', err.message);
      acquireFacebookToken(function (err) {
        if (!err) {
          // Now try again (n.b. setImmediate requires Node v10)
          setImmediate(function() {
            processFacebookFeed(f);
          }); // setImmediate
        } else if (f) {
          f(err);
        }
      }); // acquireFacebookToken
    } else if (f) {
      f(err, totalResults);
    }
  }); // async.doUntil
}

Lastly, we just need to wire these two functions together so that we get the access token, retrieve the results (i.e. the headlines from SBS World News Australia), and then print them out.

acquireFacebookToken(function (err) {
  if (err) {
    console.error('Failed authorisation to Facebook: %s', err.message);
  } else {
    console.log('Acquired Facebook access token');
    // Now let's do something interesting with Facebook
    processFacebookFeed('SBSWorldNewsAustralia/feed', function (err, results) {
      if (err) {
        console.error('Failed to retrieve Facebook feed: %s', err.message);
      } else {
        // Print out the results
        results.forEach(function (i) {
          var headline = i.message || i.name;
          // If it's an embedded video, possible there's no headline
          if (headline) {
            console.log(headline);
          }
        }); // results.forEach
      }
    }); // processFacebookFeed
  }
}); // acquireFacebookToken

And that’s it. I hope this has been useful for others. Grab the complete application from GitHub to try it out, but make sure you set up your environment variables for the App ID and App Secret first.