Gource: Software Version Control Visualization | Hacker News Reader

Gource: Software Version Control Visualization

github.com

173 pointsvortex_ape67 comments

I used this once, completely unrelated to version control, to visualise the number of referrals my dept had received over time (broken down but year and month) to visually show the growth of referrals and why we needed more people to manage the influx.

Was it cool? Yes. Did it show the issue in an easily to understand way anyone could understand? Yes. Did it change anything? Hell no.

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'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.

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

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.

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'..

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

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 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/

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

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.

I use it for some security analysis.

I once joined a company where a Dev was in the process of rewriting a big codebase.

I didn't think much of it and run Gource on it for fun.

Turns out, he did countless rewrites over the year.

Interesting to watch and explained why the CEO seemed to so concerned about the dev, lol

Same here, gource did help to visualize a complete revamp / refactor of a software, from the current mess by that time, to the final, pratically complete rewrite it was (through a process, since keep it working was mandatory). Really interesting to see the "mess" mutating into a more organized file struct, etc.

Gource is very useful getting up-to-speed on a new project. It gives you a quick visual history of the project and usually makes it clear where the problem spots are: the places with the most laser fire are the fire fights.

A while back while learning rust, I built a little tool that would kind of give you an aggregate view of what gource shows you but based on lines of code rather than commits. (i.e. see top contributors by lines of code on any git repo).

https://github.com/martinn/repoblame if anyone's curious.

That's cool, would be nice if you got a GitHub Action to build the binaries and publish them on Releases... or even publish to crates.io :)

It looks like a PR would be appreciated xD

https://github.com/martinn/repoblame/issues/6

At this stage it's mostly been a toy learning project, but I can definitely do that if there's interest.

Many years ago I used Gource to create a visualisation of the development of my Bsc thesis project, which I promptly displayed on the last slide of my presentation.

It was appreciated by exactly zero people.

No regrets, I loved it.

Hah, last time I used Gource was on a Rails project in 2012. Cool to see it pop up from time to time.

Exactly my thoughts. I used it once to showcase the development phase of a rails project to C levels back in 2012 and they loved it.

Anyone have any example videos generated by Gource they wanna share?

I'll go first: Here is a Gource video of some months of development on Typeform when I worked there: https://www.youtube.com/watch?v=jTo9qy5mIWg

Uploaded ~10 years ago, and I'm pretty sure none of that code is being deployed anymore, at least I hope so.

I can't access it; the video is set to private.

My bad, should be unlisted and viewable now. Thanks for letting me know.

Nope.

Try hard refresh? In a private window, I see the title says "Typeform development in a video" and beneath that "Unlisted".

I create a gource every couple of years wherever I happen to be working.

Here's my personal projects from 2023: https://www.youtube.com/watch?v=BuzFtbM3qU0

Heh, you made exactly the same mistake as me initially, your video is set to private :)

I had def saved it as unlisted before sharing the link. It turns out I actually found a legit bug.

1. Change to unlisted without selecting "for children"/"not for children".

2. Save, see an error about fixing it.

3. Select appropriate options.

4. Save and see "unlisted".

5. Video is actually still "private".

A long time ago I ran it against the FreeBSD repository. Haven't really thought about updating it, but it has been nearly 4 years...

https://www.youtube.com/watch?v=Wi26HnElxgM

I once automated the uploading of >26k Gource videos to YouTube. I sorted GitHub by star count, applied some filters (e.g., had to have X commits, Y files), ffmpeg, YT API. That all happened on my little 2015 MBP. Good memories. I'll clean up the repo and share my hacky code sometime. I miss Ruby, what a fun language with which to play.

IIRC, there's another YT channel that took up the torch. I'm grateful they did. I know, they might seem a little spammy, and it can be frustrating when you Google for a repo and only find a mostly useless YT video of a Gource visualization. And yet, random devs used to email me with grateful messages every week. I felt like, in some microscopic way, I was doing good.

Yeah, I need to ponder and write on that. Hm. Well, this bubbly isn't going to drink itself.

I'll edit this comment into shape later. I'm on my phone at Hedwig's.

Love you to the random internet stranger who read this comment.

Love you to the person who posted this Gource link.

Love you to Andrew Caudwell, the creator of Gource. He seems like a good fellow, that Andrew Caudwell. Yes, quite so.

Quickly, before I :homer-simpson-fade-into-bushes:

I think there is much value in Gource visualizations. My remake was rooted in a vocal minority who expressed a few negative comments on my uploads saying they were useless. I suspect they were just frustrated that they were looking for docs/tutorials and only found my video, heh.

