This is a good start, but we should understand how it supports the use cases and common practice.

On the issues we’ve been discussing on links: the OSLC specifications define vocabularies and shapes that specify links that would be reasonably considered inverses. Requirement validatedBy TestCase and TestCase validatesRquirement Requirement is one such example. However, OSLC does not specify which one is the property, which would be considered the inverse property, which or  “owed by” any particular server that supports RM and/or QM domains. Rather this is a server implementation decision, often driven by use cases/scenarios that support a particular work-flow – i.e., requirements vs. test driven develop in this case.

Fundamentally OSLC ResourceShape constraints have no way of indicating what a server expects to store vs. expects another server involved in a link relationship expects/can/has to store. So, implementations do what works for them and what is stored where must be documented outside OSLC discovery.

Added to that, OSLC delegated dialogs don’t establish a clear distinction between the requester and provider of the delegated dialog and who’s supposed to “own” the link – that is, which link property the pair of tools considers the actual source and target of the link, and whether the source or target resource will be the subject of the link property triple.

Jazz.net tools attempt to make this transparent, so the user doesn’t have to know which server is storing the link, or how the incoming links are stored or calculated. This is purely a usability issue. However, the participating servers do have to know because even through the creation of the link can be created from either direction, the servers must know which one stores it and implement the link creation accordingly. Again, there is no way to discover this.

We could expand ResourceShape to define inverse property constraints to provide a discoverable way for clients and servers to interoperate when creating links from either direction. I expect that might be a better approach than defining a number of profile special cases.

Hi,

I put together a simple table for the possible profiles after the call: https://docs.google.com/spreadsheets/d/1fjjGvHrv2yPru8S_6HNoJ5atn6617cUfFUDRz5xAfKQ/edit?usp=sharing

Please look at them and tell me what you think. Thanks to Eran for taking extra time to explain some things to me.

/A

Always trying to create both forward and back links seems like the wrong thing to do, even in opt-out mode. Servers are free to either silently ignore RDF properties it doesn’t support, or to fail the whole PUT if it contains an unsupported property. That could give rise to unpredictable behaviour.

An OSLC client may be able to discover which direction(s) are to be used. Consider a user wanting to create a validates requirement link between a test case and a requirement. There are two potential links (as defined by OSLC specs):

• oslc_qm:validatesRequirement stored on the test case
• oslc_rm:validatedBy stored on the requirement

A caller can GET the test case, look for its oslc:instanceShape, get that shape, and then look for the presence or absence of an OSLC property for oslc_qm:validatesRequirement. It can then GET the requirement, look for its oslc:instanceShape, get that shape, and then look for the presence or absence of an OSLC property for oslc_rm:validatedBy.

I wonder whether that’s sufficient to do the right thing for ELM and for other applications.

Thinking about the opt-in case….

Say you have requirement R1 version 1 (R1-1), and test case TC1 version 1 (TC1-1).
You update the test case in the context of some ETM stream, creating TC1-2 that has a oslc_qm:validatesRequirement link to the concept R1. In order to create the back-link, you’d need to update R1-1 in the context of a DNG stream, to create R1-2. A caller won’t know which stream to use for that backlink, so the only way I can see this working is if this is done in a GC context. It also has the side-effect of creating a new version of both the source and the target. If someone looked at R1 in a GC context that resolved to R1-1, and resolved TC1 to TC1-2, you end up with an inconsistency. The oslc_rm:validatedBy link didn’t exist on R1-1, but the forward link to that requirement exists on TC1-2. I think these were the reasons why ELM decided for opt-in, there would be no backlinks.

David.

This is a good start, but we should understand how it supports the use cases and common practice.

On the issues we’ve been discussing on links: the OSLC specifications define vocabularies and shapes that specify links that would be reasonably considered inverses. Requirement validatedBy TestCase and TestCase validatesRquirement Requirement is one such example. However, OSLC does not specify which one is the property, which would be considered the inverse property, which or  “owed by” any particular server that supports RM and/or QM domains. Rather this is a server implementation decision, often driven by use cases/scenarios that support a particular work-flow – i.e., requirements vs. test driven develop in this case.

