okram

Amazon has done the same thing to Apache TinkerPop (and Apache in general). They got the founder kicked off the project for being a "Nazi racist."

https://www.theregister.com/2021/02/23/apache_tinkerpop_spee...

Why would Amazon want the founder off the project? See the following presentation which interestingly enough, is no longer indexed by DuckDuckGo nor Google:

https://www.slideshare.net/slidarko/mmadt-a-virtual-machinea...

The satire site is https://twitter.com/thecoopsters

They are probably using some free OSS script.

The ElasticSearch lawsuit is still ongoing. 5 years later. They are "quite the fish."

Ha. The two comments that critique Amazon got down voted with negative points. Does Amazon have cronies patrolling Hacker News to squash dissidents?

The third wave of open source software is no software at all. It is only a matter of time before Amazon doesn't care whether it's licensed Apache2 or not. They will just take software and sell it. You have a problem with that? Have fun suing them... Year 1..2..3..oooo. you are quite the fish..4..5. broke. Out of money.

Tech is dead.

Check out mm-ADT: http://rredux.com/mm-adt/. The goal of the project is to develop a distributed virtual machine and bytecode specification to make it easier to integrate processors, storage systems, and query languages.

I recently gave a talk on mm-ADT at ApacheCon: https://www.slideshare.net/slidarko/mmadt-a-multimodel-abstr...

It just wasn't "the scene" at the time. RDF/SPARQL had its world -- permeated throughout academia and some enterprise deployments with quad/triple-stores like AllegroGraph. But it wasn't going to make a PoW in the software industry because they didn't ride the razor-edge well enough.

OWL was a foolish mistake. Triple is a clean and simple idea, but in practice -- reification and URI character hell becoming mind numbing. The RDF-guys did nail it with SPARQL. That is such a pretty query language. Simple, intuitive. I haven't studied the recent path expression advances. I should.

But yea, lots of ways of fugglin' with the data.

There is something really special about the graph database space. For as long as the space has been around (15 or so years), every vendor and dedicated practitioner has taken solid jabs at trying to realize "the best way" to think about graph traversals.

This behavior seems particular to the graph space (vs. document, wide-column, relational, key/value, etc.). While this speaks to the complexity of the type of problems you can solve with graphs, thinking back, I believe this was a cultural anomaly. When it was Neo4j, OrientDB, TinkerPop: the language trifurcation occurred.

I'm excited that Neo4j is continuing to take the query language seriously. In an age when software development is about making it easy for the 90% of developers out there with REST APIs, GraphQL, and overly SQL'd embeddings, ... graph is still searching for "that best way."

I, personally, have moved on from language-level. However, our new work is going to help my fellow data system colleagues get there languages exposed to as many developers as possible regardless of data model. It is important to me that people can come to respect the numerous ways in which we think about data and has the language we use is so important. The difference between living in Plato's Cave or not.

In an effort to support query languages in general, I'll be working on mm-ADT designing a new cluster-oriented virtual machine architecture for storage, processing, and query language developers. I see a veritable Tower of Babel on the horizon!

Congrats Neo4j on reaping the benefits of your hard work. I hope our work will converge in for a positive collaboration in 2020.

I read the article you recommended. It is interesting in that the authors include feedback to simulate loops and have explicit split and merge operators, where their + operator is used to create tuples in the stream. The text is dense so I haven't fully grocked their purpose, but it is nice to see the same concepts presented in a different formalism. If you have other links, please send them along.

It was this book https://www.amazon.com/Common-LISP-Language-Second-Steele/dp... by Guy Steele, but it had a different cover. It was silver with a 1980s like computer font on it.

I wrote the article on a boat with only an abstract algebra book, a LISP book, and a few articles that I had printed before I left. Thus, my references are my references. To then go back and back fill with references would not be an accurate representation of what I was truly referencing at the time.

But yes, there is a lot of related work out there. Hopefully, my approach and introduced novelties can inspire in a way others have not.

There are many Turing Complete languages. There are many stream-based languages. Moreover, there are many Turing Complete stream-based languages. These are instances of the presented stream ring algebra. I wanted to understand the foundation of such languages so as to have the algebraic toolkit to generate more instances.

Check out Gremlin by Apache TinkerPop: http://tinkerpop.apache.org/gremlin.html It is a Turing Complete language that can be embedded in any host language that supports function composition (f.g) and function nesting (f(g)). Finally, if this resonates with you, https://arxiv.org/abs/1508.03843 .

