Rectangle 27 3

Working on a team:

Like walkietokyo said, having your code separated into objects can make it really easy for you down the road to use your code again. Want to add another type of weapon to level 4 in your game? Easy. new GrenadeLauncher();. Eventually, you'll have a little library of components you'll use in all your projects, saving you plenty of time.

If your entire application is inside a FLA, a user has to download the entire FLA (assuming the content is available on a webpage) before she can use it. For small programs, this isn't a big deal. For massive programs with many different screens, or for games with levels, this can be a problem because everything stays in memory. You can save on download time and memory usage by only keeping in memory what you need.

Let's say you're making a game and you're coding up level 6. Meanwhile, your artist is adding some art to the library and making some tweaks on the stage. You commit your changes to the version control system, and there's a conflict. Your artist already committed her changes and now you have to replicate everything she did in your version, wasting both her and your time. If you were coding level 6 in level6.as, this wouldn't have happened. Personally, I find this the best reason to code in text files and leave the FLAs for UI and art.

Two months down the road, you're going to open up your file and want to find that nice grenade launcher you wrote, but you won't know where to begin. If you code in a structured way in files using packages, you won't need to remember. Just go through your folders, and eventually you'll find mygame.weapons.GrenadeLauncher.as.

oops. looks like I said pretty much the same thing as mitim. but there you have it. coding in text files is a clear winner.

Flash actionscript 3 differences between throwing code to timeline and...

actionscript-3 flash
Rectangle 27 85

Is the branch you are getting changes from shared with other developer...

If you have any doubt, use merge.

The only differences between a rebase and a merge are:

  • The resulting tree structure of the history (generally only noticeable when looking at a commit graph) is different (one will have branches, the other won't).
  • Merge will generally create an extra commit (e.g. node in the tree).

There are a few factors you should consider when choosing which operation to use.

If so, don't rebase. Rebase destroys the branch and those developers will have broken/inconsistent repositories unless they use git pull --rebase. This is a good way to upset other developers quickly.

you could lose committed work and/or break the consistency of other developer's repositories.

I've worked on teams where the developers all came from a time when companies could afford dedicated staff to deal with branching and merging. Those developers don't know much about Git and don't want to know much. In these teams I wouldn't risk recommending rebasing for any reason.

Some teams use the branch-per-feature model where each branch represents a feature (or bugfix, or sub-feature, etc.) In this model the branch helps identify sets of related commits. For example, one can quickly revert a feature by reverting the merge of that branch (to be fair, this is a rare operation). Or diff a feature by comparing two branches (more common). Rebase would destroy the branch and this would not be straightforward.

I've also worked on teams that used the branch-per-developer model (we've all been there). In this case the branch itself doesn't convey any additional information (the commit already has the author). There would be no harm in rebasing.

Reverting (as in undoing) a rebase is considerably difficult and/or impossible (if the rebase had conflicts) compared to reverting a merge. If you think there is a chance you will want to revert then use merge.

Rebase operations need to be pulled with a corresponding git pull --rebase. If you are working by yourself you may be able to remember which you should use at the appropriate time. If you are working on a team this will be very difficult to coordinate. This is why most rebase workflows recommend using rebase for all merges (and git pull --rebase for all pulls).

Assuming you have the following merge:

B -- C
   /      \
  A--------D

Some people will state that the merge "destroys" the commit history because if you were to look at the log of only the master branch (A -- D) you would miss the important commit messages contained in B and C.

If this were true we wouldn't have questions like this. Basically, you will see B and C unless you explicitly ask not to see them (using --first-parent). This is very easy to try for yourself.

The two approaches merge differently, but it is not clear that one is always better than the other and it may depend on the developer workflow. For example, if a developer tends to commit regularly (e.g. maybe they commit twice a day as they transition from work to home) then there could be a lot of commits for a given branch. Many of those commits might not look anything like the final product (I tend to refactor my approach once or twice per feature). If someone else was working on a related area of code and they tried to rebase my changes it could be a fairly tedious operation.

rm
rm -rf

