"Too powerful" doesn't seem like a thing until you realize it undermines DBA's skill investments, means business level people have to learn something and solve their own problems instead of managing them, disrupts the analyst level conversations that exist in powerBI and excel, seems like an extravagent performance hit with an unclear value prop to devops people, and gives unmanageable godlike powers to the person who operates it. (this unmanagability aspect might be what holds graph products back too)

If you don't believe me, the list of companies who use them also get a rep for having uncanny powers because of their graphs, FB, twitter, palantir, uber, etc.

Using ML to parse and normalize data to fit categories in RDF graphs is singularity-level tech, imo and where that exists today, I'd bet it's mostly secret.

I'm interested in this field and find it fascinating but we're still in it's early dark ages.

when it comes to Knowledge representation and reasoning there's too much emphasis on the representation part and less on the reasoning part, but even this representation part is not a solved problem.

    c1
    {
        // Marked base resource identifiers used for concatenation.
        "resources" = [
            &people:@"https://springfield.gov/people#"
            &mp:@"https://mypredicates.org/"
            &mo:@"https://myobjects.org/"
        ]

        // Map-encoded relationships (the map is the subject)
        $people:"homer_simpson" = {

            /* $mp refers to @"https://mypredicates.org/""
             * $mp:"wife" concatenates to @"https://mypredicates.org/wife"
             */
            $mp:"wife" = $people:"marge_simpson"

            // Multiple relationship objects
            $mp:"regrets" = [
                $firing
                $forgotten_birthday
            ]
        }

        "relationship statements" = [
            &marge_birthday:($people:"marge_simpson" $mp:"birthday" 1956-10-01)
            &forgotten_birthday:($people:"homer_simpson" $mp:"forgot" $marge_birthday)
            &firing:($people:"montgomery_burns" $mp:"fired" $people:"homer_simpson")

            // Multiple relationship subjects
            ([$firing $forgotten_birthday] $mp:"contribute" $mo:"marital_strife")
        ]
    }

Technologies like this remain stagnant until the landscape is ready for them. In this case, the advent of AI and big data is what will make relationship data important. "Semantic web" as in human edited XML/HTML with semantic data embedded was never going to happen and was silly from the get-go. But RDF-style semantic data transferred between machines that infer meaning is an absolute certainty.

It's one of those things that's forever a joke until suddenly it's not. There's a fortune of oil out there, but we have to get past the steam age first (and that'll come sooner than you think).

So true it should have a name, like kstenerud's Law or something.

Not that I have looked recently, what I see missing is a 'northwid' or 'contoso' database. As well as some MOOC with a gentle ramping up of skills.

If you know of a good MOOC on RDF I would love to know about it.

I've even written an engine that takes triples and renders web apps.

This is effectively a todo MVC as triples:

  var template = {
    "predicates": [
  "NewTodo leftOf insertButton",
  "Todos below insertButton",
                "Todos backedBy todos",
                "Todos mappedTo todos",
                "Todos key .description",
  "Todos editable $item.description",
  "insertButton on:click insert-new-item",
  "insert-new-item 0.pushes {\"description\": \"$item.NewTodo.description\"}",
  "insert-new-item 0.pushTo $item.todos",
  "NewTodo backedBy NewTodo",
  "NewTodo mappedTo editBox",
  "NewTodo editable $item.description",
  "NewTodo key .description"
    ],
    "widgets": {
        "todos": {
            "predicates": [
                "label hasContent .description"
            ]
        },
 "editBox": {
      "predicates": [
         "NewItemField hasContent .description"
      } 
 }
    },
    "data": {
 "NewTodo": {
      "description": "Hello world"
 },
        "todos": [
            {
                "description": "todo one"
            },
            {
                "description": "todo two"
            },
            {
                "description": "todo three"
            }
        ]
    }

See https://elaeis.cloud-angle.com/?p=71 and https://github.com/samsquire/additive-guis

I couldn't agree more. I know a lot of this kind of "semantic web" stuff has some pretty vocal detractors and that adoption seems limited, but I still think there is a ton of "meat on this bone". There's just too much potential awesomeness here for this stuff to not be used. I think this is an example of where incremental refinement is the name of the game. As computers get faster, as we get more data, as algorithms improve, etc. we'll get closer and closer to the tipping point where these technologies really start to reveal their potential.

Another example, demonstrating the querying for the relation part, would be to find Leonardo DaVinci's family members: (again in pseudocode so you don't need to dwell in the syntax)

    fetch ?kinName, ?linkName given
    ?link "is called" ?linkName.
    ?kin "is called" ?kinName.
    "Leonardo DaVinci" ?link ?kin.
    ?link "is" "familial".

In fact I would love to know if someone else does have any other resources too :)

I'll second the recommendation of Jena (and associated sub-project Fuseki). If you know Java (or any JVM language) you can use the Jena API directly for manipulating the triplestore, and submitting SPARQL queries. If you don't want to do that, Fuseki exposes an HTTP based API that you can interact with from any environment you prefer.