[RT] Let each project run using the last successfull jar from each dependency

[Nick Chalko <ni...@chalko.com>]

Here is an idea to let gump build 100% every time. 

Keep the jars from the last success full build of each project. Then a 
project fails it will not stop the rest of the tree from building. 

Of course it becomse a little more complicated to know what jars were 
used for what. But I think we could keep track of that.

Hmm almost like a gump repostory.



R,
Nick



---------------------------------------------------------------------
To unsubscribe, e-mail: general-unsubscribe@gump.apache.org
For additional commands, e-mail: general-help@gump.apache.org

Re: [RT] Let each project run using the last successfull jar from each dependency

[Michael Davey <Mi...@coderage.org>]

> Let's attempt to learn as much as possible on each run.  And that 
> means using the newest build available.
> I do see one possible   problem we could face
> From above let project A and project B both depend on Project Z
> Project Z makes a change and project B  makes a change to match.
> Now since project A is not building Project C will use the old version 
> of Project A with new version of Project B. If they are incompatible  
> Project C will see the error not Project A. But we still learn 
> something  as early as possible just not in the desired place.

If the cascading errors/warnings idea from another RT thread, or the 
list of all changes idea from another RT thread still, were implemented 
too, this wouldn't be an issue.  We would end up with something like:

Error: 'A' failed to build because of Exception dddd 
[@link-to-stacktrace], possible causes:
  'A':src/java/org/apache/a/foo.java changes to lines 34, 36, 144 
[@link-to-diff]
  'Z':/src/java/org/apache/z/bar.java changes to lines 244-268 
[@link-to-diff]
Warning: 'C' requires failed prerequisite 'A' - using build from 
2004-03-27 instead
Error: 'C' failed to build because of Exception ffff 
[@link-to-stacktrace], possible causes:
  'C':/src/java/org/apache/c/baz.java changes to lines 640-699 
[@link-to-diff]
  'A':src/java/org/apache/a/foo.java (inherited from 'A') changes to 
lines 34, 36, 144 [@link-to-diff]
  'Z':/src/java/org/apache/z/bar.java (inherited from 'A') changes to 
lines 244-268 [@link-to-diff]

-- 
Michael


---------------------------------------------------------------------
To unsubscribe, e-mail: general-unsubscribe@gump.apache.org
For additional commands, e-mail: general-help@gump.apache.org

Re: [RT] Let each project run using the last successfull jar from each dependency

[Nick Chalko <ni...@chalko.com>]

Sam Ruby wrote:

> Martin Cooper wrote:
>
>>
>>
>> The change you are suggesting would at best delay the guilty party from
>> being notified of the issues, and at worst result in everything building
>> successfully every time.
>>
>> Of course, I may be misinterpreting you entirely...
>
>
> It is more subtle that that.  What it would do is to enable a nearly 
> perfect system to run better, but it could make a bad situation worse.
>
> Example: Xalan is a stable project with a stable set of interfaces. 
> However, I have seen it fail to build.  Due to Ant's depedency on 
> Xalan, this pretty much wiped out the days's run.  Unnecessarily.
>
> On the other side is projects that rarely build.  If this is obscured 
> by substituting in older jars, projects will be provided with 
> misleading impression that


When ant fails we learn nothing else that is it for the day but there is 
more to learn

Lets look at this example
Project A, B, C
Project C depends on A and B

Now let Project A fail to build
let Project B make a non backwards compatible change.

Project C will not find this out until project A succeeds. 
If we used a old build of project A, Project C would learn this sooner.

Projects that have to many dependencies or to deep of a dependency chain 
, never get a chance to build.  The more we grow the more projects that 
will never get a chance build.

There is a gump "smell" to learn.  How old are the dependencies.  Oldest 
dependency and average age of dependency, and number old dependencies.

Let's attempt to learn as much as possible on each run.  And that means 
using the newest build available. 

I do see one possible   problem we could face
 From above let project A and project B both depend on Project Z
Project Z makes a change and project B  makes a change to match.
Now since project A is not building Project C will use the old version 
of Project A with new version of Project B. 
If they are incompatible  Project C will see the error not Project A. 
But we still learn something  as early as possible just not in the 
desired place.

R,
Nick



---------------------------------------------------------------------
To unsubscribe, e-mail: general-unsubscribe@gump.apache.org
For additional commands, e-mail: general-help@gump.apache.org

Re: [RT] Let each project run using the last successfull jar from each dependency

[Sam Ruby <ru...@apache.org>]

Martin Cooper wrote:

> On Sat, 27 Mar 2004, Nick Chalko wrote:
> 
>>Here is an idea to let gump build 100% every time.
>>
>>Keep the jars from the last success full build of each project. Then a
>>project fails it will not stop the rest of the tree from building.
> 
> I'm just a lurker here, but this seems to defeat the whole purpose of
> Gump. Gump's purpose in life is to let people know as soon as possible
> when changes in one place break things in other places.
> 
> The change you are suggesting would at best delay the guilty party from
> being notified of the issues, and at worst result in everything building
> successfully every time.
> 
> Of course, I may be misinterpreting you entirely...

It is more subtle that that.  What it would do is to enable a nearly 
perfect system to run better, but it could make a bad situation worse.

Example: Xalan is a stable project with a stable set of interfaces. 
However, I have seen it fail to build.  Due to Ant's depedency on Xalan, 
this pretty much wiped out the days's run.  Unnecessarily.

On the other side is projects that rarely build.  If this is obscured by 
substituting in older jars, projects will be provided with misleading 
impression that

One way to mitigate this would be to place an upper bound on how long 
old builds may be used.  Three days old may be fine, but three weeks old 
is probably not.

- Sam Ruby

---------------------------------------------------------------------
To unsubscribe, e-mail: general-unsubscribe@gump.apache.org
For additional commands, e-mail: general-help@gump.apache.org

Re: [RT] Let each project run using the last successfull jar from each dependency

[Martin Cooper <ma...@apache.org>]

On Sat, 27 Mar 2004, Nick Chalko wrote:

> Here is an idea to let gump build 100% every time.
>
> Keep the jars from the last success full build of each project. Then a
> project fails it will not stop the rest of the tree from building.

I'm just a lurker here, but this seems to defeat the whole purpose of
Gump. Gump's purpose in life is to let people know as soon as possible
when changes in one place break things in other places.

The change you are suggesting would at best delay the guilty party from
being notified of the issues, and at worst result in everything building
successfully every time.

Of course, I may be misinterpreting you entirely...

--
Martin Cooper


> Of course it becomse a little more complicated to know what jars were
> used for what. But I think we could keep track of that.
>
> Hmm almost like a gump repostory.
>
>
>
> R,
> Nick
>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: general-unsubscribe@gump.apache.org
> For additional commands, e-mail: general-help@gump.apache.org
>
>

---------------------------------------------------------------------
To unsubscribe, e-mail: general-unsubscribe@gump.apache.org
For additional commands, e-mail: general-help@gump.apache.org