We have a dev team in asia with tfs and one in US. We would like to have another tfs in US and sync both of them in real time. Each of them can serve as the fail over cluster for each other.
Going forward we want to have teams login to respective server.
How can we achieve replication in real time ?. How does merge and collision be dealt with?.
We have proxy already but we want something better than that.
No, you can't replicate TFS in real time. You need to backup database and restore it on another server to have full migration. Or use tools like TFS Integration Tool to migrate work items or changesets (data lossy migration).
Using Visual Studio Team Service maybe a good option for your scenario. Visual Studio Team Services provides a set of cloud-powered collaboration tools that work with your existing IDE or editor, it's not needed to set up on-premise TFS.
Get database guy in the picture and ask him how to replicate and sync DB severs. Source code and change sets are stored on SQL. This should help you to proceed further.
Challenge:
We currently have 100+ vb6 applications. Our setup is that for every desktop server that we have (currently 20), those apps should be installed. So all in all, you can do the math. Users would then approach that server, or connect through RDC, and they will generate their reports there. Problems have already popped up, but the main reason the management now chose to upgrade is because we do not have VB6 dev't licenses anymore.
What we are currently using:
Visual Studio 2010 SP1 Professional
Microsoft Server 2008 R2 (For the deployment)
Oracle 11g (where the data are coming from)
The Question:
Given the cards we were dealt, I would like to seek a proper strategy in consolidating these decentralized reports. Right now, I'm suggesting we do MVC. However, I am not certain how it should be done in such a way that multiple developers can contribute in the development simultaneously. How/what will be the layers (DAL/BLL)?
We are new to this coming from a VB6 background. Thanks!
Well, not to rain on your parade, but questions like this always boil down to ROI (return on investment), and based on what you've said, your ROI is incredibly small. MVC is a good bet, since it's based on a pattern that all good applications should follow to a greater or lesser extent, but if you're stuck with VS2010, you won't be able to work with the latest and greatest versions of MVC/Web API/Entity Framework/etc. That means your brand spanking new app will already be out of date and rotting before you even kick it out the door.
If your organization is unwilling or unable to upgrade to at least VS2012 (but as long as you're doing that you might as well go all the way to 2013), so that you can utilize MVC5, Web API 2, and Entity Framework 6, then forego any new development and just do the bare minimum to make your current applications work. From a cost perspective it's just insane to go into new development on old, out-dated technology.
My team is considering doing branch-per-task development in TFS 2010. We are thinking of using shelvesets for small tasks (1-3 days) and creating new branches for anything larger (4 days to 2 months). Once development is complete on the branch it will be merged to main and deleted (not destroyed). Typically it will be only one developer working on a particular branch.
Does anyone have experience working on a project using TFS 2010 with many branches. How did it work? Were there any server performance issues as the number of branches grew? Does it affect the performance of the VS IDE at all?
There are already many answers out there relating to questions such as "TFS sucks at merging and is crushing my soul, what can I do?" and "Why would anyone ever use TFS when x, y, and z are available?" Please try to keep your answers relating to server performance and usability of the system in the presence of a large number of branches.
Here is some background with my history of branching. The project I worked on previously used a branch-per-task strategy with ClearCase and it worked very well. Branch creation was tied to both the defect tracking and build system. Developers completed units of work each in their own branch. The lifetime of each branch varied from a day up to a couple of months. At the end of each task the code was merged into the main integration branch. This was a large project and after approximately 10 years of development the system has over 10,000 branches. ClearCase is able to handle this volume of branching quite well (except when viewing popular files in the Version Tree Browser, load time could be slow).
Basically the model you describe is a Branch by Feature, this is the model that the Dev Div of Microsoft uses to develop the Visual Studio product family, so you can tell it scales pretty well with TFS.
I recommend you to read this blog post and you can read the Branching Guide V2 to get more information.
As for the merging, the topic was pretty well covered here and on the web, in my opinion it doesn't suck when you use it correctly (and without the default merge tool).
We are investigating Plastic SCM as possible alternative to Subversion for version control with our products. We have a very large number of binary assets (mainly art assets, but also includes some documentation, AVIs, etc.) in addition to a very large source code base. Just to put a number on it - a svn checkout of our HEAD revision of the trunk branch takes a little over an hour and has a size on disk of ~9 GB.
Does anyone have any experience with Plastic SCM in such an environment, or can refer me to some whitepapers or case studies on the matter of Plastic SCM's performance and handling of large repositories? Googling hasn't really turned much in the way of objective research - just stuff published by Codice themselves. I also realize that Perforce does extremely well in this environment - I've used it before - but we're a pretty small team, with an equally small budget, and Codice offers this system free for small teams ("Community Edition").
I'm very close to just installing it on a test server and trying it out...but wanted post the question first, so as to not waste my time if someone else has already tried it out in such an environment. Thanks in advance for your time.
UPDATE 02-FEB-2011: Just an update in case anyone else has a similar question and is viewing this...I got Plastic installed on a pretty modest Windows 2008 Server machine (2.8GHz Core 2 Duo, 4 GB RAM, repositories being stored on a SAN on the local network) running SQL Server 2008 R2 for the Plastic repositories. The import of subversion revision history took a while - just under three days - ~28000 revisions. However, it is SMOKIN' fast to do a fresh checkout of a new branch from Plastic - just shy of 4 minutes with Plastic compared to over an hour on Subversion as described above. We're very impressed so far!
We are moving ourselves from Perforce to Plastic and our repository is about 360Gb,
so quite large too. It actually worked seamlessly even using HUGE files.
Since we're in the videogame industry, large files are a must, and as
you know all the other DVCS (Hg, Git) have issues handling them.
For large repositories the best options are MySQL or SQL Server.
Firebird won't scale well to that size.
I am currently creating a business case for rolling out TFS 2010 as our source control and bug/release management tool.
We currently use OnTime for our bug tracking software and subversion for our SCM.
I was wondering what advantages TFS 2010 has over OnTime?
I have done some thinking so far and would love to hear responses:
TFS 2010 allows linking changesets->work items->builds
TFS 2010 provides greater customisation of workflow than OnTime
TFS 2010 is integrated into the Visual Studio IDE - This requires less apps to be open and less window flicking
Thanks in advance.
TFS is one of the least intuitive Version Control systems I have ever had the misfortune to have to use. It may have numerous "bullet point" advantages over OnTime (and other comparable systems), in terms of raw feature-lists and capabilities, but the key factor is whether it can fit in with your working processes.
My experience with TFS is that you will be required to adapt to the TFS way of working, because adapting TFS to your way of working will be impossible or too difficult to justify.
We recently reviewed a number of possible alternatives to replace a system comprising SVN and a manual bug-tracking system (Excel spreadsheets). On-Time was evaluated but deemed too expensive and complex.
In the end we opted to continue using SVN, but drastically revised (simplified) our repository structures and chose to combine SVN with the FogBugz issue tracking system. The integration between these two systems was fairly rudimentary "out-of-the-box", but required only a little effort on our part to achieve the much closer level of integration we desired. Certainly far LESS effort than my previous experience of a TFS roll-out involved.
Our SVN/FogBugz system is also now integrated with a FinalBuilder build automation suite.
The result is a system that not only fits our working practices perfectly (since we devised the means by which the systems would integrate to achieve that) but which is also infinitely adaptable as our working practices evolve.
I think that it really depends on the size of your team(s), and what you want out of source control.
I used bugzilla in combination with Perforce for a couple of years and found that both were really very good at their own individual things while working in a very small team (2-3 people), but the suffered from a lack of integration between them and from some little idiosyncrasies that took time to get used to.
I recently moved to a new job where TFS is used extensively. There are 4 main teams in this company with 10-12 developers in each, split into further project teams below that level, and it is in this kind of environment that TFS really shines imo. It's biggest advantages in my view are:
1) The integration with Visual Studio - it's not just a case of having less windows open, but it really does speed things up and make your life easier. Things like VS automatically checking out files for you as you work (no issues with accidental checkouts due to lockless editing), being able to synronise local + TFs builds, being able to quickly compare the local version against previous ones..yes you can get 3rd party plugins to integrate but none to this level and with the same stability.
2) The communication features - simple things like integraton with Live Messenger (provided you configure TFS correctly) are great for large teams. We use WLM to communicate accross the office and for collaboration as its just quicker than walking over to someone else every time you need to ask a quick question.
3) Linking builds/changelists to tasks - Yes other SCMs do this but again it's just done in a very nice, integrated fashion..I guess it's nothing special to TFS but personally I like how it tracks this.
4) Ease of merging/lockless editing. I've had experience with some other merge tools and the TFS one works nicely enough, making merging after concurrent editing pretty simple. It's very similar to perforce in this respect, but also with a usually pretty effective auto-merge tool which I use for tiny edits that I know cannot cause any potential issues with edits other developers are working on.
5) Auto building/build management. Working with a couple of large solutions containing 20-30 projects that depend on each other, this is a godsend. We have it set to queue up a build every 20 minutes IF something has changed, and when one has happened its listed in the history log..so easy to see when you need to update your local libraries.
I don't have any experience with configuring it other than build management, but I have heard that this is the worst part of TFS..that its a bit of a pain to get everything running correctly.
So, translating that to a business case..I'd say that if you are a Microsoft software house with large/multiple teams, then the time savings and productivity improvements that you will see as a result of the above features are worth the investment in setting it up. Its free to use in most cases as you will probably have a MSDN subscription (maybe some CAL issues but i'm not sure) so your biggest cost will be in user training and configuration.
Firstly, I would suggest to consider what is your primary concern, what is the problem that you are tying to solve by rolling out TFS.
In terms of version control I would recommend the blog post from Martin Fowler on Version Control Tools and a follow up results of a version control systems survey. Admittedly this might be and is a subjective view of the subject but one that seems to be pretty popular. TFS clearly looses in comparison to other Version Control Systems.
I currently work with TFS2008 and we have migrated from SourceSafe and IBM ClearCase/ClearQuest and there is no doubt that TFS is far better then any of the previous tool, still it has its serious shortcomings and the new version will only partially address those.
Addressing the individual point you have raised:
TFS allows to link builds with changesets and work items, but so many other systems
I have not used OnTime but the workflow customisation can be both an advantage and a hindrance. Potentially, there might be a lot of work involved in creating a custom process template and you would still need a sensible UI on top of it (Team Explorer or Web Access might not be sufficient)
Integration with Visual Studio is an advantage but there are add-ons to Visual Studio that allow integration with other source control providers
On the advantages of TFS I would probably mention
Distributed builds and separate build agents - if you do many builds
Full integration with Visual Studio via the Team Explorer
Extensive reporting infrastructure (though you can only take full advantage of it when using MSTest for all the testing)
SharePoint collaboration site for each project
Given the substantial cost of rolling out full TFS installation I would really consider what real business benefit would this solution give you that others don't.
Not shure about TFS, but the UI of OnTime is kind of non intuitive.
Also I dont like that you have different fields for Bugs and Tasks. Of course you can always add your own fields, but the default layout should be ready to use.
We endet up using only "Bugs" even if it is a task.
I dont say its a bad product, but if TFS has a better UI for bugtracking now (which it hadnt 4years ago when I had to use it and hated it ), then this would be an argument for TFS.
Sorry to hear that you want to get rid of SVN. Thats a hard decision.
I'm not sure about the licensing for the Axios OnTime but if you have an MSDN subscription then it's no additional cost. See the blog post here
I've been using TFS 2008 only for version control and while it's a nice upgrade from VSS some things that we're tyring to do aren't exactly in line with what is expected. That said, I've written a quick little web app that fills in those gaps. It was pretty easy to develop against using the API and there's lots of addons to help with specific tasks.
Probably not the answer you want to hear, but I'd be doing my damnedest to make a business case against TFS.
In any event, my general advice would be to try it out yourself (or in a small team) on some very small, but real project - maybe some tool you need on a once-off basis, code that can be thrown away or easily migrated to another system because it's small. There's nothing like actually using the system!
I have used OnTime and Subversion. I have not used TFS as bug tracker, but I've used it for source control. The source control part of it is basically still the bad old Visual SourceSafe. If you are currently using Subversion you will be swearing your head off any time you need to rename a file or, heaven forbid, delete a file and then create one with the same name - never mind any branching or merging. It's hard to convey in a post just how primitive and fragile it is as a source control system - that's why you really have to use it. You'll see what I mean when you find yourself stuck with a file you can neither check in nor delete and some meaningless error. Not that Subversion is perfect - but it's a decade ahead of VSS!
The workflow part of TFS, which I've only briefly played with, seems very "heavy" to me. That is, it really restricts the user to that workflow and requires a lot of steps that are often unnecessary. This stuff can help, but it can also just as easily get in the way. A good system provides the workflow when it's needed, but allows you to bypass it when it would just get in the way. When we used OnTime, we found that even its relatively unobtrusive workflow was often just more trouble than it was worth. Of course, this all depends on the specifics of your situation. How are you using OnTime workflows now and what do you want out of TFS that OnTime doesn't provide?
Linking changesets to bugs can be done with Subversion as well. It supports some extensibility mechanism - I don't remember the details, but FogBugz uses it (we switched to it after OnTime). Linking the to builds can be done by adding a simple svn tag command to your build script. Visual Studio integration can be done with VisualSVN.
The cost is also a huge downside of TFS. It is very expensive for what it does, especially when you take into account how well it does it. Yes, it's "free" if you have to have an MSDN subscription for every developer anyway - but do you have to, without TFS? Subversion is free, full stop. OnTime and FogBugz are far more reasonably priced.
I would strongly recommend against TFS. I once tried to restore the source code from a crashed instance, but I gave up after a few days, so source code was lost (= it failed to do the one thing a VCS should do). Of course, I might have done something wrong, but it's not easy to get everything right when the restore guide is two miles long, and it really is something that should happen so rarely that nobody is experienced with it.
Now I use Subversion/Trac, which gets the job done (and customizing the workflow in Trac is so easy it's not fun, compared to TFS).
For the time being, avoid TFS!
I would stick with SVN + FinalBuilder and then choose between FogBugz or CounterSoft Gemini.