The Journal of Systems and Software 81 (2008) 2183–2193

Contents lists available at ScienceDirect

The Journal of Systems and Software

journal homepage: www.elsevier .com/ locate/ jss

Using social networking and semantic web technology in software engineering– Use cases, patterns, and a case study

Jens Dietrich a,*, Nathan Jones b, Jevon Wright a

a Massey University, Institute of Information Sciences and Technology, Te Kura Putaiao o Hangarau-a-Mohiotanga, Palmerston North, New Zealandb Orion Health, PO Box 8273, Symonds Street, Auckland, New Zealand

a r t i c l e i n f o

Article history:Received 31 July 2007Received in revised form 11 January 2008Accepted 26 March 2008Available online 9 May 2008

0164-1212/$ - see front matter � 2008 Elsevier Inc. Adoi:10.1016/j.jss.2008.03.060

* Corresponding author.E-mail addresses: j.b.dietrich@massey.ac.nz (J. Di

health.com (N. Jones), j.m.wright@massey.ac.nz (J. W

a b s t r a c t

We present an approach that uses social networking and semantic web technology to share knowledgewithin the software engineering community. We propose to use existing Web 2.0 services such as socialbookmarking and blogs as the infrastructure to share knowledge artefacts. Due to the openness of theseservices, it is crucial to provide support to establish the trustworthiness of knowledge artefacts. The solu-tion proposed is designed following the original semantic web stack architecture and uses existing andemerging W3C semantic web standards such as the Resource Description Framework (RDF), the WebOntology Language (OWL), and the Semantic Web Rule Language (SWRL). The WebOfPatterns projectis presented as a case study, which includes an Eclipse plug-in that can be used to discover design patterndefinitions in social networks, to define and publish patterns, to rate patterns, to establish the trustwor-thiness of patterns found, and finally to scan Java projects for instances of discovered patterns. We alsopropose the ContributedProperties design pattern that can be used to bridge the conceptual gap betweenRDF resources and objects in an object-oriented programming language.

� 2008 Elsevier Inc. All rights reserved.

1. Introduction

Software design patterns are design artefacts used within thesoftware engineering community to share knowledge about thedesign of software. Since their popularisation by the GangOfFourin the 90s (Gamma et al., 1995), the modus operandi of sharingpatterns has changed little: software engineers still share patternsby publishing and reading books, and partaking in online commu-nities such as discussion forums and mailing lists in order to ex-change knowledge about patterns.

There is a significant body of work exploring how design pat-terns can be formalised; for a good overview the reader is referredto Taibi’s book (Taibi, 2007). This is motivated by a number of usecases, in particular to enhance the comprehension of complex soft-ware by scanning it for occurrences of certain design patterns. Wehave argued that the Resource Description Framework (RDF)(Klyne and Carroll, 2004) and the Web Ontology Language (OWL)(Mcguinness and van Harmelen, 2004) technologies are the mostsuitable for this purpose, as patterns can be described as instancesof a software design ontology (Dietrich and Elgar, 2005, 2007). Oneof the advantages this approach has is that patterns can be easilypublished on standard web servers which use common protocolslike the Hypertext Transfer Protocol (HTTP) or the File Transfer Pro-

ll rights reserved.

etrich), Nathan.Jones@orion-right).

tocol (FTP), annotated with metadata (using established vocabular-ies, in particular Dublin Core), and discovered by users throughstandard search engines. Furthermore, this format allows an ab-stract representation of design patterns that does not depend onany particular tools, systems or programming languages.

There are a number of other artefacts that could be publishedand discovered in such a fashion, including anti-patterns, smells,refactorings, and configuration maps. They all represent tool- andprogramming language-independent knowledge about softwarethat could be published to software engineers. Most of this knowl-edge is precise enough that it can be formalised and processed bysoftware tools such as anti-pattern scanners and refactoringbrowsers. An abstract formal representation is again desirable asthis makes this knowledge more portable. There is ongoing re-search in areas such as refactoring languages, including XUpdate-based approaches (Laux and Martin, 2000, 2004), and metamodelsfor refactoring (Tichelaar et al., 2000). The use of XPath (Clark andDeRose, 1999) to represent anti-patterns in PMD is another exam-ple of an abstract, formal representation of software engineeringknowledge.

Abstracting from these examples, we use the term ‘‘knowledgeartefact” (or artefact for short) in order to refer to a language-inde-pendent document, defined in a formal language, representingcontext-independent knowledge in the software engineering do-main. This includes OWL-based design pattern definitions (Dietrichand Elgar, 2005, 2007), XML-based definitions of refactorings(Mendonca et al., 2004), and so on. Context independence refers

client

knowledge artefacts

index

annotation and

feedback

references

references

selectionmodule

inter-preter

module

querymodule

compo-sition

module

feedbackmodule

server(s)

publish

feedback

discover

select

Fig. 1. Architectural overview.

2184 J. Dietrich et al. / The Journal of Systems and Software 81 (2008) 2183–2193

to some degree of abstractness, system independence and portabil-ity of this knowledge.

We propose an infrastructure for these knowledge artefacts,including a framework to reason about these artefacts using expli-cit and harvested metadata. This is necessary to establish the trust-worthiness of knowledge discovered. Our vision is that an openinfrastructure and accompanying trustworthiness tool support willfinally lead to an open ecosystem of knowledge artefacts.

The rest of the paper is organised as follows: In Section 2 we de-scribe the main use cases for our work and provide a brief architec-tural overview of our approach. In Section 3, we summarize theWebOfPatterns project that is used in our case study. Section 4 de-scribes the services needed to address these use cases. Section 5discusses the implementation of these services, and elaborateshow the WebOfPatterns tool interacts with several social net-works. We then extract a new design pattern, ContributedProper-ties, which is suitable for use in applications sharing knowledgeartefacts, which we describe in Section 6 following the GangOfFourtemplate. We finish our contribution with a general discussion inSection 7, and a discussion of related and future work in Sections8 and 9, respectively.

