Instant Desktop Environment

Instant Operating System

Instant Syndicating Standards

Alpha CrucISS Webtop

PolarISS WebOS

StarCloud

Overview of an ITOP Application

On the lower part of the screen, we have the taskbar. The right corner of the taskbar is reserved for status information. The tasks are represented by icons on the left corner of the taskbar. The tasks may be rearranged through drag-and-drop. The buttons between the tasks allow to view two tasks at the same time, either horizontally or vertically. On limited-size screens, such as mobile phones for example, the taskbar may be hidden, appearing only when the user swipes up the lower part of the screen.

Each application window is divided in four frames: list, form, media and social. The framebar may be used to maximize or show/hide each frame. The four frames might appear simultaneously, or any combination, including just one. On limited-size screens, only one of the frames may be visible at a time. The user can navigate them by swiping left or right over the title bar.

The list frame is located on the left side of the application window and its main purpose is to help users browse different services. The list may be populated from the server-side by calling an appropriate service. Services may be interlinked with the serviceLink metadata. To allow secure cross-site access, CORS is used. Since browsing services is fundamental, a navigation bar is available on the left corner. The navigation bar allows the user to go back and forth, refresh, check the history, and access shortcuts. On limited-size screens, the navigation bar may be hidden, appearing only when the list frame is shown.

The form frame is located in the middle of the application window. Just like the list, the form may be populated from the server-side by calling an appropriate service. To allow secure cross-site access, CORS is used. The form frame features the title bar, the tool bar and the status bar. The title bar contains the name of the form currently being displayed. The tool bar provides buttons to perform actions. The status bar helps the user to be aware of which part of the form is currently being displayed, since the form might be broken into several parts. The buttons provided in the toolbar are also available from a menu on the status bar. On limited-size screens, the tool bar may be hidden, appearing only when the user swipes down the top part of the screen.

The media frame is located on the middle of the application window. Media might be an image, an audio, a video, or a graph. Conventional Web pages or self-contained Web applications may also be displayed in the media frame. In these cases, they are displayed within an iframe for security reasons.

And finally, the social frame is located on the right side of the application window. The social frame let’s the user communicate and share the application window with his/her contacts.

Now imagine a generic content type called iContent that could be transformed into anything instantly by the average user. This content type would include all available types of fields (text, number, date, file, etc) with an unlimited cardinality (i.e. the fields could be repeated if necessary).

So let us suppose a user wants to enter a Recipe. He selects the iContent and starts building the structure on the fly. He adds the Title, then the Ingredients, later the Instructions, and finally a Photo. Now, he might want to enter a Movie. So he adds a Title, then the Director, later the Duration, then the Release Date, the Genre, a Picture, and finally the Plot. He might want to save both the Recipe and Movie structures for later use as templates. But notice that only one content type was necessary to build such different content structures.

This is a simple idea, but a very powerful one. It makes us rethink how we create information today. Email, for example. You only have the option to enter the Title and the Body. No other fields are allowed, with the exception of Attachments, which provide the flexibility we are looking for since it has an unlimited cardinality. Why not extend that same flexibility to the other fields? Blogs are another example. Imagine how much richer would the Web be (semantically) if blogs had this kind of flexibility?

Let’s see an example to illustrated the point: Nick and Debbie are friends and they have subscribed to each other’s feed to receive updates. Their feeds are hosted on different servers.

In the Pull model, Nick has to poll Debbie’s server every time to check for updates from Debbie, and vice-versa.

In the Push model, the flow goes something like this:

1. Debbie publishes a new entry on her server (Push);
2. Debbie’s server lets Nick’s server know that Debbie has published a new entry (Push);
3. Nick polls his own server to receive updates (Pull).

Notice that the second step is a Push implemented in HTTP. Nick’s server didn’t have to poll Debbie’s server every time to check for updates.

