Interoperability of Interoperability of Distributed Component Distributed Component

SystemsSystems

Research TeamBryan Bentz

Jason Hayden

Upsorn PraphamontripongUpsorn Praphamontripong

Paul VandalPaul Vandal

Midterm PresentationMidterm Presentation

CSE333 – Distributed Component SystemsCSE333 – Distributed Component Systems

Professor Steven DemurjianProfessor Steven Demurjian

As of Mid-Term ReviewAs of Mid-Term Review::

We had examined different We had examined different applications of XML:applications of XML:

– Software component re-useSoftware component re-use– Open Office documentsOpen Office documents– Common Data WarehouseCommon Data Warehouse– Semantic WebSemantic Web

The issue was: What do these The issue was: What do these have to do with each other?have to do with each other?

Project DirectionProject Direction

Endemic XML ProblemEndemic XML Problem

XML is like HTML, but users may XML is like HTML, but users may define tags:define tags:

<Title><Title>Example DocumentExample Document</Title></Title>

<Created><Created>December 1, 2005December 1, 2005</Created></Created>

But this second line could as easily But this second line could as easily be:be:

<CreationDate><CreationDate>12/1/200512/1/2005</CreationDate></CreationDate>

All XML representations share this All XML representations share this problem: in what contexts does the problem: in what contexts does the metadata make sense?metadata make sense?

Metadata

Data: code, text, databases, services

In a single context, this usually isn’t a problem (though systems do grow and change);

Metadata

Data: code, text, databases, services

All XML representations share this All XML representations share this problem: in what contexts does the problem: in what contexts does the metadata make sense?metadata make sense?

Metadata

Data: code, text, databases, services

For unanticipated interactions between systems, this requires new mechanisms.

Metadata

New web service

?

Project DirectionProject Direction

While a universal XML problem, this While a universal XML problem, this consistency issue is central to the consistency issue is central to the Semantic Web;Semantic Web;

We chose to use Semantic Web ideas as We chose to use Semantic Web ideas as a unifying theme in what we were doing. a unifying theme in what we were doing.

We have been looking at different areas, We have been looking at different areas, but this problem of XML and but this problem of XML and interoperability is the common thread.interoperability is the common thread.

Semantic Web: The Common Semantic Web: The Common

ThreadThread

Topics to cover:Topics to cover:

– RDF: Resource Description RDF: Resource Description FrameworkFramework

– Practical RDFPractical RDF– Our Semantic Web server Our Semantic Web server

experimentsexperiments

RResource esource DDescription escription FFrameworkramework

RDF originated with the work of R.V. Guha at RDF originated with the work of R.V. Guha at Apple, on what was called the Meta Content Apple, on what was called the Meta Content Framework.Framework.

RDF is a major component of the Semantic RDF is a major component of the Semantic Web;Web;

It is used to describe resources and their It is used to describe resources and their properties;properties;

It has its own XML representation;It has its own XML representation; It consists of triples:It consists of triples:

Why triples?

SubjectSubject PredicatePredicate ObjectObject

Semantic Network Semantic Network RepresentationRepresentation

• A very general and powerful representation;

• Invented by Richard Richens of Cambridge Language Research Unit in 1956 for natural language work/machine translation; widely used since then.

• Strongly influenced the ‘link’ concept in HTML.

RDF Triples Encode a Semantic RDF Triples Encode a Semantic NetworkNetwork

Practical RDFPractical RDF

Want to use common set of objects and Want to use common set of objects and relationships – namespaces, repositories – relationships – namespaces, repositories – when possible.when possible.

An alternative approach is to provide An alternative approach is to provide translations (e.g. synonyms) to map translations (e.g. synonyms) to map homegrown properties to universally homegrown properties to universally accepted properties.accepted properties.

One example of universal components: One example of universal components: – Dublin Core.Dublin Core.

Practical RDF: The Dublin Practical RDF: The Dublin CoreCoreDublin Core Metadata Element Set:Dublin Core Metadata Element Set:

1. Title2. Creator3. Subject4. Description5. Publisher6. Contributor7. Date8. Type

9. Format10. Identifier11. Source12. Language13. Relation14. Coverage15. Rights

