Changes

== Purposes ==

== Purposes ==

Sugar is not unique when faces to questions like how to deploy new features to users. There is well tested and robust model in FOSS world when projects follow release(on regular bases) schedules e.g. 6month, support long time supported releases etc. But there could be cases when sugar has its specific:

Sugar is not unique when faced with questions like how to deploy new features to users. There are well-tested and robust models in the FOSS world when projects follow regular release schedules, e.g., 6-month, support, long-time supported releases, etc. But there could be cases when sugar has its specific needs:

* the most broad sugar audience is teachers, students, schools and other educational organizations thus not in all cases we can rely on the fact the all sugar users will use only last stable sugar release. For example last OLPC sugar is 0.82, next will be 0.84 but last stable is 0.86

* The most broad sugar audience is teachers, students, schools and other educational organizations. Thus, we can not rely in all cases on the fact that all sugar users will use only the latest stable sugar release. For example, the latest OLPC sugar is 0.82, next will be 0.84, but the latest stable version is 0.86.

* many developers participate on casual bases thus supporting several sugars(one for stable OLPC, one for next stable OLPC and one for last upstream stable) for theirs activities is overkill. Thus people support only one branch and either drop other users categories or do not implement useful features from last sugar(like new toolbar design).

* Many developers participate on a casual basis, thus, supporting several sugars (one for stable OLPC, one for next stable OLPC, and one for the latest stable upstream) for their activities is overkill. As such, people support only one branch, and either drop other user categories, or do not implement useful features from the latest sugar (like the new toolbar design).

So, the right answer could be more scalable and decentralized development model. That doesn't mean we should follow only decentralized model but we can effectively mix both - centralized model with core team and regular releases and adding optional decentralization.

So, the right answer could be a more scalable and decentralized development model. That doesn't mean we should follow only a decentralized model, but we can effectively mix both—a centralized model with the core team and regular releases, and add an optional, decentralized model.

== Implementation ideas ==

== Implementation ideas ==

Decentralized development model means here that activity developers' focus is moving from core releases to releases of services they use in activities.

A decentralized development model means here that the activity developers' focus is moved from core releases to releases of services they use in activities.

So, the corner stone idea is not having solid sucrose, there could several sucrose releases in the field, but bunch of services(i.g. packages) that have their own [[Documentation_Team/Services/Service_Developers_Guide#Versioning_scheme|API based]] schedules. And so for over sugar dependencies like sugargame or groupthinking.

So, the corner stone idea is not having a monolithic sucrose. There could be several sucrose releases in the field, but with a bunch of services (i.e., packages) that have their own [[Documentation_Team/Services/Service_Developers_Guide#Versioning_scheme|API-based]] schedules and similar for other sugar dependencies, like sugargame or groupthink.

For glucose components it could look like:

For glucose components, it could look like the following:

* localize code that could be changed often to separate services with often releases

* Localized code that could be changed often to separate services with frequent releases.

* keep the rest of code in services with infrequent releases

* Keep the rest of the code in services with infrequent releases.

* use robust and explicit API for all services

* Use robust and explicit APIs for all services.

For example in case of sugar-toolkit, it could be splited to:

For example, in the case of sugar-toolkit, it could be split:

* move all shell related API to shell itself to have one solid service - shell and provide dbus API for all shell related needs e.g. getting information about sugar environment

* Move all shell-related API to the shell itself to have one solid service - shell, and provide dbus API for all shell-related needs, e.g., getting information about the sugar environment.

* toolkit service, list of widgets that use stable API from shell service and mostly are shell independent

* Toolkit service, a list of widgets that use a stable API from shell service, and mostly are shell independent.

* move all datastore related code to sugar-datastore - datastore service

* Move all datastore-related code to sugar-datastore - a datastore service.

Services should be independent as much as possible e.g. activity developers could use toolkit service from 0.88 cycle with shell service from 0.82(since its API wasn't changed).

Services should be as independent as possible, e.g., activity developers could use the toolkit service from the 0.88 cycle with the shell service from 0.82 (since its API wasn't changed).