In Windows the default way is registry. This allow you to differentiate system-wide and per-user settings.
In Unix you should use text files in the /etc folder for system-wide settings (what's the convention for per-user settings?).
Many new programs (and especially those designed for being portable) use XML files.
What's the best way (and location) to store non-BLOB settings?
On Windows, it seems acceptable to use the registry. In my opinion, the registry was a poorly-devised system, and instead a simple text file in the Users\Username\AppData directory should be preferred. This is easier to back up, less dangerous for users to modify, and easier to clean up.
On Linux and most Unixes, The preferred location is /home/user/.config/appname for user-specific settings and /etc/ for global (system-wide) settings. The less-preferred (but acceptable) location for user settings is ~/.appname, but this is generally falling out of favor. These files should be user-editable, so a human-readable format is always preferred.
I disagree with most people that XML is an acceptable format for storing non-blob data. It is, in my opinion, an overwrought and excessively complex format for what usually ends up being very small pieces of structured data. I prefer to see files in YAML, JSON, ASN.1, name=value pairs, or similar formats. Having too much syntax makes it too easy for a user to mess up and leave the file in an invalid format.
Should we follow each system default or have a unified solution?
That is entirely up to you, but keep some things in mind:
/var/. Nonmutable data files should be kept in your app directory in /usr/share/ or /usr/local/share/ or /opt//etc/ should never be written to by the application when it is running, even if it has write access to them. /etc/ should be the repository for default behaviors and nothing else./usr/local/, /opt/appname, or /home/username/appname.Users\User\AppData. Nowhere else seems acceptable.~/Library/Preferences along with all of the other applications' plist files. plist seems to be the preferred format, but you'll want to double-check with the Apple guidelines.And what's the best portable way?
There is no "best," to be honest. There are only platform-specific limitations and expectations. My recommendation is to stick with platform-specific means, even if it means writing more code.
> In my opinion, the registry was a poorly-devised system, and instead a simple text file in the Users\Username\AppData directory should be preferred. @greyfade - Longtime Windows API developer, Raymond Chen, addresses this, and explains why using text files over the registry is not a better design pattern: Why are INI files deprecated in favor of the registry
Under Windows, use %APPDATA%\appname. Under *NIX, use ~/.appname. Don't use fixed directory names under either platform, since the user's home directory can be different from the default (it could be on the network, for example).
As for the format, use whatever you think is best. That is a decision that only you can make in the context of your application. It is unnecessary, and indeed, inadvisable, to have a "standard" way of doing it, if that "standard" way isn't what's best for your particular program.
For example, XML/JSON might be a good way of storing user data/configuration if your application already uses XML/JSON for something else. But if it's a simple configuration file, why add bloat to your app by introducing a dependency? In that case, it's probably best to just use a simple text file with var: value\n lines instead.
EDIT: There isn't a "best" portable way, since OSes use very different conventions for this. Don't break OS standards without a bloody good reason.
EDIT2: If you find yourself making a system-wide setting in /etc or HKEY_LOCAL_MACHINE, ask yourself if the setting is really global. Then wait 5 minutes and ask yourself again. If the answer is still yes, then by all means, make a global setting. Remember, a normal user doesn't have write access to /etc or HKEY_LOCAL_MACHINE and by doing this, you're ensuring that someone without admin rights can't install your app.
~/.config/applicaton is increasingly becoming the preferred location on *nix.
~ do so in ~/.config/appname.
Commented
Sep 15, 2010 at 17:18
I try and keep out of the registry, it is way over used. I wish everyone would.
I like keeping xml config files or a bin file or occasionally a local database (SQLite).
In Windows, I would keep the application setting in AppData folder
User settings are usually in
/home/<user>/.<application>
So for example for irssi settings are /home//.irssi/config
/home/<user>/etc/application?
~/.config/application to help keep things consolidated. I'm inclined to agree with this movement.
AppData.
I think it's best to use the preferred platform-specific mechanism. For example, on OS X, the preferred mechanism is to place a property list in ~/Library/Preferences, and the Cocoa API has a really simple interface for storing and retrieving settings from there.
If your app is cross-platform, you can abstract this away with a class or whatnot.
The only thing I write to the registry is the location of the app, so that installers and updaters can find it easily. Everything else is stored in files in /AppData/Company/App
For Java apps I think gson is a good choice. Create your settings objects and use gson to convert them to JSON and vice versa. Has the advantage of being human readable instead of some serialized blob.
Edit: ok, so its maybe not so general...
If you are writing in .NET, you can use System.Environment.SpecialFolders to find out what folder locations you can use for saving configuration or even some data.
