You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@tuscany.apache.org by Jeremy Boynes <jb...@apache.org> on 2006/07/01 09:07:41 UTC

Using scenarios, was: Proposed approach for M2

> Jean-Sebastien Delfino wrote:
> > 1. Use scenarios to drive the M2 work
> > Start a community discussion on the end to end scenarios that we want to
> > support in M2.
> >
> > I'm thinking about concrete end to end scenarios that define the end user
> > experience and the overall story going from development, build,
> > package, deploy
> > to runtime and administration of an SCA application.
snip
> > Here are a few ideas of scenarios to initiate the discussion:
> > - a scenario building your average web app with SCA
> > - a scenario showing how to aggregate multiple services into new ones
> > - mediation and routing/exchange scenarios
> > - an application using publish/subscribe
> > - building a whole system of services on a network
> > - integration with an AJAX UI
> > - what else? any thoughts?

On 6/30/06, Kevin Williams <ke...@qwest.net> wrote:
> Sebastien,
>
> This sounds great to me.  You may have intended this but, I think that
> the scenarios should be implemented as we go resulting in new unit
> tests, samples or sample apps by the time we are ready to release M2.
>
> Also, I propose a scenario that involves data access and the transfer of
> a data graph between modules.  A source module would get the graph using
> the DAS and pass it to a worker module.  The graph would be modified by
> the worker and sent back to the source module with change history intact
> to be synchronized with the database.
>
> An inter-op scenario would be nice too.
>

One the the things that came out at the BOF at ApacheConEU was that we
are not doing a good job of communicating what SCA is all about. I
think having a bunch of scenarios like this will help us do that.

Another thing that came out was that it would help if we broke the
distribution down into smaller pieces - for example, making SCA, SDO
and DAS available as individual releases rather than bundling them all
together which gave users the false impression that they were all
tightly coupled.

I think we need a lot more information on each scenario though - at
least to the level of detail Kevin provided. For example,
> > - a scenario building your average web app with SCA
I'm not sure what "your average web app" is - are we talking JSP
taglibs, working with a framework such as WebWork, or the integration
with something like Spring? Are we talking about just accessing
services, or both producing and consuming? Are we talking about
accessing a remote service or wiring local application components with
SCA? Are we talking portable web app with Tuscany bundled, or how it
works in an SCA-enabled container?

I'd like to suggest we capture these on the wiki in enough detail that
a user new to the project would be able to understand what we are
talking about. The scenarios can then become illustrative samples of
what SCA is about and how it can be realized with Tuscany.

I don't want the scenarios to become the be-all and end-all though. We
tried that with M1 and IMO it failed miserably. We scrambled to
implement features and ended up with a brittle codebase that cracked
when we needed to make significant changes. Testing focused on seeing
if a scenario worked and we ended up with poor coverage across the
codebase.

Instead I think we need to define additional, finer-grained scenarios
that cover the components of the system. For example, different ones
for SCA, SDO and DAS, and, digging deeper, different ones for
web-services, Spring, static SDOs, non-relational DAS and so on.
Basically, there are a lot of different scenarios for SDO on its own,
we don't need to matrix them all into SCA, just pick a few key ones
that help illustrate SCA concepts.

At the most detailed level, the scenarios become the unit test cases
for packages and individual classes.

Finally, I don't think we should define scenarios in the context of M2
- we should define them in the context of what we want Tuscany to be.
As we implement, at some point we can say that we think we have a
useful, consistent set of features and then turn that into a release.
When you combine this with the refactoring into smaller pieces that
can be released separately, it will help build momentum for the
project by showing continual progress.

--
Jeremy

---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
On Jul 1, 2006, at 12:07 AM, Jeremy Boynes wrote:

>> Jean-Sebastien Delfino wrote:
>> > 1. Use scenarios to drive the M2 work
>> > Start a community discussion on the end to end scenarios that we  
>> want to
>> > support in M2.
>> >
>> > I'm thinking about concrete end to end scenarios that define the  
>> end user
>> > experience and the overall story going from development, build,
>> > package, deploy
>> > to runtime and administration of an SCA application.
> snip
>> > Here are a few ideas of scenarios to initiate the discussion:
>> > - a scenario building your average web app with SCA
>> > - a scenario showing how to aggregate multiple services into new  
>> ones
>> > - mediation and routing/exchange scenarios
>> > - an application using publish/subscribe
>> > - building a whole system of services on a network
>> > - integration with an AJAX UI
>> > - what else? any thoughts?
>
> On 6/30/06, Kevin Williams <ke...@qwest.net> wrote:
>> Sebastien,
>>
>> This sounds great to me.  You may have intended this but, I think  
>> that
>> the scenarios should be implemented as we go resulting in new unit
>> tests, samples or sample apps by the time we are ready to release M2.
>>
>> Also, I propose a scenario that involves data access and the  
>> transfer of
>> a data graph between modules.  A source module would get the graph  
>> using
>> the DAS and pass it to a worker module.  The graph would be  
>> modified by
>> the worker and sent back to the source module with change history  
>> intact
>> to be synchronized with the database.
>>
>> An inter-op scenario would be nice too.
>>
>
> One the the things that came out at the BOF at ApacheConEU was that we
> are not doing a good job of communicating what SCA is all about. I
> think having a bunch of scenarios like this will help us do that.
>
> Another thing that came out was that it would help if we broke the
> distribution down into smaller pieces - for example, making SCA, SDO
> and DAS available as individual releases rather than bundling them all
> together which gave users the false impression that they were all
> tightly coupled.
>
> I think we need a lot more information on each scenario though - at
> least to the level of detail Kevin provided. For example,
>> > - a scenario building your average web app with SCA
> I'm not sure what "your average web app" is - are we talking JSP
> taglibs, working with a framework such as WebWork, or the integration
> with something like Spring? Are we talking about just accessing
> services, or both producing and consuming? Are we talking about
> accessing a remote service or wiring local application components with
> SCA? Are we talking portable web app with Tuscany bundled, or how it
> works in an SCA-enabled container?
>
> I'd like to suggest we capture these on the wiki in enough detail that
> a user new to the project would be able to understand what we are
> talking about. The scenarios can then become illustrative samples of
> what SCA is about and how it can be realized with Tuscany.
>
> I don't want the scenarios to become the be-all and end-all though. We
> tried that with M1 and IMO it failed miserably. We scrambled to
> implement features and ended up with a brittle codebase that cracked
> when we needed to make significant changes. Testing focused on seeing
> if a scenario worked and we ended up with poor coverage across the
> codebase.
>
> Instead I think we need to define additional, finer-grained scenarios
> that cover the components of the system. For example, different ones
> for SCA, SDO and DAS, and, digging deeper, different ones for
> web-services, Spring, static SDOs, non-relational DAS and so on.
I think this is really important and it's a problem IMO not just with  
Tuscany but also how the specs are presented. A lot of the feedback  
I've been getting is that it appears all of these technologies are  
tightly coupled, i.e. if one wants to use SCA then they must buy into  
a bunch of other things, such as SDO or DAS. This could also be said  
in reverse: if one wants to use SDO or DAS, then they need to use an  
SCA runtime. Obviously this is not the case (the SCA specs do not  
require SDO and vice versa) and I believe we really need to push this  
a la cart approach. For example, if I want to use the core as an  
embedded runtime and bootstrap it directly with no extensions, I  
should be able to do it. Even SCA itself is a la cart. For example, I  
may want to use assembly with Spring and no policy.

Basically, I'd like us from the SCA side to focus on scenarios which  
demonstrate SCA. We should have "integration" scenarios with other  
technologies such as SDO, DAS, JPA, JAXB, JSF, etc. but it would be  
nice if we could segment them so people can first get familiar with  
SCA and then choose the direction they want to go with ancillary  
technologies.

My other more practical concern is by splitting things up, it makes  
it easier for new people to come on board and select an area to work in.

> Basically, there are a lot of different scenarios for SDO on its own,
> we don't need to matrix them all into SCA, just pick a few key ones
> that help illustrate SCA concepts.

> At the most detailed level, the scenarios become the unit test cases
> for packages and individual classes.
>
> Finally, I don't think we should define scenarios in the context of M2
> - we should define them in the context of what we want Tuscany to be.
> As we implement, at some point we can say that we think we have a
> useful, consistent set of features and then turn that into a release.
I really like this approach. I think our release cycle is too long  
and it is showing in terms of momentum. Also, this helps avoid the M1  
mistake when we crammed features in at the expense of architectural  
considerations and wound up with a code base that we realistically  
can't go forward with.

I'd like to be able to have a release around once a month (possibly  
starting in July). Having releases at a fast clip will help gain  
momentum and highlight incremental feature support. If we modularize,  
it will also allow other pieces/ extensions to release when they are  
ready. This will have the side effect of helping to stabilize  
extension SPIs as well.

Jim

> When you combine this with the refactoring into smaller pieces that
> can be released separately, it will help build momentum for the
> project by showing continual progress.
>
> --
> Jeremy
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
More comments inline...

On Jul 2, 2006, at 2:02 PM, Simon Nash wrote:

> My comments are inline below.
>
>   Simon
>
> Jeremy Boynes wrote:
>
>>> Jean-Sebastien Delfino wrote:
>>> > 1. Use scenarios to drive the M2 work
>>> > Start a community discussion on the end to end scenarios that  
>>> we want to
>>> > support in M2.
>>> >
>>> > I'm thinking about concrete end to end scenarios that define  
>>> the end user
>>> > experience and the overall story going from development, build,
>>> > package, deploy
>>> > to runtime and administration of an SCA application.
>> snip
>>> > Here are a few ideas of scenarios to initiate the discussion:
>>> > - a scenario building your average web app with SCA
>>> > - a scenario showing how to aggregate multiple services into  
>>> new ones
>>> > - mediation and routing/exchange scenarios
>>> > - an application using publish/subscribe
>>> > - building a whole system of services on a network
>>> > - integration with an AJAX UI
>>> > - what else? any thoughts?
>> On 6/30/06, Kevin Williams <ke...@qwest.net> wrote:
>>> Sebastien,
>>>
>>> This sounds great to me.  You may have intended this but, I think  
>>> that
>>> the scenarios should be implemented as we go resulting in new unit
>>> tests, samples or sample apps by the time we are ready to release  
>>> M2.
>>>
>>> Also, I propose a scenario that involves data access and the  
>>> transfer of
>>> a data graph between modules.  A source module would get the  
>>> graph using
>>> the DAS and pass it to a worker module.  The graph would be  
>>> modified by
>>> the worker and sent back to the source module with change history  
>>> intact
>>> to be synchronized with the database.
>>>
>>> An inter-op scenario would be nice too.
>>>
>> One the the things that came out at the BOF at ApacheConEU was  
>> that we
>> are not doing a good job of communicating what SCA is all about. I
>> think having a bunch of scenarios like this will help us do that.
>> Another thing that came out was that it would help if we broke the
>> distribution down into smaller pieces - for example, making SCA, SDO
>> and DAS available as individual releases rather than bundling them  
>> all
>> together which gave users the false impression that they were all
>> tightly coupled.
>> I think we need a lot more information on each scenario though - at
>> least to the level of detail Kevin provided. For example,
>>> > - a scenario building your average web app with SCA
>> I'm not sure what "your average web app" is - are we talking JSP
>> taglibs, working with a framework such as WebWork, or the integration
>> with something like Spring? Are we talking about just accessing
>> services, or both producing and consuming? Are we talking about
>> accessing a remote service or wiring local application components  
>> with
>> SCA? Are we talking portable web app with Tuscany bundled, or how it
>> works in an SCA-enabled container?
>> I'd like to suggest we capture these on the wiki in enough detail  
>> that
>> a user new to the project would be able to understand what we are
>> talking about. The scenarios can then become illustrative samples of
>> what SCA is about and how it can be realized with Tuscany.
>> I don't want the scenarios to become the be-all and end-all  
>> though. We
>> tried that with M1 and IMO it failed miserably. We scrambled to
>> implement features and ended up with a brittle codebase that cracked
>> when we needed to make significant changes. Testing focused on seeing
>> if a scenario worked and we ended up with poor coverage across the
>> codebase.
>> Instead I think we need to define additional, finer-grained scenarios
>> that cover the components of the system. For example, different ones
>> for SCA, SDO and DAS, and, digging deeper, different ones for
>> web-services, Spring, static SDOs, non-relational DAS and so on.
>> Basically, there are a lot of different scenarios for SDO on its own,
>> we don't need to matrix them all into SCA, just pick a few key ones
>> that help illustrate SCA concepts.
>> At the most detailed level, the scenarios become the unit test cases
>> for packages and individual classes.
> I think the purpose of scenarios is not to serve as tests, but to
> define required functionality in terms that are meaningful from
> a user perspective.  From the scenarios we should derive technical
> specifications, designs that implement those specifications, and
> tests that validate that the implementations match the specifications.
> Some of the tests should validate high-level user-visible  
> functionality
> ("functional verification") and some should validate correct
> functioning of lower-level components according to their specified
> contracts ("unit tests").
>
> So I see tests as different from scenarios.  Some higher-level tests
> will look quite similar to elements of a scenario.  Lower-level tests
> won't look like scenarios, but will exercise building blocks of
> functionality that are needed to make the scenarios work.
>
>> Finally, I don't think we should define scenarios in the context  
>> of M2
>> - we should define them in the context of what we want Tuscany to be.
>> As we implement, at some point we can say that we think we have a
>> useful, consistent set of features and then turn that into a release.
>> When you combine this with the refactoring into smaller pieces that
>> can be released separately, it will help build momentum for the
>> project by showing continual progress.
> As Sebastien said, there is LOTS to do.  This means it will take time
> to get all the way to what we want Tuscany to be.  So I think it makes
> sense to stage the scenarios and not try to define right now every
> possible part of advanced functionality that we might like to see in
> Tuscany some day.
I think it is o.k. for people to outline the scenarios that are  
important to them, and implement them if they want, regardless of  
whether they are "advanced" or "simple". I like the idea of people  
choosing to work on areas they are interested in and when the  
community is comfortable, we cut a release. I think this allows for a  
rapid release cycle and, more importantly, accommodates community  
diversity.

