Hacker News Reader

Comment by phoronixrly | Hacker News Reader

This pops up from time to time and each time I ask myself what is a useful application for it? Is it just eye-candy?

I personally had to use it once to explain to someone higher up why there hasn't been a user-facing feature change in a month.

He did not understand that things can change without him seeing it in the frontend and I was in the middle of a crucial rewrite.

THIS.Could be such a great tool to visualize work being done for outsiders. Just a Screen in the lobby showing the commit history up until today in an endless loop.

I can't imagine a worse overall take on this in general because it fails to compare the alternative which is you do nothing or maybe the idea in some of these replies is just anything outside of `tree -d` is superfluous to the task at hand waste of time and bare metal GPU.

Appreciation for both the form and the function well blended in an artful way should not be offhandedly dismissed. We make a conscious choice when we build things to consider the users delight to be our responsibility, or not, so taking the extra step to make it beautiful as well as useful may sound superfluous but it isn't. Not by a long shot.

Also Amelia Wattenberger at GitHub has a great vistualization tool for those who think Gource is too much [1] while on the other side of the spectrum Ren Yuan [2] has been knocking out these amazing audiovisual art-meets-engineering pieces for all the big repos.

[1] https://githubnext.com/projects/repo-visualization [2] https://renyuan.io/commit/

I've used similar tools for tracing particular contributors, when investigating if they've been acting malisciously. Makes it easier to get a quick overview of their efforts, and how painful it will be to review everything they've touched.

what does it look like when they act maliciously? does the avatar look over its shoulder and move around furtively like a cartoon?

There's network alerts of outgoing VPN connections to Russia, Tor usage, and usage of encrypted emails, none of which fall within work duties, accompanied by anti-West sentiment at the water cooler.

It could have been nothing. Which is why you investigate.

It wasn't nothing.

EDIT: You probably meant the code. Whoops. That's simple: Removing guardrails. Removing a null check, because it's "unnecessary" or "unreachable", etc. Opening memory holes, and burying that in larger commits.

ah that makes sense thanks!

I'd say so, yes. But it's utterly cool to see yourself and the people you know create the nodes of a project over the years. In that way maybe there is some more to it, it gives perspective.

It is super useful. We started a project with some hired consultants about a year ago. Did not engage much with that project, but when I was recently asked to get back into the loop and find out what these people had been up to, a quick view of the 'gource' visualization was all that was needed in order to know who was doing stuff, and how much they had been working on it etc. At least I knew who was just attending the meetings, and who was actually coding and so on :-)

Isn't this the same thing as measuring developer productivity by number of lines of code or commits, pushes and such?

More or less, but OP didn't say it was the only measure used.

Just like LOCs and commits, it's a starting point. A general indicator of where you need to dig deeper or who to prioritize in your review.

Exactly, it's a very quick way to get an overview. Just by looking at how many developers have been working on things + their frequency of committing code is very helpful. Tons of files appearing at once is a quick give away that something is either copied from another project, or some massive "technology" (read: library, framework) is added; which can be hard to maintain unless the stuff being added is very mature.

It is sadly. And unfortunately, it's still a commonplace measure even at the "best" companies.

They say "oh it's not the only measure" ofc. Anything to downplay it to ICs. But then you chat with your jaded manager and you hear echoes of the insanity that goes on in performance review calibration and you aren't so sure about those qualifiers anymore..

It certainly isn't an alternative to actually digging into the repo and find out what has happened. But I wanted to find out something about:

1. How many developers have actually been working on this stuff

2. Has the guy who set up the wire-frame actually stepped back

3. Are there more developers doing stuff, then what we get the impression of, based on the weekly Teams meetings

All of these questions could be answered in 1 minute by starting 'gource' + increase the speed of the visualization for the past year. I was afraid that this newly hired consulting company was pretending to use less resources then they actually did, in order to sink their hooks into our company, which I could see instantly that they had been doing. I could also see that the "big gun" setting up the wire frame for the project, had not really been taken of the project at all, but had been helping some of the jr. devs all along. Something that would have taken some digging with 'git log' or 'tig'..

It's fun, at least. At a startup I cofounded, we'd run it a few times a year and it was cool to see the codebase grow from nothingness. And to see various files appear that were due to different key events in our company's history.

I had exactly the same impression. The eye-candy side is highlighted, yet just a gimmick.

I research and make valuations of software, tools like this help me quickly get a feel for the history and dominant trends in how it was developed.

It can be motivational to show progress over a milestone or larger time period.

Yeah this is from the class of "oooo pretty colours" visualisations, not "now I've seen it visually I understand better" visualisations.

I use it for some security analysis.

Reply on news.ycombinator.com