You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@ant.apache.org by Conor MacNeill <co...@cortexebusiness.com.au> on 2002/06/19 14:48:31 UTC

[mutant] Mutant Documentation

I've started writing some documentation on Mutant to help people better 
understand what it is about and what it offers. You can find it here

http://jakarta.apache.org/ant/mutant/

At the moment I've focused on the user view. In future I'll be addressing 
Mutant from the view of a task developer and then a core developer.

Feedback welcome.

Thanks
Conor


--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds [was Mutant Documentation]

Posted by Nick Chalko <ni...@chalko.com>.
The Pragmatic Programmer: From Journeyman to Master
by Hunt, Andrew / Thomas, David

see 
http://www.nerdbooks.com/item.html?id=020161622X&phpSID=545216dd4d00ab04ed61a979e5d7fc03

Patrick (Gus) Heck wrote:

>Erik Hatcher wrote:
>  
>
>>One of my all-time favorite texts!  A mandatory read for all developers, I
>>say.
>>
>>    
>>
>
>Hmm, not that I have a ton of extra time, but I'd be interested in
>knowing what the actual name/author of this text is. Being an esentially
>self taught developer, I always am on the look out for holes in my basic
>knowledge. Perhaps I know this DRY principal in some other form, or
>perhaps I should read up on it :). 
>
>-Gus
>
>--
>To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
>For additional commands, e-mail: <ma...@jakarta.apache.org>
>  
>


Re: Object oriented builds [was Mutant Documentation]

Posted by "Patrick (Gus) Heck" <pa...@olin.edu>.
Erik Hatcher wrote:
> 
> 
> One of my all-time favorite texts!  A mandatory read for all developers, I
> say.
> 

Hmm, not that I have a ton of extra time, but I'd be interested in
knowing what the actual name/author of this text is. Being an esentially
self taught developer, I always am on the look out for holes in my basic
knowledge. Perhaps I know this DRY principal in some other form, or
perhaps I should read up on it :). 

-Gus

--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds [was Mutant Documentation]

Posted by Erik Hatcher <ja...@ehatchersolutions.com>.
----- Original Message -----
From: "Conor MacNeill" <co...@cortexebusiness.com.au>

> I agree. I think today in Ant1 there is a lot of copy and paste build
> file production. That, of course, violates the DRY principle expounded
> by the Pragmatic programmers.

One of my all-time favorite texts!  A mandatory read for all developers, I
say.

> > Does the object-oriented nature of this include being able to "extend"
tasks
> > or projects?  I'm thinking at the API level now, not the XML
representation.
>
> You say "extend tasks". I may misunderstand you there and perhaps you
> mean targets.

Oops, yes, I meant targets.

> As for a more object-oriented approach to project reuse - I'm not sure
> yet. I'd like to see how the project reference concept pans out.

I will stay eagerly in tune on this.  It seems to me in my current thinking
that it has to evolve to OO at the project and target levels (again,
API-wise, XML representation is the last thing I want to consider at the
moment).  I've got to think through this some more though, and of course
experiment with the proposals, before speaking more concretely.

    Erik



--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds [was Mutant Documentation]

Posted by Conor MacNeill <co...@cortexebusiness.com.au>.
Erik Hatcher wrote:
> Conor - Thanks for documenting your design of Mutant.  I've had a quick read
> through it several days ago and my mind has been churning on some things
> triggered by what you've said there.

Cool.

> 
> One of the challenges I face when developing Ant build systems is the fact
> that it is tough to support large projects with 1.x.  Reusing build file
> pieces is difficult with entity references, and its tricky to get <ant> just
> right to control things and get properties passed down and inherited
> properly.  

I agree. I think today in Ant1 there is a lot of copy and paste build 
file production. That, of course, violates the DRY principle expounded 
by the Pragmatic programmers.

> Anyway, you mention polymorphic types for passing to tasks, which Ant 1.5
> has to some extent as well.

I would say that Ant 1.5 supports dynamic elements rather than 
polymorphism.

> 
> Does the object-oriented nature of this include being able to "extend" tasks
> or projects?  I'm thinking at the API level now, not the XML representation.