Fundamentally OSLC ResourceShape constraints have no way of indicating what a server expects to store vs. expects another server involved in a link relationship expects/can/has to store. So, implementations do what works for them and what is stored where must be documented outside OSLC discovery.

Added to that, OSLC delegated dialogs don’t establish a clear distinction between the requester and provider of the delegated dialog and who’s supposed to “own” the link – that is, which link property the pair of tools considers the actual source and target of the link, and whether the source or target resource will be the subject of the link property triple.

Jazz.net tools attempt to make this transparent, so the user doesn’t have to know which server is storing the link, or how the incoming links are stored or calculated. This is purely a usability issue. However, the participating servers do have to know because even through the creation of the link can be created from either direction, the servers must know which one stores it and implement the link creation accordingly. Again, there is no way to discover this.

We could expand ResourceShape to define inverse property constraints to provide a discoverable way for clients and servers to interoperate when creating links from either direction. I expect that might be a better approach than defining a number of profile special cases.

Hi,

I put together a simple table for the possible profiles after the call: https://docs.google.com/spreadsheets/d/1fjjGvHrv2yPru8S_6HNoJ5atn6617cUfFUDRz5xAfKQ/edit?usp=sharing

Please look at them and tell me what you think. Thanks to Eran for taking extra time to explain some things to me.

/A

A few ideas and observations and a concrete proposal:

• A helpful idea was proposed by our French Sodius Colleague whose name escapes me.  He suggested in a conversation after our last call – and he’ll correct me if I don’t represent him well - that resource shapes should be extended so that tools could indicate which links they index.

• @Jim Amsden’s  suggestion is also interesting (again he’ll correct me if I don’ represent him well) Each “link” might be represented as a pair of reciprocal predicates. For example: Let  (P and P’) be a pair of reciprocal predicates.  Then semantically, the triple (S0, P, O0), would have the same meaning the triple (O0, P’, S0).

• Also I’d observe that “links” already have the concept of a reciprocal-names. Let N be the name for the P in triple (S0, P, O0) when viewed from the perceptive of S0. Then N’, the reciprocal-name is the title of P, is the title of P when it is viewed from the perspective of O2. Naturally if we had reciprocal predicates then the name of P’ (above) would be N’.

Besides discussing these more in detail, I’d like to make the following suggestion: We should reify the concept of link beyond just a single predicate – indeed above are examples of where we are already doing this. We should formalize what we mean by links, want kind of characteristics they may have: titles, reciprocal-links, reciprocal-labels, etc.

However has  @Eran Gery has emphasized all of this is beyond the scope of the first version of Link Profiles.

For me the link profile work would look something like this:

Version 0: Describe linking as it exists in ELM today keeping modifications to a minimum. Given the importance of GC’s for real life applications – and changing my position a bit here – this should include both opt in and opt out cases (with and out GCS), even though that means waving our hands a bit and just assuming the indexing for back links.  

Version 1: We reify links and include the concepts above and more.

I am specifically not proposing to store backlinks. What I’m suggesting is that which link is the forward link depends on the use case the servers are trying to support. So rather I’m proposing using constraints as a means of discovering and perhaps specifying in a profile, what the links mean in a particular situation.

Once discovered where the link is stored, there should be standard way of determining the incoming/inverse link.

A few ideas and observations and a concrete proposal:

• A helpful idea was proposed by our French Sodius Colleague whose name escapes me.  He suggested in a conversation after our last call – and he’ll correct me if I don’t represent him well - that resource shapes should be extended so that tools could indicate which links they index.

• @Jim Amsden’s  suggestion is also interesting (again he’ll correct me if I don’ represent him well) Each “link” might be represented as a pair of reciprocal predicates. For example: Let  (P and P’) be a pair of reciprocal predicates.  Then semantically, the triple (S0, P, O0), would have the same meaning the triple (O0, P’, S0).

