Join devRant
Do all the things like
++ or -- rants, post your own rants, comment on others' rants and build your customized dev avatar
Sign Up
Pipeless API
From the creators of devRant, Pipeless lets you power real-time personalized recommendations and activity feeds using a simple API
Learn More
Search - "tfvc"
-
Today we migrated from TFVC to Git.
Emotional times. This may become the reason for a future rant or it may be the best decision we've ever made (had made for us).15 -
(first post/rant on here)
So I recently started at a new company. I was kinda aware that the project I'm working on would be rather old school (to put it in a nice way :-)).
Part of my job is to 'industrialize' and update/clean up the existing code so there is less time spent on fixing bugs due to bad design.
One of the first things I had to do was to write a new interface to integrate with external software.
I already noticed some rather nasty habits, like prefixing every variable with m (don't know why), private fields for every property (all simple properties) and a whole lot of other stuff that either is obsolete or just bad practice.
Started writing clean code (simple classes with properties only, no m prefixing, making sure everything is single responsibility, unit tests, ...).
So I check in the code, don't hear much from it again besides the original dev/architect that started the project using my code to further work on that integration.
Now recently I started converting everything from TFVC to Git (which is the company standard but wasn't used by our team yet). And I quickly skimmed through my code to check if everything was there before pushing it to the remote repo.
To my surprise, all the code I had written was replaced by m prefixed private variables used in simple properties. BL classes were thrown in together, creating giant monstrosities that did everything. And last but not least, all unit tests were commented out.
Not sure what I got myself into ... but the facepalming has commenced.14 -
So been doing a TFVC -> Git conversion the last 3 weeks. I'm finally seeing an end to this mind numbing frustrating mess, so I was thinking 'this is a good time to write down my experience in a rant'.
So first of all, I'm working on a project that's about 10 years old, and didn't have a serious refactoring in that time (still runs on .net 4).
The project structure is f*cked up and seriously complicated the git conversion. For example forms only used in the winform application were in a solution for a web app, and file referenced in the windows application. But due to the fact that these forms also needed references to some business logic in the winform app, I had to constantly jump from one project to the other, fixing references to get this shit in NuGet. Sadly this wasn't the only case, and the other 40 project I had to convert from TFVC to Git had equally f*cked up stuff.
Only thing positive to come of this, pretty much decided to leave and start as a freelancer. At least I'll get payed better for doing shit like this, and I know it'll be a temporary thing and can move on after it's done.4 -
Hi there!
I've been worrying about the following problem for months now and I don't find any solution. Maybe anybody of you can lead me the way.
We are developing a software suite which consists of a number of desktop applications:
* 12 applications written in C++; all over 20 years old; further development by 5 or 6 guys (one man armys) - mainly bugfixing, changes of law implementations, small features
* 2 applications we are currently writing in C#; completely new developments of existing C++ applications; scrum teams with at least 5 guys; this is, where we put our focus in
These applications (C++ and C#) are sharing some core assemblies and are interacting with each other. So they are not independent.
We organize them in a mono repository in one huge solution, which consists currently of about 500 projects.
Advantages:
* With all projects in one solution and through project references, Visual Studio takes care of the right build order
* Code navigation is superb - every single line of code is accessible - this makes refactoring easy
* Every developer can map the branch and build the whole suite locally
* Debugging on the local machine is easy
* DevOps pipeline is straight forward - it just have to build a single solution
Disadvantages:
* The huge solution is extremely slow.
* If you want to build the solution or you want to debug (which does essentially the same as a pre step) Visual Studio is building a lot of projects, although they haven't been changed. Their detection is buggy. So sometimes you wait 2 minutes until it starts the app. That slows us down a lot.
* Full builds need about an hour, because its building the same projects (even if they haven't been changed) over and over again (with ready made nuget packages this could be improved a lot I think)
* If a core team member changes some core apis, he is changing the calling code too, although he doesn't know the calling code, because another team has written it. I don't think, that's best practice and it doesn't scale.
* Often, a C# developer has to mess around with C++ building problems, because the C++ projects are in the same solution
* It gets more and more confusing and frustrating, because there is no clear organizational seperation between apps and nobody can't just focus on his app alone.
Idea:
I was thinking about putting the whole framework and core projects in a new solution (around 100 projects). Then we could take all old C++ projects and put them also in a new solution (around 200 projects). This would leave the newer projects (new applications - C#) in the existing solution.
This should speed up things, and would be a first step to better seperation, BUT:
How should the integration process look like?
Scenario: Core team is changing an API in our framework
Current process: Because all projects are in the same solution, they change the calling code too. So it's immediately integrated and the app developers just have to do "get latest".
New process (?): Core team is providing the changes through a nuget package (new version). So does every developer now has to keep track of if there is a new package version and if yes, do the integration? And how can we coordinate the different teams, so they are upgrading all at the same time? Because we ship our applications as a suite, all apps has to use the same versions. Or should we automate the integration process? Is there a best practice?
I have to add, that our core team is making changes very frequently, so the integration process will have to happen often.
Any ideas/feedback/inspiration?
Thank you so much in advance!4