On iPads Replacing Laptops

The newest iPad Pro seems like a killer machine, and many reviews of it are quite positive. But a lot of reviews that I saw all came back with similar thoughts:

  • Ars Technica – “The iPad Pro raises the bar for performance, but has too many other limitations.”
  • CNET – “It’s got a big, laptop-like screen. It’s more portable than the last version. But it doesn’t solve the final few things I need to make it a true laptop.”
  • TechRadar – “(…)that would help elevate the new iPad Pro towards the level of a real laptop a little more.”

Everyone is expecting iPad to replace laptops at some point in the future. But what exactly are they wanting?

It seems the expectation is that, if iPad is the future of computing, that we’ll eventually not need laptops (and maybe desktops) because iPads will replace the PC category for what we do. Thus, iPads need to eventually do everything current PCs can do and more.

However, Apple itself gave a hint about that. And I don’t think any of that is a good expectation to have.

Here’s what Phil Schiller said in an interview with Charlie Rose for 60 Minutes:

Charlie Rose: Is there danger of one product cannibalizing the other product?

Phil Schiller: It’s not a danger, it’s almost by design. You need each of these products to try to fight for their space, their time with you. The iPhone has to become so great that you don’t know why you want an iPad. The iPad has to be so great that you don’t know why you why you want a notebook. The notebook has to be so great, you don’t know why you want a desktop. Each one’s job is to compete with the other ones.

When I read that, I see each segment in its own tier, competing with the one above it. But it doesn’t imply that one category would eventually eliminate the others. It just forces each tier to keep improving.

Let’s look at the notebook tier. You can split that into two segments: consumer and pro. How am I doing that? I’m basically looking at MacBook and MacBook Air, and comparing that against the MacBook Pro line. They all do similar things, but the Pro line has more power, more ports, and is typically used for a lot more work. But they’re all in the notebook tier.

In the iPad tier, we can simplify it between iPad and iPad Pro. iPad Pro gives you more capabilities and more features to do more work on it. The USB-C port in the new iPad Pro can enable a lot of new functionality now, and it has the potential to open up even more with iOS 13 and beyond.

Yet, it’s still an iPad. It’s on the higher end of the iPad tier, but it’s in no way meant to completely replace the MacBook Pro. Again, looking at Phil Schiller’s comments, it’s competing against the notebook. It’s not replacing the notebook.

This seems confirmed in The Verge’s review of the new iPad Pro:

(…) when pushed on the iPad’s limitations, the company insists that the iPad is still an ongoing attempt to build the future of computing, not a laptop replacement.

Sure, you can review the new iPad Pro against a laptop and see what it can and can’t do. But looking to see if it’s a complete notebook replacement is futile. Sure, it may replace a notebook for some people. If someone just used a laptop for email, news, and staying in touch with family, then an iPad can definitely do all that that person wanted a laptop for. But, implied by Phil Schiller’s own words, there will always be things that a notebook or desktop do better that can’t be done by an iPad. Always.

As the iPad Pro gains more features, I’ll continue to be interested in reviews showing how people can do work on it compared to laptops. I know there are some that live the iPad life already. But I’d also be interested in seeing things from the other angle: How improvements in devices like iPad Pro drive changes and improvements to the Mac line.

The notebook is essentially defending itself from constant attack from the iPad tier. It has been from day one. As each tier improves, so do the tiers they are competing with. iPhone and iPad eventually lead to the inclusion of multi-touch on the Mac line, which I think was a very important addition. Those kinds of influences will only continue.

But whether or not an iPad replaces the notebook tier for you has no relevance to whether or not iPads will replace laptops in general. They won’t. Apple has said it as part of their own intentions. And eight years of iPad history can prove it, too. Notebooks will remain. Desktops will remain. Their differences in UI/UX will remain.

Just like any advancement in iPhone doesn’t threaten the existence of iPad, or any Apple Watch can’t kill the iPhone market, iPad won’t kill the laptop. They’ll just keep getting better and better.

It’s all about survival.

Swift Coding Puzzles #2 – Balanced Brackets

This is part of a series of coding puzzles inspired by the #CodingPuzzle tag/puzzles originally curated and shared by Ali Spittel. This is my approach to solving those puzzles in Swift. If you have any comments or answers you want to share, post them below! I’d love to read them.