• Also I’d observe that “links” already have the concept of a reciprocal-names. Let N be the name for the P in triple (S0, P, O0) when viewed from the perceptive of S0. Then N’, the reciprocal-name is the title of P, is the title of P when it is viewed from the perspective of O2. Naturally if we had reciprocal predicates then the name of P’ (above) would be N’.

Besides discussing these more in detail, I’d like to make the following suggestion: We should reify the concept of link beyond just a single predicate – indeed above are examples of where we are already doing this. We should formalize what we mean by links, want kind of characteristics they may have: titles, reciprocal-links, reciprocal-labels, etc.

However has  @Eran Gery has emphasized all of this is beyond the scope of the first version of Link Profiles.

For me the link profile work would look something like this:

Version 0: Describe linking as it exists in ELM today keeping modifications to a minimum. Given the importance of GC’s for real life applications – and changing my position a bit here – this should include both opt in and opt out cases (with and out GCS), even though that means waving our hands a bit and just assuming the indexing for back links.  

Version 1: We reify links and include the concepts above and more.

Re: We should reify the concept of link beyond just a single predicate

OSLC avoids and discourages the use of reification. It can make querying problematic, especially for OSLC query. I don’t think we should set a precedent just for this use case.

A few ideas and observations and a concrete proposal:

• A helpful idea was proposed by our French Sodius Colleague whose name escapes me.  He suggested in a conversation after our last call – and he’ll correct me if I don’t represent him well - that resource shapes should be extended so that tools could indicate which links they index.

• @Jim Amsden’s  suggestion is also interesting (again he’ll correct me if I don’ represent him well) Each “link” might be represented as a pair of reciprocal predicates. For example: Let  (P and P’) be a pair of reciprocal predicates.  Then semantically, the triple (S0, P, O0), would have the same meaning the triple (O0, P’, S0).

• Also I’d observe that “links” already have the concept of a reciprocal-names. Let N be the name for the P in triple (S0, P, O0) when viewed from the perceptive of S0. Then N’, the reciprocal-name is the title of P, is the title of P when it is viewed from the perspective of O2. Naturally if we had reciprocal predicates then the name of P’ (above) would be N’.

Besides discussing these more in detail, I’d like to make the following suggestion: We should reify the concept of link beyond just a single predicate – indeed above are examples of where we are already doing this. We should formalize what we mean by links, want kind of characteristics they may have: titles, reciprocal-links, reciprocal-labels, etc.

However has  @Eran Gery has emphasized all of this is beyond the scope of the first version of Link Profiles.

For me the link profile work would look something like this:

Version 0: Describe linking as it exists in ELM today keeping modifications to a minimum. Given the importance of GC’s for real life applications – and changing my position a bit here – this should include both opt in and opt out cases (with and out GCS), even though that means waving our hands a bit and just assuming the indexing for back links.  

Version 1: We reify links and include the concepts above and more.

Ed,

Thanks for coming back to version 0…. Indeed this is what we should focus on and we rather call it version 1.

As I mentioned in my other note, IMO for Opt-out we should not recommend link index as this is too far from how Jazz behaves. I think we should recommend OSLC query. That also reduces the requirement to support TRS in that case. And again, there is the CCM anomaly that still relies on backlinking.

Regards,

eran

A few ideas and observations and a concrete proposal:

• A helpful idea was proposed by our French Sodius Colleague whose name escapes me.  He suggested in a conversation after our last call – and he’ll correct me if I don’t represent him well - that resource shapes should be extended so that tools could indicate which links they index.

• @Jim Amsden’s  suggestion is also interesting (again he’ll correct me if I don’ represent him well) Each “link” might be represented as a pair of reciprocal predicates. For example: Let  (P and P’) be a pair of reciprocal predicates.  Then semantically, the triple (S0, P, O0), would have the same meaning the triple (O0, P’, S0).