(Properties may be further qualified.) Terms are described in detail at http://dublincore.org/documents/dcmi-terms/

RDF/XMLRDF/XML

<?xml version="1.0"?> <?xml version="1.0"?>

<!DOCTYPE rdf:RDF PUBLIC "-//DUBLIN CORE//DCMES DTD <!DOCTYPE rdf:RDF PUBLIC "-//DUBLIN CORE//DCMES DTD 2002/07/31//EN" 2002/07/31//EN" "http://dublincore.org/documents/2002/07/31/dcmes-xml/dcme"http://dublincore.org/documents/2002/07/31/dcmes-xml/dcmes-xml-dtd.dtd"> s-xml-dtd.dtd">

<rdf:RDF xmlns:<rdf:RDF xmlns:rdfrdf="http://www.w3.org/1999/02/22-rdf-="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:syntax-ns#" xmlns:dcdc="http://purl.org/dc/elements/1.1/"> ="http://purl.org/dc/elements/1.1/">

<rdf:Description rdf:about="http://example.org/"> <rdf:Description rdf:about="http://example.org/"> <dc:title>My Home Page</dc:title> </rdf:Description> <dc:title>My Home Page</dc:title> </rdf:Description>

How to read this:XML declarationReferencing the XML DTDDeclaring the use of RDFMarking the title.

Building A Semantic Web ServerBuilding A Semantic Web Server

We used We used RDF GatewayRDF Gateway, by Intellidimension , by Intellidimension ((www.intellidimension.comwww.intellidimension.com), a platform for ), a platform for development and deployment of Semantic development and deployment of Semantic Web applications.Web applications.

We chose to represent software components We chose to represent software components and associated documentation, and the and associated documentation, and the relationships between these elements.relationships between these elements.

We built RDF triples describing these We built RDF triples describing these relationships, and exercised them using relationships, and exercised them using inference rules.inference rules.

RDF Gateway:RDF Gateway:

Components Components Represented:Represented:

FFT code in C++FFT code in C++ FIR filter code in CFIR filter code in C Hidden Markov Model code in CHidden Markov Model code in C Wavelet implementation in JavaWavelet implementation in Java

Each component had one or more source code files and/or documentation files; e.g. for the HMM, we had: hmm.c The basic code file

hmm.h The header filehmmrand.c Platform-independent random nums.hmmutils.c File I/O, matrix codehmmtut.ps Postscript documentation

Semantic Network FragmentSemantic Network Fragment

FFT.c++Language: C

Language: C++

Language: Java

Hmmutils.c

hmm.c

Wavelet.java

filter.c

Hmmrand.c

Hmmtut.ps

FFT.doc

hmm.h

sysutils.h

FFT.h

Fast Fourier Transform

Hidden Markov Models

FIR filters

Wavelets

Example RDF triples:Example RDF triples:

““source/hmm.c”source/hmm.c” requiresrequires “source/hmmutils.c”“source/hmmutils.c”“source/hmmtut.ps”“source/hmmtut.ps” documents documents “source/hmm.c”“source/hmm.c”“source/hmmutils.c”“source/hmmutils.c” requires requires “sysutils.h”“sysutils.h”……

• RDF triples were instantiated using the RDFQL interface in RDF Gateway;

• There were no global software-engineering-related predicates we could draw on.

Using the ‘Semantic’ Part Using the ‘Semantic’ Part of the Semantic Webof the Semantic Web

Inference Rule Example:Inference Rule Example:INFER {INFER {?A?A 'requires' 'requires' ?C?C} }

FROM {FROM {?A?A 'requires' 'requires' ?B?B} }

AND {AND {?B?B 'requires' 'requires' ?C?C};};

Rule is recursively applied to identify all dependencies for a given file. Result when passed hmm.c is:

source/hmmutils.csource/hmmrand.csource/hmm.hsource/sysutils.h

Further InferenceFurther Inference

A similar rule returns appropriate A similar rule returns appropriate documentation for any of the files documentation for any of the files returned.returned.

