An Aspect Oriented Approach for Renarrating Web Content

by

Sai Gollapudi, Sridhar Chimalakonda, Venkatesh Choppella, Y.Raghu Babu Reddy

in

Innovations in Software Engineering Conference

Report No: IIIT/TR/2017/-1

Centre for Software Engineering Research LabInternational Institute of Information Technology

Hyderabad - 500 032, INDIAFebruary 2017

An Aspect Oriented Approach for Renarrating Web Content

Gollapudi VRJ SaiPrasadSERC

IIIT-HyderabadTelangana, India

saigollapudi1@gmail.com

Sridhar ChimalakondaSERC

IIIT-HyderabadTelangana, India

sridhar.ch@research.iiit.ac.in

Venaktesh ChoppellaSERC

IIIT-HyderabadTelangana, India

venkatesh.choppella@iiit.ac.in

Y. Raghu ReddySERC

IIIT-HyderabadTelangana, Indiaraghu.reddy@iiit.ac.in

ABSTRACTThe ability to modify the existing published web pages iswhat we are calling Renarration of the web. Such a mecha-nism is useful for improving accessibility and personalizationof the content currently on the web. There are many tech-niques in place for enabling both Web Accessibility and WebPersonalization. In this paper we propose a novel approach:an Aspects inspired design of renarration. Aspects have tra-ditionally been applied to programming. Here we reinterpretconcepts like Join Points, Point-cuts and Advices and applythem to web documents. To validate our approach, we de-signed a framework called Rennaration Studio that is builtusing microservices based architecture pattern and imple-mented using Python’s flask platform. We demonstrate thefeasibility of our proposal by renarrating different Aspects(text, language, phonetics) of two specific web documents.

CCS Concepts•Software and its engineering→Abstraction, model-ing and modularity; Organizing principles for web appli-cations; •Human-centered computing → Accessibilitytheory, concepts and paradigms;

KeywordsAspects for documents, Microservices for Annotation, Re-narration, Structured Web Documents, Annotation

1. INTRODUCTIONWe are interested in applying the notion of Aspects [15]

from Software Engineering to the problem of Renarrationof some web content. Renarration is the label being usedfor any alternate articulation of an original web source. For

Permission to make digital or hard copies of all or part of this work for personal orclassroom use is granted without fee provided that copies are not made or distributedfor profit or commercial advantage and that copies bear this notice and the full cita-tion on the first page. Copyrights for components of this work owned by others thanACM must be honored. Abstracting with credit is permitted. To copy otherwise, or re-publish, to post on servers or to redistribute to lists, requires prior specific permissionand/or a fee. Request permissions from permissions@acm.org.

ISEC ’17, February 05-07, 2017, Jaipur, Indiac© 2017 ACM. ISBN 978-1-4503-4856-0/17/02. . . $15.00

DOI: http://dx.doi.org/10.1145/3021460.3021466

instance, a translated text, an annotated image or a audioreplacement of some original web source can all be consid-ered as renarrations. Renarrations could involve modifica-tions to either the original content, flow or script. Thesemodifications could either reinforce the original material’scontext, content or the intent, or, they may significantlymodify it. Two main motivators for renarrating some exist-ing, published web content are Web Accessibility and WebPersonalization.

[8, 23, 7] have already established renarration and theneed motivating it. In this paper, our interest lies in enablingrenarration, but by using an Aspects oriented approach. Ofcourse, there are already existing solutions that implementrenarration in particular [8], and Web Accessibility solutionsand Web Personalizations in general. However, these so-lutions either incorporate a goal-driven tightly-coupled de-sign[8], or a client server architecture or a browser basedoffering. [9] discusses how accessibility can be provided atone of many control points in the workflow of a web-contentpresentation. For instance, Fairweather et. al, highlight thatthe solution can either be an external extension to the web,like a text-to-speech adapter hardware; or at the presenta-tion level, as in with Style Sheets [16]; or at an augmentedbrowsing experience, like providing a mixed modality solu-tion as in VoiceXML[17]; or at a protocol level solution as inAIAP1. In addition to these choices, there are also severalsubsequent solutions [29] that have leveraged such options asa proxy based design [27], a server based design [12], brows-er add-ons [10] etc. However, to the best of our knowledgesoftware engineering ideas and in particular Aspects havenot been applied in the context of web content renarration,which is the core contribution of this paper. More specifical-ly, this paper proposes the idea of using aspects as a way tofacilitate transformation of web documents for renarratingweb based on semantic style sheets.

Aspects have primarily emerged to address the challengesof cross-cutting concerns and to design code in a modularway based on separation of concerns principle. Initially, inlanguages like AspectJ, new programming constructs wereadded to represent Aspects [14]. Thereafter, several ap-

1Alternative Internet Access Protocol; specified by the thenNational Committee for Information Technology Standards(NCITS)

56

proaches have been proposed based on Aspects [26]. Ananalysis of a recent survey on Aspect oriented analysis anddesign [5] reveals that the primary focus of Aspects is at aprogramming level with several extensions to support As-pects in programming languages. Researchers have focusedon early Aspects at requirements and architecture level [24][35] as well. Existing work on Aspects has essentially focusedon addressing cross-cutting concerns at code level whereasin this paper we propose the use of Aspects for renarrationof web documents.

2. ASPECTS AND WEB DOCUMENTSAspects, Aspect Oriented Software Development (AOSD)