• Also I’d observe that “links” already have the concept of a reciprocal-names. Let N be the name for the P in triple (S0, P, O0) when viewed from the perceptive of S0. Then N’, the reciprocal-name is the title of P, is the title of P when it is viewed from the perspective of O2. Naturally if we had reciprocal predicates then the name of P’ (above) would be N’.

Besides discussing these more in detail, I’d like to make the following suggestion: We should reify the concept of link beyond just a single predicate – indeed above are examples of where we are already doing this. We should formalize what we mean by links, want kind of characteristics they may have: titles, reciprocal-links, reciprocal-labels, etc.

However has  @Eran Gery has emphasized all of this is beyond the scope of the first version of Link Profiles.

For me the link profile work would look something like this:

Version 0: Describe linking as it exists in ELM today keeping modifications to a minimum. Given the importance of GC’s for real life applications – and changing my position a bit here – this should include both opt in and opt out cases (with and out GCS), even though that means waving our hands a bit and just assuming the indexing for back links.  

Version 1: We reify links and include the concepts above and more.

Re: We should reify the concept of link beyond just a single predicate

OSLC avoids and discourages the use of reification. It can make querying problematic, especially for OSLC query. I don’t think we should set a precedent just for this use case.

A few ideas and observations and a concrete proposal:

• A helpful idea was proposed by our French Sodius Colleague whose name escapes me.  He suggested in a conversation after our last call – and he’ll correct me if I don’t represent him well - that resource shapes should be extended so that tools could indicate which links they index.

• @Jim Amsden’s  suggestion is also interesting (again he’ll correct me if I don’ represent him well) Each “link” might be represented as a pair of reciprocal predicates. For example: Let  (P and P’) be a pair of reciprocal predicates.  Then semantically, the triple (S0, P, O0), would have the same meaning the triple (O0, P’, S0).

• Also I’d observe that “links” already have the concept of a reciprocal-names. Let N be the name for the P in triple (S0, P, O0) when viewed from the perceptive of S0. Then N’, the reciprocal-name is the title of P, is the title of P when it is viewed from the perspective of O2. Naturally if we had reciprocal predicates then the name of P’ (above) would be N’.

Besides discussing these more in detail, I’d like to make the following suggestion: We should reify the concept of link beyond just a single predicate – indeed above are examples of where we are already doing this. We should formalize what we mean by links, want kind of characteristics they may have: titles, reciprocal-links, reciprocal-labels, etc.

However has  @Eran Gery has emphasized all of this is beyond the scope of the first version of Link Profiles.

For me the link profile work would look something like this:

Version 0: Describe linking as it exists in ELM today keeping modifications to a minimum. Given the importance of GC’s for real life applications – and changing my position a bit here – this should include both opt in and opt out cases (with and out GCS), even though that means waving our hands a bit and just assuming the indexing for back links.  

Version 1: We reify links and include the concepts above and more.

Hi David, all,

Again, pulling back towards the pragmatic principle “let’s define a profile that at least guarantees ELM (jazz) cross linking”.

Let’s push to the background for now discussions around “good architectural specification”. Profiles here are all about (ugly) pragmatics.

Note: there are some ELM anomalies we may not include in a profile, only document. Obviously we need ELM to fix that. Some examples:

• ELM currently does not support AM/AM linking (RMM). Obviously we cannot enforce this in a profile. We are pushing hard to fix it this year.
• While in opt-in mode incoming link discovery is done via LDX, RM expects AM to support OSLC query for that. This means that LDX support is not enough for an AM provider, and it needs to support both LDX feed and OSLC query. Again we can document it but recommend LDX usage across all opt-in incoming link discoveries.
• In OptOut mode (no config) ELM assumes backlinking. So for example if a Jira connector creates a link to a requirement, it also needs to create a backlink on the requirement. Ouch.

