Paper 7

Paper Title: ActiveRDF: object-oriented semantic web programming,

Eyal Oren, Renaud Delbru, Sebastian Gerke, Armin Haller, Stefan Decker,
WWW '07: Proceedings of the 16th international conference on World Wide Web

Three Critical Questions


Group 1:

Member Name:Amarthaluri Abilash, Bharadwaz Somavarapu

1. Maintaining proxy objects for accessing each resource instead of using the rich objects will require translating all methods on proxy objects into related queries for its RDF resource. But maintaining separate proxy objects involves some additional costs like caching of the data and moreover they do not maintain the state of the object. Is it preferable to use directly the rich objects instead of using the proxy objects?

2. Meta-Programming and dynamic typing alleviates the problems of object-relational mappings, but how far is it feasible to create virtual and flexible API for RDF(S) data? Does the creation of virtual programs using the meta programming will have an indirect effect on the performance of the system?

3. Every object in RDF can have multiple types. They do not specify whether the object should have to inherit behavior from all of these available types. As types in RDF actually don’t exhibit any behavior, the problem arises with the object oriented setting. “This multiple behavioral inheritance is an open issue in ActiveRDF”.

Group 2:

Member Name: Sai Ram Kota

1. When the authors say that Active RDF replaces the Active Record layer, do they mean the Ruby on Rails already has a means of satisfying the requirements. If it really does have means to do same work, then why do we need to reinvent the wheel by building a new data layer?
2. The author says that RDFreactor, Elmo and Jastor can implement the same functioning without using the flexible nature of RDF schema. How are they able to handle the flexibility aspect. ? How effective are they compared to ActiveRDF?
3. If the performance of Active RDF is can be enhanced by using the JSON result format (fig 4) then why did the authors prefer the Ruby XML.?

Group 3:

Member Name: Sunil Kumar Garrepally, Yaswanth Kantamaneni

1. The author mentioned that the ActiveRDF architecture has 4 layers which converts RDF data into the objects. Having 4 layers to convert the RDF data into relational data would require more processing time which not so feasible. Is there any other technique that would reduce the processing time?

2. The author states that the JSON is better than XML for querying sesame in ActiveRDF basing only on the performance issue. Is this the only issue that should be considered leaving the other like security, efficiency?

3. Although JSON is a light weight application which increases the speed, it too has some drawbacks such as readability issue (XML is more readable than JSON) and potential problems with character encoding. Is this still a better option over XML?

4. The problem of having more than one super class for a class has been mentioned in the paper. But, it was mentioned whether the mentioned architecture solves this problem. Does this architecture solves the problem of having more than one super class?

5. The general principle behind the architecture of ActiveRDF is through the transparent proxy objects. Proxy increases the speed of the system by storing the reference(URI) of the object in the local cache. Does it automatically change its URI if the object’s URI changes?

Group 4:

Member Name:: Nikhilesh Katakam, Prasanth Sunkari

1. The paper stated that during “ActiveRDF” evaluation, it is observed that the response time would increase. How these factors and consistency be achieved is not stated in the paper.
2. The author stated that when there are two “local parts” in the “predicates” of the “URI” from “different libraries”, then there would be “ambiguity”. How would this ambiguity be resolved in case of thousands of meta-data which has same names?
3. The main functionality of the “object manager” is to “manipulate the resources” depending on the access list of the “data source”. How these access and permissions be defined when there are large amounts of “data sources”?

Group 5:

Member Name: Ritesh Mengji, Lokesh Bindal

1. Federation manager queries multiple data sources at one time to manage the data sources. How federation manager query all the data sources at one time? What might be the logic or algorithm behind that and how much it will be beneficial to increase the speed?
2. Adapters help in translating a general RDF operation to a store specific API. How adapters do that and how can it be beneficial?
3. Meta programming is helpful in supporting the concepts like override the behavior , supporting multiple inheritance etc. How Meta programming supports these features? What is meta programming?

Group 6:

Member Name: Palla Sangram

1) Even though most of the software is developed by the object-oriented model, RDF programming is triple based. Why is it triple based?
2) The author tells that there is no need to compile when we make changes to the date in API. How it can show the new result when it is not compiled after there is a change in the data?
3) Why developers are not spending the time for integration even though with the help of RDF the effort to develop the Rails will be minimized?

Group 7:

Member Name: Mohana Siri Kamineni & Kishore Kumar Mannava

1. With the growth in the “semantic web query languages” in future how can “ActiveRDF” incorporate much more effective “Query engine” and “translations” without affecting the performance of “information finding” and “information extracting”?
2.In “RDF schema” when the resources can extract properties from multiple classes, the meta programming of the “scripting languages” might sometimes return invalid values which may not be useful for the user, how are these situations handled?
3.How can the “Federation Manager” perform various join operations of the query results when the result of the query on different “data sources” is same? So that it can be helpful to reduce the redundancies in search operations.

Group 8:

Member Name:Lakshmi Bhavani.N,Hema Snigdha.P

1) If the predicates are similar then there is no use of manipulating the resources as its hard to differenticiate because we won’t understand which result is the apt one.
2) It is mentioned that any RDF resource can use any property ,if that is the case there is no uniqueness for the resources as they are multi usable.
3) All the RDF concepts are remodified using the object-oriented concepts for developing the “semantic web”. Instead of that we can incorporate the object-oriented concepts directly, so what’s the use of developing RDF in particular.