2. Use cases

The simplest method to exchange knowledge on the web isthrough one person producing and publishing content on a webserver, and a second person consuming it by accessing this re-source. Social networking applications provide a third role byallowing users to annotate this published knowledge. There areseveral ways to do this, including quality rating (feedback) and cat-egorisation (tagging). Consumers can benefit directly from theseannotations as they may be used to assess the suitability and qual-ity of artefacts discovered online. This community-based model ofinformation exchange has been very successful in recent years, andis the basis for many commercially successful services such as on-line auction sites and peer-to-peer recommendation systems.

The following four use cases describe the actions of softwareengineers when using social networks for collaboration:

(i) Discovery: Users can discover online knowledge artefacts,preferably by using standard search engines or services,and can consume this knowledge by downloading it.

(ii) Selection: Users validate and assess discovered knowledgeartefacts in order to filter out low-quality knowledge, andto select trustworthy knowledge.

(iii) Feedback: Users can provide feedback, and therefore caninfluence which artefacts are considered to be good andtrustworthy. This allows selection to take (aggregated) userfeedback into account.

(iv) Publication: Users can easily create and publish new knowl-edge artefacts online.

Consuming knowledge after discovery generally does not implydisplay in a web browser, but rather to interpret it within a toolenvironment such that it adds value to a software engineering pro-ject. In our case study on design patterns below, patterns discov-ered online are interpreted by a pattern scanner that scans Javaprojects for instances of the respective patterns. In a similar man-ner, PMD can scan source code for instances of anti-patterns de-fined by XPath expressions.

In general, systems that implement these use cases need mod-ules that can interact with the different types of server-side ser-vices involved. In particular, a query module is needed to interactwith search engines and to discover and download knowledgeartefacts. A selection module is needed to select artefacts. This

module usually also interacts with feedback services to incorporatecommunity feedback into the selection process. Selected knowl-edge is then passed to an interpreter module that can consumethe knowledge artefacts. A composition module is used to buildnew artefacts, to publish them and to submit them to search ser-vices to be indexed. Finally, a feedback service can be used forend-users to submit feedback about knowledge artefacts or totag them. Fig. 1 depicts these main client components and theirinteraction with server-side services.

3. A case study: the WebOfPatterns project

The aim of the WebOfPatterns (WOP) project is to represent de-sign patterns as instances of a design ontology. The pattern defini-tions are programming language-independent, can be easilyserialised as XML documents by using the RDF/XML syntax, andcan be published as files on standard web servers with no addi-tional configuration. A WOP client can then load these pattern def-initions to build a set of constraints, which are then used by aconstraint resolver to discover design pattern instances insoftware.

While the pattern representation language is programming lan-guage-independent, our proof-of-concept implementation isdeveloped in Java. This client consists of a set of plug-ins for theEclipse development environment. Eclipse is a popular softwaredevelopment platform with strong industry support, and is the ba-sis for a wide range of enterprise-level software development tools.A core feature of this platform is its sophisticated plug-in architec-ture consisting of extension points, allowing plug-ins to provideplatform extensions (Gamma and Beck, 2003).

The WOP client extends Eclipse’s standard extension points,allowing the client to take advantage of the rich set of services pro-vided by Eclipse, including the abstract syntax tree (AST) modelthat is needed for source code analysis when projects are scannedfor pattern instances. The WOP client adds the following threecomponents to Eclipse:

(i) The pattern scanner. The scanner analyses a selected Javaproject for instances of design patterns extracted from pat-tern repositories. These repositories are identified by an Uni-form Resource Locator (URL), either selected from thedatabase of known repositories, or explicitly provided; alter-natively, a local copy can also be used. Several network pro-tocols and RDF syntax flavours are supported, determined bythe capabilities of the Jena framework used for RDF parsing

select network

<<uses webservice>>issue query

<<uses webservice>>validate results

is valid?

<<uses webservice>>fetch properties

apply rules

add to repository manager

is trustworthy?

[N]

[Y]

[N]

[Y]

Fig. 2. Discovering patterns.

Fig. 3. Interface definition of the pattern discovery service.

Fig. 4. Interface definition of the feedback service.

J. Dietrich et al. / The Journal of Systems and Software 81 (2008) 2183–2193 2185

and loading. The RDF predicates are mapped to constraints,and the scanner uses a constraint resolver in order to findpattern instances. The scanner uses various means for pro-gram analysis, including reflection, naming patterns, andsource code analysis. An experimental implementation forbehavioural analysis based on aspect-oriented programming(AOP) (Kiczales et al., 1997) also exists. Aggregators are usedto aggregate the pattern instances found. For details on themechanics of the pattern scanner and the conceptual frame-work underpinning the scanner, the reader is referred to ourprevious work on this subject (Dietrich and Elgar, 2005,2007).

(ii) The repository manager. This is a local database of knownrepositories. The functionality of the repository manager isfurther extended by plug-ins that can filter repository loca-tions, discover online repositories and post feedback forexisting repositories.

(iii) The pattern publishing wizard. The wizard can be used toextract patterns from existing projects, annotate them withmetadata, and publish them into RDF documents that instan-tiate the design ontology. The wizard does not require end-users to edit RDF or OWL documents directly; instead, itallows users to select participants, associations and propertiesthat are part of the pattern being defined from lists. These listsare populated through inspection. The RDF-based pattern def-inition is then generated by the tool in the background.

4. Plug-in services

The four use cases we mentioned previously are addressed byservices representing the modules introduced in the architecturaloverview (Fig. 1). For each service, the WOP plug-in provides anextension point that describes the service in abstract terms, withthe actual services implemented with additional plug-ins. By sep-arating these services from the core application the system re-mains open; additional plug-ins can be used to integrateadditional social networks into the client. This is important as dif-ferent users tend to prefer different social networks, and partici-pate in different online communities.