You say "extend tasks". I may misunderstand you there and perhaps you 
mean targets. It has always been possible to extend tasks at the API 
level :-). In fact this will probably be a little harder in Mutant due 
to classloader separation. Mutant does allow one library to declare that 
it extends another and this would allow its tasks to extend those in the 
other library.

As for projects, Mutant doesn't have the concept of project inheritance 
as such. It supports project reuse in two ways. The use of <include> is 
a simple way to extend projects. It is similar to the entity mechanism 
required by Ant1. OTOH, the <ref> mechanism supports composition of 
projects. The referenced projects may be controlled by the outer build 
and its targets and properties used. The use of antcall in Mutant should 
be less expensive than in Ant1 since Mutant does not reparse the XML, 
nor create tasks that it isn't going to use. I haven't done any tests on 
Mutant performance so far, however.

Peter has mentioned templating, (they used to be called macros). They 
are potentially interesting and I have considered their use in Mutant 
but I'm not sure I want to develop YAML (Yet another macro language). 
I'll leave that till later, I think.

As for a more object-oriented approach to project reuse - I'm not sure 
yet. I'd like to see how the project reference concept pans out.

Conor



--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds [was Mutant Documentation]

Posted by Peter Donald <pe...@apache.org>.
On Mon, 24 Jun 2002 04:27, Ara Abrahamian wrote:
> What do you guys think of making Target behave like a Task? I mean
> introduce a reusable JavaCTarget class, initialize it and put it in
> build.xml. A javac-target.xml will back this "target component".

What you describe is already possible in myrmidon. Basically you define a 
template (set of tasks to perform something and this template can be 
parameterized) and then use that template like a normal task.

> Also another thing I love to see is Ant moving to a real javabean
> design. Let me define my project in say jbuilder via visual composition
>
> :-) Funny isn't it? But why not? Some projects are so complicated you
>
> really can't live without extensive control over each step involved, and
> what's better than java and javabeans for handling it?

We tried that in the past but it ended up complicating things a bit. Ants 
patterns are a little simpler though I guess we could try to look at it 
again.

-- 
Cheers,

Peter Donald
*------------------------------------------------------*
| Despite your efforts to be a romantic hero, you will |
| gradually evolve into a postmodern plot device.      |
*------------------------------------------------------* 



--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


RE: Object oriented builds [was Mutant Documentation]

Posted by Ara Abrahamian <ar...@yahoo.com>.
What do you guys think of making Target behave like a Task? I mean
introduce a reusable JavaCTarget class, initialize it and put it in
build.xml. A javac-target.xml will back this "target component".

One thing I like in Tapestry framework is how it manages its web
components. Say you have to display a contact list in two screens. You
define a ContactListComponent class, define its formal parameters and
all its in/out bindings/etc in a xmlish ContactListComponent.jwc, the
html body of this component is in a ContactListComponent.html file with
reference to setups in jwc file.

Now take a look at it from an Ant perspective: we can define reusable
JavaCTargetComponent class which has some bean properties, in/out,
expected dependency definitions and stuff like those. Which tasks it
executes is defined in JavaCTargetComponent.atc (ant target component)
file. Since we're not generating an html like output we don't need
another html (template) file. We can do very interesting stuff imho with
these kinds of code+atc combination. JavaCTargetComponent can define a
well defined DependChecker interface, or many other useful extension
points.

Is the above scenario completely stupid or relevant? Maybe Maven does it
already? :-)

Also another thing I love to see is Ant moving to a real javabean
design. Let me define my project in say jbuilder via visual composition
:-) Funny isn't it? But why not? Some projects are so complicated you
really can't live without extensive control over each step involved, and
what's better than java and javabeans for handling it?

Ara.

