egraether

The heavy server load is also caused by lots of downloads. You can get the latest Sourcetrail 2019.4 now also from GitHub https://github.com/CoatiSoftware/Sourcetrail/releases

Thank you!

Applying the tool on your codebase should be easy. For us, using the Clang Compilation Database format, that already holds all configurations to build a project was of great value for faster C and C++ project setup.

You cannot convince developers to use a tool with just words. They need to experience the benefits first hand. And getting to the benefits should happen as fast as possible after starting to test the tool.

Sourcetrail dev here. Thanks for the feedback!

Yes, Python indexing speed is still slow, mostly due to the underlying framework that needs a lot of time to resolve symbol names. We hope we can improve this.

The crash on closing was already reported: https://github.com/CoatiSoftware/SourcetrailBugTracker/issue... I opened another issue to not inform about indexing when only renaming source groups: https://github.com/CoatiSoftware/SourcetrailBugTracker/issue...

Sourcetrail dev here. To my knowledge, without going into too much detail:

* Sourcetrail has a tighter integration between source code and graph visualization, because it offers less features than a full blown IDE like Visual Studio and can keep the UI more simple. Users of Sourcetrail can use either code or graph to navigate and both update simultaneously. In Code Maps the visualization stays the static until explicitly updated by the user.

* Sourcetrail's visualization is centered around one currently active symbol. Then other nodes are positioned up/below/left/right of it to encode additional meaning into the layout. Nodes are bundled together to de-clutter. In Code Maps the user starts with a certain symbol and then adds more and more symbols to the visualization, building a map. Filters can be applied to de-clutter.

* Sourcetrail needs to index all source code upfront, but afterwards querying and visualization generation is fast. I'm not certain, but to my knowledge Code Maps indexes only on demand/only partly upfront, so queries are not as instant.

If you are interested in Software Visualization, you can watch my recent talk at ACCU 2019, where I go through some design decisions of our visualization: https://www.youtube.com/watch?v=Gvmp3Gzhv8o

Sourcetrail dev here. Thanks for your extensive feedback!

A lot of things have changed since Sourcetrail was called Coati (about 2 years ago). We put a lot of work into improving indexing speed, handling multiple configurations/different languages within one project and reducing "sluggishness" in the UI. Sourcetrail runs now smoothly on code bases with multiple MLoC.

But I agree with your suggestion regarding data-flow analysis. That is what understanding unfamiliar source code often really comes down to. We also had some user requests to go that direction. We never really looked into this area so far, because it is a lot harder to collect the data (dynamic analysis) and it needs a whole new user interface.

While the data collection is solvable (Visual Studio debugger can do it, I think), I'm not sure whether it is really possible to come up with an effective user interface that shows which paths the different values take.

To explain why this is hard, let me use a metaphor: With data-flow you need to deal with a new dimension: time. Sourcetrail can handle dependencies between definitions really well, before the code is executed: space. What you want is a tool that combines the two into a space-time exploration tool of source code. Not sure if possible at all, but very interesting to think about. :)

Thanks, this looks really nice! It doesn't seem to resolve symbol names however, so you can't see how different functions/definitions are related to each other and navigate between them. But the same author is working on another project that seems to go in that direction: https://github.com/Bogdan-Lyashenko/codecrumbs

You should give Sourcetrail a try! It's a tool for browsing and understanding unfamiliar source code based on LLVM/Clang LibTooling.

https://www.sourcetrail.com/

No, not yet. There is a feature request: https://github.com/CoatiSoftware/SourcetrailBugTracker/issue...

Thank you for your input! I wouldn't call it a feature request though, I'd say it's another tool. But, you are right, exploration of dynamicly analyzed code would also greatly benefit understanding.

We decided to leave out editing early in the process. Most developers already have their favorite editor and it's a lot of work to implement all features that users would expect from it.

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

CodeLens is great for finding references within the IDE. It also provides information about the history, which Sourcetrail doesn't do yet.

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.

Nevertheless I opened a feature request to track demand: https://github.com/CoatiSoftware/SourcetrailBugTracker/issue...

It hasn't been requested so far. Is it actively used by C/C++ or Java developers?