Puzzle #2

Given strings of brackets, determine whether each sequence of brackets is balanced.

When would you come across a situation like this? Well, if you ever write a source editor, you might come across something like this. As most programming languages use brackets to denote context, functions, and other divisions, we’ve probably all come across a situation where we forgot to close something off.

For the sake of this exercise, let’s define what brackets mean. In this case, it’ll be three sets of characters: ( ) , [ ] , and { } . The first character we’ll call the “open bracket” and the latter the “close bracket”.

So, what makes a balanced sequence?

  1. A matched pair of brackets.
  2. Any nested brackets must also be matched pairs.

An example of some balanced sequences include: () , [(){}] , {([()])}

An example of some imbalanced sequences include: (() , [([)]] , {([)]}

If any of those become unpaired, then the entire sequence is considered imbalanced. If you’ve ever created a class in Swift and forgot to close a brace when defining functions, you’ll know what that is.

By the above definitions, we can thus determine that in a balanced sequence:

  1. It has an even number of brackets
  2. An open bracket will never meet a close bracket of a different type
  3. A closed bracket will never appear before its corresponding open bracket

That said, here’s how I approached the problem.

First, I defined what each of the brackets were.

let brackets: [Character: Character] = [
    "[":"]",
    "(":")",
    "{":"}"
]
var openBrackets: [Character] { return Array(brackets.keys) as! [Character] }
var closeBrackets: [Character] { return Array(brackets.values) as! [Character] }

Using a dictionary, I’ll be able to easily look up the close bracket for a given open bracket.

Next, let’s look at my function to solve this.

func isBalanced(_ string: String) -> Bool {
    if string.count % 2 != 0 { return false }
    var stack: [Character] = []
    for character in string {
        if closeBrackets.contains(character) {
            if stack.isEmpty {
                return false
            } else {
                let indexOfLastCharacter = stack.endIndex - 1
                let lastCharacterOnStack = stack[indexOfLastCharacter]
                if character == brackets[lastCharacterOnStack] {
                    stack.removeLast()
                } else {
                    return false
                }
            }
        }
        if openBrackets.contains(character) {
            stack.append(character)
        }
    }
    
    return stack.isEmpty
}

First, if the string has an odd number of characters, we automatically fail it. This is in line with point number 1 above.

I then declare a variable to temporarily hold brackets. This stack will be used in the following loop.

Next, we go through each character of the string. Our first check is whether the character is a close bracket or not. If it is, and our stack is empty, it means we’re encountering a close bracket before its open bracket counterpart. We thus return false. If the stack isn’t empty, we check if the last character on the stack is an open counterpart of this close bracket. If it is, we remove the open bracket from the stack. Otherwise, we return false.

If it’s not a close bracket, we’re likely looking at an open bracket. Those automatically get added to the stack.

This loop functions for all characters in the string. Afterwards, our return is whether or not the stack is empty. If it’s not empty, it meant we had more open brackets than closed brackets, and while the earlier catches may not have produced a return, it technically is an unbalanced bracket set.

Here are a few sample calls to this function and their outputs.

isBalanced("()") // True
isBalanced("[]") // True
isBalanced("][") // False
isBalanced("[][") // False
isBalanced("()()") // True
isBalanced("[(){}]") // True
isBalanced("{{[()()][]}}") // True
isBalanced("[]()({)}") // False
isBalanced("(((") // False

I had initially hoped to tackle this with recursion, but I found the above solution to be easier to follow and much easier to manage.

Did you have a different solution? Is there something I could improve with my Swift code? I’d love to hear from you!

Paper by FiftyThree

Lauren Goode at Wired: FiftyThree, Maker of Popular Paper and Paste Apps, Gets Acquired:

BACK IN 2012, a Seattle-based startup named FiftyThree launched a drawing app designed exclusively for iPad, with a name that sounded like it was designed specifically for an Apple crowd: Paper. Despite its simplicity and also because of it, Apple crowned it the iPad App of the Year. Tech writers described it as “the next great iPad app”, “a superbly designed sketching app,” and “a fresh canvas ready and waiting for your ideas, inspiration, and art.” FiftyThree later expanded to include an iPhone app, an optional subscription called Paper Pro, and Paste, a collaboration app.

Today FiftyThree announced its apps and team have been acquired by WeTransfer, a cloud-based file transfer company with headquarters in Amsterdam and Los Angeles.

I’ve been a Paper user off and on ever since they launched in 2012. It’s been my go-to app for a lot of drawing projects, is one of our son’s favorite apps on his iPad, and is popular with my wife, who uses it for a lot of wonderful sketches. Like with any acquisition, there’s a little hesitation as to whether or not it will be a good thing for an existing company and its products. But I’m hoping we’ll see Paper stick around for years to come.

Swift Coding Puzzles #1 – Simple Pig Latin

I’ve been following Ali Spittel‘s #CodingPuzzle challenges. While I’ve read most of them, I haven’t actually done them.  But each of them would be a fun little exercise. So, I figured I’d go back and tackle each of them in Swift.

Before I start, a note: There are always multiple ways to tackle coding challenges. This is just my approach to it. If there are better/more optimal ways of doing it, please comment and share your solutions! I’d love to see them. This is as much a way for me to share what I’ve done as it is for me to learn from how others see problems and want to solve them.

That said, here is the first puzzle:

Puzzle #1 – Simple Pig Latin

“Move the first letter of each word to the end of it, then add “ay” to the end of the word. Leave punctuation marks untouched.”

If this was just taking a sentence without punctuation, this would be a lot easier. You could split the array, modify the words, and rebuild the sentence. But keeping punctuation untouched adds a bit of a challenge.

Being me, I also wanted to make sure that this would handle if someone inadvertently misses a space after some punctuation. (No, this likely doesn’t handle apostrophes properly, so contractions will probably not be correct; but I’m no native Pig Latin speaker to know.) So I may have put a little too much thought into this.

First, I wanted to make a function that modifies a word into its proper Pig Latin form.

/// Takes a word and makes it Pig Latinized
func pigLatin(word: String) -> String {
    var newWord = word
    let startIndex = newWord.startIndex
    let firstCharacter = newWord[startIndex]
    newWord.append(firstCharacter)
    newWord.append("ay")
    newWord.remove(at: startIndex)
    return newWord
}

With this function, I can now pass in parts of a sentence as needed. With that done, now I just need to get the words to pass in.

I could have split the array based on space, but that wouldn’t necessarily preserve punctuation. So I instead opted to go through the string character-by-character and parsing words that are found.

func simplePigLatin(_ text: String) -> String {
    let characterSet = CharacterSet.whitespacesAndNewlines.union(.punctuationCharacters)
    var piggyText = ""
    var temporaryWord = ""
    for (index, character) in text.enumerated() {
        let scalar = character.unicodeScalars.first!
        if characterSet.contains(scalar) || index == text.count - 1 {
            if temporaryWord.count > 0 {
                let pigLatinWord = pigLatin(word: temporaryWord)
                piggyText.append(pigLatinWord)
                temporaryWord = ""
            }
            
            // Append any punctuation or white space
            if characterSet.contains(scalar) {
                piggyText.append(character)
            }
        } else {
            // Append letter to temporary word
            temporaryWord.append(character)
        }
    }
    
    return piggyText
}

I go through each character and, if it’s a letter, I add it to a temporary word. If I hit a non-letter (punctuation or whitespace) or the end of the string, I take that temporary word, modify it for authentic Pig Latin, and append it to the return string.

With all of that, here are some sample outputs:

let word = simplePigLatin("I wish I could speak in Pig Latin; I really do!")
print(word) // Iay ishway Iay ouldcay peaksay niay igPay atinLay; Iay eallyray oday!

let contractions = simplePigLatin("I've got day-to-day issues.")
print(contractions) // Iay'evay otgay ayday-otay-ayday ssuesiay.

let badSpacing = simplePigLatin("I forgot,this is not where commas,go")
print(badSpacing) // Iay orgotfay,histay siay otnay hereway ommascay,ogay

So that’s how you can do Pig Latin in Swift. No, it’s not perfect. There are other cases that aren’t dealt with, such as how to handle words starting with vowels or ‘qu’. But I’m no linguist.

Managing Time for Side Projects

I’m quickly coming up on my two year anniversary at my day job. I’ve learned quite a lot in my professional experience as an iOS developer. But one unfortunate side effect of doing something that I love during the day: it’s hard to find the time and motivation needed to work on my app projects, even when the desire is there.

Max’s tweet was originally about trying to work too much. But I felt inspired to address some of the issues as to why I feel I don’t work enough, whether or not that’s true.

The Problem(s)

Here are a few of the issues I’ve found myself facing:

  • Too Many Ideas – My mind seems to come up with new side projects at least once a month. Of course, there’s no way for me to complete (or even start) many of these. But this has been happening for a while. I still have a file in Evernote with about 6 years of app and service ideas. I want to work on one, but I sometimes get distracted with my list and lose focus on what is achievable.
  • Wrong Project Scope – For the ideas that I am able to actually work on, I find myself dreaming up massive plans. ‘Maybe I’ll completely rewrite X!‘ ‘I could do Y like this, but if I do it like this, it’ll be future proof and everything!‘ What was going to be a simple project that I could enjoy working on becomes a large project that might as well take my full time.
  • Too Little Time – I know what you’re going to say. “Isn’t that the whole point of this post?” Well, yes. But it’s worth mentioning. It’s hard to work on side projects when you spend time playing games or watching TV.  If you’ve set aside time for yourself, you are in control of what happens with that time. And that doesn’t always mean those desired projects get a share of it.Nor does that take into account responsibilities you might have if you’re a husband or father and the time you need to spend with your family.

The Solutions(?)

Before I had my current job, I did a lot of my development work on the side. Sometimes I even found some time during the lulls of the day to get a little bit of work done. But now, I have to try other things.

A few things I’ve ultimately realized:

  • I have to make up my mind. Some work I’ve done on my projects lately has stalled because I can’t make up my mind on what to do. In one example, I’m considering using Realm as a data store. I use Realm at work. It’s something I’m fairly comfortable with. But then I think that I could use this time to try working with Core Data again. Or maybe I’ll just stick to using SQLite directly but use a new library. Soon, I’m stuck in this cycle of each direction being one to consider, but I end up doing nothing but considering choices and don’t end up going any one way. So I’ve started telling myself, as my own boss on these projects, that I have to make a choice, stick with it, and move on.
  • I don’t have to be perfect. Similar to the last point, these projects exist for me and me alone. While I am particular about the quality of my own work, I am not going to be pushing these through any kind of code review. So I can let some things slide. If anything, it gives me things I can address with future releases. But ultimately, I don’t need to perfect something before I release it. So long as it works, I can be content.
  • I have to know what I’m doing. I’ve been a fan of Asana for several years. While it was great for my day jobs, I started using it over a year ago for my side projects.  It doesn’t need to be as complicated as my day job (with Epics, Work Requests, and Iteration planning), but I do need to have some idea for what I want my deliverables to be. Setting that for my various projects, including reasonable feature sets for various stages of release, is helping me to make progress.
  • I need a long term plan. I decided earlier this year to go overboard and plan out my 2018 project goals. I’ve got quarterly release goals (mostly Alpha and Beta releases), planned App Store releases, and a general idea of what I would like to accomplish this year. All of it is set up to be achievable but not overwhelming. So no, I’m not launching 6 new apps this year. Yes, I’m hoping to have at least 1 app update and 1 new app on the App Store by December. ((I said it was achievable. I didn’t say it was impressive.))

Overall, I’m not getting as much done with my side app projects as I’d like. But as I am a developer during the day, that takes a lot of my developer energy. And lastly, I have to balance my interest in side projects with my family, which has my ultimate priority. Thankfully, it’s kept me from being a workaholic. ((As much as I love to work.))

In my case, I just have to accept the reality: I can’t do what I once could. But that’s okay. ((I started this blog post shortly after Max’s initial tweet, and that was 4 days ago. Shows you how my time is allocated.))

Clips, iOS 10.3, and the future of 32-bit apps

In March, alongside a few hardware announcements, Apple also unveiled a new media sharing app called Clips. Clips was released today. Reviews seem mixed. But I’m not here to talk to you about Clips.

iOS 10.3 was released to a vast majority of iOS devices on March 27. It was a huge behind-the-scenes update that migrated iOS devices to Apple’s new file system.  But I’m not here to talk to you about iOS 10.3.

What I am here to talk to you about is 32-bit app support. It’s definitely coming to an end. And this might affect some apps you like using. For me, some of my favorite games fall into this category. Want to see which of your apps won’t work on future iOS versions? Head to Settings > General > About > Applications to see the list.

You might’ve gotten a glimpse of this even without going to the Settings app. One other change in iOS 10.3 noted by people before and after release: Apps not compiled for 64-bit present an alert to the user upon launch. This alert says that the app in question will not work with future versions of iOS.

Now, why did I mention Clips earlier? Because Clips has some notable requirements. Sure, it requires iOS 10.3. That’s the latest OS release, and its no surprise that Apple will target the latest release with its latest apps. But the hardware requirements don’t include all devices running iOS 10.3. Specifically, Clips only works on 64-bit devices. Don’t believe me? Check the bottom of the Clips site and try to find a 32-bit device in the list of supported devices. You won’t find any.

Another big tip: iOS 10.3.2 is available for developers to test. It is only available for 64-bit devices.

The writing is clearly on the wall: 32-bit apps will soon be unsupported in iOS. But while some think iOS 11 will be the big cutoff, it may be sooner than most people realize. If you see your favorite apps in that list in your Settings app, consider contacting the developers of those applications. Urge them to update their apps.

I know I don’t want to lose my favorite games.

 

On Apple’s new new iPad

This week, Apple announced a few new or updated products via press release. One of those was a brand new iPad model. Known only as iPad, it’s an update to the 9.7-inch iPad model but staying below the new Pro line in terms of functionality.

There’s been some confusion as to the iPad’s name, as well as Apple’s approach to its design and price. But if we take a moment to analyze its name, I think we can put the rest of the details into place.

Apple is calling this simply iPad. Specifically, it shows up as iPad (5th Generation) ((For instance, in the list of supported devices for the new Clips app.)) on Apple’s site, which is leading to issues on Wikipedia, as the iPad Air was unofficially known as the 5th generation iPad. Why is Apple calling it the 5th generation iPad?

Ultimately, I think we can consider the iPad itself having ended as a product line with the 4th generation iPad. When a new 9.7-inch iPad model debuted in 2013, it came with a new name: the iPad Air. This began a new line of Air model iPads. These models kept pushing the envelope forward in terms of weight, thinness, and power. I still think the iPad Air 2 is a very capable iPad, even if Apple no longer advertises it on their website.

Apple's two iPad Pro models

Apple’s two iPad Pro models

That said, the iPad Pro line is yet another new line of iPads. The fact that the iPad Pro 9.7-inch model happens to have identical dimensions to the iPad Air 2 just shows the evolution of that sleek, powerful design.

With the Pro moniker, Apple is clearly targeting the iPad Pro towards those wanting to do more with their iPad. Looking to do serious work? Here’s an iPad that also supports a convenient Smart Keyboard and state-of-the-art Apple Pencil.

The iPad (4th Generation), the predecessor to the iPad (5th Generation)

The iPad (4th Generation), the predecessor to the iPad (5th Generation)

What about the consumer? That’s where the iPad (5th Generation) comes in. This iPad isn’t a new Air model. This isn’t related to the Pro models at all. Instead, this is the follow-up to the iPad 4. As such, it’s able to get away with a few things.

First, we can revert to the design of the iPad Air. Sure, it means the iPad is thicker than the Air 2. But it still is a great size and, more importantly, is still close to 1 pound in weight. That makes this iPad one you can hold for a longer period of time than the iPad 4 (or older).

This older design also shows up when we look at the various technologies used in the iPad (5th Generation). The display is still of Retina quality, but it lacks the anti-reflective material that’s built into the latest iPads. We also see Apple resorting to the older antenna bands for the LTE models.

However, despite having some older technologies in this new model, they can also throw in some very capable internals. The A9 chip, while technically over a year old, is still more powerful than what’s in any other consumer-targeted iPad model. This puts it on par with the iPhone SE, another iOS device considered to be for those looking at a more price-friendly option.

This leads me to the second point: price. Because Apple is using a mix of older technologies and designs along with semi-newer chipsets (which, as a volume purchase, likely cost less the more Apple integrates them into products), they can also release this iPad at an amazing price: $329 for 32GB. That’s the lowest any new 9.7-inch iPad model has ever sold for.

The lower price leads me to two conclusions:

  1. Apple is going to create two tiers of iPads like they’ve done for years with the MacBook line. The average consumer will go for a powerful-but-not-too-powerful MacBook, while professionals will grab the MacBook Pro. Similarly, the iPad line will be what most consumers will need. And at a new lower price point, there’s very little reason for someone to get one of these iPads, especially as an upgrade from an older model.
  2. The iPad Mini will never again have the top-of-the-line specs. Right now, the only iPad Mini left in Apple’s lineup is the iPad Mini 4. The only configuration is a 128GB model for $399. I still think the iPad Mini line has a place with certain audiences, but at best it will share the same specs as the new consumer iPad line. At worst, it will disappear completely.

Overall, this new iPad will be a very positive thing for Apple. The lower price should bring in new iPad owners, as well as move those with anything older than an iPad Air 2 to upgrade.

Accidental Obsolescence

This post originally appeared at NotedTech on 5 September 2016.

Years ago, I remember hearing the term ‘planned obsolescence’ being thrown around. The context was typically surrounding Apple and their upgrade cycle. The idea was that Apple would not support their devices for more than two years, forcing users to upgrade to continue to receive support.

If you look at the first few iOS devices, it could be easy to see that. The original iPhone receive its last software update, iPhone OS 3.1.3, in February 2010, just over two and a half years of availability. It didn’t stand a chance of receiving iOS 4. In fact, if you look at the history of iOS releases in general, each has typically left behind some device or another.

Yet, despite older devices eventually having to fall by the wayside, something interesting began happening with the iPad 2.

In March 2011, Apple unveiled the iPad 2. It was thinner than the original iPad, included both a front and rear facing camera, and packed the Apple designed A5 chip. While not incredibly more powerful than iOS devices sold in the previous year, the iPad 2 currently holds an incredible distinction: it supported six iOS releases! Only now, five years after introduction, is Apple letting the A5-family go. It launched with iOS 4.3.5 and will end with iOS 9.3.5, the most current stable release of iOS.

iOS 9 stands as a unique iOS release: it is the only major iOS version to not drop support for a device. In other words, all iOS 8 capable devices were able to get iOS 9. Given these recent trends, it’s likely that a good number of iOS devices, especially the 64-bit ones running the A7 chip or newer, will be supported by iOS releases for years to come.

That all said, I’m sure any iPad 2 owner can tell you: The device ran smoothest with iOS 4 and slowest with iOS 9. But given that each release adds new features of some kind, it’s only an eventuality that hardware cannot keep up with the software running on it. But to support major OS releases for six years is quite a lot, at least in the mobile space. Apple, thankfully, has the advantage of controlling both the hardware and software that goes into their devices, allowing them to tweak and manage every aspect. Because of the limited hardware options, it’s also easy for them to maintain support for older devices if need be.

ACCIDENTAL (THEY DIDN’T MEAN TO)

By comparison, take a look at the recent news regarding Android devices running certain Qualcomm chipsets:

Not all of the big Android phone makers have announced their plans for the Nougat update [Android’s latest OS release], but if you look at Sony’s and Google’s and HTC’s official lists (as well as the supplemental lists being published by some carriers), you’ll notice they all have one big thing in common. None of the phones are more than a year or two old.

After doing some digging and talking to some people, we can say that it will be either very difficult if not completely impossible for any phone that uses Qualcomm’s Snapdragon 800 or 801 to get an official, Google-sanctioned Nougat update (including the Z3). And that’s a pretty big deal, since those two chips powered practically every single Android flagship sold from late 2013 until late 2014 and a few more recent devices to boot.

This situation has far-reaching implications for the Android ecosystem. And while it can be tempting to lay the blame at the feet of any one company—Google for creating this update mess in the first place, Qualcomm for failing to support older chipsets, and the phone makers for failing to keep up with new software—it’s really kind of everybody’s fault.

While the Android ecosystem allows for a great amount of variety and customization, it also can lead to situations like this. In this case, it looks likely that Qualcomm themselves have decided to stop supporting that chipset. Given that Android updates require sign-offs from multiple parties, just one can provide a roadblock.

This sets off a vicious cycle—OEMs usually don’t update their phones for more than a year or two, so chipmakers don’t worry about supporting their chipsets for more than a year or two, so OEMs can’t update their phones for more than a year or two even if they want to. It turns the 18-month minimum target that Google has been silently pushing for the last half-decade into less of a “minimum” and more of a “best-case scenario.” And people who don’t buy brand-new phones the day they come out are even worse off, since most of these update timelines are driven by launch date and not by the date the phones were taken off the market.

This isn’t the first time we’ve seen a premium or flagship handset losing support before the intended date. But for smartphone users, does the idea of an 18-month support window make you feel comfortable? I know I wouldn’t like that.

Google’s (soon to be rebranded) Nexus line might be the best supported for Android updates, but I wonder if Google will do more to tighten down the Android experience on their own devices. Will they move to take more control of the entire experience and limit situations like this? Can that even be done? One thing’s for sure: I doubt Google intended for Nougat to be limited in release. Yet, through no direct fault of their own, this is the current situation.

3D Touch – The Future of Apple’s Interfaces

This post originally appeared in NotedTech on 31 August 2016.

In 2014, Apple announced the Apple Watch. While many were expecting a shrunken iPhone on your wrist, Apple instead focused on a new experience. The Digital Crown, for instance, let users scroll their content without blocking most of the screen with their finger. To add further interactivity to apps, they also introduced something new: Force Touch.

In 2015, Apple added Force touch to the Mac lineup with the new MacBook, updated MacBook Pros, and the new Magic Trackpad 2. Later that year, the iPhone 6s was launched with a Force Touch capable display, branded on iOS devices as 3D Touch.

On each platform, the concept of Force Touch or 3D Touch acts a bit differently. For instance, with watchOS, Force Touch is really a required element to provide more interactive options without sacrificing screen space. On the Mac, default implementation seems to duplicate 3-finger taps while providing a few useful improvements, such as making use of the Taptic engine to provide feedback to the user’s finger.

On iOS, at least with iOS 9, the introduction of 3D Touch seemed like a gimmick to some. Live Photos required 3D Touch to move, yet can be activated by a long press on older devices. On the home screen, a hard press shows app shortcuts. And the concept of peeking and popping into content lets user quickly glance at information before committing to loading a certain view.

On Android, some said that the idea of detecting pressure on the screen was an old concept. Yet, looking at what was introduced early in the Android SDK showed those functions to be based more on the size of the tap than the actual pressure. In other words, it wasn’t truly making use of a pressure sensitive display.

That’s not to say that no Android device has a pressure sensitive display. Huawei beat the iPhone 6s to market with the Mate S and its pressure sensitive display. Yet, despite launch in 2015, we have yet to see many major flagship Android devices come with that feature. Even the Samsung Galaxy S7 and Galaxy Note 7 devices this year fail to include that functionality.

Following the introduction of the iPhone 6s, word began to spread of Android manufacturers coming out with their own displays. The recently released Android N was said to include support for their own implementation of 3D Touch, but the feature has now been reportedly moved to a maintenance update to the OS. Do Google, Samsung, and other Android manufacturers just think this is a useless gimmick?

If we look at Apple, however, we see a different picture. iOS 10 seems made for 3D Touch. The lock screen experience, and notifications in particular, truly benefit from 3D Touch. Having been running the iOS 10 developer beta on my iPhone 6s, I can say that my use of 3D Touch has greatly improved over iOS 9. In fact, when I switch to a non-3D Touch device, such as my iPad Air 2 or an iPhone 6 Plus used for app testing at work, I find myself trying to hard press the screen to perform certain actions.

While the implementation isn’t complete on the Mac, I fully suspect Apple will be making further use of Force/3D Touch on all of its devices. In fact, I would be surprised if this year’s iPad updates didn’t include some level of 3D Touch. And the rumored MacBook Pro update? It’ll definitely have a Force Trackpad. But in the coming months and years, I’d suspect Apple will add more 3D interactions to macOS.

All of this shows something that Apple excels at: taking their control of the hardware and software of the iPhone to make a unique experience. If Android supports pressure touch in the future, not all manufacturers will. It’ll introduce another level of fragmentation to their ecosystem. Yet, for Apple, adding this capability to their line is no trouble at all, and I’m convinced that the use of 3D Touch will only improve with each generation of Apple’s operating systems from now on.