> -----Original Message-----
> From: Adam Murdoch [mailto:adammurdoch@apache.org]
> Sent: Sunday, June 23, 2002 9:15 AM
> To: Ant Developers List
> Subject: Re: Object oriented builds [was Mutant Documentation]
> 
> On Sun, 23 Jun 2002 13:45, Erik Hatcher wrote:
> 
> > Does the object-oriented nature of this include being able to
"extend"
> > tasks or projects?  I'm thinking at the API level now, not the XML
> > representation. What I'd like to do is create a StandardJavaProject
> project
> > which does all the basic stuff like init, clean, compile, jar, and
> javadoc.
> >  In slightly more advanced projects, I might want to use a
> XDocletProject,
> > where all stays the same except a new "gensrc" target is added and
the
> > compile target is modified to depend on it and add the generated
source
> > directory to the compile and javadoc stage.  Does that make sense?
> >
> > My questions are for both Mutant and Myrmidon - do either or both of
> them
> > address this type of idea?  If so, could you elaborate on this
briefly?
> 
> There's some support for this in myrmidon, at the API level.  You do
this
> by
> providing your own ProjectBuilder implementation.  The ProjectBuilder
is
> responsible for building a Project object from a project file (a
Project
> is
> basically just a set of named Targets).
> 
> You can use a custom ProjectBuilder to do things like:
> 
> - Run the project file through a transformation, before handing it off
to
> the
> standard ProjectBuilder.
> - Do your own parsing, and assemble the Project object yourself.
> - Provide your own Project implementation.
> - Swap in your own target implementation.
> 
> ProjectBuilders are loaded from antlibs just like any other type, so
> installing them is very easy.
> 
> Also, they fit in nicely with the inter-project dependency stuff, so
that
> you
> can mix projects of different types together, and have dependencies
> between
> them.  For example, you could have an ant2 project that depends on an
ant1
> project, and a StandardJavaProject.
> 
> But regardless of how it happens, having a library of high-level
template
> projects, to use and customise ("extend"), is a great idea.
> 
> --
> Adam
> 
> --
> To unsubscribe, e-mail:
<ma...@jakarta.apache.org>
> For additional commands, e-mail:
<ma...@jakarta.apache.org>


--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds [was Mutant Documentation]

Posted by Adam Murdoch <ad...@apache.org>.
On Sun, 23 Jun 2002 13:45, Erik Hatcher wrote:

> Does the object-oriented nature of this include being able to "extend"
> tasks or projects?  I'm thinking at the API level now, not the XML
> representation. What I'd like to do is create a StandardJavaProject project
> which does all the basic stuff like init, clean, compile, jar, and javadoc.
>  In slightly more advanced projects, I might want to use a XDocletProject,
> where all stays the same except a new "gensrc" target is added and the
> compile target is modified to depend on it and add the generated source
> directory to the compile and javadoc stage.  Does that make sense?
>
> My questions are for both Mutant and Myrmidon - do either or both of them
> address this type of idea?  If so, could you elaborate on this briefly?

There's some support for this in myrmidon, at the API level.  You do this by 
providing your own ProjectBuilder implementation.  The ProjectBuilder is 
responsible for building a Project object from a project file (a Project is 
basically just a set of named Targets).

You can use a custom ProjectBuilder to do things like:

- Run the project file through a transformation, before handing it off to the 
standard ProjectBuilder.
- Do your own parsing, and assemble the Project object yourself.
- Provide your own Project implementation.
- Swap in your own target implementation.

ProjectBuilders are loaded from antlibs just like any other type, so 
installing them is very easy.

Also, they fit in nicely with the inter-project dependency stuff, so that you 
can mix projects of different types together, and have dependencies between 
them.  For example, you could have an ant2 project that depends on an ant1 
project, and a StandardJavaProject.

But regardless of how it happens, having a library of high-level template 
projects, to use and customise ("extend"), is a great idea.

-- 
Adam

--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds

Posted by Peter Donald <pe...@apache.org>.
At 03:01 PM 6/23/2002 +1000, you wrote:
>Um, Pete, you haven't checked in the <template-def> task yet.  All the other
>stuff is there - TemplateDef, TemplateTask, etc - just no TemplateDefTask.

Ug. I swear I will do it on thursday ;)


Cheers,

Peter Donald
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
"Faced with the choice between changing one's mind,
and proving that there is no need to do so - almost
everyone gets busy on the proof."
              - John Kenneth Galbraith
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds

Posted by Peter Donald <pe...@apache.org>.
On Sun, 23 Jun 2002 23:01, Stephane Bailliez wrote:
> ----- Original Message -----
> From: "Erik Hatcher" <ja...@ehatchersolutions.com>
>
> > Pretty cool.  Thanks for the discussion on this.
>
> Does all this discussion means that there is no more vetoes for project and
> target inheritance in Ant 2 (see document) ? or that it is slightly altered
> ? It seems contradictory to me or I missed something.