> Some of the initial scenarios may end up in M2 and

I'm a bit worried that this will discourage people from working on  
something important to them because it is not slated for a  
predetermined milestone. For example, if someone wanted to work on a  
feature that was not part of some milestone, would they be allowed to  
check the feature into head? Again, I think we need to be flexible  
about "milestones" and releases.

Also, this process of deciding what "ends up" in a milestone may  
result in a "tyranny of the majority"  (it's close to July 4th so I  
have to allude to de Tocqueville :-) ) where a really innovative  
feature is stifled because it does not fit into a set of release  
criteria determined by the many.

> some may not, and they should cover a progression from known use cases
> that are needed to cover the basics, up to more advanced scenarios
> that show how SCA and Tuscany can handle more sophisticated
> requirements better than alternative technologies.

Maybe it would help move things forward if people just went ahead and  
added the scenarios that were important to them to the wiki page I  
started and we separate out the discussion of how we release to  
another thread since most people seem to agree that scenarios are  
useful?

>
>> -- 
>> Jeremy
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>
> -- 
> Simon C Nash   IBM Distinguished Engineer
> Hursley Park, Winchester, UK   nash@hursley.ibm.com
> Tel. +44-1962-815156   Fax +44-1962-818999
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jeremy Boynes <jb...@apache.org>.
On 7/2/06, Simon Nash <na...@hursley.ibm.com> wrote:
> I think the purpose of scenarios is not to serve as tests, but to
> define required functionality in terms that are meaningful from
> a user perspective.

Agreed at the high level. At a low-level I don't see that there would
be much difference between a scenario and a test - we just express the
scenario as test code.

> From the scenarios we should derive technical
> specifications, designs that implement those specifications, and
> tests that validate that the implementations match the specifications.

I don't know of many Apache projects that use that type of approach.
Don't forget you're dealing with volunteers who typically would rather
code than write specifications.

>
> > Finally, I don't think we should define scenarios in the context of M2
> > - we should define them in the context of what we want Tuscany to be.
> > As we implement, at some point we can say that we think we have a
> > useful, consistent set of features and then turn that into a release.
> > When you combine this with the refactoring into smaller pieces that
> > can be released separately, it will help build momentum for the
> > project by showing continual progress.
> >
> As Sebastien said, there is LOTS to do.  This means it will take time
> to get all the way to what we want Tuscany to be.  So I think it makes
> sense to stage the scenarios and not try to define right now every
> possible part of advanced functionality that we might like to see in
> Tuscany some day.  Some of the initial scenarios may end up in M2 and
> some may not, and they should cover a progression from known use cases
> that are needed to cover the basics, up to more advanced scenarios
> that show how SCA and Tuscany can handle more sophisticated
> requirements better than alternative technologies.
>

There's a proverb that asks: "how do you eat an elephant?"

Before we sit down to dinner, I'd like to make sure that we have an
elephant rather than a whale, brontosaur, hippo, or some other large
creature. Some thought is due on what we actually want to build.
Feedback from the BOF was that we are doing a poor job of explaining
what Tuscany is about. I think we can use the scenarios to clarify
that and use it not only to define what we want to code but also as
the basis for a clear explanation on our website.

Jim has made a start on this on the wiki. I think his examples help
define the skeleton of the creature we have. We could use more at a
higher level to put meat on dem bones.

And let's not forget that not everyone involved may be motivated to
write scenarios - some people just prefer to contribute through code.
We need to be open to all.

One answer to that proverb is "one bite at a time."

That includes scenario setting as well. I don't think anyone suggested
trying to define "every possible part of advanced functionality" and I
think it would be more constructive to keep discussion balanced than
take it to extremes.  I think what people have in mind is having a
tool that help sets clear objectives. Some of those objectives are
advanced, some are basic; some are near-term, some are long-term.

Once we know the objectives we have a framework in which people can
evaluate how they want to contribute. Some may choose things with
immediate benefit, other may choose things that are steps along a
longer path. These are all bites that help consume the beast. What's
important is that bites are being taken; in a volunteer community you
simply can't direct what people are working on.

If this approach is going to get legs, it is essential that we start
to define the scenarios and objectives. I look forward to more of them
appearing on the wiki.

--
Jeremy

---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
Sure, you can add the scenario - you just need to create a wiki  
account if you don't already have one. If you are interested in  
helping to create a JSF integration, that would be fantastic.

Jim

On Jul 2, 2006, at 3:43 PM, Clemens Utschig - Utschig (Oracle) wrote:

> yup,
> this is the reason why I ask :-) can someone add that (me?)
> /clemens
>
> Jeremy Boynes wrote:
>
>> On 7/2/06, Clemens Utschig - Utschig (Oracle)
>> <cl...@oracle.com> wrote:
>>
>>> I completly miss an end-to-end scenario .. like accessing a service
>>> through tuscany ... say from a website (preferrably JSF)..
>>> helloworld via tuscany ... am I missing something?
>>>
>>
>> We have a bunch of helloworld-esque samples in the M1 distro but it
>> seems like they are not clearly spelt out. I don't think there are  
>> any
>> like that on the wiki right now.
>>
>> I would love to see a JSF scenario (and hopefully some hints on  
>> how to
>> integrate with it in a manner native to JSF users).
>>
>> -- 
>> Jeremy
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Retrieving WSDL and management API,was: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
Hi Clemens,

I changed the subject since your question may have more general  
interest than the thread on scenarios...

An entry point (now renamed "service") would be discoverable through  
a management API. There has been some talk about providing a Tuscany  
management API so if you are interested in jumping in with ideas as  
one doesn't exist yet. Also, it would serve as good feedback to the  
spec group as this functionality also does not currently exist in SCA.

One minor point is that in the .9 spec, WSDL was not the service  
definition lingua franca. We have recently revised this to require  
that remotable services be *expressable* in WSDL. In other words,  
WSDL itself is not mandated by the spec but it does define  
constraints for remotable services. Local services (those within the  
same composite) are not required to be "expressable" in WSDL.

I think it would be  good idea if we had a management API where WSDLs  
could be retrieved for services bound to a protocol that used WSDL.  
We could even provide some type of RESTful explorer core extension  
that used the API...Go ahead and add some things to the Wiki around  
this and we can iterate through it.

Jim


On Jul 2, 2006, at 5:24 PM, Clemens Utschig - Utschig (Oracle) wrote:

> Jim
> how would I discover an exposed entry point? end of day - it's a  
> wsdl ... (looking into the API, some kind of entrypoint explorer  
> functionality would be cool ...)
>
> /clemens
>
> Jim Marino wrote:
>
>> Cool!  When you have questions, ask away.
>>
>> Jim
>>
>> On Jul 2, 2006, at 4:09 PM, Clemens Utschig - Utschig (Oracle) wrote:
>>
>>> at least I added a tag to the wiki page on it :-)
>>> more to follow ..
>>>
>>> Jim Marino wrote:
>>>
>>>> It would be good if I replied before sending :-) Sure, you can   
>>>> add  the scenario - you just need to create a wiki account if  
>>>> you  don't  already have one. If you are interested in helping  
>>>> to  create a JSF  integration, that would be fantastic.
>>>>
>>>> Jim
>>>>
>>>>
>>>> On Jul 2, 2006, at 3:52 PM, Jim Marino wrote:
>>>>
>>>>>
>>>>> On Jul 2, 2006, at 3:43 PM, Clemens Utschig - Utschig (Oracle)   
>>>>> wrote:
>>>>>
>>>>>> yup,
>>>>>> this is the reason why I ask :-) can someone add that (me?)
>>>>>> /clemens
>>>>>>
>>>>>> Jeremy Boynes wrote:
>>>>>>
>>>>>>> On 7/2/06, Clemens Utschig - Utschig (Oracle)
>>>>>>> <cl...@oracle.com> wrote:
>>>>>>>
>>>>>>>> I completly miss an end-to-end scenario .. like accessing a   
>>>>>>>> service
>>>>>>>> through tuscany ... say from a website (preferrably JSF)..
>>>>>>>> helloworld via tuscany ... am I missing something?
>>>>>>>>
>>>>>>>
>>>>>>> We have a bunch of helloworld-esque samples in the M1 distro   
>>>>>>> but it
>>>>>>> seems like they are not clearly spelt out. I don't think  
>>>>>>> there   are any
>>>>>>> like that on the wiki right now.
>>>>>>>
>>>>>>> I would love to see a JSF scenario (and hopefully some hints   
>>>>>>> on  how to
>>>>>>> integrate with it in a manner native to JSF users).
>>>>>>>
>>>>>>> -- 
>>>>>>> Jeremy
>>>>>>>
>>>>>>> ---------------------------------------------------------------- 
>>>>>>> -- -- -
>>>>>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>>>>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>>>>>
>>>>>>
>>>>>> ----------------------------------------------------------------- 
>>>>>> -- --
>>>>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>>>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>>>>
>>>>>
>>>>
>>>>
>>>> ------------------------------------------------------------------- 
>>>> --
>>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>>
>>
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by "Clemens Utschig - Utschig (Oracle)" <cl...@oracle.com>.
Jim
how would I discover an exposed entry point? end of day - it's a wsdl 
... (looking into the API, some kind of entrypoint explorer 
functionality would be cool ...)

/clemens

Jim Marino wrote:

> Cool!  When you have questions, ask away.
>
> Jim
>
> On Jul 2, 2006, at 4:09 PM, Clemens Utschig - Utschig (Oracle) wrote:
>
>> at least I added a tag to the wiki page on it :-)
>> more to follow ..
>>
>> Jim Marino wrote:
>>
>>> It would be good if I replied before sending :-) Sure, you can  add  
>>> the scenario - you just need to create a wiki account if you  don't  
>>> already have one. If you are interested in helping to  create a JSF  
>>> integration, that would be fantastic.
>>>
>>> Jim
>>>
>>>
>>> On Jul 2, 2006, at 3:52 PM, Jim Marino wrote:
>>>
>>>>
>>>> On Jul 2, 2006, at 3:43 PM, Clemens Utschig - Utschig (Oracle)  wrote:
>>>>
>>>>> yup,
>>>>> this is the reason why I ask :-) can someone add that (me?)
>>>>> /clemens
>>>>>
>>>>> Jeremy Boynes wrote:
>>>>>
>>>>>> On 7/2/06, Clemens Utschig - Utschig (Oracle)
>>>>>> <cl...@oracle.com> wrote:
>>>>>>
>>>>>>> I completly miss an end-to-end scenario .. like accessing a  
>>>>>>> service
>>>>>>> through tuscany ... say from a website (preferrably JSF)..
>>>>>>> helloworld via tuscany ... am I missing something?
>>>>>>>
>>>>>>
>>>>>> We have a bunch of helloworld-esque samples in the M1 distro  but it
>>>>>> seems like they are not clearly spelt out. I don't think there   
>>>>>> are any
>>>>>> like that on the wiki right now.
>>>>>>
>>>>>> I would love to see a JSF scenario (and hopefully some hints  on  
>>>>>> how to
>>>>>> integrate with it in a manner native to JSF users).
>>>>>>
>>>>>> -- 
>>>>>> Jeremy
>>>>>>
>>>>>> ------------------------------------------------------------------ 
>>>>>> -- -
>>>>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>>>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>>>>
>>>>>
>>>>> ------------------------------------------------------------------- 
>>>>> -- 
>>>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>>>
>>>>
>>>
>>>
>>> ---------------------------------------------------------------------
>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>

Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
Cool!  When you have questions, ask away.

Jim

On Jul 2, 2006, at 4:09 PM, Clemens Utschig - Utschig (Oracle) wrote:

> at least I added a tag to the wiki page on it :-)
> more to follow ..
>
> Jim Marino wrote:
>> It would be good if I replied before sending :-) Sure, you can  
>> add  the scenario - you just need to create a wiki account if you  
>> don't  already have one. If you are interested in helping to  
>> create a JSF  integration, that would be fantastic.
>>
>> Jim
>>
>>
>> On Jul 2, 2006, at 3:52 PM, Jim Marino wrote:
>>
>>>
>>> On Jul 2, 2006, at 3:43 PM, Clemens Utschig - Utschig (Oracle)  
>>> wrote:
>>>
>>>> yup,
>>>> this is the reason why I ask :-) can someone add that (me?)
>>>> /clemens
>>>>
>>>> Jeremy Boynes wrote:
>>>>
>>>>> On 7/2/06, Clemens Utschig - Utschig (Oracle)
>>>>> <cl...@oracle.com> wrote:
>>>>>
>>>>>> I completly miss an end-to-end scenario .. like accessing a  
>>>>>> service
>>>>>> through tuscany ... say from a website (preferrably JSF)..
>>>>>> helloworld via tuscany ... am I missing something?
>>>>>>
>>>>>
>>>>> We have a bunch of helloworld-esque samples in the M1 distro  
>>>>> but it
>>>>> seems like they are not clearly spelt out. I don't think there   
>>>>> are any
>>>>> like that on the wiki right now.
>>>>>
>>>>> I would love to see a JSF scenario (and hopefully some hints  
>>>>> on  how to
>>>>> integrate with it in a manner native to JSF users).
>>>>>
>>>>> -- 
>>>>> Jeremy
>>>>>
>>>>> ------------------------------------------------------------------ 
>>>>> -- -
>>>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>>>
>>>>
>>>> ------------------------------------------------------------------- 
>>>> --
>>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>>
>>>
>>
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by "Clemens Utschig - Utschig (Oracle)" <cl...@oracle.com>.
at least I added a tag to the wiki page on it :-)
more to follow ..

Jim Marino wrote:

> It would be good if I replied before sending :-) Sure, you can add  
> the scenario - you just need to create a wiki account if you don't  
> already have one. If you are interested in helping to create a JSF  
> integration, that would be fantastic.
>
> Jim
>
>
> On Jul 2, 2006, at 3:52 PM, Jim Marino wrote:
>
>>
>> On Jul 2, 2006, at 3:43 PM, Clemens Utschig - Utschig (Oracle) wrote:
>>
>>> yup,
>>> this is the reason why I ask :-) can someone add that (me?)
>>> /clemens
>>>
>>> Jeremy Boynes wrote:
>>>
>>>> On 7/2/06, Clemens Utschig - Utschig (Oracle)
>>>> <cl...@oracle.com> wrote:
>>>>
>>>>> I completly miss an end-to-end scenario .. like accessing a service
>>>>> through tuscany ... say from a website (preferrably JSF)..
>>>>> helloworld via tuscany ... am I missing something?
>>>>>
>>>>
>>>> We have a bunch of helloworld-esque samples in the M1 distro but it
>>>> seems like they are not clearly spelt out. I don't think there  are 
>>>> any
>>>> like that on the wiki right now.
>>>>
>>>> I would love to see a JSF scenario (and hopefully some hints on  
>>>> how to
>>>> integrate with it in a manner native to JSF users).
>>>>
>>>> -- 
>>>> Jeremy
>>>>
>>>> -------------------------------------------------------------------- -
>>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>>
>>>
>>> ---------------------------------------------------------------------
>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>
>>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>

Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
It would be good if I replied before sending :-) Sure, you can add  
the scenario - you just need to create a wiki account if you don't  
already have one. If you are interested in helping to create a JSF  
integration, that would be fantastic.

Jim


On Jul 2, 2006, at 3:52 PM, Jim Marino wrote:

>
> On Jul 2, 2006, at 3:43 PM, Clemens Utschig - Utschig (Oracle) wrote:
>
>> yup,
>> this is the reason why I ask :-) can someone add that (me?)
>> /clemens
>>
>> Jeremy Boynes wrote:
>>
>>> On 7/2/06, Clemens Utschig - Utschig (Oracle)
>>> <cl...@oracle.com> wrote:
>>>
>>>> I completly miss an end-to-end scenario .. like accessing a service
>>>> through tuscany ... say from a website (preferrably JSF)..
>>>> helloworld via tuscany ... am I missing something?
>>>>
>>>
>>> We have a bunch of helloworld-esque samples in the M1 distro but it
>>> seems like they are not clearly spelt out. I don't think there  
>>> are any
>>> like that on the wiki right now.
>>>
>>> I would love to see a JSF scenario (and hopefully some hints on  
>>> how to
>>> integrate with it in a manner native to JSF users).
>>>
>>> -- 
>>> Jeremy
>>>
>>> -------------------------------------------------------------------- 
>>> -
>>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>>
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <ji...@gmail.com>.
On Jul 2, 2006, at 3:43 PM, Clemens Utschig - Utschig (Oracle) wrote:

> yup,
> this is the reason why I ask :-) can someone add that (me?)
> /clemens
>
> Jeremy Boynes wrote:
>
>> On 7/2/06, Clemens Utschig - Utschig (Oracle)
>> <cl...@oracle.com> wrote:
>>
>>> I completly miss an end-to-end scenario .. like accessing a service
>>> through tuscany ... say from a website (preferrably JSF)..
>>> helloworld via tuscany ... am I missing something?
>>>
>>
>> We have a bunch of helloworld-esque samples in the M1 distro but it
>> seems like they are not clearly spelt out. I don't think there are  
>> any
>> like that on the wiki right now.
>>
>> I would love to see a JSF scenario (and hopefully some hints on  
>> how to
>> integrate with it in a manner native to JSF users).
>>
>> -- 
>> Jeremy
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by "Clemens Utschig - Utschig (Oracle)" <cl...@oracle.com>.
yup,
this is the reason why I ask :-) can someone add that (me?)
/clemens

Jeremy Boynes wrote:

> On 7/2/06, Clemens Utschig - Utschig (Oracle)
> <cl...@oracle.com> wrote:
>
>> I completly miss an end-to-end scenario .. like accessing a service
>> through tuscany ... say from a website (preferrably JSF)..
>> helloworld via tuscany ... am I missing something?
>>
>
> We have a bunch of helloworld-esque samples in the M1 distro but it
> seems like they are not clearly spelt out. I don't think there are any
> like that on the wiki right now.
>
> I would love to see a JSF scenario (and hopefully some hints on how to
> integrate with it in a manner native to JSF users).
>
> -- 
> Jeremy
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>

---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jeremy Boynes <jb...@apache.org>.
On 7/2/06, Clemens Utschig - Utschig (Oracle)
<cl...@oracle.com> wrote:
> I completly miss an end-to-end scenario .. like accessing a service
> through tuscany ... say from a website (preferrably JSF)..
> helloworld via tuscany ... am I missing something?
>

We have a bunch of helloworld-esque samples in the M1 distro but it
seems like they are not clearly spelt out. I don't think there are any
like that on the wiki right now.

I would love to see a JSF scenario (and hopefully some hints on how to
integrate with it in a manner native to JSF users).

--
Jeremy

---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by "Clemens Utschig - Utschig (Oracle)" <cl...@oracle.com>.
I completly miss an end-to-end scenario .. like accessing a service 
through tuscany ... say from a website (preferrably JSF)..
helloworld via tuscany ... am I missing something?


Jim Marino wrote:

>
> On Jul 2, 2006, at 2:51 PM, Clemens Utschig - Utschig (Oracle) wrote:
>
>> Comments linline ...
>>
>> Jim Marino wrote:
>>
>>>
>>> On Jul 2, 2006, at 2:02 PM, Simon Nash wrote:
>>>
>>>> My comments are inline below.
>>>>
>>>>   Simon
>>>>
>>>> Jeremy Boynes wrote:
>>>>
>>>>>> Jean-Sebastien Delfino wrote:
>>>>>> > 1. Use scenarios to drive the M2 work
>>>>>> > Start a community discussion on the end to end scenarios  that  
>>>>>> we want to
>>>>>> > support in M2.
>>>>>> >
>>>>>> > I'm thinking about concrete end to end scenarios that define   
>>>>>> the end user
>>>>>> > experience and the overall story going from development, build,
>>>>>> > package, deploy
>>>>>> > to runtime and administration of an SCA application.
>>>>>
>>>>>
>>>>> snip
>>>>>
>>>>>> > Here are a few ideas of scenarios to initiate the discussion:
>>>>>> > - a scenario building your average web app with SCA
>>>>>> > - a scenario showing how to aggregate multiple services into   
>>>>>> new ones
>>>>>> > - mediation and routing/exchange scenarios
>>>>>> > - an application using publish/subscribe
>>>>>> > - building a whole system of services on a network
>>>>>> > - integration with an AJAX UI
>>>>>> > - what else? any thoughts?
>>>>>
>>>>>
>>>>> On 6/30/06, Kevin Williams <ke...@qwest.net> wrote:
>>>>>
>>>>>> Sebastien,
>>>>>>
>>>>>> This sounds great to me.  You may have intended this but, I  
>>>>>> think  that
>>>>>> the scenarios should be implemented as we go resulting in new unit
>>>>>> tests, samples or sample apps by the time we are ready to  
>>>>>> release  M2.
>>>>>>
>>>>>> Also, I propose a scenario that involves data access and the   
>>>>>> transfer of
>>>>>> a data graph between modules.  A source module would get the   
>>>>>> graph using
>>>>>> the DAS and pass it to a worker module.  The graph would be   
>>>>>> modified by
>>>>>> the worker and sent back to the source module with change  
>>>>>> history  intact
>>>>>> to be synchronized with the database.
>>>>>>
>>>>>> An inter-op scenario would be nice too.
>>>>>>
>>>>> One the the things that came out at the BOF at ApacheConEU was   
>>>>> that we
>>>>> are not doing a good job of communicating what SCA is all about. I
>>>>> think having a bunch of scenarios like this will help us do that.
>>>>> Another thing that came out was that it would help if we broke the
>>>>> distribution down into smaller pieces - for example, making SCA,  SDO
>>>>> and DAS available as individual releases rather than bundling  
>>>>> them  all
>>>>> together which gave users the false impression that they were all
>>>>> tightly coupled.
>>>>> I think we need a lot more information on each scenario though - at
>>>>> least to the level of detail Kevin provided. For example,
>>>>>
>>>>>> > - a scenario building your average web app with SCA
>>>>>
>>>>>
>> at the end it comes down to people seing the benefits (and these  are 
>> not just core engineers) - so step by step tutorials,
>> and I know this is a damn amount of work usually helps for  
>> attracting and more over making the concepts (that should be  
>> communicated) obvious
>>
>>>>> I'm not sure what "your average web app" is - are we talking JSP
>>>>> taglibs, working with a framework such as WebWork, or the  
>>>>> integration
>>>>> with something like Spring? Are we talking about just accessing
>>>>> services, or both producing and consuming? Are we talking about
>>>>> accessing a remote service or wiring local application  
>>>>> components  with
>>>>> SCA? Are we talking portable web app with Tuscany bundled, or  how it
>>>>> works in an SCA-enabled container?
>>>>> I'd like to suggest we capture these on the wiki in enough  
>>>>> detail  that
>>>>> a user new to the project would be able to understand what we are
>>>>> talking about. The scenarios can then become illustrative  samples of
>>>>> what SCA is about and how it can be realized with Tuscany.
>>>>> I don't want the scenarios to become the be-all and end-all   
>>>>> though. We
>>>>> tried that with M1 and IMO it failed miserably. We scrambled to
>>>>> implement features and ended up with a brittle codebase that  cracked
>>>>> when we needed to make significant changes. Testing focused on  
>>>>> seeing
>>>>> if a scenario worked and we ended up with poor coverage across the
>>>>> codebase.
>>>>> Instead I think we need to define additional, finer-grained  
>>>>> scenarios
>>>>> that cover the components of the system. For example, different  ones
>>>>> for SCA, SDO and DAS, and, digging deeper, different ones for
>>>>> web-services, Spring, static SDOs, non-relational DAS and so on.
>>>>> Basically, there are a lot of different scenarios for SDO on its  
>>>>> own,
>>>>> we don't need to matrix them all into SCA, just pick a few key ones
>>>>> that help illustrate SCA concepts.
>>>>> At the most detailed level, the scenarios become the unit test  cases
>>>>> for packages and individual classes.
>>>>
>>>>
>>>> I think the purpose of scenarios is not to serve as tests, but to
>>>> define required functionality in terms that are meaningful from
>>>> a user perspective.
>>>
>>>
>>> There seems to be a range there as well. For example, "users"  vary  
>>> from end-user application developers to systems extenders. I  also  
>>> think scenarios may not involve users directly at all in  some 
>>> cases,  instead defining some kind of execution flow through  the 
>>> runtime.
>>>
>>> I've just added a scenarios page to the WIKI with some things  that  
>>> are important to me at:
>>>
>>> http://wiki.apache.org/ws/Tuscany/TuscanyJava/Scenarios?action=show
>>>
>>> Hopefully you and others can add ones that are important to you  
>>> and  we can work on implementing them.
>>
>>
>> +1
>
> Great, thanks for volunteering :-) Seriously, we would welcome you to  
> add some scenarios to the Wiki and even help implement some.
>
>>
>>>> From the scenarios we should derive technical
>>>> specifications, designs that implement those specifications, and
>>>> tests that validate that the implementations match the  
>>>> specifications.
>>>
>>>
>>>
>>> This seems a bit heavy-weight for an open source project. Are you   
>>> suggesting we need to have a process where people provide  
>>> functional  and technical specifications? Not to be alarmist but  if 
>>> we required  this, I think we will find it difficult to attract  
>>> developers.
>>>
>> the point on the story is the outcome - attracting developers is  
>> definetely important, nevertheless the outcome and success will be  
>> measured
>> on people using it .. the easier common scenarios are - the  better 
>> :-) (so taking base scenarios as dev line might be a good  idea, and 
>> yes it's more work)
>> test driven dev vs. scenario driven dev :-D
>>
> I'm pretty sure most people think "scenarios" are a valuable way to  
> do development. I don't think they are sufficient though but that's  
> another topic.  More on topic, I also don't think this is a binary  
> choice between test driven and "scenario" driven development. For  
> example, many agilists start with scenarios (they may call them other  
> things) and then proceed to TDD.
>
> On TDD, I think it is a matter of personal choice; sometimes I find  
> it useful to write a test case prior to coding the implementation  
> while other times I find it constraining. Either way, it's up to  
> individuals to decide what best suits them.
>
> Overall I take a similar approach to scenarios as I do TDD: sometimes  
> it's great, other times it makes more sense just to write tests and  
> code. If people want to start with scenarios, good, if people don't,  
> that's fine with me too.
>
>> This does not interfere with attracting developers at all, one this  
>> the outcome from usability point of view the other is "core feature  
>> dev"
>>
>
> I think we're in agreement about the value of scenarios. My question  
> to Simon was whether he felt we should *require* the functional/ 
> technical specification cycle commonly associated with some  
> commercial software development processes.  My opinion is if someone  
> wants to write those things, it may be helpful but we shouldn't  
> require it.
>
>>>> Some of the tests should validate high-level user-visible   
>>>> functionality
>>>> ("functional verification") and some should validate correct
>>>> functioning of lower-level components according to their specified
>>>> contracts ("unit tests").
>>>>
>>>
>>>> So I see tests as different from scenarios.  Some higher-level tests
>>>> will look quite similar to elements of a scenario.  Lower-level  tests
>>>> won't look like scenarios, but will exercise building blocks of
>>>> functionality that are needed to make the scenarios work.
>>>>
>>> That sounds reasonable. I usually point to this article for an   
>>> approach that works well in a distributed development environment:
>>>
>>> http://martinfowler.com/articles/continuousIntegration.html
>>>
>>> Also, in core2 we have spent quite a bit of time introducing the  
>>> use  of JMock to provide very granular unit testing. While test  
>>> coverage  is still limited (around 50-60% overall, 300 or so  tests) 
>>> and we need  to do much better, it may be worth perusing  some of 
>>> the unit tests to  see if they fit your view of  "low- level" tests 
>>> (higher-level testing  IMO should be done through an  integration 
>>> build as described in the  Fowler article).
>>>
>>>
>>>>> Finally, I don't think we should define scenarios in the  context  
>>>>> of M2
>>>>> - we should define them in the context of what we want Tuscany  to 
>>>>> be.
>>>>> As we implement, at some point we can say that we think we have a
>>>>> useful, consistent set of features and then turn that into a  
>>>>> release.
>>>>> When you combine this with the refactoring into smaller pieces that
>>>>> can be released separately, it will help build momentum for the
>>>>> project by showing continual progress.
>>>>
>>>>
>>>> As Sebastien said, there is LOTS to do.  This means it will take  time
>>>> to get all the way to what we want Tuscany to be.  So I think it  
>>>> makes
>>>> sense to stage the scenarios and not try to define right now every
>>>> possible part of advanced functionality that we might like to see in
>>>> Tuscany some day.  Some of the initial scenarios may end up in M2  and
>>>> some may not, and they should cover a progression from known use  
>>>> cases
>>>> that are needed to cover the basics, up to more advanced scenarios
>>>> that show how SCA and Tuscany can handle more sophisticated
>>>> requirements better than alternative technologies.
>>>
>>>
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>

Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
On Jul 2, 2006, at 2:51 PM, Clemens Utschig - Utschig (Oracle) wrote:

> Comments linline ...
>
> Jim Marino wrote:
>
>>
>> On Jul 2, 2006, at 2:02 PM, Simon Nash wrote:
>>
>>> My comments are inline below.
>>>
>>>   Simon
>>>
>>> Jeremy Boynes wrote:
>>>
>>>>> Jean-Sebastien Delfino wrote:
>>>>> > 1. Use scenarios to drive the M2 work
>>>>> > Start a community discussion on the end to end scenarios  
>>>>> that  we want to
>>>>> > support in M2.
>>>>> >
>>>>> > I'm thinking about concrete end to end scenarios that define   
>>>>> the end user
>>>>> > experience and the overall story going from development, build,
>>>>> > package, deploy
>>>>> > to runtime and administration of an SCA application.
>>>>
>>>> snip
>>>>
>>>>> > Here are a few ideas of scenarios to initiate the discussion:
>>>>> > - a scenario building your average web app with SCA
>>>>> > - a scenario showing how to aggregate multiple services into   
>>>>> new ones
>>>>> > - mediation and routing/exchange scenarios
>>>>> > - an application using publish/subscribe
>>>>> > - building a whole system of services on a network
>>>>> > - integration with an AJAX UI
>>>>> > - what else? any thoughts?
>>>>
>>>> On 6/30/06, Kevin Williams <ke...@qwest.net> wrote:
>>>>
>>>>> Sebastien,
>>>>>
>>>>> This sounds great to me.  You may have intended this but, I  
>>>>> think  that
>>>>> the scenarios should be implemented as we go resulting in new unit
>>>>> tests, samples or sample apps by the time we are ready to  
>>>>> release  M2.
>>>>>
>>>>> Also, I propose a scenario that involves data access and the   
>>>>> transfer of
>>>>> a data graph between modules.  A source module would get the   
>>>>> graph using
>>>>> the DAS and pass it to a worker module.  The graph would be   
>>>>> modified by
>>>>> the worker and sent back to the source module with change  
>>>>> history  intact
>>>>> to be synchronized with the database.
>>>>>
>>>>> An inter-op scenario would be nice too.
>>>>>
>>>> One the the things that came out at the BOF at ApacheConEU was   
>>>> that we
>>>> are not doing a good job of communicating what SCA is all about. I
>>>> think having a bunch of scenarios like this will help us do that.
>>>> Another thing that came out was that it would help if we broke the
>>>> distribution down into smaller pieces - for example, making SCA,  
>>>> SDO
>>>> and DAS available as individual releases rather than bundling  
>>>> them  all
>>>> together which gave users the false impression that they were all
>>>> tightly coupled.
>>>> I think we need a lot more information on each scenario though - at
>>>> least to the level of detail Kevin provided. For example,
>>>>
>>>>> > - a scenario building your average web app with SCA
>>>>
> at the end it comes down to people seing the benefits (and these  
> are not just core engineers) - so step by step tutorials,
> and I know this is a damn amount of work usually helps for  
> attracting and more over making the concepts (that should be  
> communicated) obvious
>
>>>> I'm not sure what "your average web app" is - are we talking JSP
>>>> taglibs, working with a framework such as WebWork, or the  
>>>> integration
>>>> with something like Spring? Are we talking about just accessing
>>>> services, or both producing and consuming? Are we talking about
>>>> accessing a remote service or wiring local application  
>>>> components  with
>>>> SCA? Are we talking portable web app with Tuscany bundled, or  
>>>> how it
>>>> works in an SCA-enabled container?
>>>> I'd like to suggest we capture these on the wiki in enough  
>>>> detail  that
>>>> a user new to the project would be able to understand what we are
>>>> talking about. The scenarios can then become illustrative  
>>>> samples of
>>>> what SCA is about and how it can be realized with Tuscany.
>>>> I don't want the scenarios to become the be-all and end-all   
>>>> though. We
>>>> tried that with M1 and IMO it failed miserably. We scrambled to
>>>> implement features and ended up with a brittle codebase that  
>>>> cracked
>>>> when we needed to make significant changes. Testing focused on  
>>>> seeing
>>>> if a scenario worked and we ended up with poor coverage across the
>>>> codebase.
>>>> Instead I think we need to define additional, finer-grained  
>>>> scenarios
>>>> that cover the components of the system. For example, different  
>>>> ones
>>>> for SCA, SDO and DAS, and, digging deeper, different ones for
>>>> web-services, Spring, static SDOs, non-relational DAS and so on.
>>>> Basically, there are a lot of different scenarios for SDO on its  
>>>> own,
>>>> we don't need to matrix them all into SCA, just pick a few key ones
>>>> that help illustrate SCA concepts.
>>>> At the most detailed level, the scenarios become the unit test  
>>>> cases
>>>> for packages and individual classes.
>>>
>>> I think the purpose of scenarios is not to serve as tests, but to
>>> define required functionality in terms that are meaningful from
>>> a user perspective.
>>
>> There seems to be a range there as well. For example, "users"  
>> vary  from end-user application developers to systems extenders. I  
>> also  think scenarios may not involve users directly at all in  
>> some cases,  instead defining some kind of execution flow through  
>> the runtime.
>>
>> I've just added a scenarios page to the WIKI with some things  
>> that  are important to me at:
>>
>> http://wiki.apache.org/ws/Tuscany/TuscanyJava/Scenarios?action=show
>>
>> Hopefully you and others can add ones that are important to you  
>> and  we can work on implementing them.
>
> +1
Great, thanks for volunteering :-) Seriously, we would welcome you to  
add some scenarios to the Wiki and even help implement some.
>
>>> From the scenarios we should derive technical
>>> specifications, designs that implement those specifications, and
>>> tests that validate that the implementations match the  
>>> specifications.
>>
>>
>> This seems a bit heavy-weight for an open source project. Are you   
>> suggesting we need to have a process where people provide  
>> functional  and technical specifications? Not to be alarmist but  
>> if we required  this, I think we will find it difficult to attract  
>> developers.
>>
> the point on the story is the outcome - attracting developers is  
> definetely important, nevertheless the outcome and success will be  
> measured
> on people using it .. the easier common scenarios are - the  
> better :-) (so taking base scenarios as dev line might be a good  
> idea, and yes it's more work)
> test driven dev vs. scenario driven dev :-D
>
I'm pretty sure most people think "scenarios" are a valuable way to  
do development. I don't think they are sufficient though but that's  
another topic.  More on topic, I also don't think this is a binary  
choice between test driven and "scenario" driven development. For  
example, many agilists start with scenarios (they may call them other  
things) and then proceed to TDD.

On TDD, I think it is a matter of personal choice; sometimes I find  
it useful to write a test case prior to coding the implementation  
while other times I find it constraining. Either way, it's up to  
individuals to decide what best suits them.

Overall I take a similar approach to scenarios as I do TDD: sometimes  
it's great, other times it makes more sense just to write tests and  
code. If people want to start with scenarios, good, if people don't,  
that's fine with me too.

> This does not interfere with attracting developers at all, one this  
> the outcome from usability point of view the other is "core feature  
> dev"
>

I think we're in agreement about the value of scenarios. My question  
to Simon was whether he felt we should *require* the functional/ 
technical specification cycle commonly associated with some  
commercial software development processes.  My opinion is if someone  
wants to write those things, it may be helpful but we shouldn't  
require it.

>>> Some of the tests should validate high-level user-visible   
>>> functionality
>>> ("functional verification") and some should validate correct
>>> functioning of lower-level components according to their specified
>>> contracts ("unit tests").
>>>
>>
>>> So I see tests as different from scenarios.  Some higher-level tests
>>> will look quite similar to elements of a scenario.  Lower-level  
>>> tests
>>> won't look like scenarios, but will exercise building blocks of
>>> functionality that are needed to make the scenarios work.
>>>
>> That sounds reasonable. I usually point to this article for an   
>> approach that works well in a distributed development environment:
>>
>> http://martinfowler.com/articles/continuousIntegration.html
>>
>> Also, in core2 we have spent quite a bit of time introducing the  
>> use  of JMock to provide very granular unit testing. While test  
>> coverage  is still limited (around 50-60% overall, 300 or so  
>> tests) and we need  to do much better, it may be worth perusing  
>> some of the unit tests to  see if they fit your view of  "low- 
>> level" tests (higher-level testing  IMO should be done through an  
>> integration build as described in the  Fowler article).
>>
>>
>>>> Finally, I don't think we should define scenarios in the  
>>>> context  of M2
>>>> - we should define them in the context of what we want Tuscany  
>>>> to be.
>>>> As we implement, at some point we can say that we think we have a
>>>> useful, consistent set of features and then turn that into a  
>>>> release.
>>>> When you combine this with the refactoring into smaller pieces that
>>>> can be released separately, it will help build momentum for the
>>>> project by showing continual progress.
>>>
>>> As Sebastien said, there is LOTS to do.  This means it will take  
>>> time
>>> to get all the way to what we want Tuscany to be.  So I think it  
>>> makes
>>> sense to stage the scenarios and not try to define right now every
>>> possible part of advanced functionality that we might like to see in
>>> Tuscany some day.  Some of the initial scenarios may end up in M2  
>>> and
>>> some may not, and they should cover a progression from known use  
>>> cases
>>> that are needed to cover the basics, up to more advanced scenarios
>>> that show how SCA and Tuscany can handle more sophisticated
>>> requirements better than alternative technologies.
>>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by "Clemens Utschig - Utschig (Oracle)" <cl...@oracle.com>.
Comments linline ...

