You could do it to confirm no bugs.
Just dont take the prize.. or do.. 
2 Likes
Busy writing code, maybe later
And on my old phone I had an app you could enter a puzzle and itād solve it. If someone doesnāt get it in 1/2 hour there is something wrong
3 Likes
As long as it gets a couple new folk to try dweb and Autonomi I am happy 
3 Likes
Nice website , , iām thinking of making some sort of XOR address book to enrol friends and to write shortened addresses in, first few and last few (6 in total?) digits (are these always unique, anyone) to remember whoās who.
If i make an app in the future iām thinking about how to market it locally where i live and this idea came to mind, iām thinking it might be kinda like a personal yellow pages/paper app store that grows over time in a local community and dosni need eg SEO or social media (Iām WJH following you on X,but i just follow stuff now and then and donāt really engage much) , just walking about chatting 
8 Likes
8 Likes
I have moooaar planz but lesss time.
Coming soon.. err sometime 
Ps. @moderators if one of you feel so inclined perhaps better to split Atlas into its own thread?
7 Likes
meeee toooo
b5afa72021a5523a901e0de6c8e60da4dadbbb0cac4334c9415b81c366e255c222fbfcda3af67f756b1fef83f5ffedee
6 Likes
Good to see this!
I think we should actually broaden the scope of this, as there are many reasons to have short names on Autonomi.
For example, in AntTP, Iāve introduced the concept of ābookmarksā, which are just short names pointing to Autonomi addresses (either immutable or mutable addresses). These can be used as aliases for anything pointers, registers, pubic archives, single files, etc. Essentially, anything that has an address that we may want to shorten.
In AntTP, I just specified 2 defaults, which are āimimā and ātraktion-blogā. Under the hood, the first is a pointer and the latter is a register, but both resolve to a public archive. Contextually, āimimā is a public archive containing an application (typescript, css, html, etc) and ātraktion-blogā is a public archive containing markdown files (text) and media assets (pictures, videos, audio, etc). So, they have quite different contexts, but resolving them to names makes life easier.
Note that this isnāt really DNS - itās just key/value for a name to an address, which is much finer grained than domain names to hosts. For example, with IMIM, two short names can be used to build up the URL.
I was pondering just creating a super simple CSV style file and dumping name/address pairs in it, then allowing AntTP to ingest, then resolve, these. The source file could be uploaded to Autonomi, so AntTP would just need an address to point to the file. Indeed, these could be considered āTraktionās pet namesā and pointing to other files, or multiple files, could include different pet names for addresses.
Longer term, maintaining huge lists isnāt going to scale (at least from a file maintenance perspective) and we will hit similar problems to DNS (i.e. who is responsible for what names, who can you trust, what is the most truthful name set, etc). However, having the nuts/bolts to ingest and resolve a smaller set of names, could easily be extended to something more comprehensive.
4 Likes
@John @Traktion it would be good to try and standardise this. I have similar plans for dweb names (see dweb list-names and the Names demo app).
My approach is to use Scratchpads, similar to ScratchChat and Atlas - so you have private settings, public settings and can follow each otherās public settings, which can include names (aka bookmarks) etc.
Iām using JSON for that ATM, but it we can converge on a standard for that would be nice.
3 Likes
For key/value pairs, I thought JSON may be a bit bulky and you tend to have to parse the whole file. Fine/ideal for configs, especially stuff javascript/typescript needs to parse/use, but for bulk data with repeated keys, it can bloat (EDIT: although lists/arrays can be used to avoid some of that).
While CSV is as old as the hills, it is super simple, for plain text, with minimal formatting/syntax. Being able to just parse blocks/batches from a file and/or multiple files (or scratchpads, etc) could be nice and flexible.
For names, we probably need to decide whether we need UTF-8 (probably do, for better cross language support) and/or what non-alphanumeric characters we accept. Some have special meaning in some contexts, for example (e.g. dots in hostnames). Disallowing spaces makes parsing much easier too (no quoting text, etc).
Maybe it is useful storing some meta data hints about the type of data being linked too (to avoid having to actually resolve and check it - a pain with mutable types atm). That would suggest a key with a multi-dimensional value though, mind.
We should probably prepare for the long term too, where key lookups against mutable types may become the norm for resolution, etc.
Just some thoughts. Could move to another thread and thrash it out?
2 Likes
Iāll post some content tonight or tomorrow morning about the address books idea (Filofax revival sorta? ) , itās (reasoning) all scoped out ,i just need to edit and we can kick the tyres some more and see if there is something there. Back soon!
4 Likes
fwiw, I think a layered approach would help.
- name ā address resolution (and possibly meta data about native address type, e.g. immutable, mutable pointer/register/graph/scratchpad/etc)
- value at address ā format conventions (many options hereā¦ including address book ideas, etc)
2 Likes
I plan some metadata for the name but just an address. So, a type tag (website, app, file etc), short description etc. So not key value unless value is a struct.
1 Like
Not to blow my own horn here, but the key concept behind Colony is to address this exact issue: Autonomi metadata. The same semantics used for files can be used to describe Autonomi sites or in the case of Friends, people. Its all done in RDF so you can search for things with SPARQL queries once you read in all of your RDF data. For example, one entry may look like this in TriG syntax:
<ant://c859818c623ce4fc0899c2ab43061b19caa0b0598eec35ef309dbe50c8af8d59> <http://schema.org/description> "Beg Blag and Steal" ;
a <http://schema.org/MediaObject> ;
<http://schema.org/contentSize> "4MB" ;
<http://schema.org/name> "BegBlag.mp3" .
The best part is the information is additive because each āpodā containing this metadata is in its own named graph, so say I read in this metadata from someone else, but I want to tack on my own bit of information or overwrite something, I can do that:
<ant://c859818c623ce4fc0899c2ab43061b19caa0b0598eec35ef309dbe50c8af8d59>
<http://schema.org/description> "Beg Blag and Steal - live" ;
<http://schema.org/comment> "This song is awesome!" .
For search, the information is ordered by what is āclosestā to you, so if you are directly downloading this metadata file, this information will be displayed vs this entry in a metadata file that you got from a reference of a reference.
The way I envision DNS on Autonomi is entries would be made in these pod metadata files and people would choose to download them. Anyone can make and maintain their own index and attach their own information. Eventually, a handful of indexes will become the āgold standardā ones that people trust most. So unlike the WWW, there wonāt be a central registry (that is unenforceable here), DNS will be federated.
4 Likes
I 
RDF as many here know, and SPARQL. I imemented a Solid pod as a web client on an early Safe Network so am very interested in using this.
How can we go forward? A spec, Rust lib, ???
I know Rust has support for RDF, but have only used it in JavaScript (nodejs).
Weād need libs for both those at least to start for dweb settings and web apps.
2 Likes
Iāve implemented all of it in colonylib 
It creates a layer of abstraction for a āpodā which is a pointer to a scratchpad and an RDF vocabulary for collecting multiple scratchpads into a pod (for pods bigger than 4MB), referencing other pods, and a depth attribute for each pod to enable search ordering. Each pod is a named graph using the pointer address as the URI.
I use the rust oxigraph library for the RDF database and SPARQL queries. It seemed to be the most feature rich RDF library in rust.
For the vocabulary, Iāve just been using schema.org, seems to be the most widely used one these days.
We can setup a call if you would like me to walk through what Iāve got. It would be an honor to help get this integrated into dweb
4 Likes
Thanks. I work best with text but can start by looking at the library initially.
Iām not sure it makes sense to use whole Colony structure - all or nothing! Avoiding indirection might be important for example, or just cherry picking APIs to read and write the format of different types and collections. Solid was very good for that, and I hoped that using RDF would lead to apps being able to read and write each otherās data, giving users real freedom from lock-in, and the ability to process data created by any app because itās all RDF with semantics built in.
Iām not sure Schema.org is the best for that (having been built for Googleās vision of the web), but am out of touch with what Tim has been doing with his start up and the teams of researchers who were active then Theyāve been very busy but Iāve not kept in touch.
I also built an app to track and query lists of RDF servers, so have quite a bit of data about RDF resources and vocabularies squirreled away.
Based on a few years ago, my first choice would be to start with Solid, and then define application/use cases that are stored using that. Doing that makes it easy to port Solid apps, which I demonstrated back in 2018ā¦ eons ago in this business, but I wouldnāt be surprised if itās still the best supported approach. Of course, Solid builds on SPARQL. I hope RDF Star and SPARQL Star have come along too though as RDF did have some holes in itās ability to model real world data that they were created to address.
Iām not ready to start looking at this yet, but letās open a topic or a discussion (pref on Codeberg rather than GitHub where Iām winding down at last. Early days, but Iāve been very impressed with Codeberg so far.)
Are you wedded to GH or willing to try Codeberg out? Itās free but I actually like to pay to be a member and support them (and get a say). It feels much better, although they donāt seem in a hurry to take my money 
I no longer contribute to the dev forum here because Autonomi have said they intend to shut it down, and Codeberg seems a good independent option.
1 Like
So, walk us through how someone would generate a map and/or lookup a name using this format? Iām thinking we need to resolve from a name to where something like this exists is a precursor?
Iāve not used SPARQL before, but I can see how it could be used to store metadata from your examples.
BTW, should the schema exist on Autonomi as ant:// instead of http:// too?
2 Likes
@happybeing @traktion posted some thoughts XOR Address Books and Directory: A Conceptual Proposal
3 Likes
Sounds great! DM me if you have any questions or comments.
A lot of colonylib deals with all the nuts and bolts with the intent being you could drop this into an application and get up and running quickly. The actual pod concept can be described in about a page including diagrams. As long as other implementations follow the structure, everything will be compatible. Iāll write up a first pass spec for review, should be able to get the done by next week.
Iām not tied to any vocabulary in particular, this one just seemed to be the most complete and the most widely adopted. Whatever we agree upon as a group is good by me.
Iāll mirror the colony stuff to codeberg and figure out how to open a discussion. I mostly just use GH because Iāve had an account there for many years and the IF challenge required a github repo for entry. Same reason Iām on Discord, because IF forced me to
3 Likes