Yes, that's on the list as well.

Sourcetrail developer here: Pretty solid. We use clang libTooling.

Yes, we plan on supporting more languages in the future. C#, Python, Go and Rust are probably the next ones. However, I can't give a time frame at the moment. We are still polishing and improving our current C/C++ and Java support as well as our user interface.

Sometimes it's more about the challenge really. It started as an university assignment. Later I ported it to WebGL.

The original minesweeper rules don't make for a great game in 3D. I added the "sweep mode", where you can remove mines, to make the game more appealing in 3D

It's hand written WebGL. You can find it on GitHub: https://github.com/egraether/mine3D

Coati - an interactive source explorer for C/C++ based on Qt and clang: https://www.coati.io/

Too long.

I faced this problem while interning in the Google Chrome team and working on Chromium. Most of my time was used by reading the source code and figuring out the bigger picture of how classes and methods play together. I actually came to the conclusion that the big problem is that current tooling does not really support a developer on the task of reading existing source code. So I started building a new tool, Coati, an interactive source explorer for C/C++ based on clang. After using Coati myself for about half a year now, I can say that it really helps me navigate through the codebase quicker.

The tool is still at an early stage. We recently launched our website with a first release version: https://www.coati.io/

Do you think Coati is a tool that can help you?

> Developers spend more time reading than writing code.

> Yet mainstream IDEs are basically glorified text editors.

These two statements are exactly why I started working on a developer tool for exploring and understanding source code.

Coati is an interactive source explorer for C and C++ that makes comprehension of existing source code easier and allows for quick navigation whithin the source code: https://www.coati.io/

Reading this really reminded me of my time as an intern. I think I spent about 90% of my time reading source code then and doing exactly what what's described in this article. A lot of developer time is wasted reading existing source code and I think one problem is the lack of the right tools.

That's why I started building Coati, an interactive source explorer for C/C++. Coati allows you to see the relationships of classes and functions and thereby makes it easier to get an overview of your codebase. This makes the familiarization step of the process much easier.

https://www.coati.io/

It's interesting to see how easy this is in Python. I'm working on a developer tool for C/C++ that uses clang's AST for retrieving this sort of semantic information. We might support Python one day too.

https://www.coati.io/

I'm currently working on a developer tool that leverages the advantages of visualization not for writing source code, but for navigation and understanding. Coati, a source explorer for C/C++, combines graph visualization and source code interactively. The graph makes it easy to see what relationships a class or a function has, while the code still provides all the details of the implementation.

https://www.coati.io/

Naturally, you can't get rid of reading source code, that's where all the information is. But the visual representation can speed up navigation and understanding a lot. Having worked with the visual navigation of Coati for while now, I can tell you that it changed the way I develop software. Seeing at a glance which classes derive from an interface or where and how often a function is called gives you a whole new perspective on your codebase.

> code comes first; visual representation follows

I think this really is the core insight behind visual tooling. I'm currently working on Coati, a source explorer for C/C++, which does exactly that. By building a visual representation on top of a textual syntax, you can leverage the advantages of both.

https://www.coati.io/

In my opinion the biggest problem with legacy code is understanding its implementation as someone who hasn't worked on it before. In a lot of cases it's not documented well and the original authors have already left, so there's no one to ask. You are left with reading code written by someone else, which takes a lot of time.

This is not Perl related, but I'm currently working on a developer tool that makes this part of the job easier. It's a source explorer for C/C++ named Coati that simplifies navigation within source code and thereby makes understanding the implementation faster and easier. https://www.coati.io/

We just launched our website including an online store for selling software licenses. We are based in Austria. Our product is Coati, a source explorer for C/C++: https://www.coati.io/

After speaking to tax accountants and the finance office we decided to go for a reseller. The reseller does the invoicing for you. You just need to do the bookkeeping of the money you get from the reseller. We are using FastSpring. They do monthly subscriptions as well.

We just launched a new developer tool named Coati, which is designed to navigate and understand source code: https://www.coati.io/

The idea was based on our experience that you spend too much time searching through code as a developer. Coati makes it much easier to see how the different parts of the software play together.