4.1. Discovery services

The discovery services are used to discover online pattern repos-itories. These pattern definitions can then be validated against thesoftware design ontology, filtered according to location selectionservices mentioned later, and added to the client-side pattern repos-itory database. Current implementations include the use of semanticsearch engines (such as Swoogle), searching in blogs dedicated to thepublication of (formalised) design patterns, and searching for URLsassociated with a certain tag listed in a bookmarking service (suchas del.icio.us). Fig. 2 depicts pattern discovery using a UnifiedModeling Language (UML) 2.0 activity diagram.

Fig. 3 shows the discovery service interface. The semantics ofthis service is to display an Eclipse view, which can be used bythe user to discover new pattern repository locations, and thenadd patterns to the repository database. In this view, the usercan browse the patterns discovered, can analyse their metadata,and remove patterns either manually or automatically beforedownloading them into the local pattern repository database.

4.2. Feedback services

Feedback services allow users to rate discovered patterns; thisfeedback can be considered as part of the selection process. It

can be published by creating bookmarks on a bookmarking site,or by sending values to a dedicated feedback server, which is thenaggregated with other feedback to provide an average overallrating.

Fig. 4 contains the feedback service interface. Current imple-mentations display a service-specific interface that the user canuse to edit feedback for a pattern (represented through an instanceof a WOP class Location). The interface is purposely kept very ab-stract; some feedback services may provide users with an interface,

2186 J. Dietrich et al. / The Journal of Systems and Software 81 (2008) 2183–2193

such as discussion forums for textual feedbacks, whilst others mayonly accept numerical ratings.

4.3. Location properties providers

Location property provider services are used to associate pat-tern repositories with various properties harvested from social net-works. These properties can then be used by discovery services inorder to filter repositories. For instance, discovery services may fil-ter pattern repositories using the number of del.icio.us book-marks associated with the repository URL; the average ratingobtained from a dedicated feedback server; or the estimated num-ber of references found on Google. Each extension for this exten-sion point therefore provides additional properties for a dynamicobject model. This is useful because over time new types of prop-erties and new methods of access will become available. Each pro-vided property includes a unique identifier, as well as code thatdefines the semantics of the respective property, allowing theproperty value to be computed given a particular location objectidentified by a Uniform Resource Identifier (URI). In terms ofRDF, these services add functional data type properties to theselocations.

Fig. 5 shows the properties view for a repository location. Theproperties include explicit metadata such as Dublin Core annota-tions; harvested metadata such as whether the resource has beenaccessed using a secure connection; and contributed metadata likethe number of del.icio.us bookmarks found. Properties areannotated with an isNetworkProperty flag that can be used todecide whether the properties should be prefetched using a back-ground thread.

We believe that the design used here is applicable in many sce-narios where properties of objects have to be gathered from differ-ent locations within an open, distributed system. This justifies the

Fig. 5. Properties view.

introduction of a new design pattern called ContributedProperties,which we discuss in detail in Section 6.

4.4. Location selection services

Location selection services are used to filter repositories, and toselect good and trustworthy repositories. These services can usu-ally be customised by the users. Implementations of this servicecan use derivation rules, integrating properties provided by thelocation property providers, with conditions such as:

if property(location,x) and predicate(x, value) thenisTrustworthy(location, true).

Location selection rules can be serialised with the SemanticWeb Rule Language (SWRL) (Horrocks et al., 2004) into XML repre-sentations. These rules reference these properties according toURIs specified by the property provider; for example, in theSWRL-encoded rule provided in Fig. 6, the useshttps propertyis referenced using the URI nz.ac.massey.

cs.wop.eclipse:useshttps. That is, the ontology used in therules is dynamically composed by the plug-ins that are availableat runtime. In terms of OWL, these plug-ins contribute data typeproperties to the class Location.

The rules can also take advantage of a library of standard pred-icates (SWRL built-ins) and data types (from XMLSchema). This ap-proach supports the platform-independent definition of rules, andfacilitates the sharing of rules within a community. Fig. 7 shows aneditor that can be used by end-users in order to set up the rules.

4.5. Publishing services

Publishing services allow the registration of published patternrepositories with external online services (in particular their publicURL), facilitating the later discovery of these new repositories byother users. This includes repository submission to a search en-gine; associating the URL with a bookmark on a bookmarking ser-vice, or adding an entry to a blog. Naturally, plug-ins whichimplement this service usually also implement the discovery ser-vice. Fig. 8 depicts the activities involved in pattern extractionand publishing; these activities are supported by a pattern extrac-tion wizard. Design patterns are created by abstracting from a pat-tern instance found in a Java project. Currently, the technical sideof publishing the pattern – generally uploading the serialised pat-tern description to a web server – is manually performed by theuser outside the client.

The publication service interface is shown in Fig. 9. Servicesimplementing this interface are invoked at the end of the patternextraction wizard. This wizard guides users in extracting patternsfrom programs and adding metadata to the pattern definition. Atthe end of the process, an RDF file is created containing the newpattern definition, which may then be published online.

5. Implemented services

The WOP client includes a number of implementations of theservices mentioned above that interact with server-side servicesusing different network Application Programming Interfaces(APIs). Most of these service implementations use REST-based APIs(Fielding, 2000), but some use other interfaces such as the SimpleObject Access Protocol (SOAP) (Gudgin et al., 2007). Tables 1 and 2list the implemented services and the types of API used. In somecases, we had to resort to end-user interaction or direct HTMLparsing as some providers do not publish an API for the respectiveservices; for instance, Swoogle strictly permits only manual sub-mission of information. In this case the browser built into Eclipse

Fig. 6. Trustworthiness Rule serialised using SWRL.

Fig. 7. The SWRL-based rule editor.

1 The tag currently used is ‘‘wop20060324”.

J. Dietrich et al. / The Journal of Systems and Software 81 (2008) 2183–2193 2187

