Jon Iturrioz

Promoting business policies in object-oriented methods

Abstract Business policies have been proposed to bridge the gap between business and information system professionals, and at the same time, for easing system evolution. So far, however, most approaches to business policies have been biased towards providing a structural perspective. Here, we argue that there is much to be gained from moving the business-policy idea to a behavioral setting such as the one used in most object-oriented methods. This paper proposes a division of behavioral domain features into two orthogonal dimensions depending on the stability of these features: the event dimension which mainly corresponds to state-transition diagrams that are rarely changed, and the policy dimension which describes restrictions and dependencies among elements on the event dimension that routinely evolve with time. This explicit and separate description of business policies allows the changing of these policies without impacting unnecessarily on the underlying domain, thus easing requirement modifications and finally, enhancing software evolution. The paper addresses policy identification, description and implementation.

Interfaces for scripting: making Greasemonkey scripts resilient to website upgrades

Thousands of users are streamlining their Web interactions through user scripts using special weavers such as Greasemonkey. Thousands of programmers are releasing their scripts in public repositories. Millions of downloads prove the success of this approach. So far, most scripts are just a few lines long. Although the amateurism of this community can partially explain this fact, it can also stem from the doubt about whether larger efforts will pay off. The fact that scripts directly access page structure makes scripts fragile to page upgrades. This brings the nightmare of maintenance, even more daunting considering the leisure-driven characteristic of this community. On these grounds, this work introduces interfaces for scripting. Akin to the JavaScript programming model, Scripting Interfaces are event-based, but rather than being defined in terms of low-level, user-interface events, Scripting Interfaces abstract these DOM events into conceptual events. Scripts can now subscribe to or notify of conceptual events in a similar way to what they did before. So-developed scripts improve their change resilience, portability, readability and easiness to collaborative development of scripts. This is achieved with no paradigm shift: programmers keep using native JavaScript mechanisms to handle conceptual events.

Generalizing the "like" button: empowering websites with monitoring capabilities

Increasingly, a users action in a website might have an impact in other websites. The Like and ShareThis buttons are forerunners of this tendency whereby websites strive to influence and be influenced by the actions of their users in the websphere. The term Web Radar is coined to denote software that serves to impact a website (the host) from what is happening somewhere else in the websphere (i.e. the target). Current approaches provided limited expressivity in either the reactions (e.g. the Like button is limited to write entries on the users wall in Facebook), or the range of participating sites (pre-set in the Radar platform, e.g. Ifttt). We believe supporting Radars as configurable services might account for more domain-specific Radars, i.e. Radars where the monitoring sites, the tracking conditions and the reactions are not fixed by the Radar platform but rather determined by the Radar host. This vision is confronted with three main challenges: API heterogeneity, scalability and technical complexities. We address these matters in RadarThis, a service that permits webmasters to set Web Radars for their websites. We capitalize on YQL to hide API complexity, and use trigger-like syntax to specify custom radar strategies. A case study is presented using the website Instapaper as the Radar host.

Formalizing and validating behavioral models through the event calculus

Abstract Accurate gathering of requirements is a major concern during conceptual modelling. Such accurateness can only be achieved through major involvement of users, who should check whether the systems specification conforms with their expectations. This task can be facilitated both by intuitive conceptual constructs and by executable models that allow interaction with the user to explain the behavior of the system in accordance with its specification. This work proposes the notions of stimuli and business policies as intuitive behavioral constructs, and the use of the event calculus as an appropriate formalism for building executable specifications for behavioral models. The approach is borne out by an early implementation that allows the user to question why and how a given state is reached, where the answer is given in terms of the specifications, i.e. stimuli and policies, being applied. The utilization of use-cases as a first guideline for validating the model is also addressed.

Turning the mouse into a semantic device: the seMouse experience

The desktop is not foreign to the semantic way that is percolating broad areas of computing. This work reports on the experiences on turning the mouse into a semantic device. The mouse is configured with an ontology, and from then on, this ontology is used to annotate the distinct desktop resources. The ontology plays the role of a clipboard which can be transparently accessed by the file editors to either export (i.e. annotation) or import (i.e. authoring) metadata. Traditional desktop operations are now re-interpreted and framed by this ontology: copy&paste becomes annotation&authoring, and folder digging becomes property traversal. Being editor-independent, the mouse accounts for portability and maintainability to face the myriad of formats and editors which characterizes current desktops. This paper reports on the functionality, implementation, and user evaluation of this “semantic mouse”.

Script programmers as value co-creators