I always think that someday I will come across a scenario where git rebase is the awesome tool that solves the problem. Much like I think I will come across a scenario where git reflog is an awesome tool that solves my problem. I have worked with git for over five years now. It hasn't happened.

Messy histories have never really been a problem for me. I don't ever just read my commit history like an exciting novel. A majority of the time I need a history I am going to use git blame or git bisect anyways. In that case having the merge commit is actually useful to me because if the merge introduced the issue that is meaningful information to me.

I feel obligated to mention that I have personally softened on using rebase although my general advice still stands. I have recently been interacting a lot with the Angular 2 Material project. They have used rebase to keep a very clean commit history. This has allowed me to very easily see what commit fixed a given defect and whether or not that commit was included in a release. It serves as a great example of using rebase correctly.

version control - When do you use git rebase instead of git merge? - S...

git version-control git-merge git-rebase
Rectangle 27 85

Is the branch you are getting changes from shared with other developer...

If you have any doubt, use merge.

The only differences between a rebase and a merge are:

  • The resulting tree structure of the history (generally only noticeable when looking at a commit graph) is different (one will have branches, the other won't).
  • Merge will generally create an extra commit (e.g. node in the tree).

There are a few factors you should consider when choosing which operation to use.

If so, don't rebase. Rebase destroys the branch and those developers will have broken/inconsistent repositories unless they use git pull --rebase. This is a good way to upset other developers quickly.

you could lose committed work and/or break the consistency of other developer's repositories.

I've worked on teams where the developers all came from a time when companies could afford dedicated staff to deal with branching and merging. Those developers don't know much about Git and don't want to know much. In these teams I wouldn't risk recommending rebasing for any reason.

Some teams use the branch-per-feature model where each branch represents a feature (or bugfix, or sub-feature, etc.) In this model the branch helps identify sets of related commits. For example, one can quickly revert a feature by reverting the merge of that branch (to be fair, this is a rare operation). Or diff a feature by comparing two branches (more common). Rebase would destroy the branch and this would not be straightforward.

I've also worked on teams that used the branch-per-developer model (we've all been there). In this case the branch itself doesn't convey any additional information (the commit already has the author). There would be no harm in rebasing.

Reverting (as in undoing) a rebase is considerably difficult and/or impossible (if the rebase had conflicts) compared to reverting a merge. If you think there is a chance you will want to revert then use merge.

Rebase operations need to be pulled with a corresponding git pull --rebase. If you are working by yourself you may be able to remember which you should use at the appropriate time. If you are working on a team this will be very difficult to coordinate. This is why most rebase workflows recommend using rebase for all merges (and git pull --rebase for all pulls).

Assuming you have the following merge:

B -- C
   /      \
  A--------D

Some people will state that the merge "destroys" the commit history because if you were to look at the log of only the master branch (A -- D) you would miss the important commit messages contained in B and C.

If this were true we wouldn't have questions like this. Basically, you will see B and C unless you explicitly ask not to see them (using --first-parent). This is very easy to try for yourself.

The two approaches merge differently, but it is not clear that one is always better than the other and it may depend on the developer workflow. For example, if a developer tends to commit regularly (e.g. maybe they commit twice a day as they transition from work to home) then there could be a lot of commits for a given branch. Many of those commits might not look anything like the final product (I tend to refactor my approach once or twice per feature). If someone else was working on a related area of code and they tried to rebase my changes it could be a fairly tedious operation.

rm
rm -rf

I always think that someday I will come across a scenario where git rebase is the awesome tool that solves the problem. Much like I think I will come across a scenario where git reflog is an awesome tool that solves my problem. I have worked with git for over five years now. It hasn't happened.

Messy histories have never really been a problem for me. I don't ever just read my commit history like an exciting novel. A majority of the time I need a history I am going to use git blame or git bisect anyways. In that case having the merge commit is actually useful to me because if the merge introduced the issue that is meaningful information to me.

