1. Autonomy Paradigm
Warning: This document is a part of my “Responsible Programming” theme. All docs related to that theme just gather some of my ideas. It is just ideas, I don't want to impose anything to anybody.
Author: Lionel Thiry

2. Autonomy vs. Independence
Autonomy and independence are different things
Independence is to be self-sufficient
Independence of external tools, libs, servers
Independence of a kernel, and its drivers
Absolute independence is very very rare
Autonomy is the ability to take care of oneself
We know one is mature when autonomous
We are more at ease when working with mature people
Probably same fact when working with their applications

3. Autonomy of the application
The application should have the ability:
To check its own integrity
Do I have all my files?
Are they all in the right place?
Do they have the right size or checksum?
Why this?
More easy to check the integrity of an installation
Then more easy to fix problems of installation

4. Autonomy of an application
The application should have the ability:
To configure itself
With no configuration file to manually edit oneself
Exception: programmatic development tools
With no forced automation
With a good interface for it
Why this?
Application developers know their own applications at best
Then can be user friendly while user can keep control
Read my doc “AutoVSManual” for more hints

5. Autonomy of an application
The application should have the ability:
To check its environment itself
Do I have access to the tools I need?
Are the interpreters I need present on the system?
Do I have access to the libs I need?
Are all the other resources I need where I expect them to be?
Why this?
Better to check dependencies oneself: smoother, smarter
If the system changes, it helps to check if it still works
It is easier to fix problems once you have a diagnostic

6. Autonomy of an application
Separation of concerns:
The main and the maintenance parts of the application
Integrity, configuration or environment may be wrong
It is then normal the main part don't run
Or don't run smoothly
But the maintenance part should still be able to run
Ideally: whatever the problem is
Practically: the requirements needed to run should be kept minimal

7. Autonomy of an application
Installing and deinstalling
Choose the way of control
where your application keeps the control of itself best
where the user keeps control best
When meeting conflict, prefer the user
It is the “human oriented” way
Choose the way of ecology
Do not pollute the system when installing
Never leave waste when deinstalling

8. Autonomy of an application
Another separation of concerns:
Best is to have different kinds of installations
System: core module, drivers, essential libs, etc
Normal: when files are copied in some directories, plus some other tiny configurations
User (done after normal installation)
For adding icons, menu entries, etc, on the desktop
Creating directories and configuration files in home directory
And extra directories and caches elsewhere on the system
Plus corresponding uninstallations

9. Autonomy of an application
The application should have the ability:
To be able to update itself
As most quality programs already does
Update availability should be checked only on demand
Update informations can easily be retrieved
On multi-users systems, an admin password will be necessary
Why this?
Always get the latest (quality) version
Never do blind update that can be dangerous
It is my “keep control” motto

10. Autonomy of an application
If your application is extensible:
Don't let another application manage it for your
Keep control
You hardly check integrity without that
Deploy your own dedicated package system
Keep it simple
If you can't, there may be a design flaw in your system
Exception: delegation

11. Autonomy of an application
An application should always be well documented
Be pedagogic
It should be easy to read
Abuse of schematics when possible
Don't forget to give edifiant examples
And so on: be pedagogic!

12. Autonomy in installation
Provide an installation program
With a usable and pleasant interface
Don't forget about pedagogy
Users are not idiot
Say what you are doing
Users are not especially skilled
Explain the reasons why you are doing it
If you do as this, you'll teach them
But never force them to listen the lesson

13. Dependent autonomous application
Autonomous applications still needs help
They still need the help of
kernel, tools, libs and servers
They still have to integrate in a broader system
That system may provide a lot of useful services
As an adaptive UI lib for configuration programs
As some libs for easier updates
And even a repository to ensure the availability and security of those updates
As some tools for faster environment checks
As delegation services

14. Program as a responsible programmer: Make autonomous applications!
Autonomy Conclusion
Program as a responsible programmer:
Make autonomous applications!