The inference engine is quite powerful, The inference engine is quite powerful, and may be used to examine database and may be used to examine database schemas, rewrite metadata, or reformat schemas, rewrite metadata, or reformat data.data.

We used the output of inferences to write We used the output of inferences to write HTML on the fly – the inference engine HTML on the fly – the inference engine became a window into the Semantic Web.became a window into the Semantic Web.

Review So FarReview So Far

We chose the problem of disparate We chose the problem of disparate XML as the unifying theme;XML as the unifying theme;

Semantic Web technologies exist Semantic Web technologies exist specifically to address this problem;specifically to address this problem;

This is the unifying thread in our This is the unifying thread in our different research areas.different research areas.

OpenDocument IntroductionOpenDocument Introduction

What is it?What is it? Why is it important?Why is it important? Who created it?Who created it? How is XML used to contain How is XML used to contain

information?information? Testing the portability of documentsTesting the portability of documents OpenDocument and RDFOpenDocument and RDF ConclusionsConclusions

What is OpenDocument?What is OpenDocument?

Open source document file format for Open source document file format for saving and exchanging documents saving and exchanging documents across multiple editors.across multiple editors.

Editors include: OpenOffice, StarOffice, Editors include: OpenOffice, StarOffice, KOffice, IBM Workplace, and Abiword.KOffice, IBM Workplace, and Abiword.

All information is stored in XML filesAll information is stored in XML files Constantly evolving to incorporate Constantly evolving to incorporate

newest ideasnewest ideas Currently trying to become ISO Currently trying to become ISO

certifiedcertified

Why is it important?Why is it important?

Allows the use of multiple document editorsAllows the use of multiple document editors Stored in XML compared to .doc binaries Stored in XML compared to .doc binaries

allows easy access to data.allows easy access to data.– Example pre MS Word 95 unreadable in Office 2003Example pre MS Word 95 unreadable in Office 2003

European Union requiring document formats European Union requiring document formats to be approved by standards body. to be approved by standards body. – Microsoft – No Microsoft – No – OpenDocument - being reviewedOpenDocument - being reviewed

Massachusetts recommending all state Massachusetts recommending all state documents being in non proprietary format. documents being in non proprietary format. Debate ongoing.Debate ongoing.

Who created it?Who created it?

Developed by OASIS consortiumDeveloped by OASIS consortium OASIS is composed of multiple large OASIS is composed of multiple large

vendors including: Adobe, Corel, IBM, vendors including: Adobe, Corel, IBM, KDE, and SunKDE, and Sun

Based off old OpenOffice file format Based off old OpenOffice file format but modified per input from different but modified per input from different vendors vendors

How is XML used to Store How is XML used to Store information?information?

OpenDocument file is a compressed archive file OpenDocument file is a compressed archive file containing the following items:containing the following items:– Meta.xmlMeta.xml– Settings.xmlSettings.xml– Styles.xmlStyles.xml– Content.xmlContent.xml– Manifest.xmlManifest.xml– Pictures folderPictures folder– Thumbnail.pngThumbnail.png– Configuration2 folderConfiguration2 folder

Only 2 of the above files are needed to create a valid Only 2 of the above files are needed to create a valid OpenDocument fileOpenDocument file

XML files contain a combination of Dublin Core and XML files contain a combination of Dublin Core and custom elementscustom elements

Meta.xmlMeta.xml

Used to store information in XML describing the Used to store information in XML describing the document. document.

Some information stored is title, creation date, and Some information stored is title, creation date, and creatorcreator

Settings.xmlSettings.xml

Saves settings and options used by the editor that last Saves settings and options used by the editor that last saved the document.saved the document.

Application independent and not requiredApplication independent and not required Examples would be curser location and page when file Examples would be curser location and page when file

saved saved

Styles.xmlStyles.xml

Stores information about the format and layout of text that Stores information about the format and layout of text that are used within the document.are used within the document.

Styles can be applied to anything ranging from document to Styles can be applied to anything ranging from document to character.character.

Information about styles can also be stored in content.xml.Information about styles can also be stored in content.xml.

Content.xmlContent.xml

One of the 2 required filesOne of the 2 required files Contains all the content that is entered in a document.Contains all the content that is entered in a document. Can store styles instead of styles.xml but not Can store styles instead of styles.xml but not

