New Definition of SCS
Closed this issue · 7 comments
To shorten and obtain a more concise definition of the notion SCS, I suggest the following change:
Current Definition:
The Self-contained System (SCS) approach is an architecture that focuses on a separation of the functionality into many independent systems, making the complete logical system a collaboration of many smaller software systems.
New suggested version:
Self-contained System (SCS)
An architectural approach to create a set of autonomous, smaller subsystems that collaborate to cover the overall system's functionality.
The usage of the word independent of the current definition seems wrong to me because the list of characteristics states autonomy and not independence, cf. https://scs-architecture.org/#autonomous.
Either they are autonomous or they collaborate. If they are autonomous, they don't have any dependencies and therefore cannot collaborate.
I don't think so. I think they cannot be independent and collaborate at the same time (independence means that you do not need or accept resources from others, e.g. you call another SCS for help). Autonomy states only that you have free will and that you stand behind your actions and values. However, I can be autonomous but still seek support from others, e.g. an SCS calls another SCS for support.
If an SCS has dependencies on other SCS it may lose its free will as it depends on the other SCS.
IMHO "free will" is no suitable term in this discussion. However, I agree that autonomy and independence have different meanings. In most cases an SCS is dependant on other SCS. SCS interact with each other, and every interaction is a strong indication of dependance. Autonomous means that despite of any dependancies I am the one that decides how I fulfil the contract with my partners. Others must not and need not know or even dictate how I implement my interface, contract, you name it.
ok, another suggestion closer to the original version:
An architectural approach that separates a larger system's functionality into many independent, collaborating systems.
I think there are 2 scopes involved here:
- Scope Small: The scope that the SCS covers. In that scope the SCS is autonomous and (dare I say: mostly?) independant and generates a value for it's users even without the help of other systems.
- Scope Big: The scope of the overall system. This overall system needs some rules on how participants participate within it. These rules restrict the autonomy of the participating systems and their independence and thus should be few in numbers and hopefully flexible enough to leave them options.
This conflict is a source of misconceptions, as we can see. In my opinion SCS focus on the smaller scope and aims to create autonomous systems that can be run and maintained autonomously and generate value even in the presence of problems within other systems.
That being said there is nothing wrong about letting them collaborate on the happy path, as long as the above still holds true. Which to me means that collaboration is a 2nd hand concern. If we shorten the definition, I would rather leave that concern out of the definition than moving it closer to the word 'independent', which could increase the misunderstanding even more and could make people believe its a first hand concern (See? it is within the same single line definition next to 'independent' so it must be equally important!).
Since the objective of this site is to explain the notion SCS, I would assume the "Scope Small" to be the relevant one. Moreover, my impression is that people mostly agree on autonomy. Taking this discussion, my impression is that the degree of independence is less clear. So like you said @tloist I would expect the definition to stress autonomy, but right now it uses the word "independent". The sentence
An architectural approach that separates a larger system's functionality into many independent, collaborating systems.
simply shortens the current one on https://scs-architecture.org/
The Self-contained System (SCS) approach is an architecture that focuses on a separation of the functionality into many independent systems, making the complete logical system a collaboration of many smaller software systems.
If we find here a better definition, I would replace it again.
@stilkov suggested a shorter version of the current definition that we have taken, to avoid the content discussion here, but still to get it into the layout. It seems tickets are not such a good platform for such a debate. So I close this ticket now. If one of you like to re-open the debate to adapt the definition, feel free to open a new ticket.