It reminds me of a feature I've always wanted, which would be a code unravel-er. Basically I'd like to be able to select a line anywhere in a codebase, and have said codebase expand to show me the entire execution path as if it were in one single scope, with the ability to re-collapse sections back into loops and functions while reading.
I think it would help to better understand the codepaths that can start to get fuzzy when jumping between abstractions. It would be great - not only for understanding unfamiliar code - but also for double-checking logic across longer code paths.
At any rate - great idea, great implementation, and beautiful website.
My previous company used Understand on a large unfamiliar codebase, it helped greatly, but was pricey.
EDIT: It looks like https://woboq.com/codebrowser.html is what I want. The code available but not under and open source license. https://github.com/woboq/woboq_codebrowser/
I will probably try this, but I'm interested in alternatives!
It gives you nice URLs (hit Alt+Y/Opt+Y to get the full commit ID in the URL to make it permanent).
Would love to hear your feedback.
EDIT: nevermind, most of this is due to the fact that you have to keep "repo" in the search box, which I found confusing.
I quickly found the repo I wanted, but discovered that C/C++ isn't supported, so Woboq is more useful to me at the moment.
I tried to build something like this once myself, and made the mistake of going "wide" rather than "deep". That is, trying to support all languages. I think it does make sense to try to get the absolute best experience for one language. But yeah for now since C/C++ aren't supported, it's not useful for me.
I typed "cpython" in the search box on https://sourcegraph.com/ and got no results. (I also typed "python" and got no results, which seems pretty odd.)
I would have liked to browse this repo:
I guess you have to import repositories yourself? There seem to be sample repositories, but they are in Go, and I'm interested in C/C++ (the Python interpreter, not Python source code).
I'm looking for something that uses Clang as a back end for intelligent navigation of C/C++ projects.
Also, I would like to browse the bash source code, but as far as I know it isn't available on Github. Can SourceGraph import from an arbitrary git repo?
That said I'm glad somebody is working on this problem! I like your mission statement.
That's an interesting link. It only works when you go to "Help -> Language features".
I left the site not really knowing what language/s are supported.
After digging through the entire page it looks like maybe C/C++/Java?
There should be a huge button, or something, front, and center. <<SUPPORTED LANGUAGES>>
Looks like a cool idea, but I don't know if I can even utilize this tool.
Note that I'm mainly interested because my current editor of choice does not have the full suite of tools I'm used to for Go. I used to use Vim, and vim-go has such an excellent suite of tools I don't think I'd buy this. However, I've since switched to Kakoune, and the tool support is quite young and I've not had time to improve it myself. So this tool (at the $100 self employment pricing) is a nice fit for a tool I'm on the fence about. At $200 I don't think I would, but at $100 I think I would.
Anyway, just providing a bit of feedback. Looks really nice!
Runtime analysis of code that actually matters ie live code.
Often its hard to figure out what in the code base actually matters.
Debugging is still sort of difficult and dead code is really hard to find and get rid of. Particularly if reflection is used heavily which it almost always is these days.
Otherwise (IMO) as a Java developer IntelliJ and Eclipse are actually not that far off in their static analysis and already pretty good to discover the code. Especially IntelliJ as I can easily see them enhancing their code view/discovery as well as they already have static dead code analysis.
I guess I don't think discovering code bases is that much of a problem compared to understand what is actually running.
That is I think debugging particularly multithreaded applications is vastly more difficult problem. Thus runtime analysis would be very useful.
Instead of giving money to a tool like this, you could just use ctags/etags, both of which are Free Software. It doesn't show detailed graphs like Sourcetrail does, but it allows source code traversal by function definitions, and supports a crapton of languages.
We decided to focus on source exploration instead. Sourcetrail is made for the second screen. We implemented plugins for the most used source editors to enable easy switching. Please have a look at our documentation: https://www.sourcetrail.com/documentation/#CODEEDITORPLUGINS
Nice work; seems like you hit a nice medium between trying out something new and keeping it connected to the real world and practical. :)
One (potentially paying) alternative would be to provide a precompilation service. Not sure if your index generation can be parallelized, but potentially you could take an archive of the code (or pull directly from Github or Bitbucket or any other repo endpoint) then spin up a large EC2 instance (or the equivalent for your cloud of choice) and accelerate the generation of the index. For large codebases it may provide a good boost.
A couple of relatively minor comments for you:
* In C++ it might be useful to filter include guards out of the symbol lists.
* I had some problems with using the menus (couldn't click on them, when I did select them couldn't get the menu to drop down). It's probably just because I'm using a weird window manager (xmonad, no window decorations, Ubuntu 16.04).
CodeLens => https://msdn.microsoft.com/en-us/library/dn269218.aspx
CodeMap => https://docs.microsoft.com/en-us/visualstudio/modeling/use-c...
I would say we go a step further, by also providing a visual representation of the references to symbol, which quickly conveys how a symbol is embedded into the rest of the code base, without even reading a line of code. That makes exploring a lot faster.
Seems they cover a similar thing.
I now notice the free trial cannot be run on your own project. I have to say I won't buy anything that I didn't try on a real sample before. What made you decide to go for this option instead of regular limited functionality or time bound (my preference).
If done properly this could even feed into code dynamics to capture information on the runtime information. So that at every point in the program you could start asking questions like how many times did this line execute, what was the type of this variable at this point, how much memory was allocated, and so on and so forth.
North of 500k lines, few thousand cpp/h files, 40+mb
This would be particularly useful in open source.