encouraged.encouraged.

Other ComponentsOther Components

Pictures folderPictures folder – stores all images used – stores all images used within document. .bmp are convertedwithin document. .bmp are converted

Thumbnail.pngThumbnail.png – thumbnail picture of – thumbnail picture of entire document. Print preview.entire document. Print preview.

Configurations2Configurations2 – not currently used. – not currently used. Planned for future usePlanned for future use

Manifest.xmManifest.xml – 2l – 2ndnd required file. Used required file. Used by the document editor to know which by the document editor to know which XML files are created and where they are XML files are created and where they are located. located.

Testing PortabilityTesting Portability

The ability to create and edit office The ability to create and edit office documents in variety of editors is tested. documents in variety of editors is tested.

Four different documents (2 text and 2 Four different documents (2 text and 2 spreadsheet) are created in OpenOffice 2.0 spreadsheet) are created in OpenOffice 2.0 and tested for portability with StarOffice 8.0 and tested for portability with StarOffice 8.0 and Koffice 1.4.2and Koffice 1.4.2

Text and spreadsheet used because received Text and spreadsheet used because received most attention and most used in business.most attention and most used in business.

OpenOffice, StarOffice, and KOffice are the OpenOffice, StarOffice, and KOffice are the largest vendors supporting OpenDocument. largest vendors supporting OpenDocument.

Simple Text DocumentSimple Text Document

Text document that says “Open Document test” in Text document that says “Open Document test” in variety of fonts and styles. variety of fonts and styles.

The file opened correctly in all three applications.The file opened correctly in all three applications.

Advanced Text DocumentAdvanced Text Document

Advanced text document that has a table, Advanced text document that has a table, image, shading, and variety of fonts, sizes, and image, shading, and variety of fonts, sizes, and justifications.justifications.

Opened correctly in all three applicationsOpened correctly in all three applications

Simple Spreadsheet Simple Spreadsheet DocumentDocument

Simple spreadsheet that performs addition, Simple spreadsheet that performs addition, subtraction, multiplication, and division.subtraction, multiplication, and division.

Opened correctly in all three applicationsOpened correctly in all three applications

Advanced Spreadsheet Advanced Spreadsheet DocumentDocument

The complex equation is entered:The complex equation is entered:=(SUM(A1;A3;AVERAGE(A1:A5)+LOG(A1+10;10)-=(SUM(A1;A3;AVERAGE(A1:A5)+LOG(A1+10;10)-SQRT(A4*SIN(0.75)+MOD(A3;A4))) + (POWER(3;3)/LN(A4)))SQRT(A4*SIN(0.75)+MOD(A3;A4))) + (POWER(3;3)/LN(A4)))

Opened correctly in OpenOffice and StarOffice Opened correctly in OpenOffice and StarOffice KOffice had ERR:511 in the cell where the equation appearsKOffice had ERR:511 in the cell where the equation appears

Advanced Spreadsheet Document(2)Advanced Spreadsheet Document(2)

Problems occur because OpenDocument Problems occur because OpenDocument does not define a standard for functions, does not define a standard for functions, only formatting.only formatting.

Currently each application defines their Currently each application defines their own standard for function formatting.own standard for function formatting.

New research into extending New research into extending OpenDocument to developing a standard OpenDocument to developing a standard to exchange formulas in spreadsheet to exchange formulas in spreadsheet called OpenFormula proposed by David called OpenFormula proposed by David Wheeler. Currently in draft status.Wheeler. Currently in draft status.

OpenDocument and RDFOpenDocument and RDF

With the use of RDF, documents can be With the use of RDF, documents can be easily found by subject, author, creation easily found by subject, author, creation date, or keywords.date, or keywords.

Information can be retrieved through Information can be retrieved through accessing the Dublin Core elements in the accessing the Dublin Core elements in the meta.xml file.meta.xml file.

Information sharing and searching are easily Information sharing and searching are easily achieved without requiring user input during achieved without requiring user input during insertion into the databaseinsertion into the database