and Aspect Oriented Programming (AOP) [15, 21] have hadtheir hay-day in late 1990s to mid 2000s. However, of late,they have not been receiving much attention (at least inscholarly publications). Aspects initially entered the scenepromoting modularity and encapsulation in the incorpora-tion of core business logic which co-existed along with otherorthogonal requirements. The idea was that joins wouldbe made for Advices by some weaver, that would tangle across-cutting concern with the primary functionality of someexisting code. Advices could be separated out, joins andpoint-cuts would be spread-out, and cross-cutting concernswould be woven-in with the other primary concerns of theapplication.

What is interesting to us is that the notion Aspects can beextended beyond the conventional programming paradigmand could also potentially be applied to our proposed worldof renarrated web documents. Table 1 provides a brief com-parison of conventional uses of Aspects with our proposednovel use of it.

Typically AOP is applied to software programs. In ourcase, we are applying it to HTML web documents. Typical-ly a software developer is involved and she would code theAspects into the source-code and run the compiler twice. Inour case, an existing web document is beyond the editingphase. As it is already published, it is more of annotationthan editing that has to be considered. For annotation, theoriginal author is not involved. Instead, a third-party vol-unteer annotator – whom we are calling a renarrator – willintegrate the Aspects after publishing. Typically AOP takesa base code and either adds, deletes, or overwrites new codeon it. The byte code of the base is still available. And, theadditional code is cross-compiled against the same languageas the base code. For renarration, we also allow for the basedocument and the changes to coexist. Similarly, the annota-tions are also only doing add, delete, overwrite operations.And, when it comes to cross-compiling, we are not bound bythe modality of the base document. Instead we can poten-tially overlay new mode on existing base mode. For typicalAOP there exist notations, languages, related compilers andeven dedicated tools. ActiveJ is a popular Java based exam-ple of this. In the case of renarration, however, there is nosuch existing tools or technologies. For this reason, in ourproposed usage of Aspects we have limited ourselves to theideas of Aspects and not to its field-implementation in code.

In applying the concepts of Aspects to our renarration ofthe web, we find that we had to embrace a more broaderdefinition of the original AOP terminology. Table 2 high-lights the various novel interpretations we are using for ourwork.

Figure 1: Cross-cutting concerns of renarrationacross HTML DOM objects.

2.1 Cross-Cutting ConcernsThe notion of cross-cutting concerns is fundamental to

Aspects. Infact, it is the orthogonality in the focus and needof the requirements that compells the advent of Aspects. Inthe case of renarration, a similar compelling need exists. Itis infact, the renarration in itself that is cross-cutting acrossdocument. See Figure #1.

To us renarration is a modification to an existing page; itaugments an HTML document; it annotates it; it transformsit. But, renarration has a purpose. It is trying to do thisto either translate the original information into a differentlanguage, or to re-explain a complex concept in a better way;or to replace a less relevant reference with a more relevantexample. For instance, an English text can be converted toHindi2. Here the renarration of language change cross-cutsall objects of the Document Object Model (DOM) modelwithin a HTML document.

Localization could be a goal of renarration. In such a case,wherever there are some non-localized terms, they wouldneed to be amended or changed to reflect the local termi-nology. Perhaps currency values need to be changed fromUSD to INR, or units of measure need to be changed fromPounds to KGs. etc. In all these cases the text that needsto be localized could be spread all through the original doc-ument. So, a change for localization, would effectively meana cross-cutting concern.

In yet another example, let us assume that the goal of re-narrating some document is to detail it with more examples,explanations, pictures etc. Perhaps a scholarly document isbeing renarrated for consumption by a high school student.In such a case, the explanations and modifications will alsocross-cut across multiple DOM elements. Many paragraphs(i.e. <p> nodes) may be impacted throughout the body ofthe document. Also, some new nodes with their own tags– like that for an image – may need to be included. What-ever the case, cross-cutting happens across multiple DOMelements.

In a more abstract interpretation, renarration can alsobe seen as a modification of the original document’s con-text or intent. In other words, a renarrator is re-packagingan existing narrative for a newer community of users byre-contextualizing it, or by modifying the original author’sintent. Even with such a abstracted interpretation, we seethat renarration cross-cuts the DOM.

2one of the more popular Indian languages

57

Table 1: Comparison of AspectsSNo. Conventional Use Of Aspects Our Novel Application of Aspects

1 Typically applied to software programs We are applying it to HTML documents2 Typically Adds, Deletes, or Overwrites base code We use it for annotation of existing content3 Typically applied by the software developer or the

maintenance engineer who has access to the codesource

In the case of the renarration of a document, the orig-inal author is not leveraging it. Instead it is utilizedby some 3rd party volunteer user (who need not bethe author)

4 Developed and embedded into original source codebefore compile time

Applied by 3rd party volunteer to document afterpublishing

5 Cross-compiler needs support in programming lan-guages (eg. ActiveJ for Java; ActiveC for C++)

No technology has implemented Aspects for eitherdocuments in general or web content in particular

Therefore, because the applications of renarrations wouldcross-cut and scatter changes across the original content ofthe HTML document, and because sound software engineer-ing practices would compel us to maintain modularity andseparate out the renarration concern from the original in-tent of the HTML source, we feel the necessity to introduceAspects for renarrating the web.

2.1.1 PersistenceOne major requirement for sustained renarration is that