In essence, this is what RSSCloud and PubSubHubBub are trying to accomplish: promoting an architectural design that follows the Push model using HTTP. ISS implementation on top of Drupal is also promoting this.

Yes, the third step is still the Pull model, but so what? Polling is only performed when the user is online and active, and strategies like the sessionLink can help determine how frequently the client has to poll.

Regarding the ISS implementation on top of Drupal, when a user syndicates an entry to a channel, all friends that are subscribed to this channel are notified (even if they are from a different server). The notification to a different server is done via the Services module.

Since ISS encourages a more decentralized social network and the ISS policies limits who gets notified, this helps in terms of performance and scalability. The speed at which information propagates will only be limited by the speed of the social network to filter information, which guarantees a high quality and very personalized stream of information for each individual.

The great majority of standards use XML, and ISS is no different. But we need to evolve.

As such, this is an example of how the tagcloud and taglink would be in JSON:

{"data":{
  "iss":{
    "science":{
      "tagcloud":{
        "year":["2006","2007","2008"],
        "syndicated":["0,0,0,0,0,0,4,23,45,32,34,31",
          "32,44,53,23,43,32,34,64,34,21,35,23",
          "43,23,34"]},
      "taglink":{
        "base":"http:\/\/nick.iss.im\/category\/science",
        "incoming":["http:\/\/debbie.iss.im\/category\/environment",
          "http:\/\/ribas.iss.im\/category\/work",...],
        "outgoing":["http:\/\/penny.iss.im\/category\/science",
          "http:\/\/ribas.iss.im\/category\/nature",...]}
    },...
  }
}}

What do you think? Feedback is welcome!

Our presentation entitled ISS (Instant Syndicating Standards) was great! We gave a quick overview of ISS and many attendees got interested in our work. One of the highlights of the presentation was when we used tennis balls to explain how the information would travel in the social network. It was really fun to see the balls been thrown from one side of the room to the other. Some photos of the presentation are shown below:

Bruna Griebeler at FISL 10

Tiago Rosa da Silva at FISL 10

Daniel Schmidt da Silva at FISL 10

In the 90s, after Tim Berners-Lee created the World Wide Web at CERN research center, scientists around the world were able to share information with their colleagues by setting up their own personal Websites. The key concept behind the Web was the hyperlink, which allowed users to browse Web pages across different networks.

With the popularization of the Web, browsing Web pages just wasn’t enough. So by the turn of the millennium, the advent of search engines came to people’s assistance, most notably from a search engine created by Larry Page and Sergey Brin while at Stanford University. Powered by complex algorithms, search engines would rank and present Web pages to users based on keywords.

With further popularization of the Web, searching again wasn’t enough. The top-down presentation of Web pages selected from a huge collection by an algorithm has created a very undemocratic way of sharing information. In this next decade, users will rely less on monolithic algorithms and more on their own personal social network for sharing information.

While the first decade of the Web was all about browsing and the second decade was about searching, the next decade will be about syndicating. Users will connect with their personal social network to receive and disseminate information in a bottom-up manner. Information, services and interactions will all be syndicated, allowing users to share not only information but also rich and profound experiences.

Sharing Information

As of today, there is no existing technology that allows individuals to share information in a bottom-up manner on a global scale. ISS (Instant Syndicating Standards) is a proposal to create just that: a distributed worldwide recommender system perfectly tuned to output a very personalized stream of information for each individual, where information flows from the personal social network towards the whole wide world. This is accomplished by allowing each individual to create their own broadcasting channels and to connect these channels with the ones created by their personal social network. This trustful and cascading network of syndicated streams filters out irrelevant information, while still letting good information pass through at each level.

The key concept behind ISS is the tagLink. The tagLink is a semantic link created by individuals showing how their friends’ channels are connected with their own channels. If a user becomes interested in a particular channel from a friend, he may subscribe to this channel and add it to his own channel. Thus, each individual receives exactly what he wants based on these subscriptions, and all information that reaches them goes through friends’ approval first.

