1. Free content: The focus of these platforms (Khan Academy, Wikiversity, OER Commons, P2P university,…) lies in freeing educational content from the publishing industry. In most cases the focus seems to be on content and not so much on learning paths or didactics or pedagogy. The argumentation seems to be like: “first we need the content, next we can think about how to use it”. Have alook at my blog post: http://www.rene-pickhardt.de/comparison-of-open-educational-resources-services-to-host-your-mooc/ to see which open platforms perform well.
2. Commercial: There is a rising industry (Coursera, Udacity, edX, iversity,..) trying to commercialize massive open online education. Commercial platforms usually have high quality content and strong relationships with universities (most often ivy league) serving a lot of classes in this new format. Courses are usually not available under an open licence. So far most content is available at no cost and the business model is related to certification but also sometimes to tuition fees.
3. Self hosted with the use of a learning management system: There are various learning management systems (OLAT, Moodle, Google Course Builder, ILIAS,…) available as open source software which enables one to host a MOOC oneself. Most of these systems are made for eLearning and but lack this MOOC feeling of excellent usability. Often their intent also is not primary to be open.

This means besides this article I will publish three blog articles comparing platforms for each of the 3 different approaches. There is a German list of Learning platforms on Wikipedia as well as the MOOC Template in the English wikipedia from which I extracted the following lists

Platforms for online education

• MIT OpenCourseWare 
• Khan Academy 
• China Open Resources for Education 
• OpenCourseWare 
• Peer to Peer University 
• Academic Earth 
• Edulanka 
• ALISON
• Udacity 
• Coursera 
• Duolingo 
• edX 
• Canvas Network 
• Futurelearn 
• OpenHPI

People related to online education

• Anant Agarwal 
• Stephen Downes 
• Salman Khan 
• Daphne Koller 
• Peter Norvig 
• Andrew Ng 
• George Siemens 
• Sebastian Thrun

Not all of the platforms are relevant for a Web Science MOOC but still I extracted some of the most relevant sites and added a fiew others. As for the evaluation methodology we did a little survey and identified some possibilities. Since there are so many hosting services and possibilities we tried to find some dimensions that are important to us in order find which hosting service makes the most sense. We will use the following dimensions for our evaluation:

1. Overhead: How much overhead is associated providing the content for a certain platform infrastructure?
2. Open: Will the platform accept our course?
3. Licence: Who has the copyright and how is the licencing model?
4. Hosting time: How much time of hosting does the platform guarantee?
5. Open Format: Will the course content be in an open format so that we can easily export the data from the host and take it to some other service?
6. Feedback: Feedback for instructors like how long do people interact with some content?
7. Quizes: Will quizes be supported in the Platform
8. Community:Is there an active community and exchange of instructors?
9. Audience:Is there a large audience using the platform?
10. Support: is there active support from the platform?
11. Online Meetings: Does the platform support meetings of students and teachers on the cyberspace?
12. Account Management: Is it possible to have different roles for the accounts (e.g. student, tutor, creator,…)?
13. Risk: What are the risks of using this particular platform?

At least my goal would be to find a service with the following answers to our dimensions:

1. Overhead: Little overhead to submit the course material.
2. Open: The platform should be open to any course.
3. Licence: We should maintain the copyright or the licence should be at least creative commons
4. Hosting time: forever
5. Open Format: data export of the material is needed. e.g respecting http://en.wikipedia.org/wiki/IMS_Global
6. Feedback: In order to improve we need Feedback
7. Quizes: We need various forms of quizes
8. Community:A community of instructors with which one can exchange and from which one can learn would be amazing.
9. Audience:In the end good content will win but the larger the audience the better
10. Support: A platform that offers support with problems is preferable
11. Online Meetings: It would be nice if the platform supports online meetings of users with Q&A systems or even with video chat.
12. Account Management: Multiple account roles would support the learning process.
13. Risk: Obviously we want the risks to be minimized

I am looking forward to your feedback of missing platforms or other dimensions for the evaluation of the learning platforms.

• source code
• slides from the talk
• data sets
• proposal
• cypher benchmark

was great talking here and again we are open source, open data and so on. So if you have suggestions or want to contribute feel free. Just do it or contact us. We are really looking forward to meet some other hackers that just want to go geek and change the world
the video of the talk can be found here:

• overvew of current graph benchmakrs and designs
• benchmark principles and methods
• Query Languages (Cypher, Gremlin, SPARQL)
• Analysis and classification of Choke points (Supernodes, data generators)
• Benchmark transactions (which are in general very slow)
• Benchmark the complexity of queries
• Analysis (if anyone has data sets and usecases contact the LDBC, actually I think we have data comming from related work)
• Navigational benchmark (e.g. open streetmaps)
• Benchmarking design for pattern matching (e.g. SPARQL and Cypher)