the changes that a renarrator makes must persist beyond thesession for subsequent use by another arbitrary user. To en-able this, we expect the Join Point Model related metadatato persist outside the scope of the existing HTML document.

Therefore, for renarration of web content, Persistence ofchanges is yet another cross-cutting concern. In existingAspects oriented applications, Persistence has already beenaddressed and popularized. This, to us, is yet another mo-tivating reason to consider using Aspects for renarration ofthe web.

2.2 Join Point ModelAn implementation associated with a cross-cutting con-

cern is anchored to the original source code through theJoin Point Model concept. A Joint Point Model essentiallyconsists of three related elements: 1) the Join Point, 2) thePoint-cut, and 3) the Advice.

2.2.1 Join PointsThe Join Point is a location in the execution flow where

the implementation for the cross-cut concern could poten-tially be interjected. This is typically done at a call to amethod, or when accessing a member of an object, duringassignment etc.

In the case of renarration, a document does not have as-signments or method calls. Therefore, the Join Points canbe on any part of the HTML document. From a DOM treepoint of view, the Join Point can be at the node level orwithin the node as well. From a content point of view, a re-narration related Join Point can be at a tag level (e.g. <p>or <li>) or within the tag content. Therefore, for docu-ments, it is the tag that is considered as the Join Point.

For our pilot implementation we have only worked withText modality. Using identifiers and class IDs, text orientedHTML tags can be used to create Join Points. For renar-ration of the web, we go one step further. We observe thatthe original HTML DOM structure of the source (with itsgeneric document labels) may not be a sufficient semantical

representation of the content. A renarrator, on the otherhand, may have a better understanding of the human se-mantics she sees in the document. In addition, she may alsohave a need to semantically structure the source to enablefurther transformation. It is for this purpose that a renarra-tor may impose a new semantic structure on the source byway introducing a new Schema or a user-defined Ontology.For structuring the source HTML, a new set of tags can bededuced from such user-defined meta structures.

From an Aspects point of view, these new tags may alsobe used as Join Points.

Incorporation of new tags within an HTML document canbe made possible by the usage of RDFa web technologies3.Schemas too need not be invented by the user. Some com-mon Schemas that are already on the web4, can also bereused.

2.2.2 Point-cutsPoint-cuts link the Join Points to Advice. The Join Points

create the trigger. The Advice creates the response to ad-dress the cross-cutting concern. The Point-cuts could relyon one or more Join Points to trigger an Advice. The spec-ification of a Point-cut is done manually by the SoftwareDeveloper.

In the case of renarration, we have renarration rules thatlink tags (Join Points) to interpretable script code. For in-stance, if a portion of code is to be language translated, thenthe code for translation is earmarked by tags. These tag la-bels – which are essentially Join Points – could be linked toa Point-cut specification which connects to translators (ie.Advice) to modify that earmarked content.

In the case of localization, a currency change can be en-abled by, one, tagging the currency content in the HTMLpage. This is done by a renarrator. The tags would usea user-defined Schema to identify the numeric value to betransformed. A renarration rule will link some tag labelsfor it to be triggered. That is, when the earmarked tags areencountered, the rule is triggered. The rule then invokes theappropriate Advice for doing the currency conversion. TheAdvice can be yet another service that is outside the currentweb application. And, an existing Advice can rely on otherservices for its functionality.

2.2.3 AdviceAn Advice is implementation logic of an Aspect. It is

typically presented in a modularized and reusable way. The

3http://rdfa.info/4schema.org

58

Figure 2: Abstract view of our Aspect based imple-mentation.

Figure 3: Renarrator’s sequence flow in RenarrationStudio

Join Point Model enables the linking of one Advice code tomultiple Join Points.

In the case of renarration, the Advice is the place wherewe put the transformation logic. It is here that changes tothe source are computed. For example, if we are renarratingcurrencies or measurement units, then it is in Advice thatsuch calculations are made.

It is also not necessary that we restrict ourselves to justthe code in the Advice. In our case for currency changeswe may rely on an external service to get the latest in Forexfigures. Similarly, for unit measurement transformations, wecan connect with some external service to do unit transfor-mations.

3. RELEVANT WORKSAspect Oriented Programming (AOP) came in on the

heels of the rush around Object Oriented Programming. Inearly 2000s MIT predicted that AOP would be the program-ming paradigm for the next 10 years. A quick scan of theliterature, however, indicates that the uptake was not aspredicted.

”Despite the fact that aspect-oriented programming was

introduced in the second half of the 1990’s, very little ex-perimental and/or quantitative work can be found in theliterature [3].” Munoz et. al. concur with this and suggestthat ”8 years after the MIT announcement AOP is still notwidely spread [18].”

As per our analysis, current literature on AOP can be seg-mented into three categories: Category one literature tendsto explain the theory and defend the logic behind AOP [21,15]. Category two literature tends to be about usage andimplementation of AOP. Here we find literature around howAOP was used for Requirements [35, 24, 2, 34], for Security[33], for web service selection [32], for web based learningsystems [13] etc. In category two we also find informationon tools and techniques [14, 26, 5].

And, lastly, category three encompasses studies checkingthe credibility and robustness of AOP. They address ques-tions like: Does AOP increase the speed of development [11];Why was it not popular [18]; Does it deliver on maintain-ability [3] and understandability [31] etc.