displays a submission form to the user, and JavaScript is used to fillin parts of this form. Table 3 shows selected properties contributedby network services.

Additional services can be easily provided by developing addi-tional plug-ins for the respective extension points. This consistsof implementing the Java interfaces introduced earlier, and writinga plug-in configuration file to deploy this extension directly intoEclipse.

The use of public social network-based services has a number ofobvious weaknesses; for example, somebody could easily manuallybookmark an invalid (or improperly formatted) design pattern ondel.icio.us. This problem is addressed by the validation servicethat checks resources before adding them to the repository data-base, and by using aggregated user feedback. The bookmarks usedby the del.icio.us based service implementations are ratherartificial,1 but this property is justified by their purpose: they arepart of a contract between publishing and discovery services andare primarily for machine consumption. Additionally, the publishingservice allows users to provide additional bookmark tags, initiallysuggesting ‘‘webofpatterns” and ‘‘designpattern”. This links the for-mal pattern description to tags used by the community to describedesign patterns in a wider sense, and to bookmark resources usuallydesigned for human end-users (such as web pages).

select Java project

select participants (types, members and relationships)

associate participants with abstract role names

<<uses webservice>>publish pattern

select publishing service

add DublinCore meta data

generate RDF(pattern definition)

upload RDF to WebServer

Fig. 8. Creating and publishing patterns.

Table 1Implemented services

Provider Discover Publish Feedback Properties

Blogger Yes Yes No Nodel.icio.us Yes Yes Yes YesSwoogle Yes Yes No NoWopper Yes Yes Yes YesGoogle No No No Yes

Table 2Network APIs used

Provider Network API types used

Blogger REST/HTML parsingdel.icio.us REST/HTML parsingSwoogle REST/HTML formsWopper RESTGoogle SOAP

Fig. 9. Interface definition of the pattern publishing service.

2188 J. Dietrich et al. / The Journal of Systems and Software 81 (2008) 2183–2193

A similar approach is used on the schema level. The ontologyformally defines concepts such as classes and members and theirrelationships using an abstraction level suitable to define designpatterns. This model is similar to the refactoring metamodels(Tichelaar et al., 2000), but our concepts are also related to defini-tions for end-users. For instance, the OWL sameAs predicate isused to relate the formal WOP definition of a pattern with therespective Wikipedia page on design patterns.

The Wopper server is a server especially developed to allow thepublication of pattern repositories. The server itself provides a sim-ple REST-based interface that may be POSTed to with respect to anexisting schema,2 allowing the server to be accessed by third partyclients, such as a WOP client developed in Visual Studio.

Fig. 10 depicts the design of the WOP client using a UML2 com-ponent diagram. The sockets represent Eclipse extension points aslollipops extensions. The WOP library contains the core web of pat-terns framework that includes the instantiation of the design pat-tern ontology. Reflect is a framework that extends the reflectivefacilities of Java, separating the structure of software artefacts fromthe analysis methods used (naming patterns, reflection, sourcecode or behavioural analysis).

6. The ContributedProperties design pattern

The need to establish the trustworthiness of resources requiresreasoning about them using properties that generally are not di-rectly attached to these resources. Having objects (or resources)with ‘‘external” properties is common in RDF/OWL. An RDF‘‘object” is described by a set of assertions; it is not unusual to haveassertions about the same resource in different documents. In par-ticular, the statements defining the property of one (OWL) class donot have to be in the same document. This is very different fromthe closed class definition model used in most object-oriented lan-guages3; here, class definitions are packaged together by compilers.To represent resources from an open, networked environment asapplication objects, we have to overcome this limitation. In otherterms, we have to bridge the paradigm mismatch between objectsin programming languages and semantic web resources. The solu-tion proposed here is a design pattern called ContributedProperties,which we present in the remainder of this section.

6.1. Pattern name and category

pattern name: ContributedProperties,pattern category: structural patterns, patterns for distributedsystems.

6.2. Intent

Objects are usually thought to be encapsulated entities; thestate of the object is completely defined by its fields. However, con-sider an object representing a resource in a dynamic, networkedenvironment. In such an environment, the object is used in differ-ent contexts, and in each context, context-specific properties areassociated with the object; that is, there are external contributionsto the state of the object. While caching contributed properties ininstance variables is possible, it is not practical as the property val-ues may change frequently. Objects are truly distributed in a sensethat their state information is scattered around the network. Forclient applications using these objects it would still be very usefulto access this state information as if it was local in order to supporta consistent programming model.

2 http://www-ist.massey.ac.nz/wop/wopper/20050704/wopper.xsd.3 Some object-oriented languages do provide support for adding extensions to

existing classes; Smalltalk class extensions are an example of this.

discover<<plugin>>

nz.ac.massey.cs.wop.eclipse

publish

<<library>>

wop

<<library>>

reflect

feedback

<<plugin>>

nz.ac.massey.cs.wop.eclipse.simplerules

<<plugin>>

nz.ac.massey.cs.wop.eclipse.blogger

<<plugin>>nz.ac.massey.cs.wop.eclipse.delicious

server side adapters

<<uses>>

<<uses>>

selection_rules

property_provider

<<plugin>>

nz.ac.massey.cs.wop.eclipse.swrl

nz.ac.massey.cs.wop.eclipse.swoogle

<<plugin>>

<<plugin>>

nz.ac.massey.cs.wop.eclipse.wopper

REST

SOAP

Fig. 10. WOP client design.

Table 3Selected properties

Property Contributor Type Meaning

Location Internal String The URL of the resourceDiscovered where Internal String Service used to discover the resourceDiscovered when Internal Date When the resource was discoveredValidation status Internal String Whether the resource has been validatedCreator DublinCore String The creator of the resourceNumber of bookmarks del.icio.us Integer The number of del.icio.us bookmarks for this resourceOntorank Swoogle Integer An ontology metric calculated by SwoogleAvg rating Wopper Double The average user rating recorded on the wopper feedback serverNumber of feedbacks Wopper Integer The number of feedbacks recorded on the wopper feedback serverBack link count Google Integer The estimated number of pages referencing this page found on Google (using a link: query)

