What should NOT be under source control?
Language AgnosticVersion ControlLanguage Agnostic Problem Overview
It would be nice to have a more or less complete list over what files and/or directories that shouldn't (in most cases) be under source control. What do you think should be excluded?
Suggestion so far:
In general
- Config files with sensitive information (passwords, private keys etc.)
- Thumbs.db, .DS_Store and desktop.ini
- Editor backups: *~ (emacs)
- Generated files (for instance DoxyGen output)
C#
- bin\*
- obj\*
- *.exe
Visual Studio
- *.suo
- *.ncb
- *.user
- *.aps
- *.cachefile
- *.backup
- _UpgradeReport_Files
Java
- *.class
Eclipse
I don't know, and this is what I'm looking for right now :-)
Python
- *.pyc
Temporary files
- .*.sw?
- *~
Language Agnostic Solutions
Solution 1 - Language Agnostic
Anything that is generated. Binary, bytecode, code/documents generated from XML.
From my commenters, exclude:
- Anything generated by the build, including code documentations (doxygen, javadoc, pydoc, etc.)
But include:
- 3rd party libraries that you don't have the source for OR don't build.
FWIW, at my work for a very large project, we have the following under ClearCase:
- All original code
- Qt source AND built debug/release
- (Terribly outdated) specs
We do not have built modules for our software. A complete binary is distributed every couple weeks with the latest updates.
Solution 2 - Language Agnostic
OS specific files, generated by their file browsers such as
Thumbs.db
and .DS_Store
Solution 3 - Language Agnostic
Some other Visual Studio typical files/folders are
*.cachefile
*.backup
_UpgradeReport_Files
My tortoise global ignore pattern for example looks like this
bin obj *.suo *.user *.cachefile *.backup _UpgradeReport_Files
Solution 4 - Language Agnostic
files that get built should not be checked in
Solution 5 - Language Agnostic
Like Corey D has said anything that is generated, specifically anything that is generated by the build process and development environment are good candidates. For instance:
- Binaries and installers
- Bytecode and archives
- Documents generated from XML and code
- Code generated by templates and code generators
- IDE settings files
- Backup files generated by your IDE or editor
Some exceptions to the above could be:
- Images and video
- Third party libraries
- Team specific IDE settings files
Take third party libraries, if you need to ship or your build depends on a third party library it wouldn't be unreasonable to put it under source control, especially if you don't have the source. Also consider some source control systems aren't very efficient at storing binary blobs and you probably will not be able to take advantage of the systems diff tools for those files.
Paul also makes a great comment about generated files and you should check out his answer:
> Basically, if you can't reasonably > expect a developer to have the exact > version of the exact tool they need, > there is a case for putting the > generated files in version control.
With all that being said ultimately you'll need to consider what you put under source control on a case by case basis. Defining a hard list of what and what not to put under it will only work for some and only probably for so long. And of course the more files you add to source control the longer it will take to update your working copy.
Solution 6 - Language Agnostic
I would approach the problem a different way; what things should be included in source control? You should only source control those files that:
- ( need revision history OR are created outside of your build but are part of the build, install, or media ) AND
- can't be generated by the build process you control AND
- are common to all users that build the product (no user config)
The list includes things like:
- source files
- make, project, and solution files
- other build tool configuration files (not user related)
- 3rd party libraries
- pre-built files that go on the media like PDFs & documents
- documentation
- images, videos, sounds
- description files like WSDL, XSL
Sometimes a build output can be a build input. For example, an obfuscation rename file may be an output and an input to keep the same renaming scheme. In this case, use the checked-in file as the build input and put the output in a different file. After the build, check out the input file and copy the output file into it and check it in.
The problem with using an exclusion list is that you will never know all the right exclusions and might end up source controlling something that shouldn't be source controlled.
Solution 7 - Language Agnostic
Anything that can be generated by the IDE, build process or binary executable process.
Solution 8 - Language Agnostic
An exception:
4 or 5 different answers have said that generated files should not go under source control. Thats not quite true.
Files generated by specialist tools may belong in source control, especially if particular versions of those tools are necessary.
Examples:
- parsers generated by bison/yacc/antlr,
- autotools files such as configure or Makefile.in, created by autoconf, automake, libtool etc,
- translation or localization files,
- files may be generated by expensive tools, and it might be cheaper to only install them on a few machines.
Basically, if you can't reasonably expect a developer to have the exact version of the exact tool they need, there is a case for putting the generated files in version control.
This exception is discussed by the svn guys in their best practices talk.
Solution 9 - Language Agnostic
Temp files from editors.
.*.sw?
*~
etc.
Solution 10 - Language Agnostic
desktop.ini
is another windows file I've seen sneak in.
Solution 11 - Language Agnostic
Config files that contain passwords or any other sensitive information.
Solution 12 - Language Agnostic
Actual config files such a web.config in asp.net because people can have different settings. Usually the way I handle this is by having a web.config.template that is on SVN. People get it, make the changes they want and rename it as web.config.
Aside from this and what you said, be careful of sensitive files containing passwords (for instance).
Avoid all the annoying files generated by Windows (thumb) or Mac OS (.ds_store)
Solution 13 - Language Agnostic
*.bak
produced by WinMerge.
Solution 14 - Language Agnostic
additionally:
Visual Studio
- *.ncb
Solution 15 - Language Agnostic
The best way I've found to think about it is as follows:
Pretend you've got a brand-new, store-bought computer. You install the OS and updates; you install all your development tools including the source control client; you create an empty directory to be the root of your local sources; you do a "get latest" or whatever your source control system calls it to fetch out clean copies of the release you want to build; you then run the build (fetched from source control), and everything builds.
This thought process tells you why certain files have to be in source control: all of those necessary for the build to work on a clean system. This includes .designer.cs files, the outputs of T4 templates, and any other artifact that the build will not create.
Solution 16 - Language Agnostic
Temp files, config for anything other than global development and sensitive information
Solution 17 - Language Agnostic
Things that don't go into source control come in 3 classes
- Things totally unrelated to the project (obviously)
- Things that can be found on installation media, and are never changed (eg: 3rd-party APIs).
- Things that can be mechanically generated, via your build process, from things that are in source control (or from things in class 2).
Solution 18 - Language Agnostic
Whatever the language :
- cache files
- generally, imported files should not either (like images uploaded by users, on a web application)
- temporary files ; even the ones generated by your OS (like thumbs.db under windows) or IDE
- config files with passwords ? Depends on who has access to the repository
And for those who don't know about it : svn:ignore
is great!
Solution 19 - Language Agnostic
If you have a runtime environment for your code (e.g. dependency libraries, specific compiler versions etc.) do not put the packages into the source control. My approach is brutal, but effective. I commit a makefile, whose role is to downloads (via wget) the stuff, unpack it, and build my runtime environment.
Solution 20 - Language Agnostic
I have a particular .c file that does not go in source control.
The rule is nothing in source control that is generated during the build process.
The only known exception is if a tool requires an older version of itself to build (bootstrap problem). In that case you will need a known good bootstrap copy in source control so you can build from blank.
Solution 21 - Language Agnostic
Going out on a limb here, but I believe that if you use task lists in Visual Studio, they are kept in the .suo file. This may not be a reason to keep them in source control, but it is a reason to keep a backup somewhere, just in case...
Solution 22 - Language Agnostic
A lot of time has passed since this question was asked, and I think a lot of the answers, while relevant, don't have hard details on .gitignore
on a per language or IDE level.
Github came out with a very useful, community collaborated list of .gitignore
files for all sorts of projects and IDEs that is worth taking a look.
Here's a link to that git repo: https://github.com/github/gitignore
To answer the question, here are the related examples for:
- C# -> see Visual Studio
- Visual Studio
- Java
- Eclipse
- Python
There are also OS-specific .gitignore
files. Following:
So, assuming you're running Windows and using Eclipse, you can just concatenate Eclipse.gitignore
and Windows.gitignore
to a .gitignore
file in the top level directory of your project. Very nifty stuff.
Don't forget to add the .gitignore to your repo and commit it!
Chances are, your IDE already handles this for you. Visual Studio does anyway.
And for the .gitignore
files, If you see any files or patterns missing in a particular .gitignore
, you can open a PR on that file with the proposed change. Take a look at the commit and pull request trackers for ideas.
Solution 23 - Language Agnostic
I am always using www.gitignore.io to generate a proper one .ignore
file.
Solution 24 - Language Agnostic
Opinion: everything can be in source control, if you need to, unless it brings significant repository overhead such as frequently changing or large blobs.
3rd party binaries, hard-to-generate (in terms of time) generated files to speed up your deployment process, all are ok.
The main purpose of source control is to match one coherent system state to a revision number. If it would be possible, I'd freeze the entire universe with the code - build tools and the target operating system.