I've been looking at the resources definition of the Change Management module of the OSLC. Why using RDF?
Is this use related to semantic Web services?
Thanks
Put simply because RDF is portable, inter-operable and reusable
Using RDF means the data in your system is intrinsically reusable even by applications which know nothing of your specific data model (i.e. vocabularies and ontologies etc) since they can still process the data and extract information from it.
Also using RDF means you don't tie yourself to a proprietary/application-specific format or to a specific XML schema and you can easily extend your data model or add annotations which are ignored by the main application as you see fit.
Expanding on the OSLC concept —
OSLC aims provide common means of integrating resources through a common architecture using discovery, linked data, and common resource formats.
There are community topics on alignment to the W3c linked data and semantic web.
You can find out more here : http://open-services.net
A good introduction can be found here: http://open-services.net/html/case4oslc.pdf
Related
I've never really heard of HAL until I started working on a new project that is making use of it. From what I can tell, it's basically a way to easily follow links to traverse your way around a restful API's structure.
So if I understand this correctly, both tools are to make it easier to traverse around an API's documentation to see all the different means of communicating with said API. Essentially both of these are tools used for documentation purposes only?
REST APIs must be hypertext driven. It's not merely for documentation purposes, but for driving all interaction with the API. If you're not driving the interaction through links and clients are building URIs from templates in documentation, it's not RESTful. The authors of Django-REST-Framework themselves recognize the name is inadequate.
http://www.django-rest-framework.org/topics/rest-hypermedia-hateoas/
You should read the links provided in that document, specially this one:
http://roy.gbiv.com/untangled/2008/rest-apis-must-be-hypertext-driven
With that in mind, your REST API has to use a data format where links are standardized so clients know how to parse them. This would constrain most APIs to use HTML or XML, but since JSON is such a popular data-exchange format, there are some efforts into designing conventions for adding hypermedia-awareness to any format, like HAL.
Django-REST-Framework supports hyperlinks in the HTML output, but -- AFAIK -- it has no support for hyperlinks in other formats. You can use HAL-JSON if you want, but you'll have to implement support for it.
I have JSP project which uses Liferay framework. There are default Liferay cookies named COOKIE_SUPPORT and GUEST_LANGUAGE_ID in Liferay. I dont want hackers to view any of my technology information by any means. How can I rename these cookie?
If you want to protect the framework you're using, you won't have to worry about the names of the cookies. Worry about server identification, elements of the DOM, structure and mechanics of URLs, secure&hardened setup of your server, common translations, default content, standard error messages, etc.
In other words: If you don't want to give away, which standard framework you're using (and this is not limited to Liferay) you'll have to roll your own. Good luck with getting this as powerful and as well tested as any standard framework.
Rather worry about keeping your systems updated all the time and protect from well known vulnerabilities in older systems. For hardening Liferay specifically, you might want to start with my blog series on securing Liferay (linking chapter 1 which refers to the other chapters)
Promoting a comment into this answer: One way to find out how to change them is to search for their names in the source code and identify the kind of plugin you need to provide different values - most likely this will be an ext-plugin. After all, Liferay's source is available. I don't see anything short of this.
We're currently evaluating Enterprise Architect (12, release candidate).
The main reason we'd like to use it is to use the reverse engineering feature, from c++ to UML.
Our code base is documented using Doxygen tags.
Now, the parser of EA does not seem to recognize these tags. Is there a way I could enable it?
Edit:
The things I'm looking for are not to be inserted in the UML, but added to the model of the project. For instance, information defined by #param tags for methods are inserted in the "notes" of the methods and not in the "notes" of the parameters. The #author doxygen tags are not taken into consideration when generating the model, etc.
Some easy out-of-the-box customization of the parsers is probably not available.
I was solving similar problem of importing custom metadata (developer responsible for the class, corresponding database table or view mapping the entity, deployment package (.dll) and architecture layer, human-friendly class description, reference to specification documents etc.) contained elsewhere and making them available inside the Enterprise Architect in the form of informal notes and formal tagged values.
After some attempts to generate this metadata info as doxygen-style comments I gave up as the doxygen comment parser did not seem to be customizable and in order to make the non-ascii characters correctly imported the source code files had to contain the UTF-8 BOM preamble, which is not very 3rd party legacy tool-friendly encoding.
I have decided to go the way of generating XMI file with all the metadata placed inside the tags and documentation XML elements.
Before I resolved correct XMI encoding of composition and aggregation relationships the project was stopped at the phase when all the classes and attributes and associations and all the metamodel attributes (as notes and tagged values) were in there in under 600 lines of C# XMI-specific code and we had the few thousands of classes in EA available for analysts to work with.
In your case you may solve the need in a similar way:
import the C++ code base into Enterprise Architect using the reverse engineering
extract the doxygen comment metadata using some tool like doxygen's GENERATE_XML feature
export the Enterprise Architect model in a round-trip-friendly XMI format
write a single-purpose tool that will take the XMI model, your comment metadata and spit out new XMI model annotated with your proprietary information
import the XMI model back, done.
For steps 3...5 there may be an easier way as Enterprise Architect has the Scripting and Automation interface which allows to read/modify the model using languages like Visual Basic or C#
I was looking for an RDF project for django and I cant find any active.
This seems to be a good one http://code.google.com/p/django-rdf, but the last commit was in 2008, (4 years ago). The group in google-groups seems to be abandoned. Last no-spam post was in 2008.
Therefore it has no support for new django versions.
Is there any library or some prebuilt open source app to easily expose rdf data?
Maybe is easy to solve, like writing a view and returning something using https://github.com/RDFLib/rdflib in one or two lines of code, but I can't figure it out how to do it...
The idea using RDFlib would be to take a django object or collection of objects and transform it to rdf in some way, maybe using an rdf parser.
I thought I could give html responses if the client request "accept:text/html", and RDF if the user requested the same page using a html accept header with rdf+xml or rdf+turtle (and it could exist an app that handles that for me)
From what little I've read of RDF you are probably going to have to do manual work to get meaningful RDF statements from Django models since it's not a simple data representation format like JSON, it is trying to encode semantic meaning.
That said, have a look at django-rdflib:
https://github.com/odeoncg/django-rdflib
There doesn't seem to be any documentation (and it seems to have been built for a specific app) but the author has posted here about a manage.py syncvb command that generates an RDF graph from existing Django models:
https://groups.google.com/d/msg/django-rdf/14WVK7t88PE/ktAKJo-aCfUJ
Not sure exactly what views django-rdflib provides, but if it can make an RDFlib graph for you then you can probably use the serialization plugins provided by RDFlib to output rdf+xml or whatever from your own view.
http://code.google.com/p/djubby/
SURF is useful as a RDF->object mapper (or RDFAlchemy)
injecting rdfa into your templates should work either (if you want to avoid triplestores)
you can also expose your database as a sparql endpoint using a tool such as http://d2rq.org/
I need to document an application that serves as a facade for a set of webservices. The application accepts SOAP requests and transforms these requests into a format understandable by the underlying web service. There are several such services, each with its own interface. Some accept SOAP, some HTTP POST, some... other formats not mentioned in polite society.
I need to document how we map the fields from our SOAP calls to the fields for these other formats. Before everyone cries "XSLT" I must mention that the notation must be human-friendly. Ideally it would be something Excel-able.
Has anyone encountered this sort of problems before? How did you solve it? Is there a human-friendly notation for tree-to-tree transformations that can fit on a spreadsheet?
I've had to do just this. The way I did it was to just start writing, following the hierarchical structure.
I eventually would find that I was repeating myself. An example was that certain elements had a common set of attributes. I would pull the documentation of that common set up before the sections on the specific elements. Same thing with documentation of handling of specific simpleTypes.
Eventually, there was even some high level discussion on the overall flow and "philosophy" of the transformation. But I let it all happen bit by bit, fixing it as I became bored with repetition.
That said, I'm a developer, not a tech writer.
I haven't really found anything so far, but I've found pointers to many libraries that help transform objects of one type to another in Java. For reference, I'm listing the most promising ones here, all doing some kind of JavaBean to JavaBean conversion:
Transmorph
EZMorph
Dozer