J. Dietrich et al. / The Journal of Systems and Software 81 (2008) 2183–2193 2189

6.3. Motivation

The resources considered in our paper are RDF-based designpattern definitions. The properties considered are the propertiescontributed from social networks, such as the del.icio.us book-mark count, or the average user rating from a dedicated feedbackservice. In these services, the object is referenced using a uniqueresource URI. The client application is a rule-based application thatneeds to access the properties of the object representing the re-source in order to establish the trustworthiness of the resource.

6.4. Applicability

The ContributedProperties pattern is most suitable for situa-tions when:

(i) objects are used in an application to represent resources inopen networks;

(ii) properties are detached from objects;(iii) properties (and not only property values) can change at

runtime;(iv) the object state cannot be cached;(v) properties have a context that is meaningful for the client

application.

6.5. Structure

External entities contributing properties are explicitly repre-sented in this pattern as property providers. These provide proper-ties with attached type information, and also reference theirproperty provider, as properties need context information to fetchtheir values. This information is usually shared across all proper-ties provided by the same property provider, such as network set-tings and authentication. Properties are scoped by propertyproviders; in particular, property names are not required to be

2190 J. Dietrich et al. / The Journal of Systems and Software 81 (2008) 2183–2193

unique, as we generally cannot assume control over property pro-viders. However, the combination of property provider and prop-erty name allows unique identification of properties. A providerregistry is used to keep track of property providers, and can beused by clients to query property providers and the propertiesavailable. The property provider registry also has a derived associ-ation listing that gives client applications convenient access to allcurrently available properties. Fig. 11 depicts the pattern partici-pants and their relationships in a UML 2 diagram.

6.6. Participants

(i) Property – type representing the property.(ii) PropertyProvider – type representing the property provider.

(iii) PropertyProviderRegistry – type representing a register thatkeeps track of property providers.

(vi) PropertyType – the type of the property. Often, an existingclass from a programming language specific core library(such as java.lang.Class in Java applications) can be usedfor this purpose.

(v) Component – represents the object that has the properties.

6.7. Collaboration

Clients collaborate with instances of this pattern by accessingthe property, and querying the property for the current value ofan object. This is similar to field access and method invocationusing reflection in languages like Java. Client applications can usethe PropertyProviderRegistry to query the currently availableproperty providers. If the registry is dynamic, then either this infor-mation should not be cached by clients, or a change notificationmechanism must be implemented.

6.8. Consequences

When this pattern is used, clients no longer access the value of aproperty directly by querying the object, but by querying the prop-erty object itself with the object as a parameter. If the propertyprovider registry is dynamic, an application has to handle the casewhen referenced properties become unavailable or cannot be pro-vided. In the example presented here, contributed properties areused in trust rules. The application has to implement a policy forthe case when a property (e.g. del.icio.us bookmark count) be-comes unavailable (for instance, when the del.icio.us server

PropertyProviderRegistry

PropertyProvider +provider

1

1

+providers0..*

1

Fig. 11. The PropertyProv

goes offline), and a rule with a precondition (such as del.icio.uscount > 3) can no longer be evaluated.

6.9. Implementation

The WOP client contains an implementation of this pattern. Theobjects annotated with properties are instances of Location.These objects represent pattern repository locations. There is noseparate type representing the property type; instead, the Javaclass java.lang.Class is used. This is sufficient as all data typesencountered in this application scenario can be easily mapped toavailable Java types. The property provider is represented as aninterface LocationPropertyProvider that is subclassed inplug-ins that contribute properties. An example for this is the classDeliciousPropertyProvider. The registry is a class Loca-

tionProperties. It references the property provider by queryingthe Eclipse plug-in registry for available extensions for the prop-erty provider extension point. This ensures that the registry isaware of changes made in the system.

6.10. Related patterns

Contributed Properties is similar to the DynamicObjectModel(Riehle et al., 2005). The main difference is that the dynamic objectmodel does not contain a property provider. Properties are notscoped and therefore have a unique name that identifies them.Properties in the DynamicObjectModel are also mutable, whereaswe assume that all contributed properties are read only, as theyare provided by external systems which cannot be controlled bythe application. For instance, in the WOP scenario, these propertiesare the result of the aggregation of data harvested from externalsocial networks. ContributedProperties does not use a separatecomponent type. The type of the component is static. The Value-Holder pattern (Yoder et al., 1998) is similar in that it abstractsthe concept of variable by introducing a variable wrapper. ThePropertyList pattern (Riehle, 1997) can be used to configure theproperties of an object dynamically. However, the properties arestill part of the object where they are accessed by name and usu-ally stored in dictionaries, arrays or similar data structures. As-pect-oriented programming techniques (Kiczales et al., 1997) arecommonly used to design dynamic object models; however, prop-erties are not represented as separate entities, thus it is difficult toassociate metadata (such as the property provider) with the prop-erties. The RoleObject pattern (Baumer et al., 1997) extends exist-ing objects with the ability to perform multiple roles without

+getValue(Component)()

Property

PropertyType

1

+type1

+properties

1..*

+/properties0..*

ider design pattern.

J. Dietrich et al. / The Journal of Systems and Software 81 (2008) 2183–2193 2191

creating additional subclasses. ContributedProperties is only con-cerned with the existence of properties, and as such has less over-head than RoleObject. The ObjectSystem pattern (Noble, 1998) is afull-blown extensibility framework of classes and subclasses, de-signed to be very expensive; ContributedProperties, on the otherhand, is cheaper and more suitable for our motivations. Both ofthese patterns also lack any direct integration with remote datasources.

7. Discussion