To our knowledge AOP was not significantly discussed inany contexts other than programming. Neither could we findmuch discussion around applying the cross cutting concernsto the fields of web or documentation. From a Web Accessi-bility point of view, AOP need not be the only methodologyto use to deliver renarration. We could have explored Ob-ject Oriented Programming, Event Driven models or Servicebased models. While we are cautioned by the studies andthe lack of uptake of AOP, we feel that AOP as a conceptis still worth exploring because of the cross-cutting require-ments arising from renarration. And, it is here that we po-sition our novel proposal of applying AOP for web contentrenarration as a use-case.

4. ARCHITECTURE FOR RENARRATIONOur Aspect based approach is implemented as a web ap-

plication called Renarration Studio.Renarration Studio is essentially a web portal which en-

ables two things: One, it enables an arbitrary third partyuser – i.e. a renarrator – to renarrate an arbitrary web doc-ument. And two, it allows a typical user to logon and viewany existing renarrations for a given web page. See Figure#3.

4.1 Renarrating a web page - Use CaseTo renarrate a web page, a renarrator must first get to the

Renarrator Studio portal. Here she must register and informwhich web page she would like to renarrate. The conceptbehind registration is that it enables the Renarrator Studioto collect user information. This is subsequently stored (i.e.persisted) along with other annotation related parametersas useful metadata for a renarrated page.

When fetching the source page for annotation, the Renar-rator Studio injects a JavaScript into source header portionof the HTML. The idea behind injecting script is that thefetched page should have the same look-and-feel as the orig-inal source, but with one exception - it should now have anoverlay of Weaver like functionality with a User Interface(UI). In our case this Weaver functionality is called Joiner.The Joiner overlays a UI on the HTML document and placesit at the bottom. We call this UI Annolet. See Figure # 4.Annolet UI provides the renarrator with options for doingvarious types of renarration.

Using Annolet UI, the renarrator tries to position the

59

Table 2: Application of Aspects terminology to renarrationSNo. Principle Original Intention Our Application for Renarration

1 Aspect a concern that is also part of the appli-cation but it is having an impact on theprimary biz logic in such a way that thisconcern is impacting multiple functionali-ties in multiple places. This concern, cross-cuts the primary biz logic. It is scattered.

Renarration

2 Concern a grouped functionality; could be a re-quiement, feature

for a document its presentation could beits primary concern; Renarration could beits cross-cutting concern

3 biz logic concern primary functionality of a application In the case of a document, the presentationlayer is assumed to be the primary functionof the document. It wants to be represent-ed in a particular way.

4 Cross-cutting or hor-izontal concerns

There could be features that are orthog-onal to the original intention of the pro-gram. These requirements may impact theimplementation at multiple places.

Annotation component of Renarration is across-cutting concern that is not linked tothe core concern of the document (whichis its current presentation). Persistence isyet another cross-cutting concern.

5 Weaver or composi-tion

intention is to join or tangle Advice at var-ious points within spread code

A script overlay (which we call as Joiner)on top of a source HTML document

6 Join-point A location where an implementation of anAdvice can be connected

This is either implemented as a user-designed tag or a user-initiated mouse clickon document.

7 Point-cut this is where the Advice needs to be ap-plied (the portion defined by an entry andexit point of the Point-cut)

For us the tags mark the Point-cut area. Itis the insertion point.

8 Advice without modifying existing code, addingnew behavior

adding tags, structuring document. This isthe additional code that we wish to apply.Metadata can exist here

9 cross-compiling ofAspects on base code

original code is taken as base, Aspects arecross compiled ontop in the same language

no language, or tool support exists. We arenot limited by language of base implemen-tation

60

Figure 4: Annolet UI overlayed on top of an existingHTML page by Joiner. This happens by JavaScriptinjection through Selinium in Renarration Studio.Image of ISEC Conference page reduced for diagrambrevity.

Figure 5: Architecture of Renarration Studio.

mouse on the exact portion of the web page that she wouldlike to renarrate. Clicking on the earmarked components,the renarrator informs the system that she is ready for anno-tation. She has choices of services provided by the AnnoletUI. Selecting one of the presented services, the renarratormakes the change (by following the UI commands). In thebackend, this type of interaction with Annolet UI enablesthe Joiner script to grab the metadata needed by the sys-tem for subsequent use. This data (along with user regis-tration data) is subsequently persisted for later use by otherviewers.

Some of the renarration related changes (like editing, trans-lating, phonetic-replacement to English words etc) are im-mediately applied to the selected text. There could be otherrenarration services which may be implemented at a latertime.

The changes made by the renarrator are temporarily storedin the Joiner script. Later, when the renarrator presses theSubmit button, the entire metadata information is pushedto a cloud based database for storage.

5. DESIGN AND IMPLEMENTATIONRenarration Studio is currently implemented as a web por-

tal with browser client and web server model in Python us-ing Flask Virtual Environment mechanism. See Figure 5and 6. The Registration UI for the Renarration Studio is asimple Text Box prompting the user to enter a URL. Whena renarrator enters a URL, the information is directed to aSelinium Web Automation tool. Selinium studies the brows-er characteristics and opens a new window. For now we aresupporting Google Chrome browser only. The Selenium tool[28], which has largely been used in web application testing,is being used in our studio to fuse the Weaver based Join-

Figure 6: Task flow in Renarration Studio.