I feel obligated to mention that I have personally softened on using rebase although my general advice still stands. I have recently been interacting a lot with the Angular 2 Material project. They have used rebase to keep a very clean commit history. This has allowed me to very easily see what commit fixed a given defect and whether or not that commit was included in a release. It serves as a great example of using rebase correctly.

version control - When do you use git rebase instead of git merge? - S...

git version-control git-merge git-rebase
Rectangle 27 80

Is the branch you are getting changes from shared with other developer...

If you have any doubt, use merge.

The only differences between a rebase and a merge are:

  • The resulting tree structure of the history (generally only noticeable when looking at a commit graph) is different (one will have branches, the other won't).
  • Merge will generally create an extra commit (e.g. node in the tree).

There are a few factors you should consider when choosing which operation to use.

If so, don't rebase. Rebase destroys the branch and those developers will have broken/inconsistent repositories unless they use git pull --rebase. This is a good way to upset other developers quickly.

you could lose committed work and/or break the consistency of other developer's repositories.

I've worked on teams where the developers all came from a time when companies could afford dedicated staff to deal with branching and merging. Those developers don't know much about Git and don't want to know much. In these teams I wouldn't risk recommending rebasing for any reason.

Some teams use the branch-per-feature model where each branch represents a feature (or bugfix, or sub-feature, etc.) In this model the branch helps identify sets of related commits. For example, one can quickly revert a feature by reverting the merge of that branch (to be fair, this is a rare operation). Or diff a feature by comparing two branches (more common). Rebase would destroy the branch and this would not be straightforward.

I've also worked on teams that used the branch-per-developer model (we've all been there). In this case the branch itself doesn't convey any additional information (the commit already has the author). There would be no harm in rebasing.

Reverting (as in undoing) a rebase is considerably difficult and/or impossible (if the rebase had conflicts) compared to reverting a merge. If you think there is a chance you will want to revert then use merge.

Rebase operations need to be pulled with a corresponding git pull --rebase. If you are working by yourself you may be able to remember which you should use at the appropriate time. If you are working on a team this will be very difficult to coordinate. This is why most rebase workflows recommend using rebase for all merges (and git pull --rebase for all pulls).

Assuming you have the following merge:

B -- C
   /      \
  A--------D

Some people will state that the merge "destroys" the commit history because if you were to look at the log of only the master branch (A -- D) you would miss the important commit messages contained in B and C.

If this were true we wouldn't have questions like this. Basically, you will see B and C unless you explicitly ask not to see them (using --first-parent). This is very easy to try for yourself.

The two approaches merge differently, but it is not clear that one is always better than the other and it may depend on the developer workflow. For example, if a developer tends to commit regularly (e.g. maybe they commit twice a day as they transition from work to home) then there could be a lot of commits for a given branch. Many of those commits might not look anything like the final product (I tend to refactor my approach once or twice per feature). If someone else was working on a related area of code and they tried to rebase my changes it could be a fairly tedious operation.

rm
rm -rf

I always think that someday I will come across a scenario where git rebase is the awesome tool that solves the problem. Much like I think I will come across a scenario where git reflog is an awesome tool that solves my problem. I have worked with git for over five years now. It hasn't happened.

Messy histories have never really been a problem for me. I don't ever just read my commit history like an exciting novel. A majority of the time I need a history I am going to use git blame or git bisect anyways. In that case having the merge commit is actually useful to me because if the merge introduced the issue that is meaningful information to me.

I feel obligated to mention that I have personally softened on using rebase although my general advice still stands. I have recently been interacting a lot with the Angular 2 Material project. They have used rebase to keep a very clean commit history. This has allowed me to very easily see what commit fixed a given defect and whether or not that commit was included in a release. It serves as a great example of using rebase correctly.

version control - When do you use git rebase instead of git merge? - S...

git version-control git-merge git-rebase
Rectangle 27 80

Is the branch you are getting changes from shared with other developer...

If you have any doubt, use merge.