Social networking is very popular among software engineers,but is currently only used to share knowledge intended for end-users, and not for software tools. The inherent advantage socialnetworks have is their openness and accessibility; the barrier topublish knowledge is very low. This can result in a large volumeof knowledge being published, meaning some structure to validateand assess this knowledge must be made available. While the for-mat used to publish this knowledge provides some means to dothis (e.g. schema validation), additional support is needed. Wehave described a possible solution based on derivation rules andthe knowledge annotations produced within the social network.We hope that it is this combination of openness, accessibility andselection mechanisms that can finally lead to a dynamic platformwhere better knowledge is created and made accessible throughtools that are able to interpret this knowledge.

We have found that writing an (OWL) ontology is not sufficientto fully define the intended semantics of concepts to an extent thatthey can be used correctly in application. The ontology defines con-straints that make it unlikely to find an instantiation of the ontol-ogy classes that is not an intended model. Additional definitionsand guidelines are still required.4 For instance, in the core WOPframework, we use adapters that map ontology concepts to Javaclasses implementing constraints on Java objects that can be usedby the pattern scanner. These application-specific mappings repre-sent ‘‘procedural attachments” to the ontology. This raises the ques-tion of whether these attachments should be considered as part ofthe ontology, and whether ontology languages should provide sup-port for them.

The WOP client presented here uses a blend of deep (OWLbased) and shallow (‘‘folksonomies”) ontologies. This is in particu-lar triggered by the requirement for community interaction.5 Theuse of services like del.icio.us is to a certain extent caused bythe fact that there is not yet a semantic web engine with a full-fledged API with the ability to make submissions that become visible‘‘just in time”. Our combination of client-side validation and server-side discovery, which may return semantically and syntacticallyincorrect results, simulates a semantic web search engine. The ap-proach of using tag-based indexing to discover pattern repositoriesresembles the use of naming services in enterprise computing: sim-ple names are used to reference complex objects in order to boot-strap applications, and to connect the producers and consumers ofcomplex objects. While services like del.ico.us are often consid-ered as being merely sites for bookmarking resources. But throughfeatures such as subscriptions, feeds and (user) networks, these ser-vices are also platforms for social interactions, and new knowledge isactively propagated through these networks.

For the feedback functionality of the system, social networksprovide a suitable solution. A general pattern we have encounteredhere is that we can extract aggregated values from these networks.These values are obviously meaningful, and can be used to provide

4 See also Uschold’s article (Uschold, 2003) for a general discussion on these issues.5 A more general discussion on the relationship between formal ontologies and

folksonomies is provided by Mika (2007).

the semantics of predicates that can be used in trust rules. Thesetrust rules use knowledge available from both the formal ontology(such as DublinCore metadata) and knowledge harvested fromfolksonomies aggregated into literals, which is then supportedwith SWRL’s standard predicates for standard data types.

A central element of our work is the quality rating of resourcesbased on social networks. As Golbeck and Hendler have pointedout (Golbeck and Hendler, 2004):

‘‘trust has come to have several definitions on the SemanticWeb. Much research has focused on authentication of resources,including work on digital signatures and public keys. This pro-vides confidence in the source or author of a statement, whichis very important, but trust in this sense ignores the credibilityissue. Confirming the source of a statement does not have anyexplicit implication about the quality of the statement.”

In this paper, trust and trustworthiness have been used in thesense of reputation, emphasising the social component of trust. Anumber of similar approaches have been proposed in other appli-cation domains, including email filtering based on the reputationof senders (Golbeck and Hendler, 2004), and trust in peer-to-peernetworks (Kamvar et al., 2003). The focus in both approaches ison rating persons, not resources. While this makes sense forapplications like spam filtering, at least some social networks likedel.ico.us are more resource focused, with users often stayinganonymous. Maximilien and Singh (2002) have proposed a moregeneral framework for the reputation of web resources. The algo-rithms used to specify ratings, trust and reputation are left open.TRELLIS (Gil and Ratnakar, 2002) is an approach to assess infor-mation sources and content based on individual feedback.

However, the most compelling argument that community gen-erated ratings can be used successfully in order to establish trust isprovided by existing eCommerce systems such as eBay. Users useaggregated feedback provided by previous trading partners to as-sess the trustworthiness of resources, in this case of trading part-ners. The reputation generated by user feedback quickly becomesan asset and frequent traders carefully nurture their ratings by pro-viding a good quality service, in this case swift execution of honesttrades (Kollock, 1999). The existence of reputation systems doesnot only improve the performance of participants with a good rep-utation, but has been shown to significantly improve the perfor-mance of the market place as a whole (Yang et al., 2007). Inonline bookstores like Amazon, users rate the traded resources di-rectly. Users assign numerical ratings from 1 to 5 to books andother items traded, and in the main catalogue the aggregated rat-ings are displayed alongside the items. While the precise impactof those ratings is not made public by Amazon, the fact that it isdisplayed (occupying valuable space on the web site) itself indi-cates that this has a significant impact. The rule based trust systemwe propose uses the same mechanism, but in addition gives theuser the opportunity to automate the selection process. Throughthe interface to several different social networks it also gives usersthe opportunity to set up rules that establish trust based on knowl-edge gathered from different networks. This makes the trust mech-anism more robust in situations where one particular network hasbeen manipulated and the respective trust mechanism fails. Anexample for manipulating the trust mechanism of a social networkare link farms trying to manipulate the index of search engines andtherefore improving the ratings (page ranks) of certain web pages.

While the part of WOP that deals with design patterns is applica-tion-specific, the modules used to interact with server-side servicesare not. They can be easily reused to share other artefacts, such asrefactorings and software configuration maps. We see plenty of use-ful applications in these areas as there is such a high demand in thesoftware engineering community to share knowledge.

2192 J. Dietrich et al. / The Journal of Systems and Software 81 (2008) 2183–2193

8. Related work