er code onto the requested URL. That is, Selinium is usedas a means to inject our weaver oriented JavaScript codeonto the header of the fetched HTML page. The requiredscript for injection is stored on Git5 and fetched from thecloud for insertion. A corresponding CSS file is also linkedto ensure that the UI for renarration is discreetly overlaidat the bottom of the fetched source HTML page. An alter-native technology like GreaseMonkey [22] may also be usedto inject a script onto an existing, published HTML page.

As we mentioned, our implementation of Joiner includesweaver like functionality. It essentially can be thought ofas enabling a set of rules on ’how-to’ and ’where-to’ tan-gle renarration code onto the source document. The Joinerfunctions like a composer with a UI. It enables renarrators toJoin the Cross-cutting Advices onto the HTML page. TheUI in the Joiner is developed as a bookmarklet [4] and iscalled Annolet.

Renarration code is contained in Advices. Advices areimplemented in Renarration Studio as Microservices.

5.0.1 Motivation behind MicroservicesAt a general level, Microservices are a popular architec-

ture pattern [19, 30] in Software Engineering. We are optingto use the notion of this pattern in our design of our Renar-ration Studio. The reason for this choice is that Advicesin AOP are modular and can be independently developed.They can always evolve and grow in quantity. They can bedeveloped in a language other than the base code. We useMicroservices because they facilitate such loosely coupleddevelopment.

In addition, the logic supported by a specific Microservice(or the logic represented by a specific Advice) does not nec-essarily have to match the business logic of the rest of theapplication. Cross-cutting concerns of logging, security, per-sistence are known for this orthogonality. In our case, anno-tation or renarration services have no strong relationship tothe existing HTML document. So, by using Microserviceswe are essentially allowing for a good separation of cross-cutting concerns which may later be developed by differentor independent software developers.

An additional reason for using Microservices is that someservices (or Advices) maybe more complex and may requireadditional processing. The logic in one need not match an-other Microservice. For instance, in a case of renarrations

5’//rawgit.com/SSS-Studio-development/annoletjs/tagging/annolet main.js’

61

involving currency or language or measurement-unit changesetc, they may need online resources to do the conversion.This dependency on online resources is usually different foreach service. And, such dependencies may also lead to adelay in processing. In addition, services needing access tocurrent environmental variables (e.g. browser type, currenttime, current location etc.) may also compel us to mod-ularize and separate the concerns. This is more naturallyimplementable in a Microservice type architecture pattern.

In current implementation, the response time taken to re-narrate a page is real-time in that the delay is not humannoticeable and apparently immediate. Our implemented pi-lot has not yet been deployed on the web. However, wecontinue to develop it further and have shared the code onGithub6. Renarration Studio can be locally cloned from ourGit repository and deployed by interested users.

5.0.2 Microservice Vs WebservicesDespite not finding a clearcut differentiating definition be-

tween a Webservice and a Microservice, in our implementa-tion, we opted to use the notion of Microservices [20] insteadof REST based Webservices [1, 6] to represent our renarra-tion Advices.

Here are some reasons for us choosing the notion of Mi-croservices.

Microservices tend to be singular and independent func-tionalities. Whereas, a Webservice can technically be a en-terprise app with an API. A Microservice can be a completefunctionality. Whereas a Webservice can have dependencieswith other apps like databases etc. A Microservice can berun in different sequences and over varying communicationchannels. Whereas webservices tend restrict themselves toSOAP[6] or REST [25]. They may also restrict themselvesto XML(for SOAP) or JSON (for REST). Microservices donot have such restrictions.

In our assessment, we see that Advices tend to be more selfcontained, more individualistic, more independent and alsomore scalable. Developing Advices as Microservices thusallows us to develop, evolve and deploy individual servicesseparately from each other. Moreover, Microservices allowsus deploy our functionality in a staggered manner withoutimpacting prior releases.

5.0.3 Concepts not implemented by Renarration Stu-dio

As we have implemented the Renarrator Studio as a proofof concept and not as a production system, the current func-tionality is limited. Current work does not implement fewof the features that were discussed in earlier portion of thispaper. The unimplemented components were either seen asnon-critical to our thesis, or were roadmapped to a futurerelease effort.

In the current implementation, we have only developedthe first part of the studio, which deals with a renarratebeing able to annotate an existing HTML document. SeeFigure #3. The second part dealing with a subsequent newuser being able to access a prior renarration, is not yet im-plemented.

Persistence maybe implemented using SWeeTs based tech-nology. This has been introduced in [23]. In the currentversion of Renarration Studio, we have not integrated ourwork with a Sweet Store to enable persistence.

6https://github.com/vlead/SemanticTransformation

Figure 7: Sample phonetics functionality.

6. ADVICE AS MICROSERVICESTo validate our proposal that AOP can be used to renar-

rate, we have developed renarration services like ’Phonetics’,’Translations’, ’Audio’ etc as Advices. These Advices are inturn, implemented as Microservices. Our implementation ofthese renarration concerns are only representative and notof production quality. More robust development of theseAdvices is left as future work. We now present a few of ourimplemented renarration services.

6.1 PhoneticsThe intent of this particular phonetics renarration service

is to help non-native English speakers overcome the languagebarrier in accessing English content. This renarration canalso aid in learning pronunciation in the English language.By using this rennarrtion, a user, who otherwise may beintimidated or overwhelmed by complex English usage, cannow get pronunciation help on a renarrated source page.

6.1.1 Functionality of PhoneticsWhen the phonetics option is activated, the Microservice