Group 1:

Member Name:pelluri,lattupalli,voruganti

Problems occurred on using object oriented programming were cleared by using meta programming. Then why we are using object oriented programming now rather than meta programming if it has such capabilities to alter different restrictions of object oriented programming.

Author said that values for attributes is done dynamically, also dynamic typing is taking place. So if client queries for a data a lot of overhead occurs to provide the result. Then how this overhead is going to be cleared?

Object manager of the Active RDF maps RDF data to objects and data manipulation data to methods. But how can the object manager access the privately declared data? Because in object oriented programming private data cannot be accessed by the external entities.

Group 2:

Member Name: Addagalla Satyanaga Manoj Kumar; Bobbili, Shrinath; Gopinath, Sreejith

1) The authors are in favour of using scripting languages as a solution to overcoming the impedance mismatches; given the dynamics of scripting languages, this approach could enhance the chances of a runtime bug, if the programmer is not careful or not a domain expert. Is the problem being solved worth introduction of runtime bugs that are very hard to detect?
2) Does the new approach not increase performance and space overheads, especially during the parse-convert phase?
3) The new approach does not address all the issues with impedance mismatch. This is by the author’s own admission; does this not mean that the object-oriented approach is not a general solution?

Group 3:

Member Name: Swati Thorve

1>To implement Object oriented programming language in Rdf , suppose if we choose to make changes to RDF rather than object oriented languages, what all changes we have to do ?

2>Author initiates the talk of quantitative an qualitative performance evaluation. However he presented only quantitative analysis. How ActiveRDF is affecting the quality of product? Speed of development ?

3>Currently author is assuming sequential query processing. What changes we need to implement for switching to parallel query processing? How “Lock management” can be implemented while accessing resources parallely?

Group 4:

Member Name:Karunapiya Rameshwaram, Shaiv, Anusha Vunnam

Critical Questions:
1.)Inorder to resolve the mismatches between the both models, we have two approaches. They are either to put some restictions on RDF usage or removing restrictions in object-oriented method.the author explained the paper based on second approach. Will we get the same outcome if we use the first approach?
2.)For consolidating the results of the queries, what method is going to be used by the federation manager to identify the same objects from different data sources?
3.)In developing and implementing ActiveRDF architecture we are using different techniques to resolve the mismatches between the both models? What about the cost of these techniques?would it be economical?

Group 5:

Member Name: Rahul Mootha, Rahul Reddy

• In different libraries some classes have similar names. What is the mechanism provided by Ruby to eliminate clashes between these classes when mapping the RDF and namespaces is done ?
• What are the restrictions that can be imposed on the usage of RDF to resolve the mismatches between the object oriented model and RDF data?
• ActiveRDF is a light weight code, then what are the reasons for the high response time for same queries ?

Group 6:

Member Name:

Group 7:

Member Name:

Group 8:


1. In the paper the author mentioned that after the object manager gets mapped to the RUBY, the API need not be to recompile when change occurs in the data. How the API shows the new result when it is not recompiled after the data changes?
2. In the paper the author mentioned that by using the RDF the development effort of the Rails will get minimized. Then why the developers are spending most of the time for different browsers for the views rather than spending their time for the integration?
3. The developers are still using the ambiguous content which would not result in the guaranteed result. To get the guaranteed result the first matching predicate should be used. The author mentioned that the predicate can be specified in the namespace rather than specifying implicitly. But, how the predicate can be specified in the namespace?

Group 9:

Member Name: Satish Bhat, Holly Vo

1. Can some other programming paradigm be used for mapping RDF to programming languages which is more closed to the machine, so that the overhead in mapping is reduced? Can this be done without losing the easy of programming offered by ActiveRDF?
2. Instead of mapping RDF to programming language can we use a transformation engine that converts RDF to OOP format? Can we make it fast enough?
3. In some application RDF data may need to be stored in an efficient manner. So can RDF be mapped to relational database directly and efficiently?

Group 10:

Member Name: Sunae Shin, Hyungbae Park

1) When they listed the reasons why existing approaches do not address the six mismatches, they used comparisons between the relational data and six mismatches since existing methods are inspired by mapping the relational databases to object-oriented programming. However, technically, references of [15] and [16] are not related to the relational databases. [15] is related to the scripting languages and [16] is related to the SHDM method (SHDM is a model-driven approach to design web applications).
2) In the section 3.1, they were explaining about the suitability of scripting languages, however, when they talked the structural inheritance the contents don’t seem to relate to the suitability of scripting languages.
3) In their architecture, the adapters are responsible for accessing to a specific RDF data-store by translating generic RDF operations to a store-specific API. However, they described as if the federation manager works directly with data sources. This caused some ambiguities when I read.
4) They didn’t mention clearly for abnormal results of the queries #3, #4, and #5. They explained that these substantial overheads are caused by the Ruby XML parser. However, the results from the executions on the JSON were similar with the results from the Sesame.
5) They showed the time overhead and the increase of efficiency on the line of code respectively. However, they are tradeoff each other. They need to compare the ratios of the time overhead and the efficiency on the line of code with those of others.

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License