The only differences between a rebase and a merge are:

  • The resulting tree structure of the history (generally only noticeable when looking at a commit graph) is different (one will have branches, the other won't).
  • Merge will generally create an extra commit (e.g. node in the tree).

There are a few factors you should consider when choosing which operation to use.

If so, don't rebase. Rebase destroys the branch and those developers will have broken/inconsistent repositories unless they use git pull --rebase. This is a good way to upset other developers quickly.

you could lose committed work and/or break the consistency of other developer's repositories.

I've worked on teams where the developers all came from a time when companies could afford dedicated staff to deal with branching and merging. Those developers don't know much about Git and don't want to know much. In these teams I wouldn't risk recommending rebasing for any reason.

Some teams use the branch-per-feature model where each branch represents a feature (or bugfix, or sub-feature, etc.) In this model the branch helps identify sets of related commits. For example, one can quickly revert a feature by reverting the merge of that branch (to be fair, this is a rare operation). Or diff a feature by comparing two branches (more common). Rebase would destroy the branch and this would not be straightforward.

I've also worked on teams that used the branch-per-developer model (we've all been there). In this case the branch itself doesn't convey any additional information (the commit already has the author). There would be no harm in rebasing.

Reverting (as in undoing) a rebase is considerably difficult and/or impossible (if the rebase had conflicts) compared to reverting a merge. If you think there is a chance you will want to revert then use merge.

Rebase operations need to be pulled with a corresponding git pull --rebase. If you are working by yourself you may be able to remember which you should use at the appropriate time. If you are working on a team this will be very difficult to coordinate. This is why most rebase workflows recommend using rebase for all merges (and git pull --rebase for all pulls).

Assuming you have the following merge:

B -- C
   /      \
  A--------D

Some people will state that the merge "destroys" the commit history because if you were to look at the log of only the master branch (A -- D) you would miss the important commit messages contained in B and C.

If this were true we wouldn't have questions like this. Basically, you will see B and C unless you explicitly ask not to see them (using --first-parent). This is very easy to try for yourself.

The two approaches merge differently, but it is not clear that one is always better than the other and it may depend on the developer workflow. For example, if a developer tends to commit regularly (e.g. maybe they commit twice a day as they transition from work to home) then there could be a lot of commits for a given branch. Many of those commits might not look anything like the final product (I tend to refactor my approach once or twice per feature). If someone else was working on a related area of code and they tried to rebase my changes it could be a fairly tedious operation.

rm
rm -rf

I always think that someday I will come across a scenario where git rebase is the awesome tool that solves the problem. Much like I think I will come across a scenario where git reflog is an awesome tool that solves my problem. I have worked with git for over five years now. It hasn't happened.

Messy histories have never really been a problem for me. I don't ever just read my commit history like an exciting novel. A majority of the time I need a history I am going to use git blame or git bisect anyways. In that case having the merge commit is actually useful to me because if the merge introduced the issue that is meaningful information to me.

I feel obligated to mention that I have personally softened on using rebase although my general advice still stands. I have recently been interacting a lot with the Angular 2 Material project. They have used rebase to keep a very clean commit history. This has allowed me to very easily see what commit fixed a given defect and whether or not that commit was included in a release. It serves as a great example of using rebase correctly.

version control - When do you use git rebase instead of git merge? - S...

git version-control git-merge git-rebase
Rectangle 27 82

Half of the team favored four-space indentation; the other half favored two-space indentation.

As you can guess, the coding standard mandated three, so as to "offend all equally" (a direct quote).

Thats why tab identation is so great. Everyone can change the size in his editor ;)

Yeah, tab indentation is great... until you actually open someone else's file, and find things misaligned because spaces got mixed in where they shouldn't have, or didn't get mixed in where they should have. Then you auto-reformat, and version control diffs get ugly. Ugh.

that's why you're supposed to use only tabs to indent, and only spaces to align, and never the twain shall meet. and if you're going to make a change to the whitespace in a file, then that needs to be the only change you make for that particular check-in.

To "offend all equally"... I love it. I'm going to have to remember this the next time I'm somehow invloved in an indentation standardization war.

What was the strangest coding standard rule that you were forced to fo...

