Does version control have a deployment history or development history?

Question

... let's say I check some code, do a little dev or refactoring or something like that. I will only test it when I'm completely happy? ... what if I change my mind about things while I code? can i revert to the previous local version? is there a story of my local development?

Is version control of deployment history or development history?

Answer 1

Interestingly enough, no one mentioned the use of branching.

Affiliates are a great way to maintain a healthy chest by constantly checking everything you do, broken or not. Think of it as undoing a new timeline for a code; the main timeline (trunk) strokes and always works; branches can be any state at all, without affecting the trunk.

This allows you to commit early and often, without worrying about confusing someone else, and ensures that you would never have I-gone-too-far-and-not-reverse-this moment when developing what something new or oh lord-I lost-a week if your local drive should die. (It goes without saying that your repository must live somewhere, which is often backed up!)

Once your code works, you can merge the branch back into the trunk, and now the trunk receives your new code; now the new branches from the chest have all the code to process.

This is git's enormous appeal to many: it's very easy to fork and merge, which makes it easy to just drop a new branch or even branch branches when you need them. Even CVS can perform branching and merging, although it is much more cumbersome.

Answer 2

The short answer. It is both.

You need to be able to revert to earlier versions for many reasons.

Answer 3

Both, but above all a development story. The chest does not have to be constantly deployed - that would be crazy.

Instead, you commit commit until you are ready to deploy. Then you tag / tag / paste your repository to indicate which code has been deployed.

Answer 4

"Is there version control of deployment history or development history?"

AND.

Revisions / file versions for developers and branches / tags / tags for deployment.

Much of this depends on your organization’s policies.

As for local working copies and revisions - if you have a VCS that allows the use of separate workspaces / branches, and then promotion or a distributed system, it really doesn’t matter if you check bad code, and you can use VCS to private things are all you want.

For a centralized system, you probably don't want to check untested / incompatible code ...

it depends on your organization.

Answer 5

er, both ...

You should check your work at any time when it is stable - this will happen many times in development.

All source repositories have a version tagged — you use this to indicate release versions that are ultimately deployed.

So, the development is basically, but essentially also released.

Answer 6

Depends on you, on your team and on your tools. For example, with a centralized version control system, you should not do “broken” or “incomplete” things, while with a distributed one you can, and you will get benefits if you do. See here for more detailed (and interesting) examples: http://bazaar-vcs.org/Workflows

Answer 7

I think the correct answer is probably "it depends" :)

If you use version control in a production environment, then this is about the deployment history. If you use it in development, this is a development story. If you use the same version control system in both places (not uncommon), it will probably differ in branches. For example, you have your branches and branches of functions that are related to development, then you can divide them into release branches that will be placed in production systems. The history of release branches shows the deployment history.

Some version control systems like git and mercurial, and I think SVK (weird modified SVN) allows you to have local repositories from which you can get previous local versions. AFAIK, none of them will allow you to roll back unless you at least have made your change in your local repo. Eclipse also allows you to revert to previous versions regardless of your version control system.

Answer 8

Version control is security and the simultaneous modification of stored information. Even with version control software, you still need to determine what version is and what deployment unit. Without it, version control only offers a basic rollback mechanism and many options with low interest and subtle meaning.

Answer 9

The margins between the two are very small. However, if version control is used, correct it for source control, which means development management / history. If you use well, you often check and get a good version history that can be used to track when you did something, to report the time and back up if errors occur.

Short answer: when used correctly :)

Answer 10

... let's say I check some code, do a little dev or refactoring or something else .. will I only check it when I'm completely happy?

This is a matter of personal preference. Of course, you can check the code that does not compile, or where the added function is not completed. But it can hurt anyone who accesses your repository (if there is anyone) to check files that do not work. I think that the answer to this question largely depends on the size of the team of your project and the personality of the team.

is there a story of my local development?

Depends on the particular version control system you are using. Git allows you to track local changes.

Is version control of deployment history or development history?

A development history, although I don’t see what prevents you from checking the deployment files and configuration files in the repository with each version (however, there are probably better systems for tracking these kinds of things).

Answer 11

In terms of verification, when you commit is dependent on the policies of your team. Some teams use continuous integration tools to ensure that the current version of the code compiles and passes the tests, which means that you usually should not interrupt the code. Work in the branch can reduce the risk of job loss in this situation.

For local history, you do not get this for free with version control, although some IDEs keep their own local stories.

Answer 12

Jeff thinks you should check earlier, check often , then I have to subscribe to the same idea. Although, as I do this, I have to use my chest as the main storage, which is "production", and my branches are the place where I do all my development. Thus, I can check all my changes whenever I want, without worrying about what happens at the factory. When I finish with this specific improvement, I merge with this branch on the trunk.

Answer 13

This is definitely an individual choice when you register and what you register. Some things that can help determine the best choice will be whether you use a central or distributed version control system, or if there is a team or person working on the code.

In distributed systems, what you register is local to you, and only what you choose to interpret for others is what they see if you have a broken tree because you register often, it doesn’t matter, whereas with a central repository, if you are checking the trunk, it is usually recommended to have only a working code. How would you feel if you did an update for your tree and someone else on your team broke the code and then your copy will no longer compile. An easy way to get around this problem in setting up a central repository is to split the trunk code, make your changes often, and then when you are happy that it is working correctly, you can merge your branch back into the trunk. This way you do not stop the trunk from always being in the runnable state, which is a useful state to save it. This becomes even more important as you add people to your team.

As for reverting to previous versions, this is not a problem if it has been checked in the repository. You can return as many versions as you want by looking at the commit log and then using the appropriate command to return to the specific revision.

Answer 14

It depends on the use of your version control system ...

In my experience, most companies use it for deployment history in most cases. That is, only a working code should be entered. If you check something, and then in the process of adding a block of code that still does not work, then checking it back means that it is possible to check someone else's broken product.

I came across situations where companies use it in such a way that you check your code every day and whatever state you are in at the end of the day when you check it. So, if someone wants to add something, maybe no matter what state they are in right now ... and although I see some sense in the logic, it just doesn't work for me.