I summarize below why I think fine grained configurations should be preferred to groups.

The group is not a first class configuration, although it can be depended on. If you depend on a group of a configuration, it's harder to understand the consequences and it's harder to build tools for it.

Consider the graph below representing the dependencies starting from ConfigurationOfMoose #development:

It's a simple representation of dependencies, and it makes the maze of configurations easier to grasp. The interesting thing about it is that by showing a configuration node only once, you can see how multiple other projects depend on it. For example, HashTable is being depended on by two distinct configurations.

You can also see that Magritte depends on Grease, but you do not see that it only depends on the Core group. To do that, you have to look at the details of the edge.

We used to have groups in GT, however, after a while we moved to more fine grained configurations. As a consequence, you can see that GlamourCore (which used to be a group in Glamour) is being depended on by three different configurations. Using first class configurations makes tool building (like representation, navigation or release) easier.

You could argue that we could represent a Group as node, however, even then you would not be able to see dependencies between groups that reside within the same configuration because groups are not first class configurations that can explicitly define dependencies, they are just groups.

Groups might provide an apparent ease of use for quick things, but I strongly believe that they are an unessential construct and that if we would not use them, tools would become cheaper and more effective.

Cheers,

Doru