Jim Marino wrote:

>
> On Jul 2, 2006, at 2:02 PM, Simon Nash wrote:
>
>> My comments are inline below.
>>
>>   Simon
>>
>> Jeremy Boynes wrote:
>>
>>>> Jean-Sebastien Delfino wrote:
>>>> > 1. Use scenarios to drive the M2 work
>>>> > Start a community discussion on the end to end scenarios that  we 
>>>> want to
>>>> > support in M2.
>>>> >
>>>> > I'm thinking about concrete end to end scenarios that define  the 
>>>> end user
>>>> > experience and the overall story going from development, build,
>>>> > package, deploy
>>>> > to runtime and administration of an SCA application.
>>>
>>> snip
>>>
>>>> > Here are a few ideas of scenarios to initiate the discussion:
>>>> > - a scenario building your average web app with SCA
>>>> > - a scenario showing how to aggregate multiple services into  new 
>>>> ones
>>>> > - mediation and routing/exchange scenarios
>>>> > - an application using publish/subscribe
>>>> > - building a whole system of services on a network
>>>> > - integration with an AJAX UI
>>>> > - what else? any thoughts?
>>>
>>> On 6/30/06, Kevin Williams <ke...@qwest.net> wrote:
>>>
>>>> Sebastien,
>>>>
>>>> This sounds great to me.  You may have intended this but, I think  
>>>> that
>>>> the scenarios should be implemented as we go resulting in new unit
>>>> tests, samples or sample apps by the time we are ready to release  M2.
>>>>
>>>> Also, I propose a scenario that involves data access and the  
>>>> transfer of
>>>> a data graph between modules.  A source module would get the  graph 
>>>> using
>>>> the DAS and pass it to a worker module.  The graph would be  
>>>> modified by
>>>> the worker and sent back to the source module with change history  
>>>> intact
>>>> to be synchronized with the database.
>>>>
>>>> An inter-op scenario would be nice too.
>>>>
>>> One the the things that came out at the BOF at ApacheConEU was  that we
>>> are not doing a good job of communicating what SCA is all about. I
>>> think having a bunch of scenarios like this will help us do that.
>>> Another thing that came out was that it would help if we broke the
>>> distribution down into smaller pieces - for example, making SCA, SDO
>>> and DAS available as individual releases rather than bundling them  all
>>> together which gave users the false impression that they were all
>>> tightly coupled.
>>> I think we need a lot more information on each scenario though - at
>>> least to the level of detail Kevin provided. For example,
>>>
>>>> > - a scenario building your average web app with SCA
>>>
at the end it comes down to people seing the benefits (and these are not 
just core engineers) - so step by step tutorials,
and I know this is a damn amount of work usually helps for attracting 
and more over making the concepts (that should be communicated) obvious

>>> I'm not sure what "your average web app" is - are we talking JSP
>>> taglibs, working with a framework such as WebWork, or the integration
>>> with something like Spring? Are we talking about just accessing
>>> services, or both producing and consuming? Are we talking about
>>> accessing a remote service or wiring local application components  with
>>> SCA? Are we talking portable web app with Tuscany bundled, or how it
>>> works in an SCA-enabled container?
>>> I'd like to suggest we capture these on the wiki in enough detail  that
>>> a user new to the project would be able to understand what we are
>>> talking about. The scenarios can then become illustrative samples of
>>> what SCA is about and how it can be realized with Tuscany.
>>> I don't want the scenarios to become the be-all and end-all  though. We
>>> tried that with M1 and IMO it failed miserably. We scrambled to
>>> implement features and ended up with a brittle codebase that cracked
>>> when we needed to make significant changes. Testing focused on seeing
>>> if a scenario worked and we ended up with poor coverage across the
>>> codebase.
>>> Instead I think we need to define additional, finer-grained scenarios
>>> that cover the components of the system. For example, different ones
>>> for SCA, SDO and DAS, and, digging deeper, different ones for
>>> web-services, Spring, static SDOs, non-relational DAS and so on.
>>> Basically, there are a lot of different scenarios for SDO on its own,
>>> we don't need to matrix them all into SCA, just pick a few key ones
>>> that help illustrate SCA concepts.
>>> At the most detailed level, the scenarios become the unit test cases
>>> for packages and individual classes.
>>
>> I think the purpose of scenarios is not to serve as tests, but to
>> define required functionality in terms that are meaningful from
>> a user perspective.
>
> There seems to be a range there as well. For example, "users" vary  
> from end-user application developers to systems extenders. I also  
> think scenarios may not involve users directly at all in some cases,  
> instead defining some kind of execution flow through the runtime.
>
> I've just added a scenarios page to the WIKI with some things that  
> are important to me at:
>
> http://wiki.apache.org/ws/Tuscany/TuscanyJava/Scenarios?action=show
>
> Hopefully you and others can add ones that are important to you and  
> we can work on implementing them.

+1

>> From the scenarios we should derive technical
>> specifications, designs that implement those specifications, and
>> tests that validate that the implementations match the specifications.
>
>
> This seems a bit heavy-weight for an open source project. Are you  
> suggesting we need to have a process where people provide functional  
> and technical specifications? Not to be alarmist but if we required  
> this, I think we will find it difficult to attract developers.
>
the point on the story is the outcome - attracting developers is 
definetely important, nevertheless the outcome and success will be measured
on people using it .. the easier common scenarios are - the better :-) 
(so taking base scenarios as dev line might be a good idea, and yes it's 
more work)
test driven dev vs. scenario driven dev :-D

This does not interfere with attracting developers at all, one this the 
outcome from usability point of view the other is "core feature dev"

>> Some of the tests should validate high-level user-visible  functionality
>> ("functional verification") and some should validate correct
>> functioning of lower-level components according to their specified
>> contracts ("unit tests").
>>
>
>> So I see tests as different from scenarios.  Some higher-level tests
>> will look quite similar to elements of a scenario.  Lower-level tests
>> won't look like scenarios, but will exercise building blocks of
>> functionality that are needed to make the scenarios work.
>>
> That sounds reasonable. I usually point to this article for an  
> approach that works well in a distributed development environment:
>
> http://martinfowler.com/articles/continuousIntegration.html
>
> Also, in core2 we have spent quite a bit of time introducing the use  
> of JMock to provide very granular unit testing. While test coverage  
> is still limited (around 50-60% overall, 300 or so tests) and we need  
> to do much better, it may be worth perusing some of the unit tests to  
> see if they fit your view of  "low-level" tests (higher-level testing  
> IMO should be done through an integration build as described in the  
> Fowler article).
>
>
>>> Finally, I don't think we should define scenarios in the context  of M2
>>> - we should define them in the context of what we want Tuscany to be.
>>> As we implement, at some point we can say that we think we have a
>>> useful, consistent set of features and then turn that into a release.
>>> When you combine this with the refactoring into smaller pieces that
>>> can be released separately, it will help build momentum for the
>>> project by showing continual progress.
>>
>> As Sebastien said, there is LOTS to do.  This means it will take time
>> to get all the way to what we want Tuscany to be.  So I think it makes
>> sense to stage the scenarios and not try to define right now every
>> possible part of advanced functionality that we might like to see in
>> Tuscany some day.  Some of the initial scenarios may end up in M2 and
>> some may not, and they should cover a progression from known use cases
>> that are needed to cover the basics, up to more advanced scenarios
>> that show how SCA and Tuscany can handle more sophisticated
>> requirements better than alternative technologies.
>

---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Simon Nash <na...@hursley.ibm.com>.
Jim,
Comments inline below.

   Simon

Jim Marino wrote:

> 
> On Jul 3, 2006, at 2:57 PM, Simon Nash wrote:
> 
>> Jim Marino wrote:
>>
>> <cut/>
>>
>>>> From the scenarios we should derive technical
>>>> specifications, designs that implement those specifications, and
>>>> tests that validate that the implementations match the  specifications.
>>>
>>> This seems a bit heavy-weight for an open source project. Are you   
>>> suggesting we need to have a process where people provide  
>>> functional  and technical specifications? Not to be alarmist but  if 
>>> we required  this, I think we will find it difficult to attract  
>>> developers.
>>
>> I did not mean that we would necessarily produce formal specification
>> documents.  However, there should be specifications in the sense of a
>> clear intention for what the code is supposed to do, whether explicit
>> or implicit, formal or informal, recorded possibly in formal documents
>> or possibly in posts to the mailing list, or even just contained in
>> people's heads.
> 
> Thanks for clarifying. FWIW, I find unit tests a good way to guard  
> against "pointless code" since it forces me to think about the  
> intention of a unit of code and limit its scope. I think we should  
> stress this across the code base. In peoples' heads does not sound  very 
> useful to me (I assume you agree) since it is difficult to share
> 
In people's heads is less than ideal but I wouldn't reject this out
of hand, especially if they are willing to write it down later.
I'd dare to suggest that good code with a good specification in
someone's head is preferable to average or poor code with a
specification that is written down.

Unit tests are goood as well but I believe their main purpose is to
verify that the code matches the specification, rather than serving
as the specification itself.

>>
>> There is code with *NO* specification of any kind, written "ad hoc"
>> with no clear idea of what it is meant to achieve, but just does what
>> it does.  I don't think we would really want that kind of code to be
>> part of Tuscany :-)
> 
> Yes I would hope all of us agree on that!
> 
>>
>>   Simon
>> -- 
>> Simon C Nash   IBM Distinguished Engineer
>> Hursley Park, Winchester, UK   nash@hursley.ibm.com
>> Tel. +44-1962-815156   Fax +44-1962-818999
>>
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>>
> 
> 
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
> 
> 
> 

-- 
Simon C Nash   IBM Distinguished Engineer
Hursley Park, Winchester, UK   nash@hursley.ibm.com
Tel. +44-1962-815156   Fax +44-1962-818999


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
On Jul 3, 2006, at 2:57 PM, Simon Nash wrote:

> Jim Marino wrote:
>
> <cut/>
>>> From the scenarios we should derive technical
>>> specifications, designs that implement those specifications, and
>>> tests that validate that the implementations match the  
>>> specifications.
>> This seems a bit heavy-weight for an open source project. Are you   
>> suggesting we need to have a process where people provide  
>> functional  and technical specifications? Not to be alarmist but  
>> if we required  this, I think we will find it difficult to attract  
>> developers.
> I did not mean that we would necessarily produce formal specification
> documents.  However, there should be specifications in the sense of a
> clear intention for what the code is supposed to do, whether explicit
> or implicit, formal or informal, recorded possibly in formal documents
> or possibly in posts to the mailing list, or even just contained in
> people's heads.
Thanks for clarifying. FWIW, I find unit tests a good way to guard  
against "pointless code" since it forces me to think about the  
intention of a unit of code and limit its scope. I think we should  
stress this across the code base. In peoples' heads does not sound  
very useful to me (I assume you agree) since it is difficult to share
>
> There is code with *NO* specification of any kind, written "ad hoc"
> with no clear idea of what it is meant to achieve, but just does what
> it does.  I don't think we would really want that kind of code to be
> part of Tuscany :-)
Yes I would hope all of us agree on that!
>
>   Simon
> -- 
> Simon C Nash   IBM Distinguished Engineer
> Hursley Park, Winchester, UK   nash@hursley.ibm.com
> Tel. +44-1962-815156   Fax +44-1962-818999
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Simon Nash <na...@hursley.ibm.com>.
Jim Marino wrote:

<cut/>
> 
>> From the scenarios we should derive technical
>> specifications, designs that implement those specifications, and
>> tests that validate that the implementations match the specifications.
> 
> 
> This seems a bit heavy-weight for an open source project. Are you  
> suggesting we need to have a process where people provide functional  
> and technical specifications? Not to be alarmist but if we required  
> this, I think we will find it difficult to attract developers.
> 
I did not mean that we would necessarily produce formal specification
documents.  However, there should be specifications in the sense of a
clear intention for what the code is supposed to do, whether explicit
or implicit, formal or informal, recorded possibly in formal documents
or possibly in posts to the mailing list, or even just contained in
people's heads.

There is code with *NO* specification of any kind, written "ad hoc"
with no clear idea of what it is meant to achieve, but just does what
it does.  I don't think we would really want that kind of code to be
part of Tuscany :-)

   Simon
-- 
Simon C Nash   IBM Distinguished Engineer
Hursley Park, Winchester, UK   nash@hursley.ibm.com
Tel. +44-1962-815156   Fax +44-1962-818999


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
On Jul 2, 2006, at 2:02 PM, Simon Nash wrote:

