diff options
| author | Bryan Newbold <bnewbold@robocracy.org> | 2018-06-21 10:46:39 -0700 |
|---|---|---|
| committer | Bryan Newbold <bnewbold@robocracy.org> | 2018-06-21 10:46:39 -0700 |
| commit | 51770fc2ed70569f72f2af610d2102a49c15601e (patch) | |
| tree | 63153ad0517907a15c53fe23a36a0c689bd05fe4 /site/index.html | |
| parent | f7c04ce03335c24da4cfe44a1bcbc1f8ea14784c (diff) | |
| download | fatcat-51770fc2ed70569f72f2af610d2102a49c15601e.tar.gz fatcat-51770fc2ed70569f72f2af610d2102a49c15601e.zip | |
temporary static front-page
Diffstat (limited to 'site/index.html')
| -rw-r--r-- | site/index.html | 373 |
1 files changed, 373 insertions, 0 deletions
diff --git a/site/index.html b/site/index.html new file mode 100644 index 00000000..c7f3c14a --- /dev/null +++ b/site/index.html @@ -0,0 +1,373 @@ +<!DOCTYPE html> +<html> +<title>fatcat.wiki</title> + +<xmp theme="united" style="display:none;"> + +fatcat is a half-baked idea to build an open, independent, collaboratively +editable bibliographic database of most written works, with a focus on +published research outputs like journal articles, pre-prints, and conference +proceedings. + +## Technical Architecture + +The canonical backend datastore would be a very large transactional SQL server. +A relatively simple and stable back-end daemon would expose an API (could be +REST, GraphQL, gRPC, etc). As little "application logic" as possible would be +embedded in this back-end; as much as possible would be pushed to bots which +could be authored and operated by anybody. A separate web interface project +would talk to the API backend and could be developed more rapidly. + +A cronjob would make periodic database dumps, both in "full" form (all tables +and all edit history, removing only authentication credentials) and "flat" form +(with only the most recent version of each entity, using only persistent IDs +between entities). + +A goal is to be linked-data/RDF/JSON-LD/semantic-web "compatible", but not +necessarily "first". It should be possible to export the database in a +relatively clean RDF form, and to fetch data in a variety of formats, but +internally fatcat would not be backed by a triple-store, and would not be +bound to a specific third-party ontology or schema. + +Microservice daemons should be able to proxy between the primary API and +standard protocols like ResourceSync and OAI-PMH, and bots could consume +external databases in those formats. + +## Licensing + +The core fatcat database should only contain verifiable factual statements +(which isn't to say that all statements are "true"), not creative or derived +content. + +The goal is to have a very permissively licensed database: CC-0 (no rights +reserved) if possible. Under US law, it should be possible to scrape and pull +in factual data from other corpuses without adopting their licenses. The goal +here isn't to avoid all attribution (progeny information will be included, and a +large sources and acknowledgments statement should be maintained), but trying +to manage the intersection of all upstream source licenses seems untenable, and +creates burdens for downstream users. + +Special care will need to be taken around copyright and original works. I would +propose either not accepting abstracts at all, or including them in a +partitioned database to prevent copyright contamination. Likewise, even simple +user-created content like lists, reviews, ratings, comments, discussion, +documentation, etc., should go in separate services. + +## Basic Editing Workflow and Bots + +Both human editors and bots would have edits go through the same API, with +humans using either the default web interface, arbitrary integrations, or +client software. + +The usual workflow would be to create edits (or creations, merges, deletions) +to individual entities one at a time, all under a single "edit group" of +related edits (eg, correcting authorship info for multiple works related to a +single author). When ready, the editor would "submit" the edit group for +review. During the review period, humans could vote (or veto/approve if they +have higher permissions), and bots can perform automated checks. During this +period the editor can make tweaks if necessary. After some fixed time period +(72 hours?) with no changes and no blocking issues, the edit group would be +auto-accepted, if no auto-resolvable merge-conflicts have arisen. This process +balances editing labor (reviews are easy, but optional) against quality +(cool-down period makes it easier to detect and prevent spam or out-of-control +bots). Advanced permissions could allow some trusted human and bot editors to +push through edits more rapidly. + +Bots would need to be tuned to have appropriate edit group sizes (eg, daily +batches, instead of millions of works in a single edit) to make human QA and +reverts possible. + +Data progeny and citation would be left to the edit history. In the case of +importing external databases, the expectation would be that special-purpose +bot accounts would be used. Human editors would leave edit messages to clarify +their sources. + +A style guide (wiki), chat room, and discussion forum would be hosted as +separate stand-alone services for editors to propose projects and debate +process or scope changes. It would be best if these could use federated account +authorization (oauth?) to have consistent account IDs across mediums. + +## Edit Log + +As part of the process of "accepting" an edit group, a row would be written to +an immutable, append-only log table (which internally could be a SQL table) +documenting each identifier change. This log establishes a monotonically +increasing version number for the entire corpus, and should make interaction +with other systems easier (eg, search engines, replicated databases, +alternative storage backends, notification frameworks, etc.). + +## Identifiers + +A fixed number of first-class "entities" would be defined, with common +behavior and schema layouts. These would all be semantic entities like "work", +"release", "container", and "person". + +fatcat identifiers would be semantically meaningless fixed-length random numbers, +usually represented in case-insensitive base32 format. Each entity type would +have its own identifier namespace. Eg, 96-bit identifiers would have 20 +characters and look like: + + fcwork_rzga5b9cd7efgh04iljk + https://fatcat.org/work/rzga5b9cd7efgh04iljk + +128-bit (UUID size) would have 26 characters: + + fcwork_rzga5b9cd7efgh04iljk8f3jvz + https://fatcat.org/work/rzga5b9cd7efgh04iljk8f3jvz + +A 64-bit namespace is probably plenty though, and would work with most database +Integer columns: + + fcwork_rzga5b9cd7efg + https://fatcat.org/work/rzga5b9cd7efg + +The idea would be to only have fatcat identifiers be used to interlink between +databases, *not* to supplant DOIs, ISBNs, handle, ARKs, and other "registered" +persistent identifiers. + +## Entities and Internal Schema + +Internally, identifiers would be lightweight pointers to actual metadata +objects, which can be thought of as "versions". The metadata objects themselves +would be immutable once committed; the edit process is one of creating new +objects and, if the edit is approved, pointing the identifier to the new +version. Entities would reference between themselves by identifier. + +Edit objects represent a change to a single entity; edits get batched together +into edit groups (like "commits" and "pull requests" in git parlance). + +SQL tables would probably look something like the following, though be specific +to each entity type (eg, there would be an actual `work_revision` table, but +not an actual `entity_revision` table): + + entity_id + uuid + current_revision + + entity_revision + entity_id (bi-directional?) + previous: entity_revision or none + state: normal, redirect, deletion + redirect_entity_id: optional + extra: json blob + edit_id + + edit + mutable: boolean + edit_group + editor + + edit_group + +Additional type-specific columns would hold actual metadata. Additional tables +(which would reference both `entity_revision` and `entity_id` foreign keys as +appropriate) would represent things like external identifiers, ordered +author/work relationships, citations between works, etc. Every revision of an +entity would require duplicating all of these associated rows, which could end +up being a large source of inefficiency, but is necessary to represent the full +history of an object. + +## Scope + +Want the "scholarly web": the graph of works that cite other works. Certainly +every work that is cited more than once and every work that both cites and is +cited; "leaf nodes" and small islands might not be in scope. + +Focusing on written works, with some exceptions. Expect core media (for which we would pursue "completeness") to be: + + journal articles + books + conference proceedings + technical memos + dissertations + +Probably in scope: + + reports + magazine articles + published poetry + essays + government documents + conference + presentations (slides, video) + datasets + +Probably not: + + patents + court cases and legal documents + manuals + datasheets + courses + +Definitely not: + + audio recordings + tv show episodes + musical scores + advertisements + +Author, citation, and work disambiguation would be core tasks. Linking +pre-prints to final publication is in scope. + +I'm much less interested in altmetrics, funding, and grant relationships than +most existing databases in this space. + +fatcat would not include any fulltext content itself, even for cleanly licensed +(open access) works, but would have "strong" (verified) links to fulltext +content, and would include file-level metadata (like hashes and fingerprints) +to help discovery and identify content from any source. Typed file-level links +should make fatcat more useful for both humans and machines to quickly access +fulltext content of a given mimetype than existing redirect or landing page +systems. + +## Ontology + +Loosely following FRBR, but removing the "manifestation" abstraction, and +favoring files (digital artifacts) over physical items, the primary entities +are: + + work + type + <has> contributors + <about> subject/category + <has-primary> release + + release (aka "edition", "variant") + title + volume/pages/issue/chapter + open-access status + <published> date + <of a> work + <published-by> publisher + <published in> container + <has> contributors + <citation> citetext <to> release + <has> identifier + + file (aka "digital artifact") + <of a> release + <has> hashes + <found at> URLs + <held-at> institution <with> accession + + contributor + name + <has> aliases + <has> affiliation <for> date span + <has> identifier + + container + name + open-access policy + peer-review policy + <has> aliases, acronyms + <about> subject/category + <has> identifier + <published in> container + <published-by> publisher + + publisher + name + <has> aliases, acronyms + <has> identifier + +## Controlled Vocabularies + +Some special namespace tables and enums would probably be helpful; these should +live in the database (not requiring a database migration to update), but should +have more controlled editing workflow... perhaps versioned in the codebase: + +- identifier namespaces (DOI, ISBN, ISSN, ORCID, etc) +- subject categorization +- license and open access status +- work "types" (article vs. book chapter vs. proceeding, etc) +- contributor types (author, translator, illustrator, etc) +- human languages +- file mimetypes + +## Unresolved Questions + +How to handle translations of, eg, titles and author names? To be clear, not +translations of works (which are just separate releases). + +Are bi-directional links a schema anti-pattern? Eg, should "work" point to a +primary "release" (which itself points back to the work), or should "release" +have a "is-primary" flag? + +Should `identifier` and `citation` be their own entities, referencing other +entities by UUID instead of by revision? This could save a ton of database +space and chunder. + +Should contributor/author contact information be retained? It could be very +useful for disambiguation, but we don't want to build a huge database for +spammers or "innovative" start-up marketing. + +Would general-purpose SQL databases like Postgres or MySQL scale well enough +to hold several tables with billions of entries? Right from the start there +are hundreds of millions of works and releases, many of which having dozens of +citations, many authors, and many identifiers, and then we'll have potentially +dozens of edits for each of these, which multiply out to `1e8 * 2e1 * 2e1 = +4e10`, or 40 billion rows in the citation table. If each row was 32 bytes on +average (uncompressed, not including index size), that would be 1.3 TByte on +its own, larger than common SSD disk. I think a transactional SQL datastore is +the right answer. In my experience locking and index rebuild times are usually +the biggest scaling challenges; the largely-immutable architecture here should +mitigate locking. Hopefully few indexes would be needed in the primary +database, as user interfaces could rely on secondary read-only search engines +for more complex queries and views. + +I see a tension between focus and scope creep. If a central database like +fatcat doesn't support enough fields and metadata, then it will not be possible +to completely import other corpuses, and this becomes "yet another" partial +bibliographic database. On the other hand, accepting arbitrary data leads to +other problems: sparseness increases (we have more "partial" data), potential +for redundancy is high, humans will start editing content that might be +bulk-replaced, etc. + +There might be a need to support "stub" references between entities. Eg, when +adding citations from PDF extraction, the cited works are likely to be +ambiguous. Could create "stub" works to be merged/resolved later, or could +leave the citation hanging. Same with authors, containers (journals), etc. + +## References and Previous Work + +The closest overall analog of fatcat is [MusicBrainz][mb], a collaboratively +edited music database. [Open Library][ol] is a very similar existing service, +which exclusively contains book metadata. + +[Wikidata][wd] seems to be the most successful and actively edited/developed +open bibliographic database at this time (early 2018), including the +[wikicite][wikicite] conference and related Wikimedia/Wikipedia projects. +Wikidata is a general purpose semantic database of entities, facts, and +relationships; bibliographic metadata has become a large fraction of all +content in recent years. The focus there seems to be linking knowledge +(statements) to specific sources unambiguously. Potential advantages fatcat +would have would be a focus on a specific scope (not a general-purpose database +of entities) and a goal of completeness (capturing as many works and +relationships as rapidly as possible). However, it might be better to just +pitch in to the wikidata efforts. + +The technical design of fatcat is loosely inspired by the git +branch/tag/commit/tree architecture, and specifically inspired by Oliver +Charles' "New Edit System" [blog posts][nes-blog] from 2012. + +There are a whole bunch of proprietary, for-profit bibliographic databases, +including Web of Science, Google Scholar, Microsoft Academic Graph, aminer, +Scopus, and Dimensions. There are excellent field-limited databases like dblp, +MEDLINE, and Semantic Scholar. There are some large general-purpose databases +that are not directly user-editable, including the OpenCitation corpus, CORE, +BASE, and CrossRef. I don't know of any large (more than 60 million works), +open (bulk-downloadable with permissive or no license), field agnostic, +user-editable corpus of scholarly publication bibliographic metadata. + +[nes-blog]: https://ocharles.org.uk/blog/posts/2012-07-10-nes-does-it-better-1.html +[mb]: https://musicbrainz.org +[ol]: https://openlibrary.org +[wd]: https://wikidata.org +[wikicite]: https://meta.wikimedia.org/wiki/WikiCite_2017 + +</xmp> + +<script src="http://strapdownjs.com/v/0.2/strapdown.js"></script> +</html> |