Property:Contains text
- Text
- schema:text (schema | Schema.org, V 14.0)
O
a bit further afield, i'd point to the [[Open Science Framework]] as a thoughtful case study in incentive mechanism design focused on integration into *intrinsic* benefits (i'm more thoughtful about my science, i can easily document things so i don't forget them)
this podcast interview is a decent look into how he thinks about things: https://everythinghertz.com/69
if i read him right, i sort of agree that infrastructure (possibility) an usability and communities (norms) are prior to / foundational to incentives and policy. top-down incentives and policies that don't align with existing norms and usable practices may risk incentivizing 'just comply with it' practices or just fall flat, like some data sharing mandates. +
[[A System for Interleaving Discussion and Summarization in Online Collaboration#Evidence]] This section of the document references some [[Other Work]] +
P
[[Page Schemas#Creating a new Schema]]
Page schemas is mostly a handy way to generate boilerplate templates and link them to semantic properties. A Form (using [[Page Forms]] is something that is an interface for filling in values for a template.
For an example of how this shakes out, see
[[:Category:Participant]]
[[Template:Participant]]
[[Form:Participant]]
* go to a `Category:CategoryName` page, creating it if it doesn't already exist.
* Click "Create schema" in top right
* If you want a form, check the "Form" box. it is possible to make a schema without a form. The schema just defines what pages will be generated, and the generated pages can be further edited afterwards (note that this might make them inconsistent with the schema)
* Click "add template" If you are only planning on having one template per category, name the template the same thing as the category.
* Add fields! Each field can have a corresponding form input (with a type, eg. a textbox, token input, date selector, etc.) and a semantic property.
* Once you're finished, save the schema
* Click "Generate pages" on the category page. Typically you want to uncheck any pages that are already bluelinks so you don't overwrite them. You might have to do the 'generate pages' step a few times, and it can take a few minutes, bc it's pretty buggy. +
Info on using [[Page Schemas]]:
So you could only need to make schemas for the different types of nodes that you'd want, so if i'm reading right then yes you would have several hundred pages but only 4-5 schemas.
A schema is defined (using page schemas) from a Category Page
A page is only ever loosely connected to a schema (rather than strictly, ie. can only have/requires the schema's fields) through its categ +
Info on using [[Page Schemas]]:
So you could only need to make schemas for the different types of nodes that you'd want, so if i'm reading right then yes you would have several hundred pages but only 4-5 schemas.
A schema is defined (using page schemas) from a Category Page
A page is only ever loosely connected to a schema (rather than strictly, ie. can only have/requires the schema's fields) through its category. Page schemas then generates a template for the category. Typically templates will add a page to a category anyway ([ [Category:CategoryName] ]). So a page can have multiple schemas - that would just look like using multiple templates on the same page. +
[[Page Schemas#Creating a new Schema]]
Page schemas is mostly a handy way to generate boilerplate templates and link them to semantic properties. A Form (using [[Page Forms]] is something that is an interface for filling in values for a template.
For an example of how this shakes out, see
[[:Category:Participant]]
[[Template:Participant]]
[[Form:Participant]]
* go to a `Category:CategoryName` page, creating it if it doesn't already exist.
* Click "Create schema" in top right
* If you want a form, check the "Form" box. it is possible to make a schema without a form. The schema just defines what pages will be generated, and the generated pages can be further edited afterwards (note that this might make them inconsistent with the schema)
* Click "add template" If you are only planning on having one template per category, name the template the same thing as the category.
* Add fields! Each field can have a corresponding form input (with a type, eg. a textbox, token input, date selector, etc.) and a semantic property.
* Once you're finished, save the schema
* Click "Generate pages" on the category page. Typically you want to uncheck any pages that are already bluelinks so you don't overwrite them. You might have to do the 'generate pages' step a few times, and it can take a few minutes, bc it's pretty buggy. +
This project, [[Git-Mediawiki]] looks pretty good: https://github.com/Git-Mediawiki/Git-Mediawiki
I'm gonna see if i can get a further translating layer between wiki markup and markdown going, thank god for [[Pandoc]] +
[[Page Schemas#Creating a new Schema]]
Page schemas is mostly a handy way to generate boilerplate templates and link them to semantic properties. A Form (using [[Page Forms]] is something that is an interface for filling in values for a template.
For an example of how this shakes out, see
[[:Category:Participant]]
[[Template:Participant]]
[[Form:Participant]]
* go to a `Category:CategoryName` page, creating it if it doesn't already exist.
* Click "Create schema" in top right
* If you want a form, check the "Form" box. it is possible to make a schema without a form. The schema just defines what pages will be generated, and the generated pages can be further edited afterwards (note that this might make them inconsistent with the schema)
* Click "add template" If you are only planning on having one template per category, name the template the same thing as the category.
* Add fields! Each field can have a corresponding form input (with a type, eg. a textbox, token input, date selector, etc.) and a semantic property.
* Once you're finished, save the schema
* Click "Generate pages" on the category page. Typically you want to uncheck any pages that are already bluelinks so you don't overwrite them. You might have to do the 'generate pages' step a few times, and it can take a few minutes, bc it's pretty buggy. +
<@743886679554654299> brilliant idea for a [[Local Algorithm]] [[Parametrization]] along the lines of using the [[Medium as Storage]] and parametrization from a conversation I was having just now +
[[Page Schemas#Creating a new Schema]]
Page schemas is mostly a handy way to generate boilerplate templates and link them to semantic properties. A Form (using [[Page Forms]] is something that is an interface for filling in values for a template.
For an example of how this shakes out, see
[[:Category:Participant]]
[[Template:Participant]]
[[Form:Participant]]
* go to a `Category:CategoryName` page, creating it if it doesn't already exist.
* Click "Create schema" in top right
* If you want a form, check the "Form" box. it is possible to make a schema without a form. The schema just defines what pages will be generated, and the generated pages can be further edited afterwards (note that this might make them inconsistent with the schema)
* Click "add template" If you are only planning on having one template per category, name the template the same thing as the category.
* Add fields! Each field can have a corresponding form input (with a type, eg. a textbox, token input, date selector, etc.) and a semantic property.
* Once you're finished, save the schema
* Click "Generate pages" on the category page. Typically you want to uncheck any pages that are already bluelinks so you don't overwrite them. You might have to do the 'generate pages' step a few times, and it can take a few minutes, bc it's pretty buggy. +
[[Page Schemas#Creating a new Schema]]
Page schemas is mostly a handy way to generate boilerplate templates and link them to semantic properties. A Form (using [[Page Forms]] is something that is an interface for filling in values for a template.
For an example of how this shakes out, see
[[:Category:Participant]]
[[Template:Participant]]
[[Form:Participant]]
* go to a `Category:CategoryName` page, creating it if it doesn't already exist.
* Click "Create schema" in top right
* If you want a form, check the "Form" box. it is possible to make a schema without a form. The schema just defines what pages will be generated, and the generated pages can be further edited afterwards (note that this might make them inconsistent with the schema)
* Click "add template" If you are only planning on having one template per category, name the template the same thing as the category.
* Add fields! Each field can have a corresponding form input (with a type, eg. a textbox, token input, date selector, etc.) and a semantic property.
* Once you're finished, save the schema
* Click "Generate pages" on the category page. Typically you want to uncheck any pages that are already bluelinks so you don't overwrite them. You might have to do the 'generate pages' step a few times, and it can take a few minutes, bc it's pretty buggy. +
[[Page Schemas#Creating a new Schema]]
Page schemas is mostly a handy way to generate boilerplate templates and link them to semantic properties. A Form (using [[Page Forms]] is something that is an interface for filling in values for a template.
For an example of how this shakes out, see
[[:Category:Participant]]
[[Template:Participant]]
[[Form:Participant]]
* go to a `Category:CategoryName` page, creating it if it doesn't already exist.
* Click "Create schema" in top right
* If you want a form, check the "Form" box. it is possible to make a schema without a form. The schema just defines what pages will be generated, and the generated pages can be further edited afterwards (note that this might make them inconsistent with the schema)
* Click "add template" If you are only planning on having one template per category, name the template the same thing as the category.
* Add fields! Each field can have a corresponding form input (with a type, eg. a textbox, token input, date selector, etc.) and a semantic property.
* Once you're finished, save the schema
* Click "Generate pages" on the category page. Typically you want to uncheck any pages that are already bluelinks so you don't overwrite them. You might have to do the 'generate pages' step a few times, and it can take a few minutes, bc it's pretty buggy. +
[[Page Schemas#Creating a new Schema]]
Page schemas is mostly a handy way to generate boilerplate templates and link them to semantic properties. A Form (using [[Page Forms]] is something that is an interface for filling in values for a template.
For an example of how this shakes out, see
[[:Category:Participant]]
[[Template:Participant]]
[[Form:Participant]]
* go to a `Category:CategoryName` page, creating it if it doesn't already exist.
* Click "Create schema" in top right
* If you want a form, check the "Form" box. it is possible to make a schema without a form. The schema just defines what pages will be generated, and the generated pages can be further edited afterwards (note that this might make them inconsistent with the schema)
* Click "add template" If you are only planning on having one template per category, name the template the same thing as the category.
* Add fields! Each field can have a corresponding form input (with a type, eg. a textbox, token input, date selector, etc.) and a semantic property.
* Once you're finished, save the schema
* Click "Generate pages" on the category page. Typically you want to uncheck any pages that are already bluelinks so you don't overwrite them. You might have to do the 'generate pages' step a few times, and it can take a few minutes, bc it's pretty buggy. +
[[Page Schemas#Creating a new Schema]]
Page schemas is mostly a handy way to generate boilerplate templates and link them to semantic properties. A Form (using [[Page Forms]] is something that is an interface for filling in values for a template.
For an example of how this shakes out, see
[[:Category:Participant]]
[[Template:Participant]]
[[Form:Participant]]
* go to a `Category:CategoryName` page, creating it if it doesn't already exist.
* Click "Create schema" in top right
* If you want a form, check the "Form" box. it is possible to make a schema without a form. The schema just defines what pages will be generated, and the generated pages can be further edited afterwards (note that this might make them inconsistent with the schema)
* Click "add template" If you are only planning on having one template per category, name the template the same thing as the category.
* Add fields! Each field can have a corresponding form input (with a type, eg. a textbox, token input, date selector, etc.) and a semantic property.
* Once you're finished, save the schema
* Click "Generate pages" on the category page. Typically you want to uncheck any pages that are already bluelinks so you don't overwrite them. You might have to do the 'generate pages' step a few times, and it can take a few minutes, bc it's pretty buggy. +
[[Page Schemas#Creating a new Schema]]
Page schemas is mostly a handy way to generate boilerplate templates and link them to semantic properties. A Form (using [[Page Forms]] is something that is an interface for filling in values for a template.
For an example of how this shakes out, see
[[:Category:Participant]]
[[Template:Participant]]
[[Form:Participant]]
* go to a `Category:CategoryName` page, creating it if it doesn't already exist.
* Click "Create schema" in top right
* If you want a form, check the "Form" box. it is possible to make a schema without a form. The schema just defines what pages will be generated, and the generated pages can be further edited afterwards (note that this might make them inconsistent with the schema)
* Click "add template" If you are only planning on having one template per category, name the template the same thing as the category.
* Add fields! Each field can have a corresponding form input (with a type, eg. a textbox, token input, date selector, etc.) and a semantic property.
* Once you're finished, save the schema
* Click "Generate pages" on the category page. Typically you want to uncheck any pages that are already bluelinks so you don't overwrite them. You might have to do the 'generate pages' step a few times, and it can take a few minutes, bc it's pretty buggy. +
I'll try to turn this thread into [[Project Ideas#Federated knowledge synthesis]]: identify protocols, data models, tools, practices, etc. that can support the process of synthesizing and formalizing scientific knowledge, then build on these ingredients. One dimension is going from narratives via discourse graphs to knowledge graphs. Another dimension is going from conceptual ideas to formal systems. +
[[Project Ideas#Linked Data Publishing On Activitypub]]
ooh I'm very interested in this. so are you thinking a [[Twitter#Bridge]] -> [[ActivityPub#Bridge]] where one could use markup within the twitter post to declare [[Linked Data#Markup Syntax]] and then post to AP? I have thought about this kind of thing before, like using a bot command syntax to declare prefixes by doing something like
```
@ bot prefix
foaf: https:// (ontology URL)
```
or
```
@ bot alias
term: foaf.LongerNameForTerm
```
so that one could do maybe a semantic wikilink like `[ [term::value] ]` either within the tweet or as a reply to it (so the tweet itself doesn't become cluttered/it can become organized post -hoc?).
I've also thought about a bridge (I called [[Threadodo]] ) that implements that kind of command syntax to be able to directly archive threads to [[Zenodo]] along with structured information about the author, but this seems more interesting.
I can help try and clear some of the groundwork out of the way to make it easier for you and other interested participants to experiment. I have asked around fedi a bunch for a very minimal AP server implementation, and I could try and find one (or we could try and prototype one) if you want to experiment with that :), and I can also document and show you a tweepy-based bot that has an extensible command/parsing system too +
For everyone that is embarking on a project, how about setting up a page under [[Projects]] where we can start organizing people that are interested in them, and setting up any prerequisite infra/tools so we don't have to be struggling with stuff like provisioning servers and getting permissions setup during our limited time this weekend 🙂 +
R
[[Page Schemas#Creating a new Schema]]
Page schemas is mostly a handy way to generate boilerplate templates and link them to semantic properties. A Form (using [[Page Forms]] is something that is an interface for filling in values for a template.
For an example of how this shakes out, see
[[:Category:Participant]]
[[Template:Participant]]
[[Form:Participant]]
* go to a `Category:CategoryName` page, creating it if it doesn't already exist.
* Click "Create schema" in top right
* If you want a form, check the "Form" box. it is possible to make a schema without a form. The schema just defines what pages will be generated, and the generated pages can be further edited afterwards (note that this might make them inconsistent with the schema)
* Click "add template" If you are only planning on having one template per category, name the template the same thing as the category.
* Add fields! Each field can have a corresponding form input (with a type, eg. a textbox, token input, date selector, etc.) and a semantic property.
* Once you're finished, save the schema
* Click "Generate pages" on the category page. Typically you want to uncheck any pages that are already bluelinks so you don't overwrite them. You might have to do the 'generate pages' step a few times, and it can take a few minutes, bc it's pretty buggy. +
in human-computer interaction we have a similar problem of trying to think about and synthesize across many genres of contributions/research. one map (adapted for information studies) breaks things out into "empirical" contributions (these most often follow the standard intro/methods/results/discussion format), "conceptual" contributions (which are often more amorphous theory papers), and "constructive" contributions (making a new system/method)
from here: HCI Research as Problem-Solving +