So for that purpose a question about “opt out” mode: how does ELM behave here, between using a single link with incoming implemented with OSLC query, vs. using backlinks. As far as I recall, all CCM links are using backlinking, and other (RM:QM, RM:AM, AM:QM) use a query. Is that correct?

As for shapes based discovery: I think we also need to specify the storage policy, as creating apps based on discovery requires a higher level of sophistication and preparing for variability. Between two providers, if both have shapes that claim ownership, one need to concede. So to simplify we need to provide ownership map. Also another related question: do the shapes change between opt-out and opt-in mode? For example. RM in opt-out would keep a backlink to CCM. In opt-in not. Does it maintain two shapes?

Also for Anrew’s request attached is a spreadsheet  I created at the time for opt-in mode. We also need to create on for opt-out.  @David Honey2

Can you please confirm its accuracy?

Hope this makes sense…

Regards,

Eran

Always trying to create both forward and back links seems like the wrong thing to do, even in opt-out mode. Servers are free to either silently ignore RDF properties it doesn’t support, or to fail the whole PUT if it contains an unsupported property. That could give rise to unpredictable behaviour.

An OSLC client may be able to discover which direction(s) are to be used. Consider a user wanting to create a validates requirement link between a test case and a requirement. There are two potential links (as defined by OSLC specs):

• oslc_qm:validatesRequirement stored on the test case
• oslc_rm:validatedBy stored on the requirement

A caller can GET the test case, look for its oslc:instanceShape, get that shape, and then look for the presence or absence of an OSLC property for oslc_qm:validatesRequirement. It can then GET the requirement, look for its oslc:instanceShape, get that shape, and then look for the presence or absence of an OSLC property for oslc_rm:validatedBy.

I wonder whether that’s sufficient to do the right thing for ELM and for other applications.

Thinking about the opt-in case….

Say you have requirement R1 version 1 (R1-1), and test case TC1 version 1 (TC1-1).
You update the test case in the context of some ETM stream, creating TC1-2 that has a oslc_qm:validatesRequirement link to the concept R1. In order to create the back-link, you’d need to update R1-1 in the context of a DNG stream, to create R1-2. A caller won’t know which stream to use for that backlink, so the only way I can see this working is if this is done in a GC context. It also has the side-effect of creating a new version of both the source and the target. If someone looked at R1 in a GC context that resolved to R1-1, and resolved TC1 to TC1-2, you end up with an inconsistency. The oslc_rm:validatedBy link didn’t exist on R1-1, but the forward link to that requirement exists on TC1-2. I think these were the reasons why ELM decided for opt-in, there would be no backlinks.

David.

This is a good start, but we should understand how it supports the use cases and common practice.

On the issues we’ve been discussing on links: the OSLC specifications define vocabularies and shapes that specify links that would be reasonably considered inverses. Requirement validatedBy TestCase and TestCase validatesRquirement Requirement is one such example. However, OSLC does not specify which one is the property, which would be considered the inverse property, which or  “owed by” any particular server that supports RM and/or QM domains. Rather this is a server implementation decision, often driven by use cases/scenarios that support a particular work-flow – i.e., requirements vs. test driven develop in this case.

Fundamentally OSLC ResourceShape constraints have no way of indicating what a server expects to store vs. expects another server involved in a link relationship expects/can/has to store. So, implementations do what works for them and what is stored where must be documented outside OSLC discovery.

Added to that, OSLC delegated dialogs don’t establish a clear distinction between the requester and provider of the delegated dialog and who’s supposed to “own” the link – that is, which link property the pair of tools considers the actual source and target of the link, and whether the source or target resource will be the subject of the link property triple.

Jazz.net tools attempt to make this transparent, so the user doesn’t have to know which server is storing the link, or how the incoming links are stored or calculated. This is purely a usability issue. However, the participating servers do have to know because even through the creation of the link can be created from either direction, the servers must know which one stores it and implement the link creation accordingly. Again, there is no way to discover this.

