You can't easily just ignore changes to particular lines of a file, I'm afraid, so you're probably stuck with having a separate configuration file. Below I've listed two typical ways of dealing with this, and one slightly more exotic one: Have a sample configuration file in git Here, you would keep a file config. Sample in git as an example, but the application would actually use the values in a file config which is in gitignore The application would then produce an error unless config is present.
You have to remember to change values in the sample file when you add new configuration variables to your personal config file. In this case it's also a good idea to have your application check that all the required configuration variables are actually set, in case someone has forgotten to update their config file after changes to the sample Have a file of default values in git You keep a file config. Defaults in git, which has sensible default configuration values as far as possible.
Your application first sources configuration from config. Defaults and then from config (which is in gitignore ) to possibly override any of the default values. With this method, typically you wouldn't make it an error for config not to exist, so the application can work out of the box for people who haven't bothered to create config Using a single configuration file with --assume-unchanged A third possibility, which I wouldn't recommend in this case, personally, would be to have a single configuration file which is committed in git, but to use git update-index --assume-unchanged.
You can't easily just ignore changes to particular lines of a file, I'm afraid, so you're probably stuck with having a separate configuration file. Below I've listed two typical ways of dealing with this, and one slightly more exotic one: Have a sample configuration file in git Here, you would keep a file config. Sample in git as an example, but the application would actually use the values in a file config which is in .gitignore.
The application would then produce an error unless config is present. You have to remember to change values in the sample file when you add new configuration variables to your personal config file. In this case it's also a good idea to have your application check that all the required configuration variables are actually set, in case someone has forgotten to update their config file after changes to the sample.
Have a file of default values in git You keep a file config. Defaults in git, which has sensible default configuration values as far as possible. Your application first sources configuration from config.
Defaults and then from config (which is in . Gitignore) to possibly override any of the default values. With this method, typically you wouldn't make it an error for config not to exist, so the application can work out of the box for people who haven't bothered to create config.
Using a single configuration file with --assume-unchanged A third possibility, which I wouldn't recommend in this case, personally, would be to have a single configuration file which is committed in git, but to use git update-index --assume-unchanged , to tell git to ignore changes to it. (This is described further in this useful blog post. ) That means that your local changes to the configuration file won't be committed with git commit -a or show up in git status.
In my case, I have "config" variables in a separate (small) file as do all the other developers on the team. Things like my database location etc. Are kept there. We put the name of this file in our .
Gitignore so that it's not version controlled but checkin a "sample_config" file so that newcomers can make a copy and use it for their own purposes.
Python/Django-specific solution is to have a shared settings. Py files that is checked into the repository, and a local settings_local. Py imported at the end of settings.Py, that overrides some of the settings with machine-specific values.
Other options (not elegant but may be helpful): Use git stash and git stash pop for your config file Have a branch named, say, config which has your local config file changes and then use git checkout config Second option is good if you need to keep the local config changes in the repo (somewhere).
You can't easily just ignore changes to particular lines of a file, I'm afraid, so you're probably stuck with having a separate configuration file. Here, you would keep a file config. Sample in git as an example, but the application would actually use the values in a file config which is in .gitignore.
The application would then produce an error unless config is present. You have to remember to change values in the sample file when you add new configuration variables to your personal config file. In this case it's also a good idea to have your application check that all the required configuration variables are actually set, in case someone has forgotten to update their config file after changes to the sample.
You keep a file config. Defaults in git, which has sensible default configuration values as far as possible. Your application first sources configuration from config.
Defaults and then from config (which is in . Gitignore) to possibly override any of the default values. With this method, typically you wouldn't make it an error for config not to exist, so the application can work out of the box for people who haven't bothered to create config.
A third possibility, which I wouldn't recommend in this case, personally, would be to have a single configuration file which is committed in git, but to use git update-index --assume-unchanged , to tell git to ignore changes to it. (This is described further in this useful blog post.) That means that your local changes to the configuration file won't be committed with git commit -a or show up in git status.
I cant really gove you an answer,but what I can give you is a way to a solution, that is you have to find the anglde that you relate to or peaks your interest. A good paper is one that people get drawn into because it reaches them ln some way.As for me WW11 to me, I think of the holocaust and the effect it had on the survivors, their families and those who stood by and did nothing until it was too late.