A system for scaling tracking and licensing of designs.

Hello,

It seems to me that one of the problems with design repositories is that it is difficult to find, or identify, various designs and their licensing.

Suppose you go to a website. Let's call it bob.com. They have 5000 designs. As you poke through, you find something on the order of 187 yoda.stl files, 245 yoda.dxf files, and a bunch of other yoda files in different formats. All with different sizes and optimizations.

What I would like to see is the adoption on a config file. This would be an XML file that captures a lot of the key data associated with it the design in question.

So, you would have a file that would have items, such as the following: (Optional, in a number of cases)

Designer
License
Contact Info
Design Date
Design Registration Number
Design Name
Design Version
Associated Files
Description of Design
Dimensional Unit
Size Height
Size Width
Size Depth

Along these lines, I would also like to see a design registry. Each designer, or design group - like a commercial company - would be assigned a registration number. If you do it like they do with MAC addresses, you would assign a block of numbers to a group or person.

So, for instance, I register as nyself. I get assigned an ID. I was figuring a 32 bit number. I'd even format it like an IP address. So, my ID would be something like 10.11.12.133. I would then have an additional 32 bits of numbering for my designs. I would control those numbers and assign them in any fashion I'd want. I will be boring here and say my first design is 0.0.0.1. So, in the my file above. my Design Registration Number would be: 10.11.12.133.0.0.0.1

This has several advantages. Anyone putting my design in a repo would have a specific field that could easily be in a database. If 10 different people put my design in repos, it would still be easy to find.

The XML file also have an additional advantage. I personally use LinuxCNC. I would be trivial to build a debian software package from the info in that XML file. Read the file, create the the versioned debian package. If there is a later version of that design, I could upgrade, or install into a different location. I think this would also easily have a Windows install option along those same lines, but I am not a windows guy.

I take it you havent found thingtracker yet? Dont think the format contains all that data though. The data is in JSON, tbh i think that is better than xml. Goes into javascript easily, has a library to read it in other languages too, is also nicer to read, and i think it even takes a little less space than XML.

Some of the data is already in the files, admesh can get the size out..(well, range of locations)

Dont take it harshly, but frankly outside microcontrollers, your 'number assigning' method is really quite obsolete thinking, and there are no where near enough 32 bits numbers.(But then learning often ends up being hitting upon what people in the past thought) You can send plenty of data, you can identify people with gpg, and then they cant even impersonate each other without the private key.(Except for computers being insecure so the gpg is too, but *everything* suffers from that problem) You can identify every project with a sha512sum and they'll never collide, it can be completely decentralized.

And it probably should be probably there will be websites where you put your stuff, but hopefully many of them, and you can search all of them with thing trackers.

On another note: Personally have been writing thingscript to make representations of physibles.(But it seems to be turning out to be usable much more generally) Any data it uses you can fetch from it, basically... ...except the size, which it uses admesh inside for. I should add storing the admesh size and a way of making it look for that data and not the page.

Edited 1 time(s). Last edit at 05/23/2013 09:01AM by Jasper1984.

Jasper1984 Wrote:
-------------------------------------------------------
> I take it you havent found thingtracker yet? Dont
> think the format contains all that data though.
> The data is in JSON, tbh i think that is better
> than xml. Goes into javascript easily, has a
> library to read it in other languages too, is also
> nicer to read, and i think it even takes a little
> less space than XML.

XML is a bit more flexible however. The system you are describing here essentially forces a specific web design. The point to an XML is that it lends itself to alternative forms of of delivery.

For instance:

XML file lt has the following information:

Designer: Bob
License: GPL
Contact Info: bob@example.com
Design Date: 13 May 2013
Design Registration Number: 12:22:252:12:0:0:0:12
Design Name: Bob's Widget
Design Version: 1.0
Associated Files
bob.stl
bob_ortho.jpg
bob_x.jpg
bob_y.jpg
bob_z.jpg
Description of Design: Spider gear for autofocus adapter for Soligor 55-250mm lens
Dimensional Unit: mm
Size Height: 20
Size Width: 20
Size Depth: 300

With this, you could upload them all to a website, which could easily generate a page for the website from this.