coding-style
Rectangle 27 82

Half of the team favored four-space indentation; the other half favored two-space indentation.

As you can guess, the coding standard mandated three, so as to "offend all equally" (a direct quote).

Thats why tab identation is so great. Everyone can change the size in his editor ;)

Yeah, tab indentation is great... until you actually open someone else's file, and find things misaligned because spaces got mixed in where they shouldn't have, or didn't get mixed in where they should have. Then you auto-reformat, and version control diffs get ugly. Ugh.

that's why you're supposed to use only tabs to indent, and only spaces to align, and never the twain shall meet. and if you're going to make a change to the whitespace in a file, then that needs to be the only change you make for that particular check-in.

To "offend all equally"... I love it. I'm going to have to remember this the next time I'm somehow invloved in an indentation standardization war.

What was the strangest coding standard rule that you were forced to fo...

coding-style
Rectangle 27 82

Half of the team favored four-space indentation; the other half favored two-space indentation.

As you can guess, the coding standard mandated three, so as to "offend all equally" (a direct quote).

Thats why tab identation is so great. Everyone can change the size in his editor ;)

Yeah, tab indentation is great... until you actually open someone else's file, and find things misaligned because spaces got mixed in where they shouldn't have, or didn't get mixed in where they should have. Then you auto-reformat, and version control diffs get ugly. Ugh.

that's why you're supposed to use only tabs to indent, and only spaces to align, and never the twain shall meet. and if you're going to make a change to the whitespace in a file, then that needs to be the only change you make for that particular check-in.

To "offend all equally"... I love it. I'm going to have to remember this the next time I'm somehow invloved in an indentation standardization war.

What was the strangest coding standard rule that you were forced to fo...

coding-style
Rectangle 27 82

Half of the team favored four-space indentation; the other half favored two-space indentation.

As you can guess, the coding standard mandated three, so as to "offend all equally" (a direct quote).

Thats why tab identation is so great. Everyone can change the size in his editor ;)

Yeah, tab indentation is great... until you actually open someone else's file, and find things misaligned because spaces got mixed in where they shouldn't have, or didn't get mixed in where they should have. Then you auto-reformat, and version control diffs get ugly. Ugh.

that's why you're supposed to use only tabs to indent, and only spaces to align, and never the twain shall meet. and if you're going to make a change to the whitespace in a file, then that needs to be the only change you make for that particular check-in.

To "offend all equally"... I love it. I'm going to have to remember this the next time I'm somehow invloved in an indentation standardization war.

What was the strangest coding standard rule that you were forced to fo...

coding-style
Rectangle 27 7

Open your team project in your web browser.

Browse to the solution and then copy the path to your clipboard so that you can paste it into the Solution to build box of the build definition, shown above.

Git in Visual Studio Team Services, Visual Studio 2012 Project - can't...

git visual-studio tfs continuous-integration vsts
Rectangle 27 95

You can now do this in Visual Studio by going to the Synchronisation tab (Sync in the Team drop down menu) and clicking Fetch at the top.

Thx! Just a small remark, don't you find it confusing that it states: Branch master? I then always things I am performing the action on the master branch

git - Remote branch on Visual Studio online doesn't appear on Visual S...

git visual-studio vsts
Rectangle 27 91

We were doing a C++ project and the team lead was a Pascal guy.

So we had a coding standard include file to redefine all that pesky C and C++ syntax:

#define BEGIN {
#define END }
#define ENDIF }
#define CASE switch

This took what would have been perfectly readable C++ code and made it illegible to anyone except the team lead.

MyClass *class_pt  // pt = pointer to type

UINT32 maxHops_u   // u = uint32

You know, I think I'm with you on that. The hungarian warts aren't nearly so objectionable when tacked onto the end like that.