With the right options and extensions/augmentation, Gource is incredibly useful. Especially when slowed down and when you add custom tailored config for each repo. That takes time, but can be automated as well. Ooo, that sounds so much fun!! Issue titles, big refactor custom highlights / slow-downs. Have it right next to JSCity (or equivalent for non-JS), gitstats, and... What was that other tool... You know, the one that makes watching network traffic fun? Oh! Codeswarm? No... It was... I'll find it. It's like ping pong. Where is my AI side panel when I actually need info without leaving HN?? Ok bye.

Next time I spam the planet with Gource videos, I vow to do it more justice :cat-salute:

> I once automated the uploading of >26k Gource videos to YouTube.

Wow, what a monumental waste of resources. I'm kind of surprised you didn't get banned from Youtube for that.

That's some awesome work! I always used to stumble upon videos of yours/similar, partly as it was kind of a way to discover 'niche' but active repos, though mainly because Gource visualisations are just plain fun to watch.

drives me bonkers when a visualization tool has no examples/screenshots in the readme

I would agree typically, but for repositories which have a link to the main website for the product including visual examples like this one... not so much. It's one more click.

I have fond memories of parsing random things to pipe to gource as a younger me. The code is ancient, but here [0] was an experiment to get something like nmap (and other data) ready to feed to gource. Fun to watch indeed!

[0] https://github.com/leonjza/py2gource

Well this rang a bell for me! Back in 2012 I used this to generate a visualization of our work getting Basecamp 2 shipped. Behold the laser pew pews of code: https://player.vimeo.com/video/37822969

I used this frequently, but it really requires your team to enable squashed merges and have consistent feature sizes.

Otherwise a person who commits often (had someone committing per line changed) will make it super noisy. And someone who merges in a giant branch will just blow up the screen for a bit.

> commits often (had someone committing per line changed)

As long as they squash their history before it goes into the branch everyone shares/branches off from, I couldn't care less how they do their work.

But, pushing that aside, what could be the supposed benefit of committing each line like that? They'd spend more time writing commit messages than actual code, assuming the commit messages actually had proper meaning in them,.

Insecure coder or just trying to pump up their commit activity.

> what could be the supposed benefit of committing each line like that?

If you're making two meaningfully different changes, I would always say two tiny commits are better. Not only for organization, but to make it easier to revert just one change.

> If you're making two meaningfully different changes, I would always say two tiny commits are better. Not only for organization, but to make it easier to revert just one change.

As long as the tests pass on every commit that ends up the main development branch, you can pretty much do it however you want.

But committing per lines changed isn't "making two meaningful different changes", it's saying since they are on two different lines, they aren't related, which just seems wrong.

I can across this years ago, it’s a really useful way to view any actor/target relationships in the time domain- not just source control.

Can’t find install instructions for macos. No docker image.

Only way to try it out is build it?

I believe gource is on homebrew, if you have that available.

Thanks

> No docker image

This makes me sad that this became an expectation. And yet, I've been distributing softwares via Docker for almost a decade now, but CLI/GUI tools?

I don’t see the problem for quickly trying out code…

The code is in C afaict. If it would be Go or Java, I would be fine to build it myself, but C…. I’m worried about getting into a rabbit hole especially as GPU support is required. Building with GPU on mac silicon can be pretty complex.

Compare this to running a container with 1 - 2 lines.

Btw I should have inquired about a container image, don’t want to imply that Docker is the default.

it took less than a minute to figure out dependencies and build on my workstation (EL9). If you don't have an OS with a package manager, it might be harder though...

there are a few community images on docker hub

It’s a bit tricky in Docker because you need to use a virtual frame buffer I.e. xvfb using opengl to render without a GPU.

https://hub.docker.com/r/utensils/opengl/

Gource has two modes. One to generate the correctly formatted input file and another to render it.

If you are doing fixed renders, then it’s easy enough to run each process in turn, given a git repo URL which you need to pull locally.

You pipe your gource data source output to the gource renderer, which is running with a virtual screen via xvfb, which needs the same resolution viewport. You can then pipe that to ffmeg and save the output to a volume.

You could pipe using the flv option to an RTMP server or stream (see rtmp-hls based on nginx).

If you want to do realtime on Docker you’ll need to pipe one to the next and you will need to tweak ffmeg to provide a okish steady output video stream using the realtime flag on gource. You’ll need to find a way to poll your git repo and append to the gource input file though for full real time. Gource is smart, but not smart enough to do that without some workarounds. You might find supervisord useful to separate your processes in your docker container.

Gource is cool!

That would mean there are active networks of people working against net neutrality? If true, I wonder who they are...

Did you reply to the wrong thread maybe?

Indeed. Wonder how it managed to land here.

Reply on news.ycombinator.com