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

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

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

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

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

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

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

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

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

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

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!

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

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

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