replaces identified English words in the source HTML doc-ument, with their phonetic equivalent symbols. A sampleHTML page 7 has been used as a demo web page to showcasethe validity of our Advices (as Microservices). See Figure#7. It shows how a sample text This sample page demon-strates a tiny fraction of what you get with Blueprint, whichhas been earmarked for phonetic renarration, is now replacedwith its phonetic equivalent symbols.

We carried out two different trials with this webservice. Infirst trial we relied on 1000 most frequently used words andhard-coded their phonetic equivalents in a table, and usedthat to replace common or frequently used English words.This static model demonstrated our preliminary idea that aMicroservice can indeed be implement as an Advice. But,the limitation of relying on a fixed set of 1000 words con-strained its usage.

In our second trial, we sought to increase the range ofwords that can be phonetically renarrated. In this approachwe worked with a live online phonetics translation service8.Here also we were able to replace English words with theirphonetic equivalents. In addition, in this trial we were ableto demonstrate the modularity and scalability of our mi-croservice based design of an Advice. That is, we foundthat a microservice can be linked with other existing webservices for expanding the functionality of an Advice. Func-tionally, this indeed increased the coverage of translatable

7http://www.blueprintcss.org/tests/parts/sample.html8http://www.phonemicchart.com

62

words. But, it also came with a cost: there was a noticeabledelay in service execution.

Thus, by way of these trials, we were able to demonstrate1) the feasibility of using services for Advices, and 2) thescalability of having a service for an Advice.

6.1.2 Implementation of PhoneticsPhonetic renarration as a concern has been implement-

ed as an independent AOP Advice. In this design, the JoinPoints are placed around the text which is selected by renar-rator. In the current implementation, no tagging is placedbut such a technique is intended for future versions. Thechosen text is then Point-cut to the Advice on Phonetics.That is, the Joiner code enables the renarrator to place JoinPoints and Point-cut around the text selection to link it tothe cross-cut concern of phonetics.

