قالب وردپرس درنا توس
Home / IOS Development / Future interaction • furbo.org

Future interaction • furbo.org

Shortly after I completed my appointment at marzipan, I began to think about what is outside. Some of the first thoughts made it a thread on Twitter.

This post can be considered an addition or a hell of a long footnote: In both cases, you will start by reading my thoughts on the marzipan. Because what's happening this year is just the start of a big shift in how to build apps.

So while everyone else makes predictions about WWDC 2019, what I find below is that I make for 2020 and later.

What is Apple's problem?

Before we think about the future, let's look at a problem Apple has today: too many products on too many platforms.

Historically, a person just had a computer in life. For several generations it was a mainframe; more recently it was a PC. One of the disruptive changes that started with the iPhone was the need to juggle two computers. Now we have clocks that generate and display data: and there is another computer. Increasingly, the audio and video units in our living rooms are added to the mix.

Synchronization and shooting services help manage the data, but we all know the challenges of keeping a consistent view on so many machines.

If you are an iMessage developer, you need to think of a product that works on iOS, macOS and watchOS. You get a pass on tvOS, but there is little comfort. The same situation exists in different combinations for all Apple's great apps: Music, Calendar, Reminders, Notes, Mail, etc.

It is likely that all of these apps share a common data model, probably supported by an internal framework that can be shared platforms. It leaves the prospect and controls as an area where the code cannot be shared.

Marzipan is about Views

With this insight, it is easy to see the marzipan as a path towards views that share code. A UIView can be used on your TV, on your desk, on your wrist and in your pocket. It's a big win for developer productivity.

It's also a benefit to design productivity: you can share app design elements. We already see this in Apple's cross platform programs when colors in Calendar matches, speech bubbles in Message have the same shape and a special glyph for "A" in Notes.

Everyone is happy to know what Dark Mode on the IOS will look like. My guess is that people who have run a dark user interface on the Mac have already seen it. It is difficult to find a balance between readability and contrast with dark elements, and I do not see Apple's designers make any major changes in next week's announcement. There will certainly be improvements, but it makes no sense to throw out the huge amount of work that has already been done.

I also see the Mac leading to techniques that provide a more vivid interface and allow a customer to customize their device. The color of System Preferences will be a welcome addition in the IOS Settings app.

All this leads to common appearance across platforms. In the near future we will be in a nice place where our architecture can be divided into models, and our designs are divided into views.

It gives us a final problem to solve: how do we share our interaction and controls?

The Arrival of New Interactions

Apple connects interactions to platforms and related hardware. The Mac has interactions that are different than iOS. And watchOS has those that are different from iOS. On tvOS you have four arrow keys and two buttons.

There are some interactions, such as a sweep, that appear on multiple platforms, but as a whole, each platform is different. This approach allows the customer to make the most of the device they buy.

When we start thinking about how interactions are shared between platforms, it is wise to consider that new hardware may come soon.

In recent years, Apple has put much effort into magnified reality (AR). And I have no doubt that this hard work is not for our current units.

AR is a great demo on an iPhone or iPad, but the reality is that you can't hold a device in front of your face for a long time: your arm gets tired after just a few minutes. I made this argument over ten years ago when everyone was excited about multi-touch screens that came to their desk. It still applies because it is a stupid idea, just like AR on a mobile phone.

Apple will solve this problem with new hardware. And these devices will run "headgearOS" with new and completely different interactions. If you are the one that develops, it means you are going to write another code for another platform. Yay.

There are other phrases to this story: Rumors about iPads with mice and Mac with touchscreen. And let's not forget about interaction with voice commands using Siri technologies.

Everything adds to a situation where the complexity of the product increases exponentially when new entities and interactions are introduced. There must be a better way.

How not to do it

Combination frames have a long history of sucking. If you've ever used a Java app in the early days of Mac OS X, you immediately know what I'm talking about: the interactions were from another universe. The design of the system was a "least common denominator" where only a limited set of abilities were exposed. It just felt wrong.

Recent attempts have been more successful, but they still fail to solve the problem of ever-growing interactivity.

Apple has been down this road before, and I don't see them traveling again. Instead, I see them take a new and forward-looking direction. A bold and pragmatic change known to Apple: They would set themselves up for the next decade of user interaction.

So what can they do that no one else in the industry does?

Declarative Interactions [1
9659005] As Matt Gallagher notes, we have slowly been heading towards a declarative programming style.

Declarative programming describes a system using sets of rules and relationships. The rules and conditions cannot be changed during the life of the system (they are independent), so dynamic behavior in the system must be part of the description from the beginning.

Syntactic, declarative programming is often about gathering an entire system of rules as either a single expression or domain-specific language whose structure reflects the relationship between the rules of the system.

Layout is an inherent declarative task. Layout is a set of rules (which Auto Layout calls "constraints") that apply to the contents of a view, ideal for the entire lifetime of the content. Programming limitation is sometimes considered a sub-discipline for declarative programming.

He draws this along with his own experiences to a prediction of a Swift-only framework for "declarative views".

Independently, John Gruber has made similar observations.

The general idea is that instead of writing classic Procedure Code to say, create a button, then configure the button and then insert the button into a view. Instead, you declare the button and its attributes using another form. HTML is probably the most easily understood example. In HTML, you do not create procedural elements such as paragraphs, images, and tables – you declare them with tags and attributes in markup.

In my opinion, this thinking limits the view that only impressions and layouts are short-term.

That's because it doesn't address the interaction problem with an ever-increasing set of platforms. But what if this new framework not only allows you to declare views, but also the behaviors they activate?

The developer would describe the interaction that an app supports. There would be relationships between the declared interactions. All of this unchanging information will then be processed by the user interface frames. The app's behavior will be determined at time of use, not when it was collected.

Think of how this would work using automatic setup as a comparison point. Until the declared system came together, we all worried about framework placement. Now we are only concerned about the relationship between the frames and let the system choose what is best.

With our interaction, we still have this tight link between a user action and the app's behavior. Pressing a button or a stretching motion calls for some code directly. A declarative interaction would be a layer of abstraction between what a customer does and how your app responds.

Again, using automatic setup to help think of the thing, what if there were "classes of interaction" that served as size classes? Your iPad would behave as it always has until you connect a mouse. At that time, you customize how to interact with the device:

  • Controls may be reduced due to increased pointing accuracy
  • Views may be given a turn mode to display additional information
  • Drag and Drop may change because it is no longer Depending on two fingers
  • A mechanical wheel can replace a finger to roll

This type of adaptability would work across platforms – your app would behave differently when it ran in magnified reality or on a TV screen. As a developer, you don't have to worry about what hardware is available, you need to worry about what to do when a customer used it to perform a task.

I'm not going to predict how this would be achieved. Yes, it can draw inspiration from React or other similar technology. The only thing I'm sure at this time is that Apple knows it's having a problem and is working actively to resolve it in a platform-independent way.

Marsipan is our first step. And what I have described above is Amber the next step.

Source link