Hi -

I've been trying to wet my feet with Metacello a little by writing a 
ConfigurationOfWebClient and in the process I've come across various 
things that I don't understand or don't know how to express. The 
configuration itself can be found here:

	http://www.squeaksource.com/MetacelloRepository

Here are the questions I'm having:

1) #includes: vs. #requires:
What is the difference between #includes: and #requires:? They sound 
entirely interchangeable, in particular after reading the tutorial which 
states:

	"When you use the #includes: directive, you are not only specifying 
that the listed packages should be loaded when the parent package is 
loaded, but that the #included: packages should be loaded _before_ any 
packages that require the parent package."

I would expect that precise behavior for required packages, i.e., if Foo 
requires: Bar then Bar is loaded before Foo if some other package 
requires: Foo. What am I missing?

2) Why is HelpSystem not loaded?
In my configuration, baseline specifies that HelpSystem is required for 
WebClient-Help:

		"Documentation doesn't require Core/Tests, but HelpSystem"
		spec package: 'WebClient-Help' with:[spec requires: 'HelpSystem'].

		spec project: 'HelpSystem' with:[
			spec
				className: 'ConfigurationOfHelpSystem';
				repository: 'http://www.squeaksource.com/MetacelloRepository'
		].

However, when executed, Metacello goes through the motions but doesn't 
actually *load* any version of HelpSystem (I can see it 'fetch' the 
packages but not load them). It even calls the postLoadDoIt on it (which 
fails since nothing was loaded). What am I doing wrong?

3) When exactly is HelpSystem loaded?

What I'm wondering about in the above is that HelpSystem should only be 
loaded if WebClient-Help is being loaded. Is this implicitly part of 
specifying a 'project' instead of a 'package'? Or is there some other 
way of specifying that?

I guess really the question here is what entities get loaded implicitly 
simply by declaring them (packages for sure, any others?) and what 
entities need to be 'required' in order to be loaded?

4) How does one define dependencies that differ based on platform?

In WebClient, the WebClient-HTTP package requires WebClient-Core and 
-only for: #pharo- also WebClient-Pharo. How does one express that 
there's an additional dependency for WebClient-HTTP that only exists 
for: #pharo? The config currently specifies:

	spec for: #common do:[
		" ... "
		spec package: 'WebClient-HTTP' with:[spec requires: 'WebClient-Core'].
		" ... "
	].

	spec for: #pharo do:[
		"Just the fact it exists; no requirements here"
		spec package: 'WebClient-Pharo'.
	].

Which means that WebClient-Pharo will be loaded on Pharo by default but 
it's missing the fact that WebClient-Pharo is in fact a requirement for 
WebClient-HTTP (but only on that platform). How is that best expressed?

5) Bootstrapping Metacello?

I found that most of the ConfigurationsOfXXX include some code to 
'bootstrap' Metacello in some form. There appear to be variants on the 
code; is there a "canonical bootstrap method" that should be used?

6) A standard Configuration template?

The Metacello tutorial is very useful as far as the configuration goes 
but it falls short of getting into the details of what it means to 
provide a 'working' configuration. Testing the configuration isn't 
covered (is there a way to get back to a 'clean' state?); bootstrapping 
isn't covered; the meaning of #isMetacelloConfig, 
#metacelloVesion:loads:, #lastMetacelloVersionLoad and several other 
-seemingly random- methods that can be found on most -but not all- of 
the configurations. There is no indication on what these do, if they're 
required, recommended, or optional. Is there some 'standard' 
Configuration template that people can use to avoid guessing about which 
parts of the boilerplate to copy from some other configuration?

That's it for now. Thanks for any insights on any of these issues.

Cheers,
   - Andreas