> My comments are inline below.
>
>   Simon
>
> Jeremy Boynes wrote:
>
>>> Jean-Sebastien Delfino wrote:
>>> > 1. Use scenarios to drive the M2 work
>>> > Start a community discussion on the end to end scenarios that  
>>> we want to
>>> > support in M2.
>>> >
>>> > I'm thinking about concrete end to end scenarios that define  
>>> the end user
>>> > experience and the overall story going from development, build,
>>> > package, deploy
>>> > to runtime and administration of an SCA application.
>> snip
>>> > Here are a few ideas of scenarios to initiate the discussion:
>>> > - a scenario building your average web app with SCA
>>> > - a scenario showing how to aggregate multiple services into  
>>> new ones
>>> > - mediation and routing/exchange scenarios
>>> > - an application using publish/subscribe
>>> > - building a whole system of services on a network
>>> > - integration with an AJAX UI
>>> > - what else? any thoughts?
>> On 6/30/06, Kevin Williams <ke...@qwest.net> wrote:
>>> Sebastien,
>>>
>>> This sounds great to me.  You may have intended this but, I think  
>>> that
>>> the scenarios should be implemented as we go resulting in new unit
>>> tests, samples or sample apps by the time we are ready to release  
>>> M2.
>>>
>>> Also, I propose a scenario that involves data access and the  
>>> transfer of
>>> a data graph between modules.  A source module would get the  
>>> graph using
>>> the DAS and pass it to a worker module.  The graph would be  
>>> modified by
>>> the worker and sent back to the source module with change history  
>>> intact
>>> to be synchronized with the database.
>>>
>>> An inter-op scenario would be nice too.
>>>
>> One the the things that came out at the BOF at ApacheConEU was  
>> that we
>> are not doing a good job of communicating what SCA is all about. I
>> think having a bunch of scenarios like this will help us do that.
>> Another thing that came out was that it would help if we broke the
>> distribution down into smaller pieces - for example, making SCA, SDO
>> and DAS available as individual releases rather than bundling them  
>> all
>> together which gave users the false impression that they were all
>> tightly coupled.
>> I think we need a lot more information on each scenario though - at
>> least to the level of detail Kevin provided. For example,
>>> > - a scenario building your average web app with SCA
>> I'm not sure what "your average web app" is - are we talking JSP
>> taglibs, working with a framework such as WebWork, or the integration
>> with something like Spring? Are we talking about just accessing
>> services, or both producing and consuming? Are we talking about
>> accessing a remote service or wiring local application components  
>> with
>> SCA? Are we talking portable web app with Tuscany bundled, or how it
>> works in an SCA-enabled container?
>> I'd like to suggest we capture these on the wiki in enough detail  
>> that
>> a user new to the project would be able to understand what we are
>> talking about. The scenarios can then become illustrative samples of
>> what SCA is about and how it can be realized with Tuscany.
>> I don't want the scenarios to become the be-all and end-all  
>> though. We
>> tried that with M1 and IMO it failed miserably. We scrambled to
>> implement features and ended up with a brittle codebase that cracked
>> when we needed to make significant changes. Testing focused on seeing
>> if a scenario worked and we ended up with poor coverage across the
>> codebase.
>> Instead I think we need to define additional, finer-grained scenarios
>> that cover the components of the system. For example, different ones
>> for SCA, SDO and DAS, and, digging deeper, different ones for
>> web-services, Spring, static SDOs, non-relational DAS and so on.
>> Basically, there are a lot of different scenarios for SDO on its own,
>> we don't need to matrix them all into SCA, just pick a few key ones
>> that help illustrate SCA concepts.
>> At the most detailed level, the scenarios become the unit test cases
>> for packages and individual classes.
> I think the purpose of scenarios is not to serve as tests, but to
> define required functionality in terms that are meaningful from
> a user perspective.
There seems to be a range there as well. For example, "users" vary  
from end-user application developers to systems extenders. I also  
think scenarios may not involve users directly at all in some cases,  
instead defining some kind of execution flow through the runtime.

I've just added a scenarios page to the WIKI with some things that  
are important to me at:

http://wiki.apache.org/ws/Tuscany/TuscanyJava/Scenarios?action=show

Hopefully you and others can add ones that are important to you and  
we can work on implementing them.

> From the scenarios we should derive technical
> specifications, designs that implement those specifications, and
> tests that validate that the implementations match the specifications.

This seems a bit heavy-weight for an open source project. Are you  
suggesting we need to have a process where people provide functional  
and technical specifications? Not to be alarmist but if we required  
this, I think we will find it difficult to attract developers.

> Some of the tests should validate high-level user-visible  
> functionality
> ("functional verification") and some should validate correct
> functioning of lower-level components according to their specified
> contracts ("unit tests").
>

> So I see tests as different from scenarios.  Some higher-level tests
> will look quite similar to elements of a scenario.  Lower-level tests
> won't look like scenarios, but will exercise building blocks of
> functionality that are needed to make the scenarios work.
>
That sounds reasonable. I usually point to this article for an  
approach that works well in a distributed development environment:

http://martinfowler.com/articles/continuousIntegration.html

Also, in core2 we have spent quite a bit of time introducing the use  
of JMock to provide very granular unit testing. While test coverage  
is still limited (around 50-60% overall, 300 or so tests) and we need  
to do much better, it may be worth perusing some of the unit tests to  
see if they fit your view of  "low-level" tests (higher-level testing  
IMO should be done through an integration build as described in the  
Fowler article).


>> Finally, I don't think we should define scenarios in the context  
>> of M2
>> - we should define them in the context of what we want Tuscany to be.
>> As we implement, at some point we can say that we think we have a
>> useful, consistent set of features and then turn that into a release.
>> When you combine this with the refactoring into smaller pieces that
>> can be released separately, it will help build momentum for the
>> project by showing continual progress.
> As Sebastien said, there is LOTS to do.  This means it will take time
> to get all the way to what we want Tuscany to be.  So I think it makes
> sense to stage the scenarios and not try to define right now every
> possible part of advanced functionality that we might like to see in
> Tuscany some day.  Some of the initial scenarios may end up in M2 and
> some may not, and they should cover a progression from known use cases
> that are needed to cover the basics, up to more advanced scenarios
> that show how SCA and Tuscany can handle more sophisticated
> requirements better than alternative technologies.
>
>> -- 
>> Jeremy
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>
> -- 
> Simon C Nash   IBM Distinguished Engineer
> Hursley Park, Winchester, UK   nash@hursley.ibm.com
> Tel. +44-1962-815156   Fax +44-1962-818999
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
On Jul 4, 2006, at 1:11 PM, Simon Nash wrote:

> I think releasing every 4-6 weeks is probably a bit too often.
> Most users won't want to upgrade so frequently, especially at
> this stage of an incubator project when new releases may be a bit
> unstable.
At this stage I think we need to have small, incremental releases to  
gain momentum, and more importantly, to get features out that  
demonstrate the value of Tuscany and attract developers to it. Most  
users are bleeding edge people right now so I don't think upgrading  
will be an issue. End-users who need to build real, production-ready  
applications shouldn't be using Tuscany at this point (they also  
shouldn't be using SCA at this stage as the specifications have not  
been stabilized). Also, I have found people that deal with open  
source software, particularly the developer community we are  
primarily concerned with (see my comments below), are used to and  
want frequent upgrades.

> Another factor is the overhead involved in cutting a
> release.  On balance I'd suggest releasing every 2 months would be
> reasonable timing, with a release closedown cycle starting perhaps
> 2-3 weeks before the release goes out.
>
Part of the overhead was due to the fact that we tried to roll  
everything together (including SDO and DAS) and it was the our first  
time. If we modularize, while we will still have some overhead (e.g.  
voting), 4-6 week release cycles seem reasonable to me. I'm not  
saying *everything* should be released at the same time or at that  
pace. We should be modular enough to break out releases. Also, if a  
module does not change much, it does not need to be released that  
frequently. However, two month time frames with a 2-3 week feature  
freeze sounds a bit long but it's not that far off from 4-6 weeks (a  
feature freeze of three weeks is a bit lengthy though).

> I think there's value in forward planning for release content.
> Our scenarios should provide a basis for deciding what new function
> is most needed in the next release, and maybe even thinking a bit
> further ahead ("pencilled in" rather than a firm commitment or plan).
> For major pieces of functionality, it is likely that forward planning
> will be needed to get a realistic idea of what can be fitted into
> each release.

While I have no problem with lightweight planning, coordination, etc.  
I don't think we can or should project manage our release cycle  
according to dates (which are different than "timeframes"). I'm not  
sure if you are arguing for that, but I throw it out for discussion  
anyway. We're dealing with volunteers, not resources under our  
control. I'd rather use the scenarios as a roadmap and when we arrive  
at a functional state we believe worthy for release, enter into a  
ramp down period. Of course we can have timeframes and goals for the  
release, but IMO it would be wrong to over-manage the project by  
instituting a release schedule pegged to specific dates.

> Other items that are smaller or less critical to our
> users (don't forget that these are the audience for our releases) can
> be accomodated with a lot less in the way of pre-planning.
>
I think the way people deal with features that are really important  
is to make sure they are implemented. What is important to you may or  
may not be important to me. We can both get what we want by doing the  
work to implement them - and I may even help you with yours because  
you are a nice guy ;-) My point is while there may be some features  
everyone agrees on that are important, there will be others that are  
important to only a particular segment. We need to be able to  
accommodate and encourage this diversity.

One other point is I don't think end-users are our primary audience,  
although they are an important constituency. I'd say we are the most  
important audience, in other words, the Tuscany developer community.

>   Simon
>
> Jim Marino wrote:
>
>> On Jul 3, 2006, at 11:31 PM, ant elder wrote:
>>> On 7/3/06, Jim Marino <jm...@myromatours.com> wrote:
>>>
>>>>
>>>> ...and involve a lot less "upfront planning"?
>>>> In other words, people work on what interests them and the  
>>>> community
>>>> cuts a release when it decides a useful level of new functionality
>>>> has been reached.
>>>
>>>
>>>
>>> Can you provide pointers to any other Apache projects that work   
>>> like this?
>>> I've never seen any other project of significant size, open  
>>> source or
>>> otherwise, work like that.
>>>
>>> There's three main problems I see with the 'do whatever you  
>>> like'  approach.
>>>
>> Please read my words carefully:
>> - I wrote, "a lot less 'upfront planning'" as opposed to "no  
>> upfront  planning". I'm not an anarchist :-)
>> - The rest of the passage was also important in this respect:   
>> "Practically, people should just detail the scenarios and  
>> features  that they think are interesting on the wiki, through  
>> email, etc. and  work on implementing them". By *documenting* what  
>> interests people in  some way (we should be flexible here),  
>> letting people work on those  features, and then deciding at quick  
>> intervals (4-6 weeks) when to  cut a release sounds pretty  
>> reasonable to me. The "lightweight"  planning part comes in with  
>> the documenting of interests and then the  decision process to  
>> have a release.
>> Of course, there is the waterfall approach commonly associated  
>> with  commercial software development. I don't think this works  
>> well in  many open source environments for a variety of reasons  
>> that I won't  go into as they are off topic.
>> In terms of open source projects, I think you will find this type  
>> of  "lightweight" planning happening in a lot of projects. For  
>> example,  AspectWerkz operated very successfully this way as does  
>> Spring  (although they are taking a little longer for releases,  
>> probably due  to the maturity of the project). I think you will  
>> find some Apache  projects as well...
>>> With no clear goals, direction, or coordination we wont end up  
>>> with  anything
>>> very useful that fits together and works in an elegant and  
>>> seamless  way.
>> I probably could have gone into more detail on my thinking around   
>> release cycles, but it should be patently clear that I was not   
>> advocating an agenda of no goals and no coordination. I assume  
>> you  did notice that I have been spending a lot of time creating  
>> scenarios  on the wiki? It is also the subject of the current  
>> thread. Hyperbole  in my opinion doesn't really move the community  
>> forward.
>> I believe scenarios are an excellent way to form a basis for   
>> coordination and bring the community together. My point was that  
>> by  having people detail what interests them, others join in and  
>> a  consensus emerges when certain scenarios gain momentum. I find  
>> this  to be a nice balance between the interests of large group as  
>> well as  smaller pockets of one or two individuals. Under this  
>> system, one or  two people can make a difference since they are  
>> free to implement  features they feel strongly about (assuming  
>> they are aligned with the  project charter).
>>> No
>>> one will do the boring work - documentation, testing,  
>>> uninteresting  bugs in
>>> JIRAs, etc.
>> That's why we have coding standards. I have been one of the   
>> staunchest advocates of unit testing, documentation, etc. as you  
>> are  aware.
>>> And it will be hard to grow the community.
>>>
>> Modularity, scenarios and having a positive environment which   
>> encourages people to work on what interests them are all great  
>> ways  to grow a community.
>>> Over the past months I've been trying to get new people to come   
>>> participate
>>> in Tuscany and they all complain about no roadmap of what we  
>>> trying to
>>> achieve, no wish list of wanted function, and no plan of whats   
>>> coming up in
>>> the next few milestones.
>> In the past we had "roadmaps" here:
>> http://wiki.apache.org/ws/Tuscany/TuscanyJava/Tasks
>> http://wiki.apache.org/ws/Tuscany/TuscanyJava/Roadmap
>> There is, however, a general issue related to the SCA specs and   
>> Tuscany of what the value adds are. I have been working with  
>> others  in the spec group to help fix this from the braoder SCA  
>> perspective.
>> In terms of Tuscany, I would suggest we as a community do  
>> likewise.  To me, that starts with actions of individuals. Could  
>> you please  begin by posting your "wish list" of wanted function  
>> somewhere? I  think it would be great to do this as scenarios but  
>> emails to the  list will do.
>>> Yes we need to encourage new people to come
>>> contribute whatever function they think is useful regardless of  
>>> if  or where
>>> we had that function in our plans, but surely the main  
>>> development  team need
>>> to have a bit more focus and coordination if we're to create   
>>> something very
>>> useful.
>>>
>>>   ...ant
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>
> -- 
> Simon C Nash   IBM Distinguished Engineer
> Hursley Park, Winchester, UK   nash@hursley.ibm.com
> Tel. +44-1962-815156   Fax +44-1962-818999
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Simon Nash <na...@hursley.ibm.com>.
I think releasing every 4-6 weeks is probably a bit too often.
Most users won't want to upgrade so frequently, especially at
this stage of an incubator project when new releases may be a bit
unstable.  Another factor is the overhead involved in cutting a
release.  On balance I'd suggest releasing every 2 months would be
reasonable timing, with a release closedown cycle starting perhaps
2-3 weeks before the release goes out.

