I was wondering if there is a way to implement backward chaining in Protege(5) using any plugin.
The likes of Jesstab and Algernon are not compatible with Protege anymore and I cannot find any other plugin which is.
Any leads will be much appreciated.
Thanks!
Related
I was wondering if there are any tips or documents describing dart workflow to easily migrate from Closure tools background to Dart. I am especially interested in a replacement for soy templates and internationalization. What would you suggest for those as well for some of the bigger parts there (like control / component).
The Dart internationalization library is modeled after Closure's, so it's probably a pretty easy replacement, although not everything is finished yet.
I took a brief look at Closure tools documentation and soy templates.
I haven't seen something similar in Dart.
Dart i18n is WIP and still a bit rough around the edges.
The best template/component technologies available for Dart are IMHO AngularDart and PolymerDart
but I don't think there is an easy migration path.
I wonder what the REST API clients are available for using from Ruby (not JRuby, so native bindings are not an option)?
Ideally, I would want the API similar to the neo4j gem or ActiveRecord (validations, migrations, observers etc).
Currently available (REST) tooling doesn't even come close to what we have, for example, in ActiveRecrod:
neograhy - just plain REST API. Nothing to do with models etc.
neology - is just a wrapper over neography and isn't a full featured ActiveModel.
architect4r - conforms to ActiveModel, but provides only one way to query data (Cypher language), also no indexes support.
I like the code of architect4r a little bit more (primarily because it uses ActiveModel).
But neology seems to be much more pragmatic choice as it already is using neography under the hood.
The choice is pretty small and tough.
Could you please tell when one should be used rather than the other?
Also any recommendations that would help me to decide on the gem are very welcome.
Thanks.
The short answer is that there is no any mature ActiveModel-like gems for RESTful neo4j.
The most common scenario is to just use Neography.
I haven't worked with neoj yet, but i do work with api's a lot.
I have found the same trouble as you and my solution was to create my own.
Maybe if you have time, you can check it out. ApiClient
It still in development, so let me know of any feature you may need. =)
I have only used Neography which does its job very well. Have not heard about architect4r, but it looks really pragmatic and pleasing - need to check it out!
/peter
I know this thread is a little old, but there is activity on the neo4j-core gem geared towards using its API for the standalone database server in addition to the embedded database. Thought this might help people who find this thread when searching around.
https://github.com/andreasronge/neo4j-core/tree/3.0
Note: Before anyone yells at me for not making this a comment instead of an answer, I don't have the required reputation for doing so. Sorry.
Have you looked at REST-Client? https://github.com/archiloque/rest-client
it seems like it might be a very easy to to create and examine the responses from calls to a REST API. but maybe you need more than that?
(I was searching for answers and found your question, so far rest-client seems like the top candidate for what I need, figured it might help you also.
There is also activerecord-neo4j-adapter, but I have no experience with it.
https://github.com/digitalbias/activerecord-neo4j-adapter
Another option is Keymaker, which provides ActiveModel support for Neo4j.
Problem is, docs are non-existent, so you have to search out slideshows/presentations to find actual examples.
After reading RichFaces Vs PrimeFaces (for performance), I was tempted to use both in my web application to get the maximum benefit from both.
Do you think that is possible? What are the advantages and disadvantages?
Both are great component libraries. You can definitely combine them. But it is not true that it's 1+1=2 here. It's more 1*1=1. You should really investigate the both component libraries more closely. What exactly do you need from RichFaces which PrimeFaces doesn't offer? What exactly do you need from PrimeFaces which RichFaces doesn't offer? You need to find the right balance yourself. The one webapp isn't the other.
As to advantages/disadvantages, that's pretty subjective. Go play with them yourself. First each separately and then together. Own experience is the best experience. I myself had good experiences with PF 2.1. PF 2.2 had some serious issues in among others the datatable component. I didn't try PF 3.0 yet. I am currently working on a project which uses some RF 3.3 components and we are in a progress to upgrade it to RF 4.0. All I can say is that it's a pretty decent component library with good documentation. The full PF documentation isn't freely available anymore.
My answer is "no". It's better for you choose one of them. There are a lot of compatibility issues. For example, I've spent two days fixing a bug with rich:fileUpload. Finally, I've commented primefaces in my pom.xml (only a few components from primefaces were used) and all works fine then.
The answer is 'no' as of RF 4.5.7 and PF 5.2. There are jQuery conflicts which mean that some of the PF controls don't work. They've been talking together about sorting this out for five years but nothing appears to have been resolved.
I looked at both and ended up with PrimeFaces. The documentation for V 2.2 is now paid-for (I think about $9US) and gets you going very quickly.
Actually I did try this once when I was evaluating. I had PrimeFaces and RichFaces on the same page. It worked, but I was mostly looking at how the components were styled and how they looked. I did not try, for example, using AJAX requests from components from both packages on the same page. Since they are both based on the "native" JSF implementation, it should work but I wouldn't count on it.
Pick one of the other, and stick with it. Save yourself some grief.
Django as a framework is a neat little package. There are very few files (compared to Rails) and it's got a clean structure. The fact that you can plug and unplug apps between different projects is an extremely nifty feature. At the same time, Ruby's hacking ability is unparalleled. It's complete object-orientedness makes it more expressive and fun.
To cut the story short, is there a Django-like or Django inspired framework on Ruby?
If not, would be possible for an implementation of Django on Ruby? What would be the challenges?
If one were to create a Django-inspired framework for Ruby, how would it's Domain Specific Language (DSL) nature come into play?
I've spent a good chunk of my past life using Symfony, which is a PHP framework heavily inspired from Rails. When I saw Django, it came as a bout of fresh air. I'm really curious to know what you guys think and have to say on this.
Update: I stumbled on a framework call Ramaze for Ruby. It seems to be a bare-bones MVC framework with pluggable components for the JS framework, ORM layer and the templating engine. So you could use Prototype / Sequel / Sass, or Mootools / ActiveRecord / XSLT, or any other combination of your choice! As a side-note, Merb is an interesting choice too.
Update 2: I'm sticking to PHP for big-ass commercial projects and Django for my personal projects. Reason why I decided to side with Django was the amount of flexibility it offered. That said, I realized that with greater power comes greater responsibility.
My advice to others: if you know exactly what you want - go with Django. It's probably easier to define things explicitly in it than in Rails. Merb may have been a good choice too, but I didn't have the time to explore it. Django seemed like a good fit and so I stopped being anal about the language I'm using. Thanks for all the help guys!
Try merb, merb-slices, and datamapper is probably the closest you can get in ruby.
I think you need to define a little closer what you mean by "Django-like". Depending on your exact definition, any of these might fit the bill:
Ruby on Rails
Mack
Waves
Merb
Iowa
Is having less files really a deciding factor on choosing a framework?
I agree that keeping track of a smaller number of files is easier on the brain, but I would choose a framework on:
documentation
size of community
maturity
before I woried about file count.
I'm interested in the possibility of developing Liferay portlets on Grails, using the Grails Portlets plugin. I reckon introducing a portlet framework (such as the Spring Portlet API) will make development faster and more comfortable, so being able to further add Groovy and Grails conventions to the mix sounds almost too good to be true.
I guess this combo is relatively new, since this far I've found no experiences on how well this works in practice, or of its potential pitfalls.
Any experiences, suggestions or warnings? I would greatly appreciate them.
As you said, the plugin is very new so you might have to get involved by suggesting improvements/logging JIRAs.
But I think the nice Grails features would make it worth the while. Both Kenji and I read the mailing list so you should get an answer to any questions you have.
I've never used it to create a real application (only test apps while developing the original plugin code which Kenji has since improved).