Or, you could feed it into a script that could convert the format to a repository. If someone is running, you could easily write a script to convert this a package. For instance, you could create a debian package, or an rpm package, or even a Windows installer package. You could then load it to a repository and download via standard OS tools. Avoid web pages completely in that distribution channel.

>
> Some of the data is already in the files, admesh
> can get the size out..(well, range of locations)
>
> Dont take it harshly, but frankly outside
> microcontrollers, your 'number assigning' method
> is really quite obsolete thinking, and there are
> no where near enough 32 bits numbers.(But then
> learning often ends up being hitting upon what
> people in the past thought) You can send plenty of
> data, you can identify people with gpg, and then
> they cant even impersonate each other without the
> private key.(Except for computers being insecure
> so the gpg is too, but *everything* suffers from
> that problem) You can identify every project with
> a sha512sum and they'll never collide, it can be
> completely decentralized.
>

Except how scalable and searchable is that? If the designer is from a country where their names are transliterated into English spelling, you could easily have a designer whose name is spelled 10, or more, different ways. The point to the registration number is to unamibiguously identify the design agency, be it a person, or company. Let's say, you want every design by Osama Khadaffi (using a well known combination of names). Just a quick web search shows 2 or 3 versions of the first name. There are about 10 versions of the family name.

The 32 bit is nothing more than a registration number to unambiguously identify a specific designer. It would still need a checksum and signature.



> And it probably should be probably there will
> be websites where you put your stuff, but
> hopefully many of them, and you can search all of
> them with thing trackers.
>
> On another note: Personally have been writing
> thingscript to make representations of
> physibles.(But it seems to be turning out to be
> usable much more generally) Any data it uses you
> can fetch from it, basically... ...except the
> size, which it uses admesh inside for. I should
> add storing the admesh size and a way of making it
> look for that data and not the page.

Yes, the mesh information could be pulled from the file.


In your system, if I want to find every design by someone named Gary Hodgson, I see where I can do that. But, what is there is more than 1 Gary Hodgson?

Edited 1 time(s). Last edit at 05/25/2013 10:19AM by arjalon.

The format makes it easier for javascript writer, but i dont think it disadvantages other approaches much. Searching for json in just my package manage finds 5 readers/writers in C, one for perl, two for python, further i find them for common lisp, C++(well the C ones would work there anyway), it actually seems php has json build-in.. I doubt any approach worth its salt does not have a way of parsing json.

(Of course XML has a lot of parsers too, stil)

Tbh, in thingtracker i dont see any sort of crypto identification like pgp, just a name and a link. (The content behind that link is controlled by the author) It probably should have that. Pgp is a matter of person/servers keeping a list of signers and the submitters just signing stuff, there isnt any scalability problem there, and without the private key, you couldnt impersonate someone if you wanted to.

So if search for Gary Hodgson you see multiple, but they're signing with different private keys, and you know some of Gary Hodgson designs, so you can select one of them and then search by his public key. (Or if you're more advanced you'd just use the public key immediately.)

Said differently, pgp allows you to show you have some private key without revealing it, and the private key is identified by the public key. So if you generate a private key randomly and keep it to yourself you can identify yourself.

Finally: also note that in a sense everything is searchable. One solution could be to have people put things in the title/url/text and use `intitle`, `inurl:` or `intext. Hmm, to implement really good searching you could use regular search engines, and then see if the urls indicate a thing tracker, and then you take all those that do, and use the data in the thing tracker to make a physible-oriented result entry.

Well.. here's a few uses case to consider:

1) Company A has a website with a lot of designs. Potentially thousands of designs. Company is bought out. Website goes away. How do you easily transfer these to a repository and have that info put out there? Especially in the case where a design lab could easily have its catalog broken up and sent to other locations/websites/companies?

2) Once you have downloaded the file, how do you track it on your local systems? I could easily download 50 yoda.stl's off thinginverse right now and lose all licensing and designer information as well as see nothing but 50 files in my Download directory. I could also easily snarf hundreds of designs, but when what?

3) I mention a 32 bit identifier to register a designer. You suggest an entire PGP key. Which do you think would be easier to enter and define? And you still have the issue of how to determine which designer is the correct one. If you don't know of any designs, how would I be able to determine which one is the correct one?