haha takes me back to the days when I switched from Pascal to C++ (about 16 years ago). Every time I saw a { I had to mentally tell myself "{ means BEGIN". At least for me it was just in my head.

When I worked in MS VC++ support, we had several customers submit repro code written like this. It took a while for us to realize it was actually in C++ (they didn't include the #defines).

What was the strangest coding standard rule that you were forced to fo...

coding-style
Rectangle 27 91

We were doing a C++ project and the team lead was a Pascal guy.

So we had a coding standard include file to redefine all that pesky C and C++ syntax:

#define BEGIN {
#define END }
#define ENDIF }
#define CASE switch

This took what would have been perfectly readable C++ code and made it illegible to anyone except the team lead.

MyClass *class_pt  // pt = pointer to type

UINT32 maxHops_u   // u = uint32

You know, I think I'm with you on that. The hungarian warts aren't nearly so objectionable when tacked onto the end like that.

haha takes me back to the days when I switched from Pascal to C++ (about 16 years ago). Every time I saw a { I had to mentally tell myself "{ means BEGIN". At least for me it was just in my head.

When I worked in MS VC++ support, we had several customers submit repro code written like this. It took a while for us to realize it was actually in C++ (they didn't include the #defines).

What was the strangest coding standard rule that you were forced to fo...

coding-style
Rectangle 27 91

We were doing a C++ project and the team lead was a Pascal guy.

So we had a coding standard include file to redefine all that pesky C and C++ syntax:

#define BEGIN {
#define END }
#define ENDIF }
#define CASE switch

This took what would have been perfectly readable C++ code and made it illegible to anyone except the team lead.

MyClass *class_pt  // pt = pointer to type

UINT32 maxHops_u   // u = uint32

You know, I think I'm with you on that. The hungarian warts aren't nearly so objectionable when tacked onto the end like that.

haha takes me back to the days when I switched from Pascal to C++ (about 16 years ago). Every time I saw a { I had to mentally tell myself "{ means BEGIN". At least for me it was just in my head.

When I worked in MS VC++ support, we had several customers submit repro code written like this. It took a while for us to realize it was actually in C++ (they didn't include the #defines).

What was the strangest coding standard rule that you were forced to fo...

coding-style
Rectangle 27 91

We were doing a C++ project and the team lead was a Pascal guy.

So we had a coding standard include file to redefine all that pesky C and C++ syntax:

#define BEGIN {
#define END }
#define ENDIF }
#define CASE switch

This took what would have been perfectly readable C++ code and made it illegible to anyone except the team lead.

MyClass *class_pt  // pt = pointer to type

UINT32 maxHops_u   // u = uint32

You know, I think I'm with you on that. The hungarian warts aren't nearly so objectionable when tacked onto the end like that.

haha takes me back to the days when I switched from Pascal to C++ (about 16 years ago). Every time I saw a { I had to mentally tell myself "{ means BEGIN". At least for me it was just in my head.

When I worked in MS VC++ support, we had several customers submit repro code written like this. It took a while for us to realize it was actually in C++ (they didn't include the #defines).

What was the strangest coding standard rule that you were forced to fo...

coding-style
Rectangle 27 9

Per May 16th 2013, using XCode 4.6.2, I had to do the following to add a device (which I do not have physical access to) to the team provisioning profile:

  • Add the UDID in Devices
  • Select the Team Provisioning profile in Provisioning Profiles
  • And under devices for that provisioning profile, click Select All, or just the devices you want included.
  • Then go back to XCode and click refresh icon (bottom right) under Organizer -> Devices -> Provisioning Profiles

Sometimes it takes a while before the certificate is updated and fetched from XCode.

No more Provisioning Profiles tab in Organiser in XCode 5. I guess that means it's all automatic now?

In xCode 5, it's moved to Preferences -> Accounts -> View Details (under the apple ID) -> then hit the tiny refresh button at the bottom. My guess is, it was too easy to do in xCode 4, so apple moved it somewhere harder to find

If the Provisioning Profile is "Managed By Xcode" the "Edit" button is greyed out on the website.

Since we've got XCode 5 now, a lot has changed, but clicking delete will make XCode create a new one for you. And I think all devices will be automatically added for you.

iphone - Adding devices to team provisioning profile - Stack Overflow

iphone provisioning
Rectangle 27 69

People need to put down the gun, step away from the ledge, and think for a minute. It turns out there are objective, concrete, and undeniable advantages to DVCS that will make a HUGE difference in a team's productivity.

Before DVCS, the guiding principle was "Pray to God that you don't have to get into branching and merging. And if you do, at least beg Him to let it be very, very simple."

Now, with DVCS, branching (and merging) is so much improved, the guiding principle is, "Do it at the drop of a hat. It will give you a ton of benefits and not cause you any problems."

And that is a HUGE productivity booster for any team.

The problem is, for people to understand what I just said and be convinced that it is true, they have to first invest in a little bit of a learning curve. They don't have to learn Git or any other DVCS itself ... they just need to learn how Git does branching and merging. Read and re-read some articles and blog posts, taking it slow, and working through it until you see it. That might take the better part of 2 or 3 full days.

But once you see that, you won't even consider choosing a non-DVCS. Because there really are clear, objective, concrete advantages to DVCS, and the biggest wins are in the area of branching and merging.

Thanks, Charlie. I know it, and you know it, but it is hard to get through to people who say things like "integration of source control with Visual Studio is the most important feature for me"

I know. A friend and I were throwing this analogy around -- imagine you need a serious relational database. You evaluate Sql Server, Oracle, and MS Access. You end up choosing Access because it has the nicest GUI, in spite of the fact that it can't scale, doesn't enforce referential integrity very well, etc. Branching and Merging are the absolute meat and potatoes of a version control system. Any other feature is just a little bling on the side. But people are making choices based on the bling.

While I tend to agree with your statements, I don't see why Git's branching and merging is "better" just because it is a "distributed" system. I'm not sure that being a DVCS has anything to do with its ability to merge. I'd love an explanation of why merging is easier in a distributed system. In my experience, which is primarily Git and Svn, merging in SVN is terrible not because it is a centralized VCS, but because it doesn't properly track revisions across branches like GIT does.

@rally25rs -- I agree with most of that. There's no reason a VCS can't be good at merging too. There just aren't any yet (that I know of). But the part I disagree with is "purely by writing better merge routines that resolved conflicts better." The secret sauce is not in better-smarter merge routines, but in taking a fundamentally different approach to what information you store in the repo and how you organize it. Mainly, making Commits the foundation of the internal state. Commits are not just a cool bolt-on ... they are the foundation of the capabilities.

@rally25rs totally agree re: commits being the atomic unit of work. Not only do most centralized systems not organize the data this way, but they discourage the moment-to-moment kind of work the developers have to do in order to make really good branch-and-merge work. Distributed systems encourage what I call "apposite" commits (self-contained, small commits of relevant work with good descriptions) and centralized systems encourage what I call "diff bombs" where you hole up in a cave until you are ready and then drop days (or weeks) worth of work on the system. Guess which kind merges best?

tfs - Git vs Team Foundation Server - Stack Overflow

git tfs
Rectangle 27 31

My team moved away from Bower and migrated to npm because:

  • Some features, like the url shorthand, are entirely broken
  • Using both Bower and npm in the same project is painful
  • Keeping bower.json version field in sync with git tags is painful
  • CommonJS support is not straightforward

javascript - What is the difference between Bower and npm? - Stack Ove...

javascript npm bower
Rectangle 27 31

My team moved away from Bower and migrated to npm because:

  • Some features, like the url shorthand, are entirely broken
  • Using both Bower and npm in the same project is painful
  • Keeping bower.json version field in sync with git tags is painful
  • CommonJS support is not straightforward

javascript - What is the difference between Bower and npm? - Stack Ove...

javascript npm bower
Rectangle 27 31

My team moved away from Bower and migrated to npm because:

  • Some features, like the url shorthand, are entirely broken
  • Using both Bower and npm in the same project is painful
  • Keeping bower.json version field in sync with git tags is painful
  • CommonJS support is not straightforward

javascript - What is the difference between Bower and npm? - Stack Ove...

javascript npm bower