We could expand ResourceShape to define inverse property constraints to provide a discoverable way for clients and servers to interoperate when creating links from either direction. I expect that might be a better approach than defining a number of profile special cases.

Hi,

I put together a simple table for the possible profiles after the call: https://docs.google.com/spreadsheets/d/1fjjGvHrv2yPru8S_6HNoJ5atn6617cUfFUDRz5xAfKQ/edit?usp=sharing

Please look at them and tell me what you think. Thanks to Eran for taking extra time to explain some things to me.

/A

David

Can you please look up the link storage/discovery tables I sent and confirm? These tables are a practical basis to discuss the linking profile.

Would be great if you can do before tomorrow’s meeting… shouldn’t take you more than 5 minutes.

(See XL attachment to the original message)

Thanks

Eran

Hi David, all,

Again, pulling back towards the pragmatic principle “let’s define a profile that at least guarantees ELM (jazz) cross linking”.

Let’s push to the background for now discussions around “good architectural specification”. Profiles here are all about (ugly) pragmatics.

Note: there are some ELM anomalies we may not include in a profile, only document. Obviously we need ELM to fix that. Some examples:

• ELM currently does not support AM/AM linking (RMM). Obviously we cannot enforce this in a profile. We are pushing hard to fix it this year.
• While in opt-in mode incoming link discovery is done via LDX, RM expects AM to support OSLC query for that. This means that LDX support is not enough for an AM provider, and it needs to support both LDX feed and OSLC query. Again we can document it but recommend LDX usage across all opt-in incoming link discoveries.
• In OptOut mode (no config) ELM assumes backlinking. So for example if a Jira connector creates a link to a requirement, it also needs to create a backlink on the requirement. Ouch.

So for that purpose a question about “opt out” mode: how does ELM behave here, between using a single link with incoming implemented with OSLC query, vs. using backlinks. As far as I recall, all CCM links are using backlinking, and other (RM:QM, RM:AM, AM:QM) use a query. Is that correct?

As for shapes based discovery: I think we also need to specify the storage policy, as creating apps based on discovery requires a higher level of sophistication and preparing for variability. Between two providers, if both have shapes that claim ownership, one need to concede. So to simplify we need to provide ownership map. Also another related question: do the shapes change between opt-out and opt-in mode? For example. RM in opt-out would keep a backlink to CCM. In opt-in not. Does it maintain two shapes?

Also for Anrew’s request attached is a spreadsheet  I created at the time for opt-in mode. We also need to create on for opt-out.  @David Honey2

Can you please confirm its accuracy?

Hope this makes sense…

Regards,

Eran

Always trying to create both forward and back links seems like the wrong thing to do, even in opt-out mode. Servers are free to either silently ignore RDF properties it doesn’t support, or to fail the whole PUT if it contains an unsupported property. That could give rise to unpredictable behaviour.

An OSLC client may be able to discover which direction(s) are to be used. Consider a user wanting to create a validates requirement link between a test case and a requirement. There are two potential links (as defined by OSLC specs):

• oslc_qm:validatesRequirement stored on the test case
• oslc_rm:validatedBy stored on the requirement

A caller can GET the test case, look for its oslc:instanceShape, get that shape, and then look for the presence or absence of an OSLC property for oslc_qm:validatesRequirement. It can then GET the requirement, look for its oslc:instanceShape, get that shape, and then look for the presence or absence of an OSLC property for oslc_rm:validatedBy.

I wonder whether that’s sufficient to do the right thing for ELM and for other applications.

Thinking about the opt-in case….

Say you have requirement R1 version 1 (R1-1), and test case TC1 version 1 (TC1-1).
You update the test case in the context of some ETM stream, creating TC1-2 that has a oslc_qm:validatesRequirement link to the concept R1. In order to create the back-link, you’d need to update R1-1 in the context of a DNG stream, to create R1-2. A caller won’t know which stream to use for that backlink, so the only way I can see this working is if this is done in a GC context. It also has the side-effect of creating a new version of both the source and the target. If someone looked at R1 in a GC context that resolved to R1-1, and resolved TC1 to TC1-2, you end up with an inconsistency. The oslc_rm:validatedBy link didn’t exist on R1-1, but the forward link to that requirement exists on TC1-2. I think these were the reasons why ELM decided for opt-in, there would be no backlinks.