There are a number of online pattern repositories similar towhat we propose in the sense that they are community-driven.The Portland Pattern Repository is the oldest online repository,interestingly co-hosted with WikiWikiWeb, the first Wiki. TheHypermedia Design Patterns Repository is a repository for hypermedia and web applications without feedback or rating function.The Yahoo design pattern library is an example for a closed repos-itory maintained by a vendor (instead of a community). While itdoes not have a feedback function as such, there are blog pagesassociated with the patterns where the community discusses thepatterns published by Yahoo. These pages can also be used in orderto implicitly rate patterns. The ServerSide, an online communitydedicated to Java enterprise technology, maintains a communitydriven pattern section that includes a discussion forum. The maindifference to our approach is that all these approaches are webbased and the patterns are not formally defined. The artefacts pub-lished are accessed by using a web browser, and cannot be inter-preted in a software engineering application such as adevelopment environment or a design tool. Therefore, the patternshave to consumed manually by the interested software engineer.

There is an online catalogue for refactoring closely associatedwith Fowler’s book (Fowler et al., 1999). Refactorings are repre-sented in a semi-formal style, usually using a combination of tex-tual descriptions and UML diagrams embedded as images. Thereare no features that allow the community to contribute to the cat-alogue or provide feedback. There is ongoing research into formal-ising refactorings. An good overview is given by Mens and Tourwe(2004). But to the best of our knowledge, this has not yet resultedin systems that can be used to effectively share formalisedrefactorings.

As far as anti-patterns are concerned, the PMD project main-tains a repository of patterns formalised using XPath expressions.These definitions are executable, they can be interpreted by thePMD tool and used to scan software for occurrences of the respec-tive anti-patterns. There are no features that allow users to dis-cover, publish and rate patterns in PMD.

9. Conclusion and future work

In this paper we have presented an approach that uses a combi-nation of social networking and knowledge representation basedon formal ontologies to share knowledge about design patterns.We see two advantages in our approach over traditional knowl-edge repositories. Firstly, knowledge is shared in an executable for-mat. Secondly, knowledge is easier to discover, publish and rate,and therefore the latency of sharing knowledge can be greatlyreduced.

As a proof-of-concept, we have designed and developed anEclipse-based tool, implementing the general concepts of our workin Java. We have also extracted a design pattern in an attempt toabstract from these project-specific settings, which we describein detail in this paper. We think that this pattern provides a generalsolution for applications interfacing with heterogeneous socialnetworks.

The SourceForge download statistics and the email feedback weget from users indicate that the tool is indeed being used by soft-ware engineers, although most users seem to be interested in thedesign pattern scanner rather than the social networking features.An important point currently missing in our work is end-user val-idation. Here we hope that once the system has gained traction anda community is formed of end-users providing feedback and pub-lishing content, we will have the necessary data to allow us to per-form user-based validation.

10. Access and installation of the WOP client

The WOP client presented in this paper is provided under anopen-source license (the General Public License, GPL) and can bedownloaded from SourceForge. The client is designed to work withEclipse 3.2 or greater. The SourceForge project URL is:

http://sourceforge.net/projects/webofpatterns

Access to the source code is also available via Subversion; theSVN repository URL is:

https://svn.sourceforge.net/svnroot/webofpatterns

The WOP client uses the Eclipse proxy settings in the Install/Up-date preference page. Some services, in particular Google, requirean account to access the network APIs. The respective informationcan be entered in the WOP preference page.

Acknowledgments

The authors wish to thank Chris Elgar for his contributions tothe WOP project. We thank John Grundy, John Hosking, James No-ble and Philip Tetlow for their comments and feedback. This workwas supported in part by the Massey University Research Fund.

References

Baumer, D., Riehle, D., Siberski, W., Wulf, M., 1997. The role object pattern. Tech.Rep. 97-34, Washington University. <http://st-www.cs.uiuc.edu/users/hanmer/PLoP-97/Workshops.html>.

Clark, J., DeRose, S., 1999. XML path language (XPath) version 1.0. Tech. Rep., W3CRecommendation, 16 November 1999. <http://www.w3.org/TR/xpath>.

del.icio.us Bookmarking Service. <http://del.icio.us>.Dietrich, J., Elgar, C., 2005. A formal description of design patterns using OWL. In:

ASWEC’05: Proceedings of the 2005 Australian Conference on SoftwareEngineering. IEEE Computer Society, Washington, DC, USA, pp. 243–250.

Dietrich, J., Elgar, C., 2007. Towards a web of patterns. J. Web Semantics 5 (2), 108–116.

Fielding, R., 2000. Architectural styles and the design of network-based softwarearchitectures. Ph.D. Thesis, University of Califormia, Irvine, USA.

Fowler, M., Beck, K., Opdyke, J.B.W., Roberts, D., 1999. Refactoring: improving thedesign of existing code. Addison-Wesley Longman Publishing Co., Inc., Boston,MA, USA.

Gamma, E., Beck, K., 2003. Contributing to Eclipse: Principles, Patterns, and Plugins.Addison Wesley Longman Publishing Co., Inc., Redwood City, CA, USA.

Gamma, E., Helm, R., Johnson, R., Vlissides, J., 1995. Design patterns: elements ofreusable object-oriented software. Addison-Wesley Professional.

Gil, Y., Ratnakar, V., 2002. Trusting information sources one citizen at a time. In:ISWC’02: Proceedings of the First International Semantic Web Conference onThe Semantic Web. Springer-Verlag, London, UK, pp. 162–176.

Golbeck, J., Hendler, J.A., 2004. Accuracy of metrics for inferring trust and reputationin semantic web-based social networks. In: Motta, E., Shadbolt, N., Stutt, A.,Gibbins, N. (Eds.), EKAW. Lecture Notes in Computer Science, vol. 3257.Springer, pp. 116–131.

Golbeck, J., Hendler, J.A., 2004. Reputation network analysis for email filtering. In:CEAS 2004 – First Conference on Email and Anti-Spam, Mountain View,California, USA, Proceedings, July 30–31, 2004.

