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