Registries?

[bakaq]

How will we do registries? Should we do registries at all? I have a hard time seeing how to do proper versioning without registries, though Zig and Go seem to do it so maybe it's worth it so check them out.

For those who don't know, a package registry is a place that hosts many versions of packages for package managers to download (like Rust's crates.io, Javascript's npm, or Python's PyPI). They are usually quite a non-trivial thing, because you need some way to authenticate package mantainers for them to publish new versions of packages, and you also need to host the packages themselves, which takes storage and bandwidth.

When you ask for "version 1.3.5" of a package to Cargo, npm or pip, they go to the registries to actually get the files, otherwise how could they actually know what to download? I think Zig resolves that by requiring that you always provide an URL to somewhere you can get the package (and the "source of truth" is actually the hash, so you don't actually have to trust the URL). Go seems to use specially named git tags to do it, which would be the way I would personally do "versions without registries".

I think we should do the Go style "special git tags", at least initially, because it's both good enough and very easy to adopt. Does anyone have any other ideas?

[dougransom]

I think registries are a good idea. hat hash idea is pretty good, then you can use the hash to locate the package from anywhere including a local cache. The Git special tags seems fine, except that not everyone will publish their module in GIT.

Maybe a registry just needs to be supplied with a single hyperlink to the project, which much have some sort of metadata? A human readable and machine-readable index could be automated. I guess that is all PyPI does.

I asked copilot some questions around using RDF for a packing index. Never heard off DOAP before.

❓ Question

I'm exploring ideas for the bakaq/bakage project, which aims to be a cross-compatible Prolog package manager. What would be a good approach to create an index of Prolog packages using RDF?

---

💡 Suggested Approach

Creating an index of Prolog packages using RDF (Resource Description Framework) is a great idea, especially if you're aiming for interoperability, semantic querying, and integration with the broader Linked Data ecosystem. Here's a suggested approach:

---

🔧 1. Define an RDF Vocabulary for Prolog Packages

You can either:

• Reuse existing vocabularies like DOAP (Description of a Project) or DCMI (Dublin Core)
• Or create a custom ontology for Prolog-specific metadata.

Example RDF snippet:

@prefix doap: <http://usefulinc.com/ns/doap#> .
@prefix prolog: <http://example.org/prolog#> .

<https://bakage.org/package/somepkg>
    a doap:Project ;
    doap:name "somepkg" ;
    doap:description "A Prolog library for parsing JSON" ;
    doap:programming-language "Prolog" ;
    prolog:compatibleWith "SWI-Prolog", "Scryer-Prolog" ;
    prolog:isoCompliant true ;
    doap:repository <https://github.com/user/somepkg> .

## ❓ Question

What is DOAP?

---

## 💡 Answer

**DOAP** (Description of a Project) is an RDF vocabulary designed to describe software projects, especially open-source ones. It allows you to represent metadata about a project in a machine-readable way, making it easier to share, discover, and integrate project information across platforms.

---

### 🔑 Key Features of DOAP

- **RDF-based**: Built on the Resource Description Framework, making it compatible with the Semantic Web.
- **Standardized**: Widely used in open-source ecosystems, including by projects like Apache and Debian.
- **Extensible**: You can combine it with other vocabularies like Dublin Core or FOAF.

---

### 🧱 Common DOAP Properties

| Property                   | Description                                      |
|----------------------------|--------------------------------------------------|
| `doap:name`                | Name of the project                              |
| `doap:description`         | A short description of the project               |
| `doap:homepage`            | URL of the project's homepage                    |
| `doap:license`             | License under which the project is distributed   |
| `doap:repository`          | Link to the source code repository               |
| `doap:maintainer`          | Person or organization maintaining the project   |
| `doap:release`             | Information about specific releases              |
| `doap:programming-language`| Language(s) used in the project                  |

---

### 🧪 Example in Turtle Syntax

```turtle
@prefix doap: <http://usefulinc.com/ns/doap#> .

<https://example.org/project/myprologlib>
    a doap:Project ;
    doap:name "MyPrologLib" ;
    doap:description "A library for advanced logic programming in Prolog." ;
    doap:homepage <https://example.org/myprologlib> ;
    doap:programming-language "Prolog" ;
    doap:license <https://opensource.org/licenses/MIT> ;
    doap:repository [
        a doap:GitRepository ;
        doap:location <https://github.com/user/myprologlib>
    ] .

[bakaq]

except that not everyone will publish their module in GIT.

Well, the same could be said about registries, except that running a registry is a lot of effort, and git (not Github in specific, which is a git forge) is decentralized and can even be self-hosted, which makes it even easier to put into. If someone won't even put up a git repo in Github or sourcehut I don't think they would want to log into a registry either.

Look at Go, which is has a widely successful package ecosystem. They do exactly the Git thing. They still host caches to not overwhelm the git hosts, but that is easier than doing a full registry like PyPI, crates.io or npm, and not really necessary at the small scale of the Prolog community.

[dougransom]

❓ Question

What will Bing do with DOAP?

---

💡 Answer

Bing does not directly support DOAP (Description of a Project) as a recognized structured data format for enhancing search results. However, it does support RDFa, which is the format DOAP is typically expressed in.

---

🔍 What Bing Supports

According to Bing Webmaster Tools, Bing supports the following structured data formats:

• Schema.org (via Microdata, JSON-LD)
• RDFa
• Microformats
• Open Graph

---

✅ What This Means for DOAP

• If you embed DOAP metadata using RDFa in your HTML, Bing can technically parse it, but:
  • It may not understand or use the DOAP-specific vocabulary (doap:name, doap:repository, etc.) for rich snippets or search enhancements.
  • It will treat it as generic RDFa unless the vocabulary aligns with something Bing recognizes (like Schema.org).

---

🧭 Recommendation

If your goal is to:

• Expose project metadata to search engines → Use Schema.org (e.g., SoftwareApplication, CreativeWork) in JSON-LD or Microdata.
• Expose project metadata to semantic web agents or RDF consumers → DOAP in RDFa is still a solid choice.

You could also dual-publish metadata:

• Use DOAP in RDFa for semantic web tools.
• Use Schema.org in JSON-LD for search engines like Bing and Google.

---

Would you like help generating both formats for a sample Prolog package?