Website owners are gradually realising the benefits of viewing customers as co-creators of value. Unfortunately, current development models offer little help in understanding and managing this new form of value co-creation. The Metropolis Model has recently identified three realms of roles for crowdsourcing: the kernel (providing the core functionality), the periphery (the partners) and the masses (the end users). Technically wise, the periphery requires mechanisms for the commons to suggest, develop and maintain additional services on top of the kernel. This work concretizes the Metropolis Model for crowdsourced website development based on user scripts. We outline some technical challenges to foster the relationship between end users (the masses), scripters (the periphery) and the web site (the kernel) on the way to promote script-based crowdsourcing.

Facing Tagging Data Scattering

Web2.0 has brought tagging at the forefront of user practises for organizing and locating resources. Unfortunately, these tagging efforts suffer from a main drawback: lack of interoperability. Such situation hinders tag sharing (e.g. tags introduced at del.icio.us to be available at Flickr ) and, in practice, leads to tagging data to be locked to tagging sites. This work argues that for tagging to reach its full potential, tag management systems should be provided that accounts for a common way to handle tags no matter the tagging site (e.g. del.icio.us, Flickr ) that frontended the tagging. This paper introduces TAGMAS (TAG MAnagement System) that offers a global view of your tagging data no matter where it is located. By capitalizing on TAGMAS , tagging applications can be built in a quicker and robust way. Using measurements and one use case, we demonstrate the practicality and performance of TAGMAS .

Cross Publishing 2.0: Letting Users Define Their Sharing Practices on Top of YQL

One of Web2.0 hallmarks is the empowerment of users in the transit from consumers to producers. So far, the focus has been on content: text, video or pictures on the Web has increasingly a layman’s origin. This paper looks at another Web functionality, cross publishing, whereby items in one website might also impact on sister websites. The Like and ShareThis buttons are forerunners of this tendency whereby websites strive to influence and be influenced by the actions of their users in the websphere (e.g. clicking on Like in site A impacts a different site B, i.e. Facebook). This brings cross publishing into the users’ hands but in a “canned” way, i.e. the ’what’ (i.e. the resource) and the ’whom’ (the addressee website) is set by the hosting website. However, this built-in focus does not preclude the need for a ’do-it-yourself’ approach where users themselves are empowered to define their cross publishing strategies. The goal is to turn cross publishing into a crosscut, i.e. an ubiquitous, website-agnostic, do-it-yourself service. This vision is confronted with two main challenges: website application programming interface (API) heterogeneity and finding appropriate metaphors that shield users from the technical complexities while evoking familiar mental models. This work introduces Trygger, a plugin for Firefox that permits to define cross publishing rules on top of the Yahoo Query Language (YQL) console. We capitalize on YQL to hide API complexity, and envision cross publishing as triggers upon the YQL’s virtual database. Using SQL-like syntax, Trygger permits YQL users to specify custom cross publishing strategies.

Facing Document-Provider Heterogeneity in Knowledge Portals

Knowledge portals aim at facilitating the location, sharing and dissemination of information by sitting ontologies at the core of the system. For heterogeneous environments where content-providers are free to deliver the content in any format, mechanisms are required that extract and lift these content sources onto a common ontology model. This paper focuses on document providers where diversity stems from either the metadata vocabulary or the metadata location mechanism used. The ontology repository should be isolated from this heterogeneity. To this end, a rule-based approach is presented where rules encapsulate the specificities of each provider. The paper presents a working system where JENA, WebDAV, and QuickRules realise the knowledge portal, the resource repository and the rule component, respectively. Rules are given for PDF, WORD and OpenOffice resources.

A Model-Based Approach to Web-Application Development

The increasing growth in size and complexity of portals calls for a systematic way to web-application development that is able to face the stringent demands imposed on both the development and maintenance of these systems Model-based approaches have been proposed to mitigate this situation. These approaches aim to find models, preferably orthogonal, that allow designers to declaratively specify a distinct concern of the application without being immediately immersed in details of implementations. This paper presents AtariX, a model-based tool that renders HTML pages from the declarative schemata specified by the designer. Each concern is described by a separate XML document: how data is integrated and structured (the content document), the topology of links (the navigation document) and the layout of each element (the presentation document). An application is then conformed by a set of schemata (i.e. model instances), for each of the distinct models. Separation of concerns and declarativeness enhance the application maintenability, as well as promoting concurrent development as each model can be assigned to a different team. AtariX has been fully implemented and its use is illustrated by designing and delivering a website for a scientific conference.