Microsoft switches to git
-
@captain Imagine if there were some kind of UI where you could see a high-level overview of the commits, then drill down when and if you needed more detail.
Oops, can't do that with Git, it has shit UI.
-
@blakeyrat said in Microsoft switches to git:
Oops, can't do that with Git
-
@blakeyrat said in Microsoft switches to git:
@captain Imagine if there were some kind of UI where you could see a high-level overview of the commits, then drill down when and if you needed more detail.
Oops, can't do that with Git, it has shit UI.
What would one see in a high level overview?
-
@boomzilla said in Microsoft switches to git:
What would one see in a high level overview?
-
@timebandit Too bad that's an external tool.
You can't just type
git gui
and... wait a minute.
-
@zecc said in Microsoft switches to git:
You can't just type git gui and... wait a minute.
alias gitgui=git-cola
-
All git GUIs are shit. Every single one. I tested all I could find and the only one that didn't make me puke was GitKraken (recently at least, I had to use SourceTree before ).
-
@mrl The one in VS is... okayish.
-
@blakeyrat said in Microsoft switches to git:
Imagine if there were some kind of UI where you could see a high-level overview of the commits, then drill down when and if you needed more detail.
When I am looking for (almost) anything other than cost specific details, I take a different approach.
IF every entry into SCM (for Git a Commit, for TFVC a ChangeSet, etc.) is associated with a Task, and contains only the changes necessary to complete that task, and each Task is part of a granular increment of value [User Story, PBI, etc], which is part of delivering a Feature, which is part of a larger business Objective [Epic], then one has a multitude of ways to slice/dice the information get (nearly) any desired level of overview/drilldown/detail....
-
@mrl Haven't had to do anything complicated with it, but the one in IntelliJ's never steered me wrong.
-
@pie_flavor said in Microsoft switches to git:
@mrl Haven't had to do anything complicated with it, but the one in IntelliJ's never steered me wrong.
I'm in C# land, so I can't really comment about it.
@blakeyrat said in Microsoft switches to git:
@mrl The one in VS is... okayish.
It kept loosing my credentials and asking for password 10 times a day when I tested it.
I turned it off and it kept turning itself on randomly, which made me furious, so I uninstalled git integration from VS and never looked back.
-
@onyx said in Microsoft switches to git:
Basically the main difference between my coworker and me (it's only two of us committing to the repo in question so strict rules aren't in place): He makes tiny commits, I make larger ones. Because I hate committing something that I know doesn't work yet (I don't mean bugs, I mean I know that it can't even be functional because it's missing parts).
Learn/get into the habit of branching now, while there's just the two of you doing this.
Pull your branch, check in your stuff frequently to that even if it's known not to work (what the other person is effectively doing on trunk.) Merge back (i.e. what you'd normally commit at the moment) when it does 'work.'
-
@pjh we're doing branching, I was just commenting on our commit styles and why we don't have a strict convention for that particular point at the time.
-
@pjh said in Microsoft switches to git:
Pull your branch, check in your stuff frequently to that even if it's known not to work
An alternative is to never (at least not for more than 30-45 minutes) have code that is "known not to work" in the first place.
-
@thecpuwizard said in Microsoft switches to git:
@pjh said in Microsoft switches to git:
Pull your branch, check in your stuff frequently to that even if it's known not to work
An alternative is to never (at least not for more than 30-45 minutes) have code that is "known not to work" in the first place.
At work, I'm currently implementing an SNMP table that has to re-implement functionality available elsewhere.
There's no way that can be completely done in 30-45 minutes, nor do I want to check in over a week's worth of work in one lump.
I can, however, check in work that's cromulent. e.g.
- the skeleton code generated by
mib2c
compiles - the skeleton code now responds to SNMP requests
- it returns a fake row with data
- it returns a row for each configured item, but with fake data
- column 1 now returns 'live' data
- columns 12 and 15 now return 'live' data
... etc. - it now works
That first step took a couple of hours.
- the skeleton code generated by
-
Forgive me for being stupid, but why the fuck does git require you to "clone" the repository in the first place? Why do you need to fetch more than the last version of the code youre working on?
-
@anonymous234 said in Microsoft switches to git:
Forgive me for being stupid, but why the fuck does git require you to "clone" the repository in the first place? Why do you need to fetch more than the last version of the code youre working on?
Directed acyclic graph.
-
@anonymous234 said in Microsoft switches to git:
Forgive me for being stupid, but why the fuck does git require you to "clone" the repository in the first place? Why do you need to fetch more than the last version of the code youre working on?
The 'distributed' part of 'distributed version control.'
You can just fetch the most recent part of it by adding
--depth=1
to yourgit clone
.
-
@anonymous234 said in Microsoft switches to git:
Forgive me for being stupid, but why the fuck does git require you to "clone" the repository in the first place? Why do you need to fetch more than the last version of the code youre working on?
Git does not work "remotely". There's no way to issue a command to a remote repository other than "sync". Instead you clone the thing as a whole or a part of it, and then sync your changes to somewhere else.
Linus more or less calls it a "versioned filesystem", and everything else was then built on top.
-
BTW: if you read the original article from a year ago then you'll see that Microsoft took it one step further by inventing a Windows filesystem driver which seamlessly clones git files when you need them, but otherwise leaves everything on the server: https://github.com/Microsoft/gvfs
-
@thecpuwizard said in Microsoft switches to git:
An alternative is to never (at least not for more than 30-45 minutes) have code that is "known not to work" in the first place.
Yeah I had to write IRS tax exempt savings account rules for a previous employer. Just setting up the objects required to set up the logic required like 3 weeks.
That super-fast agile stuff only works when the program's already written (and you're just fixing/adding things) or when you're doing trivial stupid work.
-
@anonymous234 said in Microsoft switches to git:
Forgive me for being stupid, but why the fuck does git require you to "clone" the repository in the first place? Why do you need to fetch more than the last version of the code youre working on?
It's not you who are stupid, but Git.
Actually one of the first patches Microsoft made to Git so they could use it was adding the ability to do partial checkouts of a repository. You know, like TFS has been able to do since 2005 or so.
-
@mrl I've never had a problem with VSGit. Xcode? I've had issues. The PHP IDE I use (NetBeans? Maybe?)--tons of problems.
-
@blakeyrat said in Microsoft switches to git:
@thecpuwizard said in Microsoft switches to git:
An alternative is to never (at least not for more than 30-45 minutes) have code that is "known not to work" in the first place.
Yeah I had to write IRS tax exempt savings account rules for a previous employer. Just setting up the objects required to set up the logic required like 3 weeks.
That super-fast agile stuff only works when the program's already written (and you're just fixing/adding things) or when you're doing trivial stupid work.
I have worked on similar, but have also adhered to the principle above. The most trivial scenario is that "Code which is not called has almost zero chance of breaking the program".
So write a little bit of logic, a simple test to prove that little bit "works", and you can safely check it in.
I have written entire feature sets where all of the code has been independently validated (over the course of weeks or months) before it gets "connected" to the rest of the system. Rarely (there are times I got sloppy, I am human - otherwise it would have been never) was there more than an hour of work that did not create a small tested increment.
-
@thecpuwizard There problem is there's no "small tested increment" for determining, for example, what the maximum HSA contribution is. So there's no way to develop something like that in small increments unless you're just ok with it giving utterly wrong answers during development, which is a bridge too far for me.
-
@blakeyrat Sure. Financial calculations are horrible and take hundreds of datapoints to do correctly. It's more a matter of breaking things into chunks and getting those small chunks correct. I don't buy the idea that you need 100 datapoints to a single step of calculation, or that the individual steps in the calculation aren't worth getting right. Obviously you test the whole thing too.
-
@mrl said in Microsoft switches to git:
@pie_flavor said in Microsoft switches to git:
@mrl Haven't had to do anything complicated with it, but the one in IntelliJ's never steered me wrong.
I'm in C# land, so I can't really comment about it.
Well, the same one is in Rider, so
-
-
@mrl Just saying. I get it through an educational license, so I never had to bother with that.
-
@pie_flavor said in Microsoft switches to git:
@mrl Just saying. I get it through an educational license, so I never had to bother with that.
To be honest, I'm not against payed software, to the contrary actually - I'm eager to buy software that I like. If anything, I'm wary of free software, with the usual 'fuck your problems, it's free' and all that.
But this is an IDE and I'm not changing from VS for sure. Plus I don't like SC integration, with IDEs, consoles, file explorers, etc.
-
@magus said in Microsoft switches to git:
@blakeyrat Sure. Financial calculations are horrible and take hundreds of datapoints to do correctly. It's more a matter of breaking things into chunks and getting those small chunks correct. I don't buy the idea that you need 100 datapoints to a single step of calculation, or that the individual steps in the calculation aren't worth getting right. Obviously you test the whole thing too.
Magus - I completely agree. While it does require a mind-shift, it is rather amazing how small these "chunks" can be.
Let's say some function F(...) can be decomposed into G(...), H(...), J(...) along with combinations logic/calc. Furthermore G(...) can be decomposed into K(...), L(...), M(...).... repeat the process until there is some minimal Z(...) which can not be reasonably deconstructed further.
Z(...) can be fully implemented and tested :) The process can be repeated all the way back up the chain until F(...) is functional.
Since there is nothing in the "live/running" application that invokes F(...) all of this work can be done safely and placed into source control directly without any significant risk.
-
@thecpuwizard said in Microsoft switches to git:
The tiniest of details may provide significant value, and any information loss (in this case the granular evolution of the implementation) can prevent that value from being realized.
So go and build a version control system that permanently records each keystroke.
Too much irrelevant information impedes understanding.
-
@dkf said in Microsoft switches to git:
I'm more lenient (review just the delta, not the path to get there)
My point was that when the delta is 40 changed files, with changes throughout several layers and including a few refactors, it is difficult and time consuming to pick apart in order to adequately review.
-
@magus said in Microsoft switches to git:
It's more a matter of breaking things into chunks and getting those small chunks correct.
I don't have time to break things into small chunks. I've got an arbitrarily imposed deadline to meet.
@thecpuwizard said in Microsoft switches to git:
all of the code has been independently validated
Luxury!
months
Luxury!
-
@greybeard said in Microsoft switches to git:
So go and build a version control system that permanently records each keystroke.
I do know of an increasing number of groups that are using timed keystrokes (and mouse activity) during their Katas to improve their understanding of the mechanical effort of writing software.
Too much irrelevant information impedes understanding.
A single piece of missing information can completely prohibit understanding. My position is to:
a) Lower the cost of acquisition (as close to free as possible)
b) Provide systems so that only the relevant information is exposed for a given analysis (which addresses your point)
-
@thecpuwizard said in Microsoft switches to git:
I do know of an increasing number of groups that are using timed keystrokes (and mouse activity) during their Katas to improve their understanding of the mechanical effort of writing software.
What is a "kata" as relates to writing software, please?
-
@thecpuwizard said in Microsoft switches to git:
an increasing number of groups
Going from one to two is an increasing number…
-
@boomzilla said in Microsoft switches to git:
@thecpuwizard said in Microsoft switches to git:
I do know of an increasing number of groups that are using timed keystrokes (and mouse activity) during their Katas to improve their understanding of the mechanical effort of writing software.
What is a "kata" as relates to writing software, please?
-
@dkf said in Microsoft switches to git:
Going from one to two is an increasing number…
True, but I do not have hard statistics at a large scope, so just some observations..
-
Tampa Bay used to have Code Kata groups once a week (3 organizations, 2 once per month, and one twice per month). Unfortunately the Iron Yard closed so there is currently a hunt for a new stable and appropriate venue for 2 of the groups.
-
Of the 23 clients I have engaged with over the past 15 months, only one had not heard of this, three had heard, but not attended, 19 had developers who had attended at least one Kata focused meetup that used the technique. In terms of on-the-job, 9 of the clients had regular-hours sessions and 5 of them used keystroke timers during certain exercise.
-
-
@greybeard Only because you tell them you'll meet their deadlines when they shorten them.
-
- I never did.
- The schedule was never longer to begin with.
-
@greybeard said in Microsoft switches to git:
- I never did.
- The schedule was never longer to begin with.
Remember, the "correct" response is either of the following:
a) Pick a Date, and we will see what Features we have...
b) Pick a Feature Set, and we will see what Date that is ready on...
-
@thecpuwizard In this case it was “We’ll see what Quality you get for the demo. And shrink the Features too.”
-
Interestingly, Facebook has done something similar but with Mercurial:
Apparently they could do it without a virtual file system
-
@grunnen said in Microsoft switches to git:
Interestingly, Facebook has done something similar but with Mercurial:
https://code.facebook.com/posts/218678814984400/scaling-mercurial-at-facebook/
Apparently they could do it without a virtual file system
The difference is that Facebook found Mercurial easier to modify thanks to its consistent use of Python rather than the mess of C, shell script, Perl and TCL/TK under git's hood, and they actually found the upstream willing to integrate their changes.
For example, Facebook's
hgwatchman
is now the fsmonitor extension.
-
@boomzilla said in Microsoft switches to git:
What is a "kata" as relates to writing software, please?
I got this shit in an interview.
Someone gives you a problem description and an implementation of it (which has some bugs/inefficiencies/bad design) and you're supposed to basically refactor or rewrite the whole thing until the judge "decides you've done enough" I guess?
When I did it in an interview, first I looked like an idiot because I had to ask what a "kata" was (dumbshits like CPUWizard apparently think this is a term in common use) and then after I'd refactored it to my complete liking, the interviewer just sat there staring at me asking what to do next, when my answer was: nothing. (Or, rather, "you could abstract behavior X to another class but that'd just make the code way harder to read for virtually no benefit," which was apparently the wrong answer.) I didn't get that job and I don't for a millisecond regret it.
It seems to be common among teams of idiots who think code quality is the only thing that matters and "code is art" and all that bullshit, but ignore the other 99% of product development.
-
@blakeyrat said in Microsoft switches to git:
dumbshits like CPUWizard apparently think this is a term in common use
Have you ever seen this book?
Written in 1999, it is where the term Code Katas was first used (or at least it is acknowledged as such, previous usages, should they exist are not relevant to this point).
Perhaps there are a number of books/material you might want to catch up on, including Katas developed/published
by Robert (Uncle Bob) Martin...
-
@greybeard Work takes time. No matter how much your marketing department yells, they aren't the ones who know how long things take, and them failing to keep their worthless promises has nothing to do with you. You tell them how long it will actually take, and stop letting them push you around.
-
@thecpuwizard Normally my 3rd or 4th attempt at a problem gets a nice solution.
However most of almost all my professional dev is along the lines of:
- Do firstly just good enough so it works.
- Break it up into methods.
- Break it up into proper classes / modules
- Make it into a lib.
-
@thecpuwizard I have yet to see them as anything remotely beneficial. I don't sit around writing the same code over and over. I refactor whenever I can, but it's almost never the same scenario. All the basic stuff, I'd rather set up templates for. Sure, I can write the code needed to get a WPF app running with automatically injected viewmodels with MEF pretty quickly, but a template makes more sense.
Honestly, most kata stuff seems to treat writing code as a mechanical procedure that they think will improve through repetition. But in my experience, repetition is the worst thing you can do when programming.