When renarrator chooses a text and presses the Phoneticsbutton on the Annolet UI, a HTTP Request is posted to awebservice (e.g. phonetic-translive) running on a differentserver (e.g. //localhost:5000). If successful, the webserviceoutcome – i.e. phonetic equivalent – is then used to replacethe original source text.

Here is the pseudo code which is triggered when renarratorchooses Phonetics option in Annolet UI of the Joiner in thesource HTML document.

function get_phonetics(Sentence) {Post XMLHttpRequest ("//localhost:5000

/phonetic-translive", Sentence)If readyState replace text with responseText;

}

Here is the functionality of Phonetics, which is implement-ed as a service on a server which is different from the Re-narration Studio server.

@app.route("/phonetic-translive", methods=[’POST’])def phonetictranslive():

get sentence, split it into wordsfor each word in list

normalize wordsend word to online translator by

req.get(’http://www.phonemic chart.com/transcribe/ ?w=’+word)

if successfulanswer.append(returned.string)

else :answer.append(word)

return " ".join(answer)

6.1.3 Validation of MicroservicesIn the implementation of this service, we validated what

we had proposed as values for using Microservices. One,we tested the idea of ’developer independence’ by utilizinga new software developer who was different from the devel-oper who implemented Joiner. Two, we tested the notionof ’language independence’ by developing this Microservicein Python (while Joiner is using JavaScript). Three, wetested the notion of cascading services by using APIs fromthis service to connect to other existing services on the web.Four, we partially tested the idea of ’release independence’as the code repositories were separated. However, betterservice composition might be needed to further validate thedynamic addition and deletion of services.

Figure 8: A portion of a transcribed ISEC Confer-ence page reduced for diagram brevity.

6.2 TranslationsThe intent of this particular Translation renarration is to

help non-native English speakers get English web-content intheir own vernacular. This renarration replaces English textwith one of many earmarked target languages. By using thisrennarration, a user, who otherwise may have been neglectedby some existing published content, will now have access toits semantic contents.

Translation renarration is implemented in much the samewas as Phonetics.

For implementation language translations we have reliedon an external site – Yandex.com9. Though we relied on aspecific site for translation, in implementation, our tool isagnostic to the specific approach used for translations.

This translations concern has been implemented as a AOPAdvice. The Join Points are placed around the text whichis selected by renarrator. In the current implementation, notagging is placed but such a technique is intended for futureversions. The chosen text is then Point-cut to the Advice ontranslations. That is, the Joiner code enables the renarratorto place Join Points and Point-cut around the text selectionto link it to the cross-cut concern of translations.

When renarrator chooses a text and presses the Translatebutton on the Annolet UI, a HTTPRequest is posted to awebservice (e.g. language-translive) running on a differentserver (e.g. //localhost:5000). If successful, the webserviceoutcome – i.e. target language equivalent – is then used toreplace the original source text.

Here is the functionality of translations, which is imple-mented as a service on the webservice server.

@app.route("/language-translive", methods=[’POST’])def languagetranslive():

get sentence, from-language, to-language (default=en)req.get(’https://translate.yandex.net

/api/v1.5/tr/translate?key=’+translatekey+’&text=’+sentence+’&lang=’+fromlang+’-’+tolang+’&format=plain&options=0’);

soup = bs4.BeautifulSoup(res.text)return soup.text;

See Figure #8. This shows a manual transcription of asingle English text into multiple vernacular languages. Theimage showcases source text captured from the bottom por-tion of the ISEC 2017 conference web page. The portionedited is having text which reads About ISEC. In Figure #8we wanted to showcase the language versatility in renarra-tion. The output shown, however, is not from the transla-tions Microservice. The output of the Microservice is similarand automatic in production.

9https://translate.yandex.com/m/translate

63

Figure 9: Sample page with highlight used for audiofunctionality.

6.3 AudioAudio renarration sounds out the English text in audio

modality. It is intended to help users listen to what is beingshown. Users with visual challenges may benefit by thisaccessibility solution. See Figure #9. It shows a text beinghighlighted for renarration in audio format.

The implementation of Audio renarration is slightly differ-ent from the other previously documented renarration Mi-croservices. Here we experimented with renarration codebeing placed in Joiner (in the Weaver) itself. That is, wedid not create a new Microservice for this Advice. Our in-tent here was to demonstrate that Aspect implementationcan be scattered anywhere in the system. By running theservice from the Joiner side we are able to show that a con-cern can still be addressed in our system even if it is notmodularized as a Microservice. That is, we show that theimplementation can also be scattered.

The audio voicing of the text is provided by a back-endText To Speech (TTS) system. For our test purposes we areusing an online TTS called Voice RSS10. The documentationfor the API for this system is given online as well11.

Here is the pseudocode in Joiner that interacts with VoiceRSS system.

function anno_audio(xpath){

set Audio renarration to activeget selected text stringappend a child element to clicked nodechild element to call

"https://api.voicerss.org/"to include keyto specify audio, src, controls, en and autoplay

attributes.remove child node

}

The code for Audio renarration was implemented in JavaScript(to be inkeeping with the rest of the Joiner code). Thefunction was activated upon clicking of the Audio button inAnnolet UI.

This renarration validates the multimodal nature of re-narration. It also demonstrates that code can be scatteredand that base code language (e.g. JavaScript) can also besupported. Also, it demonstrates that other services may betriggered from within Joiner (weaver) code.

7. CONCLUSIONIn general we are interested in the larger idea of improv-

10http://www.voicerss.org/11http://www.voicerss.org/api/documentation.aspx

ing web content accessibility by renarrating the web. Sim-ple string replacements with pattern matching would onlyreplace text locally. But, for improving accessibility, we areinterested in renarrating the existing content at a semanticlevel. Adding new content, summarizing existing material,or adding links to existing content as annotation is what weconsider as renarration of original source.

To enable such changes on an existing page, content needsto be replaced or modified at various points within the sourcepage. This scatters and also cross-cuts the changes. It ishere that we found a similarity between the original notionof Aspects and the applications of renarration.

In this work we were keen to extend the idea of Aspectsand apply it to documentation (and not just programming).

We began by emphasizing the strong need for renarra-tion of a an increasing number of web documents for variedcontexts. We then motivated the need for Aspects orienteddesign by suggesting how renarration too had cross-cuttingconcerns that were orthogonal to the original HTML source.We then proposed to expand the usage of Aspects to nowinclude documents. We then illustrated how the notion ofAspects can be used to facilitate renarration of web docu-ments beyond traditional view of Aspects for programming.We then mapped different concepts like Join Points, Point-cuts and Advices for the context of web documents. Wethen presented Renarration Studio framework as an illustra-tion of our Aspects based approach. We then detailed theuse of Microservices based architecture for implementing therenarration services for text, transliteration and phonetics.We underlined how Microservices can help in adding newAdvices independent of language.

We see this research work as a first direction to leveragethe idea of Aspects in software engineering for the world ofweb documents, web personalization and semantic web.

8. REFERENCES[1] G. Alonso, F. Casati, H. Kuno, and V. Machiraju.

Web services. In Web Services, pages 123–149.Springer, 2004.

[2] J. Araujo, A. Moreira, I. Brito, and A. Rashid.Aspect-oriented requirements with uml. In Workshopon Aspect-oriented Modeling with UML, volume 7.Citeseer, 2002.

[3] M. Bartsch and R. Harrison. An exploratory study ofthe effect of aspect-oriented programming onmaintainability. Software Quality Journal,16(1):23–44, 2008.

[4] S. C. Buraga and A. Panu. A web tool for extractingand viewing the semantic markups. In InternationalConference on Knowledge Science, Engineering andManagement, pages 570–579. Springer, 2013.

[5] R. Chitchyan, A. Rashid, P. Sawyer, A. Garcia, M. P.Alarcon, J. Bakker, B. Tekinerdogan, S. Clarke, andA. Jackson. Survey of aspect-oriented analysis anddesign approaches. 2015.

[6] F. Curbera, M. Duftler, R. Khalaf, W. Nagy,N. Mukhi, and S. Weerawarana. Unraveling the webservices web: an introduction to soap, wsdl, and uddi.IEEE Internet computing, 6(2):86, 2002.

[7] T. Dinesh, V. Choppella, and S. Uskudarli.Re-narration as a basis for accessibility and inclusionon the world wide web.

64

[8] T. Dinesh, S. Uskudarli, S. Sastry, D. Aggarwal, andV. Choppella. Alipi: A framework for re-narrating webpages. In Proceedings of the InternationalCross-Disciplinary Conference on Web Accessibility,page 22. ACM, 2012.

[9] P. G. Fairweather, V. L. Hanson, S. R. Detweiler, andR. S. Schwerdtfeger. From assistive technology to aweb accessibility service. In Proceedings of the fifthinternational ACM conference on Assistivetechnologies, pages 4–8. ACM, 2002.

[10] J. L. Fuertes, R. Gonzalez, E. Gutierrez, andL. Martınez. Hera-ffx: a firefox add-on forsemi-automatic web accessibility evaluation. InProceedings of the 2009 InternationalCross-Disciplinary Conference on Web Accessibililty(W4A), pages 26–35. ACM, 2009.

[11] S. Hanenberg, S. Kleinschmager, andM. Josupeit-Walter. Does aspect-orientedprogramming increase the development speed forcrosscutting code? an empirical study. In Proceedingsof the 2009 3rd International Symposium on EmpiricalSoftware Engineering and Measurement, pages156–167. IEEE Computer Society, 2009.

[12] J. Kahan, M.-R. Koivunen, E. Prud’Hommeaux, andR. R. Swick. Annotea: an open rdf infrastructure forshared web annotations. Computer Networks,39(5):589–608, 2002.

[13] M. Kersten and G. C. Murphy. Atlas: a case study inbuilding a web-based learning environment usingaspect-oriented programming. In ACM SIGPLANNotices, volume 34, pages 340–352. ACM, 1999.

[14] G. Kiczales, E. Hilsdale, J. Hugunin, M. Kersten,J. Palm, and W. G. Griswold. An overview of aspectj.In European Conference on Object-OrientedProgramming, pages 327–354. Springer, 2001.

[15] G. Kiczales, J. Lamping, A. Mendhekar, C. Maeda,C. Lopes, J.-M. Loingtier, and J. Irwin.Aspect-oriented programming. In European conferenceon object-oriented programming, pages 220–242.Springer, 1997.

[16] H. W. Lie, B. Bos, C. Lilley, and I. Jacobs. Cascadingstyle sheets. WWW Consortium,(September 1996),2005.

[17] B. Lucas. Voicexml. Communications of the ACM,43(9):53, 2000.

[18] F. Munoz, B. Baudry, R. Delamare, and Y. Le Traon.Inquiring the usage of aspect-oriented programming:an empirical study. In Software Maintenance, 2009.ICSM 2009. IEEE International Conference on, pages137–146. IEEE, 2009.

[19] D. Namiot and M. Sneps-Sneppe. On micro-servicesarchitecture. International Journal of OpenInformation Technologies, 2(9), 2014.

[20] S. Newman. Building Microservices. ” O’Reilly Media,Inc.”, 2015.

[21] N. Pahlsson. Aspect-oriented programming. TopicReport for Software Engineering, pages 11–03, 2002.

[22] M. Pilgrim. Greasemonkey Hacks: Tips & Tools forRemixing the Web with Firefox. ” O’Reilly Media,Inc.”, 2005.

[23] G. V. S. Prasad, T. Dinesh, and V. Choppella.Overcoming the new accessibility challenges using the

sweet framework. In Proceedings of the 11th Web forAll Conference, page 22. ACM, 2014.

[24] A. Rashid, P. Sawyer, A. Moreira, and J. Araujo.Early aspects: A model for aspect-orientedrequirements engineering. In RequirementsEngineering, 2002. Proceedings. IEEE JointInternational Conference on, pages 199–202. IEEE,2002.

[25] A. Rodriguez. Restful web services: The basics. IBMdeveloperWorks, 2008.

[26] A. Schauerhuber, W. Schwinger, E. Kapsammer,W. Retschitzegger, M. Wimmer, and G. Kappel. Asurvey on aspect-oriented modeling approaches.Relatorio tecnico, Vienna University of Technology,2007.

[27] L. Seeman. The semantic web, web accessibility, anddevice independence. In Proceedings of the 2004international cross-disciplinary workshop on Webaccessibility (W4A), pages 67–73. ACM, 2004.

[28] A. Sirotkin. Web application testing with selenium.Linux Journal, 2010(192):3, 2010.

[29] J. Thatcher, C. Waddell, and M. Burks. Constructingaccessible web sites, volume 34. GlasshausBirmingham, 2002.

[30] J. Thones. Microservices. IEEE Software,32(1):116–116, 2015.

[31] S. L. Tsang, S. Clarke, and E. Baniassad. Anevaluation of aspect-oriented programming forjava-based real-time systems development. InObject-Oriented Real-Time Distributed Computing,2004. Proceedings. Seventh IEEE InternationalSymposium on, pages 291–300. IEEE, 2004.

[32] B. Verheecke, M. A. Cibran, and V. Jonckers.Aspect-oriented programming for dynamic web servicemonitoring and selection. In Web Services, pages15–29. Springer, 2004.

[33] J. Viega, J. Bloch, and P. Chandra. Applyingaspect-oriented programming to security. Cutter ITJournal, 14(2):31–39, 2001.

[34] M. A. Wehrmeister, E. P. Freitas, C. E. Pereira, andF. R. Wagner. An aspect-oriented approach fordealing with non-functional requirements in amodel-driven development of distributed embeddedreal-time systems. In 10th IEEE InternationalSymposium on Object and Component-OrientedReal-Time Distributed Computing (ISORC’07), pages428–432. IEEE, 2007.

[35] Y. Yu, J. C. Leite, and J. Mylopoulos. From goals toaspects: discovering aspects from requirements goalmodels. In Requirements Engineering Conference,2004. Proceedings. 12th IEEE International, pages38–47. IEEE, 2004.

65