I think there's value in forward planning for release content.
Our scenarios should provide a basis for deciding what new function
is most needed in the next release, and maybe even thinking a bit
further ahead ("pencilled in" rather than a firm commitment or plan).
For major pieces of functionality, it is likely that forward planning
will be needed to get a realistic idea of what can be fitted into
each release.  Other items that are smaller or less critical to our
users (don't forget that these are the audience for our releases) can
be accomodated with a lot less in the way of pre-planning.

   Simon

Jim Marino wrote:

> 
> On Jul 3, 2006, at 11:31 PM, ant elder wrote:
> 
>> On 7/3/06, Jim Marino <jm...@myromatours.com> wrote:
>>
>>>
>>> ...and involve a lot less "upfront planning"?
>>> In other words, people work on what interests them and the community
>>> cuts a release when it decides a useful level of new functionality
>>> has been reached.
>>
>>
>>
>> Can you provide pointers to any other Apache projects that work  like 
>> this?
>> I've never seen any other project of significant size, open source or
>> otherwise, work like that.
>>
>> There's three main problems I see with the 'do whatever you like'  
>> approach.
>>
> Please read my words carefully:
> 
> - I wrote, "a lot less 'upfront planning'" as opposed to "no upfront  
> planning". I'm not an anarchist :-)
> 
> - The rest of the passage was also important in this respect:  
> "Practically, people should just detail the scenarios and features  that 
> they think are interesting on the wiki, through email, etc. and  work on 
> implementing them". By *documenting* what interests people in  some way 
> (we should be flexible here), letting people work on those  features, 
> and then deciding at quick intervals (4-6 weeks) when to  cut a release 
> sounds pretty reasonable to me. The "lightweight"  planning part comes 
> in with the documenting of interests and then the  decision process to 
> have a release.
> 
> Of course, there is the waterfall approach commonly associated with  
> commercial software development. I don't think this works well in  many 
> open source environments for a variety of reasons that I won't  go into 
> as they are off topic.
> 
> In terms of open source projects, I think you will find this type of  
> "lightweight" planning happening in a lot of projects. For example,  
> AspectWerkz operated very successfully this way as does Spring  
> (although they are taking a little longer for releases, probably due  to 
> the maturity of the project). I think you will find some Apache  
> projects as well...
> 
> 
>> With no clear goals, direction, or coordination we wont end up with  
>> anything
>> very useful that fits together and works in an elegant and seamless  way.
> 
> 
> I probably could have gone into more detail on my thinking around  
> release cycles, but it should be patently clear that I was not  
> advocating an agenda of no goals and no coordination. I assume you  did 
> notice that I have been spending a lot of time creating scenarios  on 
> the wiki? It is also the subject of the current thread. Hyperbole  in my 
> opinion doesn't really move the community forward.
> 
> I believe scenarios are an excellent way to form a basis for  
> coordination and bring the community together. My point was that by  
> having people detail what interests them, others join in and a  
> consensus emerges when certain scenarios gain momentum. I find this  to 
> be a nice balance between the interests of large group as well as  
> smaller pockets of one or two individuals. Under this system, one or  
> two people can make a difference since they are free to implement  
> features they feel strongly about (assuming they are aligned with the  
> project charter).
> 
>> No
>> one will do the boring work - documentation, testing, uninteresting  
>> bugs in
>> JIRAs, etc.
> 
> 
> That's why we have coding standards. I have been one of the  staunchest 
> advocates of unit testing, documentation, etc. as you are  aware.
> 
>> And it will be hard to grow the community.
>>
> 
> Modularity, scenarios and having a positive environment which  
> encourages people to work on what interests them are all great ways  to 
> grow a community.
> 
>> Over the past months I've been trying to get new people to come  
>> participate
>> in Tuscany and they all complain about no roadmap of what we trying to
>> achieve, no wish list of wanted function, and no plan of whats  coming 
>> up in
>> the next few milestones.
> 
> 
> In the past we had "roadmaps" here:
> 
> http://wiki.apache.org/ws/Tuscany/TuscanyJava/Tasks
> http://wiki.apache.org/ws/Tuscany/TuscanyJava/Roadmap
> 
> There is, however, a general issue related to the SCA specs and  Tuscany 
> of what the value adds are. I have been working with others  in the spec 
> group to help fix this from the braoder SCA perspective.
> 
> In terms of Tuscany, I would suggest we as a community do likewise.  To 
> me, that starts with actions of individuals. Could you please  begin by 
> posting your "wish list" of wanted function somewhere? I  think it would 
> be great to do this as scenarios but emails to the  list will do.
> 
>> Yes we need to encourage new people to come
>> contribute whatever function they think is useful regardless of if  or 
>> where
>> we had that function in our plans, but surely the main development  
>> team need
>> to have a bit more focus and coordination if we're to create  
>> something very
>> useful.
>>
>>   ...ant
> 
> 
> 
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
> 
> 
> 

-- 
Simon C Nash   IBM Distinguished Engineer
Hursley Park, Winchester, UK   nash@hursley.ibm.com
Tel. +44-1962-815156   Fax +44-1962-818999


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
On Jul 3, 2006, at 11:31 PM, ant elder wrote:

> On 7/3/06, Jim Marino <jm...@myromatours.com> wrote:
>>
>> ...and involve a lot less "upfront planning"?
>> In other words, people work on what interests them and the community
>> cuts a release when it decides a useful level of new functionality
>> has been reached.
>
>
> Can you provide pointers to any other Apache projects that work  
> like this?
> I've never seen any other project of significant size, open source or
> otherwise, work like that.
>
> There's three main problems I see with the 'do whatever you like'  
> approach.
>
Please read my words carefully:

- I wrote, "a lot less 'upfront planning'" as opposed to "no upfront  
planning". I'm not an anarchist :-)

- The rest of the passage was also important in this respect:  
"Practically, people should just detail the scenarios and features  
that they think are interesting on the wiki, through email, etc. and  
work on implementing them". By *documenting* what interests people in  
some way (we should be flexible here), letting people work on those  
features, and then deciding at quick intervals (4-6 weeks) when to  
cut a release sounds pretty reasonable to me. The "lightweight"  
planning part comes in with the documenting of interests and then the  
decision process to have a release.

Of course, there is the waterfall approach commonly associated with  
commercial software development. I don't think this works well in  
many open source environments for a variety of reasons that I won't  
go into as they are off topic.

In terms of open source projects, I think you will find this type of  
"lightweight" planning happening in a lot of projects. For example,  
AspectWerkz operated very successfully this way as does Spring  
(although they are taking a little longer for releases, probably due  
to the maturity of the project). I think you will find some Apache  
projects as well...


> With no clear goals, direction, or coordination we wont end up with  
> anything
> very useful that fits together and works in an elegant and seamless  
> way.

I probably could have gone into more detail on my thinking around  
release cycles, but it should be patently clear that I was not  
advocating an agenda of no goals and no coordination. I assume you  
did notice that I have been spending a lot of time creating scenarios  
on the wiki? It is also the subject of the current thread. Hyperbole  
in my opinion doesn't really move the community forward.

I believe scenarios are an excellent way to form a basis for  
coordination and bring the community together. My point was that by  
having people detail what interests them, others join in and a  
consensus emerges when certain scenarios gain momentum. I find this  
to be a nice balance between the interests of large group as well as  
smaller pockets of one or two individuals. Under this system, one or  
two people can make a difference since they are free to implement  
features they feel strongly about (assuming they are aligned with the  
project charter).

> No
> one will do the boring work - documentation, testing, uninteresting  
> bugs in
> JIRAs, etc.

That's why we have coding standards. I have been one of the  
staunchest advocates of unit testing, documentation, etc. as you are  
aware.

> And it will be hard to grow the community.
>

Modularity, scenarios and having a positive environment which  
encourages people to work on what interests them are all great ways  
to grow a community.

> Over the past months I've been trying to get new people to come  
> participate
> in Tuscany and they all complain about no roadmap of what we trying to
> achieve, no wish list of wanted function, and no plan of whats  
> coming up in
> the next few milestones.

In the past we had "roadmaps" here:

http://wiki.apache.org/ws/Tuscany/TuscanyJava/Tasks
http://wiki.apache.org/ws/Tuscany/TuscanyJava/Roadmap

There is, however, a general issue related to the SCA specs and  
Tuscany of what the value adds are. I have been working with others  
in the spec group to help fix this from the braoder SCA perspective.

In terms of Tuscany, I would suggest we as a community do likewise.  
To me, that starts with actions of individuals. Could you please  
begin by posting your "wish list" of wanted function somewhere? I  
think it would be great to do this as scenarios but emails to the  
list will do.

> Yes we need to encourage new people to come
> contribute whatever function they think is useful regardless of if  
> or where
> we had that function in our plans, but surely the main development  
> team need
> to have a bit more focus and coordination if we're to create  
> something very
> useful.
>
>   ...ant


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by ant elder <an...@gmail.com>.
On 7/3/06, Jim Marino <jm...@myromatours.com> wrote:
>
> ...and involve a lot less "upfront planning"?
> In other words, people work on what interests them and the community
> cuts a release when it decides a useful level of new functionality
> has been reached.


Can you provide pointers to any other Apache projects that work like this?
I've never seen any other project of significant size, open source or
otherwise, work like that.

There's three main problems I see with the 'do whatever you like' approach.
With no clear goals, direction, or coordination we wont end up with anything
very useful that fits together and works in an elegant and seamless way. No
one will do the boring work - documentation, testing, uninteresting bugs in
JIRAs, etc. And it will be hard to grow the community.

Over the past months I've been trying to get new people to come participate
in Tuscany and they all complain about no roadmap of what we trying to
achieve, no wish list of wanted function, and no plan of whats coming up in
the next few milestones. Yes we need to encourage new people to come
contribute whatever function they think is useful regardless of if or where
we had that function in our plans, but surely the main development team need
to have a bit more focus and coordination if we're to create something very
useful.

   ...ant

Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
On Jul 3, 2006, at 3:08 PM, Simon Nash wrote:

> Jim Marino wrote:
>
> <cut/>
>>> Some of the initial scenarios may end up in M2 and
>> I'm a bit worried that this will discourage people from working  
>> on  something important to them because it is not slated for a   
>> predetermined milestone. For example, if someone wanted to work on  
>> a  feature that was not part of some milestone, would they be  
>> allowed to  check the feature into head? Again, I think we need to  
>> be flexible  about "milestones" and releases.
>> Also, this process of deciding what "ends up" in a milestone may   
>> result in a "tyranny of the majority"  (it's close to July 4th so  
>> I  have to allude to de Tocqueville :-) ) where a really  
>> innovative  feature is stifled because it does not fit into a set  
>> of release  criteria determined by the many.
> I was not suggesting that scenarios should be tagged from the start as
> targeted for some particular release.  I expect that the scenarios
> supported by a release would be decided quite close to when that  
> release
> enters the phase of being closed down and delivered.
So it sounds as if you may be saying something similar to Jeremy and  
I regarding release cycles, i.e. that they should be modular, short  
in duration (4-6 weeks), and involve a lot less "upfront planning"?  
In other words, people work on what interests them and the community  
cuts a release when it decides a useful level of new functionality  
has been reached. Practically, people should just detail the  
scenarios and features that they think are interesting on the wiki,  
through email, etc. and work on implementing them, whatever the may  
be, as long as they are consistent with the project charter. When we  
think we have sufficient functionality in a discrete area, we release  
it as a "module". Modules may also have their own release cycle.

My concern above was that we would err on the side of providing too  
much "upfront direction" as opposed to just letting people work on  
what interests them and allowing innovation to grow organically.

> And I have no
> problem with code going into head that targets a more advanced
> feature that won't be fully supported until a later release, as long
> as this code doesn't cause any problems for the upcoming release.
>
>   Simon
> -- 
> Simon C Nash   IBM Distinguished Engineer
> Hursley Park, Winchester, UK   nash@hursley.ibm.com
> Tel. +44-1962-815156   Fax +44-1962-818999
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Simon Nash <na...@hursley.ibm.com>.
Jim Marino wrote:

