2014 Development Trend: Decouple User Experience from Functionality

The article represents an interesting trend in relation with need for decoupling user experience from functionality that is happening as result of different UI channels such as web, mobile devices using which users could access the software functionality.  This can be termed as “Paradigm Shift” that needs to be adopted by developers sooner than later as part of the development practice. This is becoming much more relevant for this year, 2014 where there will be a need for delivering functionality on different devices/channels. What this means is that developers need to stop visualizing user interfaces (UIs) when they analyze the feature/functionality development. This is primarily because of the following reasons:

1. Different Versions for Different UI Channels: Presence of multiple UI channels such as Web, mobile devices, APIs etc. Visualizing UI when developing functionality will lead to development of functionality which would get UI logics embedded into it. This would require developers to develop different versions for different UI channels
2. Maintainability Nightmare: The above would lead to the need for maintaining different versions of functionality serving different UIs. Isn’t this a maintainability nightmare?
3. Innovation Killer: With multiple UI channels coming into picture and users wanting to access the software features and functionality from these devices from anywhere, anytime can give rise to innovative business processes/ideas which could become cumbersome and time-taking for go-to-market due to sheer complexity associated with different versions of functionality.
4. Limitation Posed to Enhanced User Experience: With innovations happening in Javascript world with frameworks such as Angular, Backbone, Ember etc taking the center stage, it is becoming much more importance to develop the functionality as API and expose them via REST. This would definitely need the developers to stop relating user experience with functionality that they will be developing.

How does an average developer develops the functionality today?

Most of the developers I have come across do consider following when developing the web functionality primarily because they are so much used to MVC design pattern for web development. And, one of the key element of MVC pattern is view which is user interface (UI) as described below:

1. How does the user interface (UI) or “view” (MVC) look like?
2. What are user inputs that come from user interface?

This leads to developer creating functionality which gets coupled with specific user experience related with web UI. This was good until few years back. But, given several UI channels from where users could access the system, this actually ends up creating big overhead of having to maintain different versions of the functionality that works for different UIs.

And, what are different possible user experiences for same functionality?

1. Web UI
2. Mobile UI (mobile phones, tablets etc)
3. Partner APIs

So, what is needed to decouple user experiences from Functionality?

1. Change in Mindset: This is pretty hard as visualizing a functionality with UI sounds like an abstract thing to do and traditionally, it is never done like that.
2. API Development: Development practices that focus more on service-oriented development or API development
3. Reusable Components: Development practices that mandates the creation of loosely-coupled, smaller, light-weight, reusable components

[adsenseyu2]