Re: Internal processes and/or external choreographies (was RE: Ev ents and States ...

Burdett, David wrote:

> I've just read all of this rapidly expanding thread but wanted to 
> really reply to this earlier email from Martin.
>
> I agree with Martin that we have:
> 1. External choreography definitions that imply a shared state machine 
> between multiple roles
> 2. Internal process definitions that define a process that is not 
> shared and is executed by one role, and
> 3. Glue that binds the internal end external together.
>
> Now let's think about implementation for a moment as I think the way 
> you probably want to implement the internal and external is different ...
>
> INTERNAL DEFINITIONS
> These definitions can be executed much like a programming language 
> where there is an engine that decides once one step in the process is 
> complete what the next step should be and then invokes it, i.e. it can 
> be a turing-complete language.
>
> EXTERNAL DEFINITIONS
> These definitions are used to validate that the observable behavior is 
> as expected. For example, when a message arrives, it is checked that 
> it is valid to receive a message at this point in the choreography. 
> There is no engine that can execute the next step in the choreography, 
> you can only flag problems as they arise.
>
> Bottom line, Internal Definitions can (should?) be used in an *active 
> way* to control a process, whereas External Definitions are used in a 
> *passive way* to check that the behavior of others beyond your control 
> is correct.
>
> As these are *so* different, do we think we can have one choreography 
> definition language that can be used for both?
>
I would definitely say yes, one definition language can do both. If you 
look at the underlying model of specifying behavior there is no 
distinction between "internal" and "external". It's only a matter of 
perspective. There's a lot of research into just this topic of 
specifying behavior of distributed systems (pi-calculus et al) which 
proves exactly this point. I would consider this proof to be conviencing 
argument that is can be done and in fact an explanation of how easy it 
is to do.

But the issue here is, can you have one behavior specification (the 
implementation) and another behavior specification (the public 
interface) and ensure that one conforms to the other? Let's say that one 
language has more details (e.g. Java, BPEL, BPML, etc) and another has 
less details and is not turing complete. Can you propose a model for the 
second language that can be used to constrain/verify the first?

arkin

> I don't think so.
>
> Thoughts?
>
> David
>

Received on Friday, 11 April 2003 15:02:44 UTC