An ongoing topic of research in ways to An ongoing topic of research in ways to efficiently parse the XML files for information.efficiently parse the XML files for information.

OpenDocument Conclusions

The documents are not yet universally The documents are not yet universally portable but work is continuing to portable but work is continuing to improve this ability.improve this ability.

Information stored in XML results in Information stored in XML results in many benefits over a binary file.many benefits over a binary file.

With the use of RDF, an exciting future With the use of RDF, an exciting future is ahead with the ability to find is ahead with the ability to find documents extremely efficiently and documents extremely efficiently and easily.easily.

Software Component Retrieval: Software Component Retrieval: Basic Basic

ArchitectureArchitecture

LibraryComponent

Specification

Component Analyzer

Lexical Analyzer Syntactic Analyzer

Semantic Analyzer

QueryComponent

Specification

Component Analyzer

Lexical Analyzer Syntactic Analyzer

Semantic Analyzer

Extracted librarycomponent specification

MatchMaker

Extracted querycomponent specification

Retrievedcomponents

<component> <cname> component_name </cname> <method> <mname> method_name </mname> <paramNo> no_of_parameter </paramNo> <param> <pname> parameter_name </pname> <ptype> type_of_parameter </ptype> <psize> size_of_parameter </psize> </param> … <precond> <left> left_operand1 </left> <operator> operator1 </operator> <right> right_operand1 </right> </precond>

<precond> <left> left_operand2 </left> <operator> operator2 </operator> <right> right_operand2 </right> </precond> … <postcond> <left> left_operand1 </left> <operator> operator1 </operator> <right> right_operand1 </right> </postcond> <postcond> <left> left_operand2 </left> <operator> operator2 </operator> <right> right_operand2 </right> </postcond> … <return> return_type </return> </method> …</component>

<postcond> <subcond> <left> left_operand1 </left> <operator> operator1 </operator> <right> right_operand1 </right> </subcond> <and> <subcond> <left> left_operand2 </left> <operator> operator2 </operator> <right> right_operand2 </right> </subcond> </and> <and> <subcond> <left> left_operand3 </left> <operator> operator3 </operator> <right> right_operand3 </right> </subcond> </and> … </postcond>

A component – method with Boolean conditions

A component – method with a set of individual conditions

XML-based software component specificationXML-based software component specification

XML-based software component specificationXML-based software component specification

<postcond> <subcond> <left> left_operand1 </left> <operator> operator1 </operator> <right> right_operand1 </right> <and> <subcond> <left> left_operand2 </left> <operator> operator2 </operator> <right> right_operand2 </right> <and> <subcond> <left> left_operand3 </left> <operator> operator3 </operator> <right> right_operand3 </right> </subcond> … </and> </subcond> </and> </subcond></postcond>

A component – method with multi-level conditions (Boolean join)

A component – method with multi-level conditions

<postcond> <left> <subcond> <left> left_operand1 </left> <operator> operator1 </operator> <right> right_operand1 </right> </subcond> </left> <operator> operator2 </operator> <right> right_operand2 </right></postcond>

<component> <cname> component_name1 </cname> …</component><component> <cname> component_name2 </cname> <isa> component_name1 </isa> <method> <mname> method_name </mname> <paramNo> no_of_parameter </paramNo> <param> <pname> parameter_name </pname> <ptype> type_of_parameter </ptype> <psize> size_of_parameter </psize> </param> … <precond> … </precond> <postcond> … </postcond> <return> return_type </return> </method> …</component>

An “isa” component

Exact MatchExact MatchMatchExactMatchExact((QQ, , LL) = () = (QpreQpre LpreLpre)) ( (QpostQpost LpostLpost) )

((QinQin LinLin) ) ( (QoutQout LoutLout) )

Generalization MatchGeneralization MatchMatchGen(Q, L) = (Lpre MatchGen(Q, L) = (Lpre Qpre Qpre Lpost Lpost Qpost) Qpost)

Specialization MatchSpecialization MatchMatchSpecMatchSpec((QQ, , LL) = () = (QpreQpre LpreLpre QpostQpost LpostLpost))