Sharing Services

ISS is being developed as a set of services on top of Drupal. This service-oriented architecture promotes interoperability and allows individuals from different networks to share information with each other. The ISS services englobes user, channel and content management. These services together with services that provide file, language, search and session management will transform Drupal from a Content Management System into a Web Operating System.

The key concept behind the Drupal WebOS is the serviceLink, which is a structured format that links services together, including services from different networks. For example: a user may browse his way to a friend’s profile and become aware of her interests by visualizing her channels. If there is a common interest, the user may subscribe to a channel and create a taglink that connects her remote channel with his local channel. The fact that the friend is from another network is totally transparent to the user. This is possible when these systems follow a set of open standards called IOS (Instant Operating System). Users will be served by multiple WebOS.

Sharing Interactions

The services provided by the Drupal WebOS can be accessed through a Webtop, i.e. a Desktop Environment that works on top of the Web. The Ext Webtop is a Webtop created using the Ext JavaScript Library following a set of open standards called ITOP (Instant Desktop Environment). From this Webtop, users can share interactions with each other.

The key concept behind the Ext Webtop is the sessionLink. The sessionLink is a service that follows the publish/subscribe pattern and provides users and applications with (almost) real-time updates for subscribed services. For example, when a chat application is loaded in the Ext Webtop, the Webtop subscribes to the user.im service to be kept aware of any updates. More sophisticated interactions may also be shared, including sharing the whole Desktop Environment (this is called an Instant Session). In an Instant Session, when a user opens a window in the Webtop, his friend sees the window being opened. Likewise, when his friend closes a window, the user sees the window being closed.

Conclusion

In this text, we have presented ISS (Instant Syndicating Standards), an open set of standards that challenges the top-down model of information-sharing and gives place to a bottom-up model, where each person has a unique voice and equal opportunity to contribute and benefit. In this way, we hope to bring people closer together to discuss common interests and share information in a more open and democratic manner.

Also, we have presented the IOS and ITOP open standards, which we believe will help people to have more rich and profound experiences. We want to bring the Instant from Instant Messaging to the Web. And by Instant, the most important aspect that we want to exploit is not so much the When, but the Who. We want to empower individuals to “exchange” their Operating Systems and Desktop Environments with friends much the same way that they exchange Messages with friends when using Instant Messaging applications.

Along these two decades, the Web has evolved tremendously. The Web’s influence in democratizing access to information is evident. Yet, there is still a long way to go before reaching a truly democratic Web, where information flows freely in all directions. Also, there is still a long way to go before reaching a truly interactive Web, where people can connect with each other to create rich and profound experiences. We hope that the work here presented will help shape the way we share information, services and interactions in the next decade, as we believe that this will fundamentally shape us into better individuals and into a better society as a whole.

Acknowledgements

I would like to thank the following organizations for sponsoring my work:

• The GIMSCOP research group from UFRGS university for sponsoring the development of the Drupal WebOS and Ext Webtop. Special regards to my mentor Dr. Jorge Otávio Trierweiler.
• The PPGC (Computer Graduate Program) from UFRGS university and the CAPES brazilian federal agency, who provided me with a scholarship to develop ISS. Special regards to my mentor Dr. José Valdeni de Lima.
• The Knight Foundation, for sponsoring the development of ISS on top of Drupal. Special regards to the UFRGSWeb team for helping me out and for giving me the opportunity to mentor them.

I would also like to thank the following open source communities for their contributions:

• Dries Buytaert and the Drupal community. Special regards to Scott Nelson for the Services Module and Dmitri Gaskin for the JSON Server Module.
• Jack Slocum and the ExtJS Community. Special regards to Todd Murdock for the Web Desktop extension and Thorsten Suckow-Homberg for the LiveGrid extension.

Further Information

• ISS (Instant Syndicating Standards)
• IOS (Instant Operating System)
• ITOP (Instant Desktop Environment)

References

• http://iss.im/references