Naah there is no project/target inheritance in myrmidon. I believe I may have 
been one of the people who initially vetoed that feature. This is less 
inheritance and all that jazz, it is just defining a task in 
terms of other tasks.However I find it more useful to think of it as defining 
a new "build process" as a task.

It would be possible to implement inheritance in myrmidon as it is all fairly 
pluggable however we have not yet gone down that path to test things out.

-- 
Cheers,

Peter Donald
---------------------------------------------------
"It is easy to dodge our responsibilities, but we 
cannot dodge the consequences of dodging our 
responsibilities." -Josiah Stamp 
--------------------------------------------------- 



--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds

Posted by Stephane Bailliez <sb...@apache.org>.
----- Original Message -----
From: "Adam Murdoch" <ad...@apache.org>

>Those vetos are sooo old.  I wonder if it'd still be vetoed, particularly
>since we've had things like maven come along to demonstrate how much more
>powerful it can be to define projects in high-level terms.

I failed to explain clearly my position about project and target
inheritance, but when I asked for it back in march 2001 it was because I
spent a good deal of time gumpifying all my company projects and setup
something like maven, so project inheritance could have been a good addition
to me and it was kind of evident. Now that a lot more people use Gump or
Maven, I guess it shows up more.

>Something we've done in myrmidon, is to make the project model as pluggable
as
>possible.  So, even if, say, project/target inheritance is vetoed, it is
easy
>enough for someone to write their own project model that added it in.  They
>could then chuck it in an antlib and share it with others.

>A decent templating solution might be a good middle ground between the ant1
>model, and built-in project/target inheritance.  It could provide the tools
>you'd need to put together inheritance, without affecting the core project
>model.

Good stuff. It's even better.

Stephane


--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds

Posted by Conor MacNeill <co...@cortexebusiness.com.au>.
Adam Murdoch wrote:
> On Sun, 23 Jun 2002 23:01, Stephane Bailliez wrote:
> 
>>Does all this discussion means that there is no more vetoes for project and
>>target inheritance in Ant 2 (see document) ? or that it is slightly altered
>>? It seems contradictory to me or I missed something.
> 
> 
> Those vetos are sooo old.  

Agreed. They were useful to get a broad idea of what Ant2 could and 
should do. Today I think implementation has overtaken some of the 
original issues.

Conor



--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds

Posted by Adam Murdoch <ad...@apache.org>.
On Sun, 23 Jun 2002 23:01, Stephane Bailliez wrote:
> ----- Original Message -----
> From: "Erik Hatcher" <ja...@ehatchersolutions.com>
>
> > Pretty cool.  Thanks for the discussion on this.
>
> Does all this discussion means that there is no more vetoes for project and
> target inheritance in Ant 2 (see document) ? or that it is slightly altered
> ? It seems contradictory to me or I missed something.

Those vetos are sooo old.  I wonder if it'd still be vetoed, particularly 
since we've had things like maven come along to demonstrate how much more 
powerful it can be to define projects in high-level terms.

Something we've done in myrmidon, is to make the project model as pluggable as 
possible.  So, even if, say, project/target inheritance is vetoed, it is easy 
enough for someone to write their own project model that added it in.  They 
could then chuck it in an antlib and share it with others.

A decent templating solution might be a good middle ground between the ant1 
model, and built-in project/target inheritance.  It could provide the tools 
you'd need to put together inheritance, without affecting the core project 
model.


-- 
Adam

--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds

Posted by Stephane Bailliez <sb...@apache.org>.
----- Original Message -----
From: "Erik Hatcher" <ja...@ehatchersolutions.com>


> Pretty cool.  Thanks for the discussion on this.

Does all this discussion means that there is no more vetoes for project and
target inheritance in Ant 2 (see document) ? or that it is slightly altered
? It seems contradictory to me or I missed something.

Stephane


--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds

Posted by Erik Hatcher <ja...@ehatchersolutions.com>.
Pretty cool.  Thanks for the discussion on this.

    Erik

----- Original Message -----
From: "Peter Donald" <pe...@apache.org>
To: "Ant Developers List" <an...@jakarta.apache.org>
Sent: Sunday, June 23, 2002 12:08 AM
Subject: Re: Object oriented builds


