The build server then builds the whole application and runs the unit tests. I might do this once a day if I'm mostly thinking rather than furiously typing or ten times a day if it is all flowing perfectly.
It's not just the kids who do this, I'll be 61 in a couple of months. On the other hand one of my colleagues who really is half my age prefers to complete the feature and only commit to the build server once the whole feature is complete. He uses TFS shelvesets to make sure he won't lose anything.
More generally I don't see the connection? I'm not making commits to show off my cool code to my colleagues. I'm making commits in case I want to revert specific changes later.
I learn to commit more frequently every time I realise I need to undo something manually because my history is insufficiently granular.
If your experience is limited to university and programming for work, how in the world do you develop advanced knowledge of... well, anything?
That is - is that new grad perchance a hobbyist programmer? When you do this stuff for fun and without deadline pressure, especially when young and thus having ample free time, it's much easier to actually learn stuff, and to develop deep understanding of it. Adult life and commercial pressures really go a long way to make people avoid understanding things they work with - after all, we're not being paid to comprehend the tech deeply, we're paid to achieve business goals.
I learned Linux in the '90s, when it came on a stack of floppies, long before anyone else would have thought to use it in production. It was never more than a pet project, but I kept hammering it because it was so cool. Unlimited size matrices. Compile the kernel any way I want. A real multi-user OS? Holy smokes, this is a very cool hobby.
Eventually I got a job at a startup that was running all their stuff on Linux. Lo and behold, I was the local "Linux expert", blowing everyone else out of the water with my knowledge of, well, everything needed to make that thing work.
So that's how it happens. If you like something, and you're passionate about it, and you have an obsessive streak, you'll jump lightyears ahead in a very short time.
The Git guy probably spent countless hours figuring out obscure aspects of the tool's workflow, just for the heck of it. Deep interest + focus + long practice = mastery.
> On my personal projects, I rarely need anything more than git add/commit/push/pull and basic branching)
Neither did he, strictly speaking, but the difference is that he kept hammering it.
So you see, this is not about generational differences. This is good old fashion geeks doing what geeks do best.
You forgot lots and lots of free time . Time like that you simply don't have as an adult.
A lot of devs see commit messages and rebasing as useless pedantry, but once you start to take it seriously it only takes a little bit of extra time, and it provides so much future benefit via git-bisect and general spelunkability.
I also think it's worth investing more time in a tool based on its longevity in ones workload. In that regard I put git at the top of the food chain, as I expect to use it even longer than Linux, for example in my case: Git > Linux > Vim > Ruby/Python > OS X / GUI tools.
A side effect of being this good at git is the ability to bail out your colleagues when they royally fuck up a merge or rebase.
The workflow is directly inspired by git-as-a-wrapper-around-Perforce used at Google.
It's nice to have a cohesive unit of change in a single commit, but if your mergeable features have a lot of moving parts it may be too much information in one giant blob, losing valuable history. There are certain things I like to be in individual commits, like for instance, DB migrations in Rails or Django, or Gemfile/Gemfile.lock upgrades. Having these in separate commits allows for easier conflict resolution later, and are also a nice granularity for practices like zero-downtime continuous deployment where you need to have multi-phase deploy of migrations (ie. phase 1: deploy migrations that add fields, phase 2: deploy code that requires new fields, phase 3: remove fields required by legacy code).
Maybe in a large team with a large volume of PRs then squashing by default is preferred so you can make sense of a fast-moving history, but given that it's so easy to squash selectively with `git rebase -i` that is my preferred method, at least for the team I'm on now.
Thinking of it this way, I know the solution to my code repo problems before I know the exact commands that perform the graph transitions. Because I have this mental model, I know the commands must exist in one form or another.
I think Git is like Javascript, it takes relatively little time to learn enough to get up and running, causing most people to forgoe learning all they'll actually need to be successful.
That guy is probably smarter than me and both dug into git and was diligent in his homework. Those kind of people can have some really deep knowledge on areas they care about.
I also suspect the young coders today are all about github so knowing git's in's and out's is going to be natural for them.
Now, I have no idea how this is possible, but he has deeper knowledge of Hg and Git than anyone I've ever met (If your experience is limited to school and solo personal projects, how in the world do you develop advanced knowledge of version control? On my personal projects, I rarely need anything more than git add/commit/push/pull and basic branching).
I'm over 10 years older than this guy, but I find myself asking his advice whenever I need to do something advanced or out of the ordinary with Git.