Gudgin, M., Hadley, M., Mendelsohn, N., Moreau, J.-J., Nielsen, H.F., Karmarkar, A.,Lafon, Y., 2007. Simple object access protocol. Tech. Rep., W3CRecommendation, 27 April 2007. <http://www.w3.org/TR/soap12-part1/>.

Horrocks, I., Patel-Schneider, P.F., Boley, H., Tabet, S., Grosof, B., Dean, M., 2004.SWRL: a semantic web rule language combining OWL and RuleML. Tech. Rep.,W3C Member submission, 21 May 2004. <http://www.w3.org/Submission/SWRL/>.

Jena A Semantic Web Framework for Java. <http://jena.sourceforge.net>.Kamvar, S.D., Schlosser, M.T., Garcia-Molina, H., 2003. The Eigentrust algorithm for

reputation management in P2P networks. In: WWW’03: Proceedings of the12th International Conference on World Wide Web. ACM Press, New York, NY,USA, pp. 640–651 <http://portal.acm.org/citation.cfm?id=775242>.

Kiczales, G., Lamping, J., Menhdhekar, A., Maeda, C., Lopes, C., Loingtier, J.-M., Irwin,J., 1997. Aspect-oriented programming. In: Aks�it, M., Matsuoka, S. (Eds.),Proceedings European Conference on Object-Oriented Programming, vol. 1241.Springer-Verlag, Berlin/Heidelberg/New York, pp. 220–242.

Klyne, G., Carroll, J.J., 2004. Resource description framework (RDF): concepts andabstract syntax. Tech. Rep., W3C Recommendation, 10 February 2004. <http://www.w3.org/TR/rdf-concepts/>.

Kollock, P., 1999. The production of trust in online markets. Adv. Group Process. 16,99–123.

J. Dietrich et al. / The Journal of Systems and Software 81 (2008) 2183–2193 2193

Laux, A., Martin, L., 2000. XUpdate working draft – 2000-09-14. Tech. Rep. <http://xmldb-org.sourceforge.net/xupdate/xupdate-wd.html>.

Maximilien, E.M., Singh, M.P., 2002. Conceptual model of web service reputation.SIGMOD Rec. 31 (4), 36–41.

Mcguinness, D.L., van Harmelen F, 2004. OWL web ontology language overview.Tech. Rep., W3C Recommendation, 10 February 2004. <http://www.w3.org/TR/2004/REC-owl-features-20040210/>.

Mendonca, N.C., Maia, P.H.M., Fonseca, L.A., Andrade, R.M.C., 2004. RefaX: arefactoring framework based on XML. In: ICSM’04: Proceedings of the 20thIEEE International Conference on Software Maintenance. IEEE ComputerSociety, Washington, DC, USA, pp. 147–156.

Mens, T., Tourwe, T., 2004. A survey of software refactoring. IEEE Trans. Softw. Eng.30 (2), 126–139.

Mika, P., 2007. Ontologies are us: a unified model of social networks and semantics.J. Web Semantics 5 (1), 5–15.

Noble, J., 1998. The object system pattern. In: Proceedings EuroPloP 1998.The PMD Project. <http://pmd.sourceforge.net>.Refactoring. <http://www.refactoring.com>.Riehle, 1997. A role based design pattern catalog of atomic and composite patterns

structured by pattern purpose. Tech. Rep. 97-1-1, UbiLabs.Riehle, D., Tilman, M., Johnson, R., 2005. Dynamic object model. Pattern Languages

of Program Design, vol. 5. Addison-Wesley, Washington, DC, USA, pp. 3–24.Swoogle Semantic Web Search Engine. <http://swoogle.umbc.edu>.Taibi, T. (Ed.), 2007. Design Pattern Formalization Techniques. IGI Publishing.The Dublin Core Metadata Initiative. <http://dublincore.org>.The Eclipse Project. <http://www.eclipse.org>.The Hypermedia Design Patterns Repository. <http://www. designpattern.lu.

unisi.ch/HypermediaHomePage.htm>.The Portland Pattern Repository. <http://c2.com/ppr/>.The ServerSide Patterns. <http://www.theserverside.com/patterns/index.tss>.The Yahoo Design Pattern Library. <http://developer.yahoo.com/ypatterns/

index.php>.

Tichelaar, S., Ducasse, S., Demeyer, S., Nierstrasz, O., 2000. A meta-model for language-independent refactoring. In: Proceedings ISPSE 2000. IEEE, pp. 157–167.

Uschold, M., 2003. Where are the semantics in the semantic web? AI Mag. 24 (3),25–36.

The WebOfPatterns Project. <http://www-ist.massey.ac.nz/wop/>.Yang, J., Hu, X., Zhang, H., 2007. Effects of a reputation feedback system on an online

consumer-to-consumer auction market. Decis. Support Syst. 44 (1), 93–105.Yoder, J.W., Foote, B., Riehle, D., Tilman, M., 1998. Metadata and active object-

models. In: OOPSLA’98 Addendum: Addendum to the 1998 Proceedings of theConference on Object-oriented Programming, Systems, Languages, andApplications (Addendum). ACM Press, New York, NY, USA.

Jens Dietrich has an MSc in Mathematics and doctorate in Computer Science fromthe University of Leipzig in Germany. He has worked as software engineer andconsultant between 1996 and 2003 first for Bauer and Partner and later for GTZ/CIMin Germany, Switzerland, the UK and Namibia. Since 2003 Jens is a senior lecturer atMassey University in New Zealand. His research interests include design patternformalisation, the use of ontologies in software engineering, and softwarecomponentry.

Nathan Jonesh as a BSc degree in Computer Science from Massey University and iscurrently working as a software engineer for Orion Health.

Jevon Wright is a doctoral student at the School of Engineering and AdvancedTechnoloy at Massey University, New Zealand. His research interests include webapplication modelling, web engineering and model-driven development.