<cut/>
>> Some of the initial scenarios may end up in M2 and
> 
> 
> I'm a bit worried that this will discourage people from working on  
> something important to them because it is not slated for a  
> predetermined milestone. For example, if someone wanted to work on a  
> feature that was not part of some milestone, would they be allowed to  
> check the feature into head? Again, I think we need to be flexible  
> about "milestones" and releases.
> 
> Also, this process of deciding what "ends up" in a milestone may  result 
> in a "tyranny of the majority"  (it's close to July 4th so I  have to 
> allude to de Tocqueville :-) ) where a really innovative  feature is 
> stifled because it does not fit into a set of release  criteria 
> determined by the many.
> 
I was not suggesting that scenarios should be tagged from the start as
targeted for some particular release.  I expect that the scenarios
supported by a release would be decided quite close to when that release
enters the phase of being closed down and delivered.  And I have no
problem with code going into head that targets a more advanced
feature that won't be fully supported until a later release, as long
as this code doesn't cause any problems for the upcoming release.

   Simon
-- 
Simon C Nash   IBM Distinguished Engineer
Hursley Park, Winchester, UK   nash@hursley.ibm.com
Tel. +44-1962-815156   Fax +44-1962-818999


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Jim Marino <jm...@myromatours.com>.
More comments inline...

On Jul 2, 2006, at 2:02 PM, Simon Nash wrote:

> My comments are inline below.
>
>   Simon
>
> Jeremy Boynes wrote:
>
>>> Jean-Sebastien Delfino wrote:
>>> > 1. Use scenarios to drive the M2 work
>>> > Start a community discussion on the end to end scenarios that  
>>> we want to
>>> > support in M2.
>>> >
>>> > I'm thinking about concrete end to end scenarios that define  
>>> the end user
>>> > experience and the overall story going from development, build,
>>> > package, deploy
>>> > to runtime and administration of an SCA application.
>> snip
>>> > Here are a few ideas of scenarios to initiate the discussion:
>>> > - a scenario building your average web app with SCA
>>> > - a scenario showing how to aggregate multiple services into  
>>> new ones
>>> > - mediation and routing/exchange scenarios
>>> > - an application using publish/subscribe
>>> > - building a whole system of services on a network
>>> > - integration with an AJAX UI
>>> > - what else? any thoughts?
>> On 6/30/06, Kevin Williams <ke...@qwest.net> wrote:
>>> Sebastien,
>>>
>>> This sounds great to me.  You may have intended this but, I think  
>>> that
>>> the scenarios should be implemented as we go resulting in new unit
>>> tests, samples or sample apps by the time we are ready to release  
>>> M2.
>>>
>>> Also, I propose a scenario that involves data access and the  
>>> transfer of
>>> a data graph between modules.  A source module would get the  
>>> graph using
>>> the DAS and pass it to a worker module.  The graph would be  
>>> modified by
>>> the worker and sent back to the source module with change history  
>>> intact
>>> to be synchronized with the database.
>>>
>>> An inter-op scenario would be nice too.
>>>
>> One the the things that came out at the BOF at ApacheConEU was  
>> that we
>> are not doing a good job of communicating what SCA is all about. I
>> think having a bunch of scenarios like this will help us do that.
>> Another thing that came out was that it would help if we broke the
>> distribution down into smaller pieces - for example, making SCA, SDO
>> and DAS available as individual releases rather than bundling them  
>> all
>> together which gave users the false impression that they were all
>> tightly coupled.
>> I think we need a lot more information on each scenario though - at
>> least to the level of detail Kevin provided. For example,
>>> > - a scenario building your average web app with SCA
>> I'm not sure what "your average web app" is - are we talking JSP
>> taglibs, working with a framework such as WebWork, or the integration
>> with something like Spring? Are we talking about just accessing
>> services, or both producing and consuming? Are we talking about
>> accessing a remote service or wiring local application components  
>> with
>> SCA? Are we talking portable web app with Tuscany bundled, or how it
>> works in an SCA-enabled container?
>> I'd like to suggest we capture these on the wiki in enough detail  
>> that
>> a user new to the project would be able to understand what we are
>> talking about. The scenarios can then become illustrative samples of
>> what SCA is about and how it can be realized with Tuscany.
>> I don't want the scenarios to become the be-all and end-all  
>> though. We
>> tried that with M1 and IMO it failed miserably. We scrambled to
>> implement features and ended up with a brittle codebase that cracked
>> when we needed to make significant changes. Testing focused on seeing
>> if a scenario worked and we ended up with poor coverage across the
>> codebase.
>> Instead I think we need to define additional, finer-grained scenarios
>> that cover the components of the system. For example, different ones
>> for SCA, SDO and DAS, and, digging deeper, different ones for
>> web-services, Spring, static SDOs, non-relational DAS and so on.
>> Basically, there are a lot of different scenarios for SDO on its own,
>> we don't need to matrix them all into SCA, just pick a few key ones
>> that help illustrate SCA concepts.
>> At the most detailed level, the scenarios become the unit test cases
>> for packages and individual classes.
> I think the purpose of scenarios is not to serve as tests, but to
> define required functionality in terms that are meaningful from
> a user perspective.  From the scenarios we should derive technical
> specifications, designs that implement those specifications, and
> tests that validate that the implementations match the specifications.
> Some of the tests should validate high-level user-visible  
> functionality
> ("functional verification") and some should validate correct
> functioning of lower-level components according to their specified
> contracts ("unit tests").
>
> So I see tests as different from scenarios.  Some higher-level tests
> will look quite similar to elements of a scenario.  Lower-level tests
> won't look like scenarios, but will exercise building blocks of
> functionality that are needed to make the scenarios work.
>
>> Finally, I don't think we should define scenarios in the context  
>> of M2
>> - we should define them in the context of what we want Tuscany to be.
>> As we implement, at some point we can say that we think we have a
>> useful, consistent set of features and then turn that into a release.
>> When you combine this with the refactoring into smaller pieces that
>> can be released separately, it will help build momentum for the
>> project by showing continual progress.
> As Sebastien said, there is LOTS to do.  This means it will take time
> to get all the way to what we want Tuscany to be.  So I think it makes
> sense to stage the scenarios and not try to define right now every
> possible part of advanced functionality that we might like to see in
> Tuscany some day.
I think it is o.k. for people to outline the scenarios that are  
important to them, and implement them if they want, regardless of  
whether they are "advanced" or "simple". I like the idea of people  
choosing to work on areas they are interested in and when the  
community is comfortable, we cut a release. I think this allows for a  
rapid release cycle and, more importantly, accommodates community  
diversity.

> Some of the initial scenarios may end up in M2 and

I'm a bit worried that this will discourage people from working on  
something important to them because it is not slated for a  
predetermined milestone. For example, if someone wanted to work on a  
feature that was not part of some milestone, would they be allowed to  
check the feature into head? Again, I think we need to be flexible  
about "milestones" and releases.

Also, this process of deciding what "ends up" in a milestone may  
result in a "tyranny of the majority"  (it's close to July 4th so I  
have to allude to de Tocqueville :-) ) where a really innovative  
feature is stifled because it does not fit into a set of release  
criteria determined by the many.

> some may not, and they should cover a progression from known use cases
> that are needed to cover the basics, up to more advanced scenarios
> that show how SCA and Tuscany can handle more sophisticated
> requirements better than alternative technologies.

Maybe it would help move things forward if people just went ahead and  
added the scenarios that were important to them to the wiki page I  
started and we separate out the discussion of how we release to  
another thread since most people seem to agree that scenarios are  
useful?

>
>> -- 
>> Jeremy
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
>> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>
> -- 
> Simon C Nash   IBM Distinguished Engineer
> Hursley Park, Winchester, UK   nash@hursley.ibm.com
> Tel. +44-1962-815156   Fax +44-1962-818999
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
>


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org


Re: Using scenarios, was: Proposed approach for M2

Posted by Simon Nash <na...@hursley.ibm.com>.
My comments are inline below.

   Simon

Jeremy Boynes wrote:

>> Jean-Sebastien Delfino wrote:
>> > 1. Use scenarios to drive the M2 work
>> > Start a community discussion on the end to end scenarios that we 
>> want to
>> > support in M2.
>> >
>> > I'm thinking about concrete end to end scenarios that define the end 
>> user
>> > experience and the overall story going from development, build,
>> > package, deploy
>> > to runtime and administration of an SCA application.
> 
> snip
> 
>> > Here are a few ideas of scenarios to initiate the discussion:
>> > - a scenario building your average web app with SCA
>> > - a scenario showing how to aggregate multiple services into new ones
>> > - mediation and routing/exchange scenarios
>> > - an application using publish/subscribe
>> > - building a whole system of services on a network
>> > - integration with an AJAX UI
>> > - what else? any thoughts?
> 
> 
> On 6/30/06, Kevin Williams <ke...@qwest.net> wrote:
> 
>> Sebastien,
>>
>> This sounds great to me.  You may have intended this but, I think that
>> the scenarios should be implemented as we go resulting in new unit
>> tests, samples or sample apps by the time we are ready to release M2.
>>
>> Also, I propose a scenario that involves data access and the transfer of
>> a data graph between modules.  A source module would get the graph using
>> the DAS and pass it to a worker module.  The graph would be modified by
>> the worker and sent back to the source module with change history intact
>> to be synchronized with the database.
>>
>> An inter-op scenario would be nice too.
>>
> 
> One the the things that came out at the BOF at ApacheConEU was that we
> are not doing a good job of communicating what SCA is all about. I
> think having a bunch of scenarios like this will help us do that.
> 
> Another thing that came out was that it would help if we broke the
> distribution down into smaller pieces - for example, making SCA, SDO
> and DAS available as individual releases rather than bundling them all
> together which gave users the false impression that they were all
> tightly coupled.
> 
> I think we need a lot more information on each scenario though - at
> least to the level of detail Kevin provided. For example,
> 
>> > - a scenario building your average web app with SCA
> 
> I'm not sure what "your average web app" is - are we talking JSP
> taglibs, working with a framework such as WebWork, or the integration
> with something like Spring? Are we talking about just accessing
> services, or both producing and consuming? Are we talking about
> accessing a remote service or wiring local application components with
> SCA? Are we talking portable web app with Tuscany bundled, or how it
> works in an SCA-enabled container?
> 
> I'd like to suggest we capture these on the wiki in enough detail that
> a user new to the project would be able to understand what we are
> talking about. The scenarios can then become illustrative samples of
> what SCA is about and how it can be realized with Tuscany.
> 
> I don't want the scenarios to become the be-all and end-all though. We
> tried that with M1 and IMO it failed miserably. We scrambled to
> implement features and ended up with a brittle codebase that cracked
> when we needed to make significant changes. Testing focused on seeing
> if a scenario worked and we ended up with poor coverage across the
> codebase.
> 
> Instead I think we need to define additional, finer-grained scenarios
> that cover the components of the system. For example, different ones
> for SCA, SDO and DAS, and, digging deeper, different ones for
> web-services, Spring, static SDOs, non-relational DAS and so on.
> Basically, there are a lot of different scenarios for SDO on its own,
> we don't need to matrix them all into SCA, just pick a few key ones
> that help illustrate SCA concepts.
> 
> At the most detailed level, the scenarios become the unit test cases
> for packages and individual classes.
> 
I think the purpose of scenarios is not to serve as tests, but to
define required functionality in terms that are meaningful from
a user perspective.  From the scenarios we should derive technical
specifications, designs that implement those specifications, and
tests that validate that the implementations match the specifications.
Some of the tests should validate high-level user-visible functionality
("functional verification") and some should validate correct
functioning of lower-level components according to their specified
contracts ("unit tests").

So I see tests as different from scenarios.  Some higher-level tests
will look quite similar to elements of a scenario.  Lower-level tests
won't look like scenarios, but will exercise building blocks of
functionality that are needed to make the scenarios work.

> Finally, I don't think we should define scenarios in the context of M2
> - we should define them in the context of what we want Tuscany to be.
> As we implement, at some point we can say that we think we have a
> useful, consistent set of features and then turn that into a release.
> When you combine this with the refactoring into smaller pieces that
> can be released separately, it will help build momentum for the
> project by showing continual progress.
> 
As Sebastien said, there is LOTS to do.  This means it will take time
to get all the way to what we want Tuscany to be.  So I think it makes
sense to stage the scenarios and not try to define right now every
possible part of advanced functionality that we might like to see in
Tuscany some day.  Some of the initial scenarios may end up in M2 and
some may not, and they should cover a progression from known use cases
that are needed to cover the basics, up to more advanced scenarios
that show how SCA and Tuscany can handle more sophisticated
requirements better than alternative technologies.

> -- 
> Jeremy
> 
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
> For additional commands, e-mail: tuscany-dev-help@ws.apache.org
> 
> 
> 

-- 
Simon C Nash   IBM Distinguished Engineer
Hursley Park, Winchester, UK   nash@hursley.ibm.com
Tel. +44-1962-815156   Fax +44-1962-818999


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org