Sourcegraph CEO here. We 100% agree, and that's why we built Sourcegraph. Check out our roadmap at https://sourcegraph.com/plan.

And try browsing code on Sourcegraph: https://sourcegraph.com/github.com/gorilla/websocket/-/blob/... (we support other languages as well). Right-click on "parseURL" and choose "Find All References". If you click on "HasPrefix" a few lines below, you'll see a cross-repo jump (and the right-click menu lets you see global/cross-repo references).

Sign up at https://sourcegraph.com to get it on your own GitHub repos.

Very interesting demo. So it has at least one feature I'm looking for :). Basically, I'd like something like that, but with annotations like in Acrobat Reader (but more), on a tablet, and off-line at least for my own codebase.

I found a small issue with "peek definition" window: http://imgur.com/TT2KmpR.

Shoot me an email at [email protected] if you want to get early access to some of the upcoming things (or sign up at https://sourcegraph.com/beta). I think you'll like what's coming. Thanks for the bug report. :)

This is very impressive, well done!

Sounds like you described https://www.jetbrains.com/upsource/

(I am not affiliated with Jetbrains in any way)

I've seen a couple brief comments about Upsource in this thread. Can anyone give a deeper dive on their experiences? I tried it very briefly but didn't have time to configure integration with my IDE, just played in the web browser. I suspect that means I didn't try the best feature.

Pros/cons of this tool?

Upsource team member here. Since Upsource indexes your code just like any JetBrains IDE does, it gives you code navigation, inspections, etc. in the browser, which means its "best features" don't require using it as an IDE plugin.

Pros: I'm obviously biased so I won't go into those.

Cons: it's not a lightweight tool that's happy with 1 gig of memory. Configuring and waiting for code indexes takes a bit of time, especially if you're trying it out on large legacy codebases. It also won't manage a Git repository for you.

Right now, I would take a button to go to the previous revision of a file, showing the full file with the diff underneath. That way I could very easily 'browse' through the history of a file to find out things like when a particular change got introduced or just get a feel for its history. Why on earth don't github/bitbucket provide this? Surely it's a reasonable and common requirement? Or is there something inherent to git that makes it too awkward?

My product for GitLab and GitHub does this. This is an example of browsing diffs one by one:

https://gitsense.com/rapid-browsing-1.mp4

And this is an example of bulk diffs browsing:

https://gitsense.com/rapid-browsing-2.mp4

You can find the source for the chrome extension at

http://github.com/gitsense/insight

And the Git indexing engine at

http://gitsense.com/download

Edit:

It may not be obvious, but for the second example, I'm clicking the right arrow to quickly iterate through the diffs.

Yes, that second video is pretty much exactly what I'm looking for. I've been considering implementing it myself as a general-purpose git tool (i.e. not github etc. dependant) - were there any major gotchas? Do you need to pre-cache commit or diff info. or is it efficient enough to do everything in real-time?

The major gotchas is building the indexing engine. Once you have that in place, getting the commit information takes milliseconds. The only time consuming thing is extracting the from and to blobs from the repo. However, that is a one time hit, since you can cache the blobs.

For the diff, this is done in realtime with https://github.com/Microsoft/monaco-editor

Also my product isn't really dependent on GitLab or GitHub. It works in standalone mode as well.

GitPlex can show history of any path (a file or directory) quickly via history button, and from there you can even refine the history (search for certain tags, commits made by certain people, etc) of the file, and once you get to the point, you can either view content of the file, or hit the compare button to compare with your previous browsed copy. An example here: http://gitplex.pmease.com/demo/android-framework-base/commit...

Some (if not most) GUI Git tools should do this, e.g. I personally use Git Extensions[1] which shows history and diff side-by-side.

For what it's worth, features like that (along with, say, line-by-line staging) are the reason why I usually use a GUI client and only drop down to the command line when necessary.

[1] https://github.com/gitextensions/gitextensions

Are you looking for something akin to `git blame`? Github & Bitbucket both provide a gui for this.

Something even closer to what you're asking for... in github hit the 'history' button on a file (next to blame) and you'll get the commits which affected it. Hit the 7 character commit-id and you'll be taken to the diff of that change, jumped specifically to the file in question.

I never really use `git blame` - my primary git use case is as a single user.

The history button in github is close to what I'd like, but it's not quite as friendly as single next/previous buttons that just paginate the changes to a file. That makes cycling through the history very easy, whilst 'click commit id, back, remember which commit we just viewed, click following commit id, repeate' all sounds a bit painful.

I get the feeling that Microsoft has a lot of these things, but they're disparate.

e.g. code navigation [1], search [2] and CodeLens [3].

[1] https://referencesource.microsoft.com/#mscorlib/system/strin...

[2] https://www.visualstudio.com/en-us/docs/search/code/advanced...

[3] https://msdn.microsoft.com/en-us/library/dn269218.aspx

I think GitPlex meets most of the requirement here if you are writing Java code (and more languages are being added). Unlike other tooks, it does not place any requirements on project build system (Maven, Gradle, etc) and can work on any project containing supported languages.

Checkout android code base for instance: http://gitplex.pmease.com/demo/android-framework-base/files?...

I actually created this tool to suffice my own needs when browsing history of QuickBuild source code.

I'm building something like that now but instead of annotations in the code it captures your browse through the codebase as a tree that you can then annotate, save and share. It is going to run both in the browser to explore code hosted on GitHub, BitBucket, GitLab, etc and locally as an Electron app.

Very vague landing page with signup here:

http://www.browsethesource.com/

For quick browsing of a files commits I use Emacs with Magit and utilize the time travel feature of Git-Timemachine https://github.com/pidu/git-timemachine You don't get the annotations you want, but you could make a comment with a common starting word like NOTE: then remove them before you merge the refactorings.

Yes! This is this tool I've been dreaming of too! I would pay a lot of money for something like this.

> annotations - not just "comments"

What kind of annotations would not make sense as comments?

Annotations as what you scribble in the margin of an article or on a page in a book.

Comments are inline with the code. Annotations are aside, and serve both as visual anchors and as "aside" notes.

Is it something like this? http://gitplex.pmease.com/demo/android-framework-base/files?...

You may also put annotations on any diffs: http://gitplex.pmease.com/demo/android-framework-base/commit...

I'm thinking in terms of what I'd do if the code was printed out on paper.

http://imgur.com/KMCBMjA

The trouble with that is, how on earth do you get the annotations to apply across revisions? Or would you be OK with them only applying to a given revision and then ... what, disappearing? Or going into a 'floating bucket' of annotations for the entire file?

I'd be fine with them sticking to particular lines of code[0] and disappearing if those lines were changed. This is not something I'd like to commit into codebase, it's for exploration / preparing work.

--

[0] - "smart stick" can be implemented by remembering not just the line in file, but also the contents of that line and a (fuzzy) context.

Interesting. In these terms, it could probably just be a totally separate, general-purpose 'text file annotation' tool with git support (but not a requirement).

Sticky comment is actually another form of git blame, and will be available in future versions of GitPlex.

Upsource has sticky comments that survive code changes well.

Discussions about the code perhaps.

That is a great list of features! I will create feature requests for them in GitLab (I work at GitLab).

I'm curious what you think of the single file history in current systems, are they OK but just missing annotations?

> Would be doubly useful if I could use it on a tablet

That's something that baffles me: the complete lack of a comfortable (or at least not painful) way to read and annotate source code on Android.

Indeed. The closest I came to what I need was a proof-of-concept I did - printing source code to PDF and using Adobe Reader's annotation tools. Wasn't exactly convenient without a good ability to switch between multiple source files, but could be made to work. I'd love to have such browsing/annotation tool I could take with me to a park, to browse code and think about it while on a walk, without continuous distractions of the office / Internet connection.

I recommend you watch this:

https://youtu.be/dSqLt8BgbRQ

Thanks for the link, bookmarked it for studying, :)

You mean an IDE?

After a fashion. A reading/exploration-oriented lightweight IDE. No IDE that I know of support scribbling over code, for example. Also, for the mode of work I'm thinking about, having no ability to actually write code would be a feature.

Truly you've described this: https://www.jetbrains.com/upsource/