As you could here from beside there is a huge discussion going on about query languages which i like. Creating a query language is a tough task. The more expressive a language is (like SPARQL) the less efficient this might become. So I hope the EU project will really create some good solid output. I am also happy that many different industry vendors are part of this project. In this sense the results will hopefully be objective and don’t suffer from the “Who ever puts it on wins” paradigm.
Interestingly the LDBC makes a speration between graph data bases and rdf stores which I am very pleased to see and have been thinking a lot.

 Paper1  <--[ref]-->  Paper2
   |                    |
   |[author]            |[author]
   v                    v
 Author1              Author2

For the benchmark we where trying to find coauthors which is basically a friend of a friend query following the author relationship (or breadth first search (depth 2))
As we know there are basically 3 ways of communicating with the neo4j Database:

Java Core API

Here you work on the nodes and relationship objects within java. Formulating a query once you have fixed an author node looks pretty much like this.

for (Relationship rel: author.getRelationships(RelationshipTypes.AUTHOROF)){
Node paper = rel.getOtherNode(author);
for (Relationship coAuthorRel: paper.getRelationships(RelationshipTypes.AUTHOROF)){
Node coAuthor = coAuthorRel.getOtherNode(paper);
if (coAuthor.getId()==author.getId())continue;
resCnt++;
}
}

We see that the code can easily look very confusing (if queries are getting more complicated). On the other hand one can easy combine several similar traversals into one big query making readability worse but increasing performance.

Traverser Framework

The Traverser Framework ships with the Java API and I really like the idea of it. I think it is really easy to undestand the meaning of a query and in my opinion it really helps to create a good readability of the code.

Traversal t = new Traversal();
for (Path p:t.description().breadthFirst().
relationships(RelationshipTypes.AUTHOROF).evaluator(Evaluators.atDepth(2)).
uniqueness(Uniqueness.NONE).traverse(author)){
Node coAuthor = p.endNode();
resCnt++;
}

Especially if you have a lot of similar queries or queries that are refinements of other queries you can save them and extend them using the Traverser Framework. What a cool technique.

Cypher Query Language

And then there is Cypher Query language. An interface pushed a lot by neo4j. If you look at the query you can totally understand why. It is a really beautiful language that is close to SQL (Looking at Stackoverflow it is actually frightening how many people are trying to answer Foaf queries using MySQL) but still emphasizes on the graph like structure.

ExecutionEngine engine = new ExecutionEngine( graphDB );
String query = "START author=node("+author.getId()+
") MATCH author-[:"+RelationshipTypes.AUTHOROF.name()+
"]-()-[:"+RelationshipTypes.AUTHOROF.name()+
"]- coAuthor RETURN coAuthor";
ExecutionResult result = engine.execute( query);
scala.collection.Iterator it = result.columnAs("coAuthor");
while (it.hasNext()){
Node coAuthor = it.next();
resCnt++;
}
I was always wondering about the performance of this Query language. Writing a Query language is a very complex task and the more expressive the language is the harder it is to achieve good performance (same holds true for SPARQL in the semantic web) And lets just point out Cypher is quite expressive.


What where the results?

• The Core API is able to answer about 2000 friend of a friend queries (I have to admit on a very sparse network).
• The Traverser framework is about 25% slower than the Core API
• Worst is cypher which is slower at least one order of magnitude only able to answer about 100 FOAF like queries per second.

I was shocked so I talked with Andres Taylor from neo4j who is mainly working for cypher. He asked my which neo4j version I used and I said it was 1.7. He told me I should check out 1.9. since Cypher has become more performant. So I run the benchmarks over neo4j 1.8 and neo4j 1.9 unfortunately Cypher became slower in newer neo4j releases.




Quotes from Andres Taylor:

Cypher is just over a year old. Since we are very constrained on developers, we have had to be very picky about what we work on the focus in this first phase has been to explore the language, and learn about how our users use the query language, and to expand the feature set to a reasonable level

I believe that Cypher is our future API. I know you can very easily outperform Cypher by handwriting queries. like every language ever created, in the beginning you can always do better than the compiler by writing by hand but eventually,the compiler catches up

Conclusion:

So far I was only using the Java Core API working with neo4j and I will continue to do so.
If you are in a high speed scenario (I believe every web application is one) you should really think about switching to the neo4j Java core API for writing your queries. It might not be as nice looking as Cypher or the traverser Framework but the gain in speed pays off.
Also I personally like the amount of control that you have when traversing over the core yourself.
Adittionally I will soon post an article why scripting languages like PHP, Python ore Ruby aren’t suitable for building web Applications anyway. So changing to the core API makes even sense for several reasons.
The complete source code of the benchmark can be found at https://github.com/renepickhardt/related-work.net/blob/master/RelatedWork/src/net/relatedwork/server/neo4jHelper/benchmarks/FriendOfAFriendQueryBenchmark.java (commit: 0d73a2e6fc41177f3249f773f7e96278c1b56610)
The detailed results can be found in this spreadsheet.

]]> https://www.rene-pickhardt.de/get-the-full-neo4j-power-by-using-the-core-java-api-for-traversing-your-graph-data-base-instead-of-cypher-query-language/feed/ 16