Partial MatchPartial MatchMatchPartMatchPart((QQ, , LL) = () = (MatchGenMatchGen((QQ, , LL) ) MatchSpecMatchSpec((QQ, , LL)) ))

((L’inL’in Lin Lin ((L’in L’in = = QinQin) ) L’outL’out Lout Lout ((L’out L’out = = QoutQout))))

Reference MatchReference MatchMatchRefMatchRef((QQ, , LL) = () = (MatchExactMatchExact((QQ, , ll) ) MatchPartialMatchPartial((QQ, , ll)) ))

((MatchExactMatchExact((qq, , LL) ) MatchPartialMatchPartial((qq, , LL))))

Software Component Retrieval: Software Component Retrieval: Determine MatchingDetermine Matching

Q and q denote queriesL and l denote existing components in the library/repository

Software Component Retrieval: Compute SimilaritySoftware Component Retrieval: Compute Similarity

Component Component SimilaritySimilarity

Method SimilarityMethod Similarity

Pre-condition Pre-condition SimilaritySimilarity

Post-condition Post-condition SimilaritySimilarity

Input SimilarityInput Similarity

Out SimilarityOut Similarity

Software Component Retrieval: Software Component Retrieval: IllustrationIllustration

Repository/Library: lib1.xmlQuery: q2.xmlWeight: input: 10 output: 10 precondition: 30 postcondition: 50

<query> <component> <cname> q2 </cname> <method> <mname> m2 </mname> <paramNo> 2 </paramNo> <param> <pname> k </pname> <ptype> real </ptype> </param> <param> <pname> j </pname> <ptype> real </ptype> </param> <precond> <left> j </left> <operator> greater_or_equal </operator> <right> 0 </right> </precond> <postcond> <left> k </left> <operator> greater_or_equal </operator> <right> 0 </right> </postcond> <postcond> <left> <subcond> <left> k </left> <operator> power </operator> <right> 2 </right> </subcond> </left> <operator> equal </operator> <right> j </right> </postcond> <return> k </return> </method> </component></query>

Display Similarity TableFormat: component name, method name, Sim-Post, Sim-Pre, Sim-Param, Sim-Return, method-sim, match_type, ref_match=========================================================q2, math1, sqr, 50.0, 100.0, 100.0, 100.0, 75.0, generalizationq2, math2, sqr2, 100.0, 100.0, 100.0, 100.0, 100.0, exactq2, math3, sqr, 0.0, 100.0, 100.0, 100.0, 50.0, partial

Component name: q2

Parameter ----> Method: m2 k Method: m2 j

Pre condition ----> Method: m2 weight =100.00% j greater_or_equal 0

Post condition ----> Method: m2 weight =50.00% k greater_or_equal 0 Method: m2 weight =50.00% ( k power 2 ) equal j

Return value ----> Method: m2 k

Software Component Retrieval: Software Component Retrieval: IllustrationIllustration

Repository/Library: lib1.xmlQuery: q_isa_1.xmlWeight: input: 10 output: 10 precondition: 35 postcondition: 45

Component name: q_math1

Parameter ----> Method: q_sqr x Method: q_sqr r

Pre condition ----> Method: q_sqr weight =100.00% x greater_or_equal 0

Post condition ----> Method: q_sqr weight =100.00% ( r power 2 ) equal x

Return value ----> Method: q_sqr r

Component name: isa_test1

Parameter ----> Method: find_max param1 Method: find_max param2

Pre condition ----> Method: find_max weight =50.00% param1 greater 0 Method: find_max weight =50.00% param2 greater 0

Post condition ----> Method: find_max weight =100.00% param1 greater param2

Return value ----> Method: find_max param1

