Java is an interesting language for a Fediverse project because it's the one language with several mature implementations of Semantic Web tech (RDF, SPARQL, etc). JSON-LD just works, out of the box. It was kind of shocking to see Apache Jena do in a few minutes of work what took me weeks in Deno!
And I learned about a piece of the Semantic Web ecosystem I wasn't familiar with before. Have you heard the good word of OWL?
"The United States strongly condemns the attack (Friday) from Rwanda Defense Forces and M23 positions on the Mugunga camp for internally displaced persons in eastern Democratic Republic of the Congo," State Department spokesperson Matthew Miller said in a statement"
Good old Rwanda, that very safe country ( because the UK says so). Of course, the UK won't condemn this, as it's part of the Rwanda deportation deal not to.
Has anyone actually tried to aggregate diverse, decentralized #RDF data beyond basic lookup of URIs and beyond sticking to one and only ontology? Centralized aproaches like Wikidata and schema.org for Google Search don't count. Asking for a frustrated friend.
Have been looking at #dat again, do you think we can build this:
The Open Media Network is a trust based, human moderated, #4opens project that builds a database shared across many peers (both #p2p and server). The project is more important for what it DOES NOT DO, than what it does do, using technology to build human networks. There are ONLY 5 main functions:
• Publish (object to a stream of objects) – to publish an object (text, image, link)
• Subscribe (to a stream of objects) – to a person or organization, a page, a group, a hashtag subject etc.
• Moderate (stream or object) – you can say I like/dislike (push/pull or yes/no) this etc you can comment.
• Rollback (stream) – you can remove from your flow (instance database) untrusted historical content by publishing flow/source/tag.
• Edit (meta data of object/stream) – you can edit the metadata in any site/instance/app you have a login on.
We would build in the moderation tools of the #Fediverse.
This is the back-end of the project to build a #DIY trust based, grassroots, semantic web. The front-end may be anything you like, for example regional-/city-/subject-based #indymedia sites to a distributed archiving project #makeinghistory
The data cauldron and the golden ladle. The technology we call the #WitchesCaldron.
@witchescauldron Another platform to consider is #SafeNetwork which is coming together right now. (For example, I'm looking into porting my earlier proof of concept for a an LDP interface (#LinkedData / #RDF) to the new API, and then some #Solid apps.)
I think what you propose would be feasible, certainly worth looking into because the platform has some unique characteristics and I think now would be the perfect time to start building for it. Fully autonomous #p2p#e2e#security.
The @RIOT_OS has a lot of underutilized metadata – about boards, about features, and how they play together; some in YAML, some in Make, some in Doxygen. With some #RDF I'm pulling them together. If only I were a bit more fluent in on-the-fly HTML building tools…
WIP Code at <https://github.com/RIOT-OS/RIOT/pull/20395>
Hi Fediverse, a short #introduction !
ActivityPods is a general-purpose ActivityPub server that uses #SolidProject pods to store user data in a standardized, semantic, interoperable data format, #RDF.
This way, we bridge the gap between an interoperable web, where users are in control of their data, and the social web.
Developers can focus on creating client applications without having to worry about the backend for most parts.
Fun fact: had #ActivityPub object representation been #XML#RDF instead of #JSON, little more than a thin wrapper with #XSLT and #noJavaScript would have been sufficient to serve them on the web —statically.
having uh fun specifying any-shaped arrays as lists of lists with @pydantic for @linkml 's new array syntax... how do you specify a recursive python type that can generate recursive JSON schema and do recursive type checks that can use pydantic's fast rust core validators and not upset the type checker????
@SnoopJ that is exactly what we are doing with @linkml by being able to specify arrays in the schema. it's a downright authorable schema language, and i'm working on different interfaces now to be able to actually use that. That's historically been one of the major problems with #LinkedData / #RDF array specifications - you might be able to describe it, but what's the point, that description is totally removed from how i actually use my data.
so if instead you could just start with some schema, use that to generate a bunch of models (that don't suck to use, having used other schema -> code generator tools before) that you can use in your analyisis/whatever code and then also publish the data in some standardized format, that would be an astronomically better situation than what most scientists have to do now.
This lists of lists version is just the default one if you want to add zero dependencies to whatever you're doing (aside from pydantic, it is the pydantic version of the schema after all). It's a little more clumsy but it works out of the box. I'm also cooking up a tiny lil package (also with minimal deps) with a type that lets you use whatever the heck else array format you want to, right now just got numpy, dask, and hdf5, but going to split those out into plugins and make hooks for any additional formats too ( https://github.com/p2p-ld/numpydantic )
I have an increasing hunch that blank nodes in #RDF are just a local minimum byproduct of ppl insisting that all names need to be globally unique, and if u relax that then u can avoid a lot of the graph isomorphism probs at the expense of having some mechanism of referring to nodes relative to one another
I'm not really a constructivist or finitist in a philosophical sense (and I'm only really a weak platoist just to start with), but they are such incredibly useful models when working with computers.
Like do you realize how powerful it is to be able to say that something is "not proved" rather than that it is "true" or "false"? How great it is to start from an assumption that a number may be large but not actually infinite?
Yes, this is me indirectly dissing #RDF why do you ask >_>
As I read through the discussions around the creation of and revisions around #RDF three things are clear in my eye.
Usability was not the primary concern. It seems to have been widely believed that Other Tools™ would fill this gap and that RDF should focus first on a kind of expressibility.
Those Other Tools™ never materialized.
Most who use RDF-derived tooling seem to assume either that it gives them those tools or that Others™ will build them on top of their solution as well
This is… whatever it is for #RDF or even for #JsonLD, but I'd argue that it is absolutely the wrong choice for something like ActivityPub.
Just in a general communication over unreliable radio networks/distributed systems sense, nothing about this is a good idea.
Because when I am building a social network—or most apps of this nature—I care about things like round trip times, number of network calls, and what pieces of information I have, don't have, or can/cannot get to make a decision.
Yes, they are, and I'm not even advocating changing any of them (except AS2, separate debate), what I'm saying instead is that maybe part of your protocol is that it needs to actually constrain the lexical forms, not just be defined in terms of semantics, and also constrain the semantics, not just aim to capture "that which is expressible."
You can only kick these decisions down the road so many times.
#RDF stuff has this unique ability to just make me go "what"
What do RDF graphs mean? the options:
"a name means nothing"
"a name is a selection of one from all possible names"
"a name means the thing it refers to."
"a name means the thing that you get when you refer to it"
bro i'm just trying to store some data i did not know i would have to relitigate Searle with you
A: "What if the entire internet was one giant database."
B: "Okay, that's an interesting thought experiment, but how will we make sure that everyone is using everything the same way? How will we handle security? What about performance?"
A: "One. Giant. Database."
B: "Can we at least agree on terms and reduce the scope of the weirdness that people can do?"
A: "But someone might want to have that weirdness! It could enable cool things in our one giant database!"
@hrefna you're so deeply right in this thread. this essentially defines the early and formative years of #RDF and #RDFS around some key decisions. There is so much worry about errors from mishandling, but the very possibility of expressing something that could be wrong. There is so much here it's hard to even know where to start but from the very start of the rdf-core and especially rdf-logic mailing lists the emphasis on correctness of expression vs. agency of interpretation is heated. This is a pretty unsubtle example: https://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2001Nov/0423.html
"Summary: RDF is not just a data model. The RDF specs should define a semantics so that an RDF statement on the web is interpreted as an assertion of that statement such that its author would be responsible in law as if it had been published in, say, a newspaper."
"The RDFCore WG takes the view that RDF/XML documents, ie. encodings of
RDF graphs, are represenations of claims or assertions about the world. [...] we note that RDF graphs are the kind of things that can be true or false (rather than 'mere bytes'). For each linear syntax of RDF, there will be conventions (social, legal) for indicating which chunks of data are encodings of RDF graphs in that syntax, and thus of propositional content."
So ya very very early they had decided that RDF was intended to be platonic representation of the world - it is a method of making propositions that must directly bear on the world, there is no ambiguity, there are only true or false things. (There's a lot of subtlety in that but yno.)
Another thing that comes to mind is the discussion of monotonicity that happens throughout, that's also tied up with the discussion of closed worldedness, containers, and whether or not things belong in sets for the purpose of local meaning or need to belong to the One Great Uniform Graph. It must be impossible for adding new triples into the reasoner to make it less certain of some outcome (ie. if it was possible for ambiguity to be introduced eg. by tangled type hierarchies etc.). This thread is all very illustrative but this message is super spicy and also touches on what you're talking about re using the level of granularity you care about: https://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2001Nov/0363.html
this quote from D bricks is also pretty telling of the epistemological commitments:
"RDF Schema is not about policing the content of specific descriptions
'what is said'; it's about policing what is sensibly sayable."