You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@avalon.apache.org by Carsten Ziegeler <cz...@s-und-n.de> on 2004/03/18 12:56:14 UTC
[Meta] Confused by the terms
I started reading the docs about the meta package, the new entries
on the wiki etc. and the more I read the more I get confused (might
be my problem, I don't know).
The way I learned about components uses three terms: component, service
and implementation. So a component is separated into one (or more)
services and the implementation. When assembling my application, I
define which implementation I want to use for what service.
Reading now the meta tags, I see that an *implementation* has the
avalon.service meta tags that define the services. Good.
But what exactly does the avalon.component tag mean?
And more irritating for me: all the meta info is assembled to a "type"
and this is where I'm totally lost.
If there is some good docs about these terms can you please point me to
it as I don't get it from the docs.
Thanks
Carsten
Carsten Ziegeler
Open Source Group, S&N AG
http://www.osoco.net/weblogs/rael/
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Niclas Hedhman <ni...@hedhman.org>.
On Thursday 18 March 2004 21:59, Berin Loritsch wrote:
> > Comments?
>
> http://mindview.net/WebLog/log-0051
>
> Should be simple enough.
Interesting, but I fail to see what you are refering to. :o(
I guess it is somewhat related to the conclusion that "Semantics can/should
not be enforced into interfaces."
And knowing your "known standpoint", I am quick to draw (perhaps incorrect)
conclusions, that we shouldn't even bother to try to define a Service Type,
which defines semantics beyond the interface. Just provide more flexibility
to the world and we all be happy hereafter... (This has nothing to do with
the Generics discussed in the article. I have not gotten a firm opinion about
that - yet).
If so, we live on different planets, solving different problems...
It sounds to me that Avalon, even Fortress and ECM, are far too restrictive
for the ultimate anarchist, who don't want to be constrained and follow
guidelines that improves the daily lives of many (Hope you see the
satire/sarcasm, and take it well :o) )
Niclas
--
+---------//-------------------+
| http://www.bali.ac |
| http://niclas.hedhman.org |
+------//----------------------+
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Berin Loritsch <bl...@d-haven.org>.
Niclas Hedhman wrote:
> On Thursday 18 March 2004 20:19, Stephen McConnell wrote:
>
>>Carsten Ziegeler wrote:
>
>
> Carsten, thanks for bringing this up. Something just struck me hard !
>
>
>> The Avalon Meta Model defines the functional structure
>> of component types and services.
>
>
> We don't allow for specification of Services !!
>
> An interface is not enough to define the semantics of a Service.
>
> Comments?
http://mindview.net/WebLog/log-0051
Should be simple enough.
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Is interface enough to express semantics? (was: [Meta] Confused by the terms)
Posted by Anton Tagunov <at...@list.ru>.
Hello Niclas,
Niclas Hedhman wrote:
NH> An interface is not enough to define the semantics of a Service.
NH> Comments?
It is an URL that COULD be associated with semantics.
That's the way we do it with XML DTDs. Like,
avalon.apache.org/xml/transformer/v1
But, package names are quite url-like. Compare the above to
org.apache.avalon.xml.transformer.v1.Service
So I don't know what to say here.
Sure SOME interfaces are not descriptive enough to capture semantics,
like java.util.Map.
But others MAY be.
Interface name could even
include a version number.
Anton
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Niclas Hedhman <ni...@hedhman.org>.
On Thursday 18 March 2004 20:19, Stephen McConnell wrote:
> Carsten Ziegeler wrote:
Carsten, thanks for bringing this up. Something just struck me hard !
> The Avalon Meta Model defines the functional structure
> of component types and services.
We don't allow for specification of Services !!
An interface is not enough to define the semantics of a Service.
Comments?
Niclas
--
+---------//-------------------+
| http://www.bali.ac |
| http://niclas.hedhman.org |
+------//----------------------+
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re[2]: [Meta] Confused by the terms
Posted by Anton Tagunov <at...@list.ru>.
Hello Stephen!
SM> A Type definition
SM> contains information about deployment and runtime
SM> dependencies together with information about the
SM> services that a component type can provide.
Sounds a lot like a Component or ComponentDescriptor.
Perhaps intially it was
ComponentDescriptor -> ComponentType -> Type?
So, Type here is synonim to Descriptor?
Anyway, Component[Descriptor] sounds lots more intuitive.
Anton
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Stephen McConnell <mc...@apache.org>.
Niclas Hedhman wrote:
> On Thursday 18 March 2004 21:21, Stephen McConnell wrote:
>
>>Theoretically yes - but in practice no.
>
>
> I think my point is, that there should probably be a split between "Type" and
> "Requirements", where the Type belongs more to the Service interface, and the
> Requirements belongs with the component.
Keeping in mind ...
org.apache.avalon.meta.info.Service
Cheers, Steve.
--
|------------------------------------------------|
| Magic by Merlin |
| Production by Avalon |
| |
| http://avalon.apache.org/merlin |
| http://dpml.net/merlin/distributions/latest |
|------------------------------------------------|
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Niclas Hedhman <ni...@hedhman.org>.
On Thursday 18 March 2004 21:21, Stephen McConnell wrote:
> Theoretically yes - but in practice no.
I think my point is, that there should probably be a split between "Type" and
"Requirements", where the Type belongs more to the Service interface, and the
Requirements belongs with the component.
Niclas
--
+---------//-------------------+
| http://www.bali.ac |
| http://niclas.hedhman.org |
+------//----------------------+
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
RE: [Meta] Confused by the terms
Posted by Leo Sutic <le...@inspireinfrastructure.com>.
> From: Stephen McConnell [mailto:mcconnell@apache.org]
>
> Niclas Hedhman wrote:
>
> > On Thursday 18 March 2004 20:39, Niclas Hedhman wrote:
> >
> >>Because more than one component can be of the same Type.
>
> Theoretically yes - but in practice no.
Umm... Doesn't Type include the implementing class?
Since the Type specifies properties about the implementing
class. You'll never two types that are equal.
/LS
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Stephen McConnell <mc...@apache.org>.
Niclas Hedhman wrote:
> On Thursday 18 March 2004 20:39, Niclas Hedhman wrote:
>
>>Because more than one component can be of the same Type.
>
>
> And in that lies a problem... Gut feeling says something is wrong here.
>
> If more than one component can be of the same Type (natural associations),
> then the Type descriptor should be decoupled from the component completely,
> and the component just reference which Type it is adhering to.
Theoretically yes - but in practice no.
When you combine all of the information about a component type into a
Type instance you end up with something that is aligned and reflective
of the implementation logic (lifestyle assumptions), structural
associations (dependencies), deployment dependencies (stage
dependencies), and capabilities (services and extension handling abilities).
The Type instance is not something used to describe a potential solution
- that what services do. Instead the information contained in a Type
allows structural validation - i.e. can all of the rules be respected -
is the component type's class available in the classloader? Are the
services that it depends on known and available in the classloader? If
these basic fundamentals cannot be fulfilled - you know your not even
going to bother with subject like instantiation, deployment, etc.
Moving on - assuming you have a valid type, you available to you
sufficient information to determine if the a component instance can (in
principal) be wired to run. If yes - then and only then - you can start
playing with the profile for deployment (configurations, context,
parameterization, etc.).
There is also another benefit form the separation of type and component.
A Type is an immutable data model that can be exchanged between
systems. It does not reference classes or resources outside of the
meta-info api - which means you can do a lot of things in a system to
create the environment that a type requires. We aren't doing this sort
of thing yet but were getting real close.
Cheers, Stephen.
> Niclas
--
|------------------------------------------------|
| Magic by Merlin |
| Production by Avalon |
| |
| http://avalon.apache.org/merlin |
| http://dpml.net/merlin/distributions/latest |
|------------------------------------------------|
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Niclas Hedhman <ni...@hedhman.org>.
On Thursday 18 March 2004 20:39, Niclas Hedhman wrote:
> Because more than one component can be of the same Type.
And in that lies a problem... Gut feeling says something is wrong here.
If more than one component can be of the same Type (natural associations),
then the Type descriptor should be decoupled from the component completely,
and the component just reference which Type it is adhering to.
Niclas
--
+---------//-------------------+
| http://www.bali.ac |
| http://niclas.hedhman.org |
+------//----------------------+
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Niclas Hedhman <ni...@hedhman.org>.
On Thursday 18 March 2004 20:29, Carsten Ziegeler wrote:
> Now, we could argue about the correct terms for months but the
> term "type" is imho misleading here. If a type exposes all
> features of a component why is it called a type and not
> component?
Because more than one component can be of the same Type.
Niclas
--
+---------//-------------------+
| http://www.bali.ac |
| http://niclas.hedhman.org |
+------//----------------------+
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Stephen McConnell <mc...@apache.org>.
Carsten Ziegeler wrote:
> Stephen McConnell wrote:
>
>>Carsten Ziegeler wrote:
>>
>>
>>>Stephen McConnell wrote:
>>>
>>>
>>>>>From the front page:
>>>>
>>>> The Avalon Meta Model defines the functional structure
>>>> of component types and services. A Type definition
>>>> contains information about deployment and runtime
>>>> dependencies together with information about the
>>>> services that a component type can provide.
>>>>
>>>>The following page describes the XML schema used to define a Type
>>>>instance - http://avalon.apache.org/meta/meta/info/type/index.html
>>>>This is paralleled in the API documentation for the immutable Type
>>>>class (org.apache.avalon.meta.info.Type). Keep in mind
>>
>>that the Type
>>
>>>>is simply an immutable class that exposes all of the descriptive
>>>>features of a component (that's it).
>>>>
>>>
>>>Ok. So by defining a type I don't "create" a component, which means
>>>if I only define a type, I can't lookup up something?
>>
>>Not directly.
>>
>>A Type is a description of a component implementation.
>
> Ok, yes sorry that was my latest understanding as well :) Ok, so type
> as a term makes sense.
> Perhaps the docs should simply contain your sentence above as
> the first sentence, so readers immediately see what a type is
> before they read the longer and more detailed version.
>
>
>>Based on
>>information accessible from an instance of Type you know all
>>about the
>>structural and runtime dependencies that a instance of a
>>corresponding
>>component class will require.
>>
>
> Ok.
>
>
>>>Now, we could argue about the correct terms for months but the
>>>term "type" is imho misleading here. If a type exposes all
>>>features of a component why is it called a type and not
>>>component?
>>
>>What is a component?
>>
>>Here is my view.
>>
>>A component is a reusable computation unit that provides zero or more
>>functional services.
>
> Agreed.
>
>
>>This implies that a component is more
>>than a class
>>or collection of classes. It is computational unit that can
>>be deployed
>>predictably in different application scenarios and environments.
>
> Yes.
>
>
>>To achieve this you can break down "component" into:
>>
>> * a component *type* description
>
> Containing the provided services.
>
>
>> * an *implementation* of the type
>> * a deployment *profile*
>>
>>Collectively these different aspect are brought together by a
>>container
>>through the process of "instantiating a component".
>>
>
> Ok, now I'm on track :) I will post my other questions about meta
> soon :)
Great!
I'll try and craft together a better introductory paragraph that
captures these point more clearly.
Cheers, Steve.
>
> Many thanks!
>
> Carsten
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
> For additional commands, e-mail: dev-help@avalon.apache.org
>
>
--
|------------------------------------------------|
| Magic by Merlin |
| Production by Avalon |
| |
| http://avalon.apache.org/merlin |
| http://dpml.net/merlin/distributions/latest |
|------------------------------------------------|
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
RE: [Meta] Confused by the terms
Posted by Carsten Ziegeler <cz...@s-und-n.de>.
Stephen McConnell wrote:
>
> Carsten Ziegeler wrote:
>
> > Stephen McConnell wrote:
> >
> >> From the front page:
> >>
> >> The Avalon Meta Model defines the functional structure
> >> of component types and services. A Type definition
> >> contains information about deployment and runtime
> >> dependencies together with information about the
> >> services that a component type can provide.
> >>
> >>The following page describes the XML schema used to define a Type
> >>instance - http://avalon.apache.org/meta/meta/info/type/index.html
> >>This is paralleled in the API documentation for the immutable Type
> >>class (org.apache.avalon.meta.info.Type). Keep in mind
> that the Type
> >>is simply an immutable class that exposes all of the descriptive
> >>features of a component (that's it).
> >>
> >
> > Ok. So by defining a type I don't "create" a component, which means
> > if I only define a type, I can't lookup up something?
>
> Not directly.
>
> A Type is a description of a component implementation.
Ok, yes sorry that was my latest understanding as well :) Ok, so type
as a term makes sense.
Perhaps the docs should simply contain your sentence above as
the first sentence, so readers immediately see what a type is
before they read the longer and more detailed version.
> Based on
> information accessible from an instance of Type you know all
> about the
> structural and runtime dependencies that a instance of a
> corresponding
> component class will require.
>
Ok.
> > Now, we could argue about the correct terms for months but the
> > term "type" is imho misleading here. If a type exposes all
> > features of a component why is it called a type and not
> > component?
>
> What is a component?
>
> Here is my view.
>
> A component is a reusable computation unit that provides zero or more
> functional services.
Agreed.
> This implies that a component is more
> than a class
> or collection of classes. It is computational unit that can
> be deployed
> predictably in different application scenarios and environments.
Yes.
>
> To achieve this you can break down "component" into:
>
> * a component *type* description
Containing the provided services.
> * an *implementation* of the type
> * a deployment *profile*
>
> Collectively these different aspect are brought together by a
> container
> through the process of "instantiating a component".
>
Ok, now I'm on track :) I will post my other questions about meta
soon :)
Many thanks!
Carsten
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Stephen McConnell <mc...@apache.org>.
Carsten Ziegeler wrote:
> Stephen McConnell wrote:
>
>> From the front page:
>>
>> The Avalon Meta Model defines the functional structure
>> of component types and services. A Type definition
>> contains information about deployment and runtime
>> dependencies together with information about the
>> services that a component type can provide.
>>
>>The following page describes the XML schema used to define a
>>Type instance -
>>http://avalon.apache.org/meta/meta/info/type/index.html
>>This is paralleled in the API documentation for the immutable
>>Type class (org.apache.avalon.meta.info.Type). Keep in mind
>>that the Type is simply an immutable class that exposes all
>>of the descriptive features of a component (that's it).
>>
>
> Ok. So by defining a type I don't "create" a component, which means
> if I only define a type, I can't lookup up something?
Not directly.
A Type is a description of a component implementation. Based on
information accessible from an instance of Type you know all about the
structural and runtime dependencies that a instance of a corresponding
component class will require.
> Now, we could argue about the correct terms for months but the
> term "type" is imho misleading here. If a type exposes all
> features of a component why is it called a type and not
> component?
What is a component?
Here is my view.
A component is a reusable computation unit that provides zero or more
functional services. This implies that a component is more than a class
or collection of classes. It is computational unit that can be deployed
predictably in different application scenarios and environments.
To achieve this you can break down "component" into:
* a component *type* description
* an *implementation* of the type
* a deployment *profile*
Collectively these different aspect are brought together by a container
through the process of "instantiating a component".
Stephen.
>
> Carsten
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
> For additional commands, e-mail: dev-help@avalon.apache.org
>
>
--
|------------------------------------------------|
| Magic by Merlin |
| Production by Avalon |
| |
| http://avalon.apache.org/merlin |
| http://dpml.net/merlin/distributions/latest |
|------------------------------------------------|
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
RE: [Meta] Confused by the terms
Posted by Carsten Ziegeler <cz...@s-und-n.de>.
Stephen McConnell wrote:
>
> From the front page:
>
> The Avalon Meta Model defines the functional structure
> of component types and services. A Type definition
> contains information about deployment and runtime
> dependencies together with information about the
> services that a component type can provide.
>
> The following page describes the XML schema used to define a
> Type instance -
> http://avalon.apache.org/meta/meta/info/type/index.html
> This is paralleled in the API documentation for the immutable
> Type class (org.apache.avalon.meta.info.Type). Keep in mind
> that the Type is simply an immutable class that exposes all
> of the descriptive features of a component (that's it).
>
Ok. So by defining a type I don't "create" a component, which means
if I only define a type, I can't lookup up something?
Now, we could argue about the correct terms for months but the
term "type" is imho misleading here. If a type exposes all
features of a component why is it called a type and not
component?
Carsten
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org
Re: [Meta] Confused by the terms
Posted by Stephen McConnell <mc...@apache.org>.
Carsten Ziegeler wrote:
> I started reading the docs about the meta package, the new entries
> on the wiki etc. and the more I read the more I get confused (might
> be my problem, I don't know).
>
> The way I learned about components uses three terms: component, service
> and implementation. So a component is separated into one (or more)
> services and the implementation. When assembling my application, I
> define which implementation I want to use for what service.
>
> Reading now the meta tags, I see that an *implementation* has the
> avalon.service meta tags that define the services. Good.
> But what exactly does the avalon.component tag mean?
>
> And more irritating for me: all the meta info is assembled to a "type"
> and this is where I'm totally lost.
From the front page:
The Avalon Meta Model defines the functional structure
of component types and services. A Type definition
contains information about deployment and runtime
dependencies together with information about the
services that a component type can provide.
The following page describes the XML schema used to define a Type
instance - http://avalon.apache.org/meta/meta/info/type/index.html
This is paralleled in the API documentation for the immutable Type class
(org.apache.avalon.meta.info.Type). Keep in mind that the Type is
simply an immutable class that exposes all of the descriptive features
of a component (that's it).
Cheers, Stephen.
--
|------------------------------------------------|
| Magic by Merlin |
| Production by Avalon |
| |
| http://avalon.apache.org/merlin |
| http://dpml.net/merlin/distributions/latest |
|------------------------------------------------|
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org