A colleague of mine who gets confused by "all the symbols" said that they appreciated the verbose stream notation that I build throughout the article. I would recommend giving the article a earnest try up through to page 5. Then after that, jump to page 17 and read Section 5C on Set Operations. See if the standard concepts of union, intersection, difference, etc. mixed with the verbose stream notation gives you insight and ultimately, the confidence to keep trying to tackle the work.

I wrote the paper for technically savvy individuals who are not versed in abstract algebra. While writing the first 5 pages, I constantly asked myself: "Will my mom be able to follow what I'm saying?" Fortunately, after reading it, she said: "I get the general idea."

At page 5, the stream ring is defined as a product of the coefficient ring and the function ring and from there, the notation gets heavy and there was little I could do. Hopefully by building confidence in the reader up to page 5, they would have the patience to forge ahead because the true nuggets of value are in the latter parts of the article.

Finally, to the "Captain" comment -- this article was written while in the Sea of Cortez aboard the S/V Red Herring: http://svredherring.com and https://twitter.com/SV_RedHerring.

Can the author go this direction with Gremgo? http://tinkerpop.apache.org/docs/3.2.1-SNAPSHOT/tutorials/gr...

I've noticed so many misconceptions over the years about Gremlin, that I was excited to be able to write http://www.planettinkerpop.org/#gremlin.

It has a very similar look and feel to Gremlin (http://tinkerpop.apache.org).

   (->> ($alice) (assoc $friends) (assoc $friends) (filter (> age 20)) (count))

...in Gremlin is:

   g.V(alice).out("friends").out("friends").has("age",gt(20)).count()

Your last sentence is perfect. Each chosen internal representation has time/space-tradeoffs its making. Users needs to pick a graph database based on the tradeoffs they can live with for their application.

You have to consider both in-memory and disk representation.

http://thinkaurelius.com/2013/11/01/a-letter-regarding-nativ...

Some graph databases have direct references in-memory and thats great, but a poor organization on-disk and thats bad.

Gremlin is the language of Apache TinkerPop (http://tinkerpop.apache.org)

Note that Gremlin is the graph language of the Apache TinkerPop project: http://tinkerpop.apache.org.

Huh. That is a good point. In Gremlin you can chain steps together (e.g. out("knows").out("mother").out("worksFor")) and you can match patterns. So, to be clearer, I should have represented the chain as a one-liner or as a two liner with an indent.

  out("knows").aggregate("friends").out("knows").where(not(within("friends")))

OR

  out("knows").aggregate("friends").
    out("knows").where(not(within("friends")))

Note the "." concatenation that ties the two lines together into a chain. When nesting parallel traversals (e.g. match()), the traversal patterns are delineated by ",".

  . = AND
  , = OR

Ha. Thats a generally neat way to think of "." and "," in computing. mult and + ...the algebra.

Apache TinkerPop3 has been in development for 2 years. It is a complete rewrite since TinkerPop2. It was just released in July 2015. Its light years ahead of Gremlin2.

http://tinkerpop.incubator.apache.org/

The two big things:

1. Gremlin language is much cleaner and easier to use.

2. It supports OLTP graph databases (e.g. Titan/Neo4j/Stardog) and OLAP graph processors (e.g. Hadoop/Spark/Giraph).

In Gremlin3:

  g.V(blah).out("knows").aggregate("friends").
    out("knows").where(not(within("friends"))).
    select().
      by("name").
      by(count("friends")).
    order().by(valueDecr)

This is an exact replica in Gremlin3:

  g.V().has("name","Charlie Sheen").
    as("person").out("actedIn").as("movie").
      select("movie")

However, this can be expressed in a much simpler form as you don't need all the variables. Simply do:

  g.V().has("name","Charlie Sheen").out("actedIn")

Ah, thats better as you don't need all the unbound variables. However, you still don't need "graphs" unless for the English reading of the promotion.

In Gremlin3, the above is:

  g.V().match(
    as("openCypher").out("makesAvailable").hasLabel("QueryLanguage").as("cypher").out("queries").as("graphs"),
    as("user").out("uses").as("cypher"),
      where("user", within(["Oracle","Apache Spark", "Tableau", "Structr"])),
        select("cypher").by("attributes")

In Apache TinkerPop's Gremlin3.

  g.V().match(
    as("cypher").hasLabel("QueryLanguage").out("queries").as("graphs"),
    as("user").out("uses").as("cypher"),
      where("user", within(["Oracle","Apache Spark", "Tableau", "Structr"])),
    as("openCypher").out('makesAvailable").as("cypher")).
      select("cypher").by("attributes")

The original query is sort of an odd query as you don't don't need all the unbound variables...

And if you want to use SPARQL over TinkerPop, just use a SPARQL->Gremlin Virtual Machine compiler. https://github.com/dkuppitz/sparql-gremlin