> At 11:45 PM 6/22/2002 -0400, you wrote:
> >  I'm thinking at the API level now, not the XML representation.
> >What I'd like to do is create a StandardJavaProject project which does
all
> >the basic stuff like init, clean, compile, jar, and javadoc.  In slightly
> >more advanced projects, I might want to use a XDocletProject, where all
> >stays the same except a new "gensrc" target is added and the compile
target
> >is modified to depend on it and add the generated source directory to the
> >compile and javadoc stage.  Does that make sense?
>
> In myrmidon this is the case. You can define "templates" for each of your
> important build processes and then reuse them. For example you could do
the
> following
>
> <template-def name="x-buildnumber">
>    <attribute name="file" type="java.io.File" default="build.number"/>
>    <logic>
>      <buildnumber file="@{file}"/>
>      <exec command="cvs commit @{file}"/>
>    </logic>
> </template-def>
>
> Then later in your build you just do
>
> <x-buildnumber/> and it increments build number and commits it back to
CVS.
> Of course these templates can be as complex or simple as you want.
>
> As the templates get larger or shared you will want them to be stored in a
> library. So you create a separate XML file and then register them template
> as a task with a special factory. Usually you register tasks via
>
> <types>
>    <task name="buildnumber" impl="o.a.a.build.BuildNumber"/>
> </types>
>
> However when you are doing template tasks you need an extra attribute
> ("factory") to indicate how the tasks are created. (Note that this is not
> entirely implemented in Myrmidon just yet I don't think - Adam?). So it
> ends up looking like
>
> <types>
>    <task name="x-buildnumber" impl="o/a/a/build/BuildNumber.template"
> factory="template-factory"/>
> </types>
>
> The problem with the current implementation is that the template is loaded
> into memory when it is declared which ends up using massive amounts of
> memory when you are not using template. So in the future myrmidon will
load
> and cache templates at runtime.
>
> The idea is to support all the functionality needed for meta build
projects
> like Centipede/Maven (but let them rigfht the actual templates).
>
>
> Cheers,
>
> Peter Donald
> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> "Faced with the choice between changing one's mind,
> and proving that there is no need to do so - almost
> everyone gets busy on the proof."
>               - John Kenneth Galbraith
> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>
>
> --
> To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
> For additional commands, e-mail: <ma...@jakarta.apache.org>
>
>


--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds

Posted by Adam Murdoch <ad...@apache.org>.
On Sun, 23 Jun 2002 14:08, Peter Donald wrote:
> At 11:45 PM 6/22/2002 -0400, you wrote:
> >  I'm thinking at the API level now, not the XML representation.
> >What I'd like to do is create a StandardJavaProject project which does all
> >the basic stuff like init, clean, compile, jar, and javadoc.  In slightly
> >more advanced projects, I might want to use a XDocletProject, where all
> >stays the same except a new "gensrc" target is added and the compile
> > target is modified to depend on it and add the generated source directory
> > to the compile and javadoc stage.  Does that make sense?
>
> In myrmidon this is the case. You can define "templates" for each of your
> important build processes and then reuse them. For example you could do the
> following
>
> <template-def name="x-buildnumber">
>    <attribute name="file" type="java.io.File" default="build.number"/>
>    <logic>
>      <buildnumber file="@{file}"/>
>      <exec command="cvs commit @{file}"/>
>    </logic>
> </template-def>

Um, Pete, you haven't checked in the <template-def> task yet.  All the other 
stuff is there - TemplateDef, TemplateTask, etc - just no TemplateDefTask.

> As the templates get larger or shared you will want them to be stored in a
> library. So you create a separate XML file and then register them template
> as a task with a special factory. Usually you register tasks via
>
> <types>
>    <task name="buildnumber" impl="o.a.a.build.BuildNumber"/>
> </types>
>
> However when you are doing template tasks you need an extra attribute
> ("factory") to indicate how the tasks are created. (Note that this is not
> entirely implemented in Myrmidon just yet I don't think - Adam?).

Not entirely.  It's near the top of my ever-growing todo list, though.


-- 
Adam

--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Re: Object oriented builds

Posted by Peter Donald <pe...@apache.org>.
At 11:45 PM 6/22/2002 -0400, you wrote:
>  I'm thinking at the API level now, not the XML representation.
>What I'd like to do is create a StandardJavaProject project which does all
>the basic stuff like init, clean, compile, jar, and javadoc.  In slightly
>more advanced projects, I might want to use a XDocletProject, where all
>stays the same except a new "gensrc" target is added and the compile target
>is modified to depend on it and add the generated source directory to the
>compile and javadoc stage.  Does that make sense?

In myrmidon this is the case. You can define "templates" for each of your 
important build processes and then reuse them. For example you could do the 
following

<template-def name="x-buildnumber">
   <attribute name="file" type="java.io.File" default="build.number"/>
   <logic>
     <buildnumber file="@{file}"/>
     <exec command="cvs commit @{file}"/>
   </logic>
</template-def>

Then later in your build you just do

<x-buildnumber/> and it increments build number and commits it back to CVS. 
Of course these templates can be as complex or simple as you want.

As the templates get larger or shared you will want them to be stored in a 
library. So you create a separate XML file and then register them template 
as a task with a special factory. Usually you register tasks via

<types>
   <task name="buildnumber" impl="o.a.a.build.BuildNumber"/>
</types>

However when you are doing template tasks you need an extra attribute 
("factory") to indicate how the tasks are created. (Note that this is not 
entirely implemented in Myrmidon just yet I don't think - Adam?). So it 
ends up looking like

<types>
   <task name="x-buildnumber" impl="o/a/a/build/BuildNumber.template" 
factory="template-factory"/>
</types>

The problem with the current implementation is that the template is loaded 
into memory when it is declared which ends up using massive amounts of 
memory when you are not using template. So in the future myrmidon will load 
and cache templates at runtime.

The idea is to support all the functionality needed for meta build projects 
like Centipede/Maven (but let them rigfht the actual templates).


Cheers,

Peter Donald
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
"Faced with the choice between changing one's mind,
and proving that there is no need to do so - almost
everyone gets busy on the proof."
              - John Kenneth Galbraith
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>


Object oriented builds [was Mutant Documentation]

Posted by Erik Hatcher <ja...@ehatchersolutions.com>.
Conor - Thanks for documenting your design of Mutant.  I've had a quick read
through it several days ago and my mind has been churning on some things
triggered by what you've said there.

One of the challenges I face when developing Ant build systems is the fact
that it is tough to support large projects with 1.x.  Reusing build file
pieces is difficult with entity references, and its tricky to get <ant> just
right to control things and get properties passed down and inherited
properly.  And I'm sure there are many other issues that folks could think
of related to large project projects, such as lack of an <antOn>.

Anyway, you mention polymorphic types for passing to tasks, which Ant 1.5
has to some extent as well.

Does the object-oriented nature of this include being able to "extend" tasks
or projects?  I'm thinking at the API level now, not the XML representation.
What I'd like to do is create a StandardJavaProject project which does all
the basic stuff like init, clean, compile, jar, and javadoc.  In slightly
more advanced projects, I might want to use a XDocletProject, where all
stays the same except a new "gensrc" target is added and the compile target
is modified to depend on it and add the generated source directory to the
compile and javadoc stage.  Does that make sense?

My questions are for both Mutant and Myrmidon - do either or both of them
address this type of idea?  If so, could you elaborate on this briefly?

Am I even thinking coherently on this?  Or am I way off-base?

I'm eager to see where this leads!

    Erik


----- Original Message -----
From: "Conor MacNeill" <co...@cortexebusiness.com.au>
To: "Ant Developers List" <an...@jakarta.apache.org>
Sent: Wednesday, June 19, 2002 8:48 AM
Subject: [mutant] Mutant Documentation


> I've started writing some documentation on Mutant to help people better
> understand what it is about and what it offers. You can find it here
>
> http://jakarta.apache.org/ant/mutant/
>
> At the moment I've focused on the user view. In future I'll be addressing
> Mutant from the view of a task developer and then a core developer.
>
> Feedback welcome.
>
> Thanks
> Conor
>
>
> --
> To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
> For additional commands, e-mail: <ma...@jakarta.apache.org>
>
>


--
To unsubscribe, e-mail:   <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>