Norms for applications

I don't think so, and I suspect it is still premature to do so. Not enough practice yet.

We also might have some different approaches to app ecosystems among the people so far assembled here.

One is like DigLife, a bunch of existing apps connected by single signon and common navigation. FairCoop is also doing something like that. I think DigLife also do some amount of data sharing among the apps, but I don't know exactly what, nor how they do it.

While we also think single signon is important, @lynnfoster and I (and probably others) are focusing on data sharing using common vocabularies. We're working on the ValueFlows vocabulary for economic apps, and @gregorycassel has been working on standards for organizational communication.

@matthewslater has been working on APIs for intents and mutual credit, which is like a vocabulary in that it includes standards for data communication.

Lynn is working on an API for a ValueFlows vocabulary on top of our NRP software, which is now being used among three different apps. NRP does not fit the expectations of the Open App Ecosystem (lots of tiny mostly single-purpose apps) but the API is meant to be usable in an ecosystem of smaller apps.

Communector and others are working on vocabulary translators, which I think will become another important part of an ecosystem.

Those are just descriptions of what I see out there, not prescriptions for what must be done. I don't think we have any explicit agreements on that. And I could also be missing something,

Thank you for your answer !

I was wondering, how can an application use your common vocabulary ?

Two cases :
* The app already exist : can it transform itself to use your common vocabulary ?
* The app doesn't exist yet

Thank you :)

The app already exist : can it transform itself to use your common vocabulary ?

All the app needs to do is use a common vocabulary for communicating with other apps. That is now being done with a fork of our old NRP software: @lynnfoster created an API using the ValueFlows vocabulary that is being used by three different other apps now.

The app doesn't exist yet

The app could use the VF model and vocabulary internally. The only apps doing that that I know of so far are
* two new UIs for our old NRP software: https://github.com/django-rea/rea-app/wiki and https://github.com/LearnDeepMilwaukee,
* http://valueflows.pythonanywhere.com/ (a demo I did),
* and a new app being started in the scuttleverse: https://github.com/nanomonkey/ssb_valueflows

So, some experience, but not a lot.

We've probably addressed this elsewhere, but I'd like to note the creative importance of distinguishing between technical and ethical standards.

Those aren't entirely separate categories. In fact, ethical standards can (and practically must) be defined as technical standards. (And, we can refer to the end results simply as "standards".) However, "ethical standards" are ethically (and culturally) motivated. By contrast, many other standards are "purely" technical-- for the sake of compatibility, and efficiently coordinated interactivity.

For example, there's nothing inherently ethical about choosing orange as the color for a car's turn signal, or in the timing of stoplights at a specific intersection. Those design choices exist simply for the (crucially important) sake of efficiently coordinating the interactions of individual drivers.

With that in mind, and without looking up previous materials: I note that when this group has discussed standards for open applications-- including definitions and derivations of "open source"-- we've often been talking about ethical standards. That's important, and it's not just because people who don't meet our desired standards are necessarily mistreating others. We're concerned with ethical safety standards which can greatly reduce risks of (potentially legal) exploitation.

This group has also noted, of course, that any specific software-app system must indicate standards for technical compatibility. That may include some decisions which seem entirely arbitrary (or "random") and others which clearly increase technical efficiency.

Also, I note that standars should generally IMO distinguish requirements from recommendations. (Or, using other terms such as "MUST" and "MAY".)

Just throwing some thoughts here while I'm here. Thanks for the topic @draft , and questions welcome.

I totally agree with your answer. I didn't precise, but this topic is about technical norms.

Your approach is really interesting and would deserve a topic for itself ! ;) That could be interesting too !

I agree with Bob @bobhaugen that it doesn't seem like there is enough practice to establish norms yet -- technical or ethical. But, in my view, that shouldn't stop people (including you) from suggesting some possible norms for discussion, as long as we use that discussion, not as a means to try to agree norms prematurely, but as a guide to the kind of experience and practice that would be needed to try out these norms -- or indeed as a way of gathering existing relevant experience.

Yes ! That was the goal of this discussion in my head :D

Gonna put it more clearly in the head post !

Thank you for your feedback !

Just to clarify, if you want some independently-developed apps to be able to work together, they need to agree on something. If they want to share data, they need to agree on data formats and what they mean. That's a vocabulary.
If we want lots of apps to be able to work together, without each pair of apps needing to create their own 2-app vocabulary, then we need a common at least somewhat standardized vocabulary.
Doesn't need to be our vocabulary. And our vocabulary only handles economic interactions, and those are not the whole universe of communication.

Indeed, that makes complete sense. The next step, to me, is to ask the community, if anyone else writes a new app dealing with economic applications, they use essentially the same vocabulary. The new app can extend the established vocabulary with new terms for new data items, but if there seems to be some need to change anything within the established vocabulary, it should be ideally done in agreement and collaboration with the people who have established usage of that vocabulary. If that's done well, there will remain one agreed way of representing things, ready for new apps to be built using those terms.

Sure, we don't always do things perfectly, and sometimes it becomes clear that the initially agreed vocabulary took some short cuts, or did something in an awkward way. That's the tricky time. We all need to be sensitive, to find a good way forward that does not needlessly lead to divergent vocabularies.

That's what I expect to happen with https://github.com/nanomonkey/ssb_valueflows
They don't totally agree with VF. But if they stay open, we will work with them and see if we need to adjust the VF vocab or work out the details of using different names or structures. And in some cases, I think they will want to use more than one vocabulary, for example Good Relations, because it doesn't make sense for VF to duplicate stuff that Good Relations does very well.

As there is no description to this github link https://github.com/nanomonkey/ssb_valueflows , I'm not quite sure what they are doing. Are you part of it ?

What is Good Relations ?

Anyway, I've started a document, I will try to centralize the information I gather about the norms of each app of the ecosystem. https://hackmd.lescommuns.org/OwFgjArApiBsUFoAcATAhgMweADIgRvmkggMb4aECcOYdSSQA===#

As there is no description to this github link https://github.com/nanomonkey/ssb_valueflows , I'm not quite sure what they are doing.

We're not sure either.

Are you part of it ?

Same answer.

What is Good Relations ?

http://www.heppnetz.de/projects/goodrelations/

New update of the head post :

Hi everyone !!!

Objective

To define what technical norms, the apps of the ecosystem will have to respect, and then test it until we find good ones.

Collaborative document

This hackmd gathers every useful informations about it.

Feel free to contribute to it, or just push new information in this thread.

Summarize

Several ways to interconnect applications :
* SSO : To connect through several applications by one IdP (Identifiant Provider)
* ETL : Transform data in another format
* Common vocabulary : Bob and Lynn worked on a common vocabulary for economic apps

This subject is to define norms and then test it. At some point if we notice that they work, they'll become standards that we'll use. If they don't we'll keep on updating them.

This subject if not about ethical norms (which could be interesting to talk about in another thread).