Display Similarity TableFormat: component name, method name, Sim-Post, Sim-Pre, Sim-Param, Sim-Return, method-sim, match_type, ref_match================================================================q_math1, math1, sqr, 100.0, 100.0, 100.0, 100.0, 100.0, exactq_math1, math2, sqr2, 100.0, 100.0, 100.0, 100.0, 100.0, specializationq_math1, math3, sqr, 0.0, 100.0, 100.0, 100.0, 55.0, partialisa_test1, list_operation, add_list, 0.0, 0.0, 50.0, 0.0, 5.0, partialisa_test1, simple_array, add_to_array, 0.0, 0.0, 100.0, 0.0, 10.0, partialisa_test1, simple_array, find_max, 100.0, 0.0, 100.0, 100.0, 65.0, partialisa_test1, stack_operation, pop, 0.0, 50.0, 50.0, 0.0, 22.5, partialisa_test1, stack_operation, push, 0.0, 0.0, 100.0, 0.0, 10.0, partialisa_test1, graphic_obj, pop, 0.0, 50.0, 0.0, 0.0, 17.5, partialisa_test1, math1, sqr, 100.0, 100.0, 100.0, 100.0, 100.0, generalization-referenceisa_test1, math2, sqr2, 100.0, 100.0, 100.0, 100.0, 100.0, generalization-reference

M1

M2

Mn

Matchmakers

…

… …

Que

ry In

terf

ace P

ublish Interface

Component DescriptionRepository

Licensing server

Component Integrators Component Vendors

(Varadarajan, et. al. “Componentxchange: An E-Exchange for Software Components”, WWW’10, 2001)

Software Component Retrieval: IssuesSoftware Component Retrieval: Issues

Different tags refer to the same elementDifferent tags refer to the same element<input-type> string </input-type> and<input-type> string </input-type> and<datatype> string </datatype><datatype> string </datatype>

Different terms refer to the same contentDifferent terms refer to the same content– For an array’s operationsFor an array’s operations: :

<operator> add </operator> and<operator> add </operator> and<operator> insert </operator> <operator> insert </operator>

RDF:RDF: INFER {?s ?B ?o} FROM {?A is-a-synonym-of ?B} AND {?s ?A ?o};INFER {?s ?B ?o} FROM {?A is-a-synonym-of ?B} AND {?s ?A ?o};

Integration of software component specificationsIntegration of software component specifications – Same standards of specificationsSame standards of specifications– different standards of specificationsdifferent standards of specifications

Software Component Retrieval: RDFSoftware Component Retrieval: RDF

input-type datatype(relation)

add insert(relation)

C1 C2(relation)

<component> <cname> stack_operation </cname> <method> <mname> push </mname>

… <precond> <left> n </left> <operator> greater_equal </operator> <right> 0 </right> </precond> <precond> <left> S </left> <operator> not </operator> <right> full </right> </precond> <postcond> <left> x </left> <operator> in </operator> <right> S </right> </postcond> <postcond> <left> x </left> <operator> top </operator> <right> S </right> </postcond> <postcond> <left> n </left> <operator> increase </operator> <right> 1 </right> </postcond> <return> none </return> </method> <method> <mname> pop </mname>

… <precond> <left> n </left> <operator> greater </operator> <right> 0 </right> </precond> <postcond> <left> n </left> <operator> decrease </operator> <right> 1 </right> </postcond> <return> peak </return> </method> </component>

<component> <cname> simple_array </cname> <method> <mname> find_max </mname>

…<precond>

<subcond> <left> param2 </left> <operator> in </operator> <right> temp_array </right> <and> <subcond> <left> param2 </left> <operator> greater </operator> <right> 0 </right> </subcond> </and> </subcond> </precond> <postcond> <left> param1 </left> <operator> greater </operator> <right> param2 </right> </postcond> <return> param1 </return> </method> <method> <mname> add </mname>

…<precond>

<left> x </left> <operator> not_in </operator> <right> A </right> <and> <subcond> <left> A </left> <operator> not </operator> <right> full </right> </subcond> </and> </precond> <postcond> <left> x </left> <operator> in </operator> <right> A </right> </postcond> <return> none </return> </method> </component>

Integration of software component specifications described the same standardsIntegration of software component specifications described the same standards

<component> <cname> simple_array </cname> <method> <mname> find_max </mname>

…<precond>

<subcond> <left> param2 </left> <operator> in </operator> <right> temp_array </right> <and> <subcond> <left> param2 </left> <operator> greater </operator> <right> 0 </right> </subcond> </and> </subcond> </precond> <postcond> <left> param1 </left> <operator> greater </operator> <right> param2 </right> </postcond> <return> param1 </return> </method> <method> <mname> add </mname>