David.

This is a good start, but we should understand how it supports the use cases and common practice.

On the issues we’ve been discussing on links: the OSLC specifications define vocabularies and shapes that specify links that would be reasonably considered inverses. Requirement validatedBy TestCase and TestCase validatesRquirement Requirement is one such example. However, OSLC does not specify which one is the property, which would be considered the inverse property, which or  “owed by” any particular server that supports RM and/or QM domains. Rather this is a server implementation decision, often driven by use cases/scenarios that support a particular work-flow – i.e., requirements vs. test driven develop in this case.

Fundamentally OSLC ResourceShape constraints have no way of indicating what a server expects to store vs. expects another server involved in a link relationship expects/can/has to store. So, implementations do what works for them and what is stored where must be documented outside OSLC discovery.

Added to that, OSLC delegated dialogs don’t establish a clear distinction between the requester and provider of the delegated dialog and who’s supposed to “own” the link – that is, which link property the pair of tools considers the actual source and target of the link, and whether the source or target resource will be the subject of the link property triple.

Jazz.net tools attempt to make this transparent, so the user doesn’t have to know which server is storing the link, or how the incoming links are stored or calculated. This is purely a usability issue. However, the participating servers do have to know because even through the creation of the link can be created from either direction, the servers must know which one stores it and implement the link creation accordingly. Again, there is no way to discover this.

We could expand ResourceShape to define inverse property constraints to provide a discoverable way for clients and servers to interoperate when creating links from either direction. I expect that might be a better approach than defining a number of profile special cases.

Hi,

I put together a simple table for the possible profiles after the call: https://docs.google.com/spreadsheets/d/1fjjGvHrv2yPru8S_6HNoJ5atn6617cUfFUDRz5xAfKQ/edit?usp=sharing

Please look at them and tell me what you think. Thanks to Eran for taking extra time to explain some things to me.

/A

David

Can you please look up the link storage/discovery tables I sent and confirm? These tables are a practical basis to discuss the linking profile.

Would be great if you can do before tomorrow’s meeting… shouldn’t take you more than 5 minutes.

(See XL attachment to the original message)

Thanks

Eran

Hi David, all,

Again, pulling back towards the pragmatic principle “let’s define a profile that at least guarantees ELM (jazz) cross linking”.

Let’s push to the background for now discussions around “good architectural specification”. Profiles here are all about (ugly) pragmatics.

Note: there are some ELM anomalies we may not include in a profile, only document. Obviously we need ELM to fix that. Some examples:

-          ELM currently does not support AM/AM linking (RMM). Obviously we cannot enforce this in a profile. We are pushing hard to fix it this year.

-          While in opt-in mode incoming link discovery is done via LDX, RM expects AM to support OSLC query for that. This means that LDX support is not enough for an AM provider, and it needs to support both LDX feed and OSLC query. Again we can document it but recommend LDX usage across all opt-in incoming link discoveries.

-          In OptOut mode (no config) ELM assumes backlinking. So for example if a Jira connector creates a link to a requirement, it also needs to create a backlink on the requirement. Ouch.

So for that purpose a question about “opt out” mode: how does ELM behave here, between using a single link with incoming implemented with OSLC query, vs. using backlinks. As far as I recall, all CCM links are using backlinking, and other (RM:QM, RM:AM, AM:QM) use a query. Is that correct?

As for shapes based discovery: I think we also need to specify the storage policy, as creating apps based on discovery requires a higher level of sophistication and preparing for variability. Between two providers, if both have shapes that claim ownership, one need to concede. So to simplify we need to provide ownership map. Also another related question: do the shapes change between opt-out and opt-in mode? For example. RM in opt-out would keep a backlink to CCM. In opt-in not. Does it maintain two shapes?