…<precond>

<left> x </left> <operator> not_in </operator> <right> A </right> <and> <subcond> <left> A </left> <operator> not </operator> <right> full </right> </subcond> </and> </precond> <postcond> <left> x </left> <operator> in </operator> <right> A </right> </postcond> <return> none </return> </method> </component>

Integration of software componentIntegration of software component

specifications described with specifications described with

different standardsdifferent standards

Future WorkFuture Work

Generate test cases: RDF dealing with Generate test cases: RDF dealing with – Different tags refer to the same elementDifferent tags refer to the same element

– Different terms refer to the same contentDifferent terms refer to the same content

– Integration of software component Integration of software component specifications specifications

Domain-specificDomain-specific

Interpretation on the retrieval toolInterpretation on the retrieval tool

Authority and privacyAuthority and privacy

Data Warehouse Data Warehouse IntroductionIntroduction

Common Metamodel for Data WarehousesCommon Metamodel for Data Warehouses Data Warehouse SearchesData Warehouse Searches

– Full text SearchFull text Search– Metadata SearchMetadata Search– Global Metadata SearchGlobal Metadata Search– RDF Repository SearchRDF Repository Search

RDF Repository Search ExampleRDF Repository Search Example

Full Text SearchFull Text Search

Data

Search Tool

Data Data

Data

Warehouse

Metadata SearchMetadata Search

Metadata

Warehouse Tool

Search Tool

Metadata Metadata

Warehouse Tool

Warehouse Tool

Common Warehouse Common Warehouse MetamodelMetamodel

Metamodel standard for all data Metamodel standard for all data warehouse toolswarehouse tools

Designed for the data warehouse Designed for the data warehouse domaindomain

Allows extensibility of metadata from Allows extensibility of metadata from standard modelstandard model

Creates a global metadata solutionCreates a global metadata solution

Global Metadata SearchGlobal Metadata Search

CWM

Repository

Warehouse Tool

Search

Tool Warehouse Tool

Warehouse Tool

Warehouse Tool

Warehouse Tool

Glue CWM to RDFGlue CWM to RDF

CWM metadata mapped to RDF CWM metadata mapped to RDF metadatametadata– RDF RepositoryRDF Repository

Exposes user to a richer data setExposes user to a richer data set– RDF metadata are created as objectsRDF metadata are created as objects– Stored in a table as triplesStored in a table as triples– Inferences are created between objects Inferences are created between objects

Only as good as the tagsOnly as good as the tags– Rely on quality of taggingRely on quality of tagging– High Quality most likely found in corporate High Quality most likely found in corporate

officeoffice

Ontology Mapping Ontology Mapping SearchSearch

CWM

Repository

RDF

Repository

Search Tool Warehouse

Tool

Warehouse Tool

Warehouse Tool

Warehouse Tool

Homeland SecurityHomeland Security

Disjoint CIA and FBI CWM Disjoint CIA and FBI CWM repositoriesrepositories– Map these to one RDF repositoryMap these to one RDF repository

FBI

CWM

RepositoryRDF

Repository

Query Tool CIA

CWM

Repository

Persons of Interest Persons of Interest TrackingTracking

Track Persons of InterestTrack Persons of Interest– Insertion of dataInsertion of data

A spy inserts all recorded data on A spy inserts all recorded data on suspectsuspect

These are mapped to an RDF repository These are mapped to an RDF repository Inferences created between suspects Inferences created between suspects

and actionsand actions

– Raise flags for suspicious activitiesRaise flags for suspicious activities Can be a combination certain activitiesCan be a combination certain activities

Suspected TerroristSuspected Terrorist

Search Suspected Terrorist using RDF Search Suspected Terrorist using RDF repositoryrepository– Suspicious ActivitiesSuspicious Activities

One way plane ticketsOne way plane tickets Large exchanges of money at bankLarge exchanges of money at bank

– Link activities Link activities Terrorist X uses bankTerrorist X uses bank

– Has suspected terrorists Y and Z used the Has suspected terrorists Y and Z used the same bank recently?same bank recently?

Questions?Questions?