Also for Anrew’s request attached is a spreadsheet  I created at the time for opt-in mode. We also need to create on for opt-out.  @David Honey2

Can you please confirm its accuracy?

Hope this makes sense…

Regards,

Eran

Always trying to create both forward and back links seems like the wrong thing to do, even in opt-out mode. Servers are free to either silently ignore RDF properties it doesn’t support, or to fail the whole PUT if it contains an unsupported property. That could give rise to unpredictable behaviour.

An OSLC client may be able to discover which direction(s) are to be used. Consider a user wanting to create a validates requirement link between a test case and a requirement. There are two potential links (as defined by OSLC specs):

·         oslc_qm:validatesRequirement stored on the test case

·         oslc_rm:validatedBy stored on the requirement

A caller can GET the test case, look for its oslc:instanceShape, get that shape, and then look for the presence or absence of an OSLC property for oslc_qm:validatesRequirement. It can then GET the requirement, look for its oslc:instanceShape, get that shape, and then look for the presence or absence of an OSLC property for oslc_rm:validatedBy.

I wonder whether that’s sufficient to do the right thing for ELM and for other applications.

Thinking about the opt-in case….

Say you have requirement R1 version 1 (R1-1), and test case TC1 version 1 (TC1-1).
You update the test case in the context of some ETM stream, creating TC1-2 that has a oslc_qm:validatesRequirement link to the concept R1. In order to create the back-link, you’d need to update R1-1 in the context of a DNG stream, to create R1-2. A caller won’t know which stream to use for that backlink, so the only way I can see this working is if this is done in a GC context. It also has the side-effect of creating a new version of both the source and the target. If someone looked at R1 in a GC context that resolved to R1-1, and resolved TC1 to TC1-2, you end up with an inconsistency. The oslc_rm:validatedBy link didn’t exist on R1-1, but the forward link to that requirement exists on TC1-2. I think these were the reasons why ELM decided for opt-in, there would be no backlinks.

David.

This is a good start, but we should understand how it supports the use cases and common practice.

On the issues we’ve been discussing on links: the OSLC specifications define vocabularies and shapes that specify links that would be reasonably considered inverses. Requirement validatedBy TestCase and TestCase validatesRquirement Requirement is one such example. However, OSLC does not specify which one is the property, which would be considered the inverse property, which or  “owed by” any particular server that supports RM and/or QM domains. Rather this is a server implementation decision, often driven by use cases/scenarios that support a particular work-flow – i.e., requirements vs. test driven develop in this case.

Fundamentally OSLC ResourceShape constraints have no way of indicating what a server expects to store vs. expects another server involved in a link relationship expects/can/has to store. So, implementations do what works for them and what is stored where must be documented outside OSLC discovery.

Added to that, OSLC delegated dialogs don’t establish a clear distinction between the requester and provider of the delegated dialog and who’s supposed to “own” the link – that is, which link property the pair of tools considers the actual source and target of the link, and whether the source or target resource will be the subject of the link property triple.

Jazz.net tools attempt to make this transparent, so the user doesn’t have to know which server is storing the link, or how the incoming links are stored or calculated. This is purely a usability issue. However, the participating servers do have to know because even through the creation of the link can be created from either direction, the servers must know which one stores it and implement the link creation accordingly. Again, there is no way to discover this.

We could expand ResourceShape to define inverse property constraints to provide a discoverable way for clients and servers to interoperate when creating links from either direction. I expect that might be a better approach than defining a number of profile special cases.

Hi,

I put together a simple table for the possible profiles after the call: https://docs.google.com/spreadsheets/d/1fjjGvHrv2yPru8S_6HNoJ5atn6617cUfFUDRz5xAfKQ/edit?usp=sharing

Please look at them and tell me what you think. Thanks to Eran for taking extra time to explain some things to me.

/A