hound VS septum

The same algorithm is also used in Hound (https://github.com/hound-search/hound) though I have to say the best implementation of code search by far that I've seen is https://grep.app

You really should check it out if you haven't already. It's incredibly useful; I used it all the time. Not open source though.

There is also Hound [8].

[8]: https://github.com/hound-search/hound

Agreed, I already have Hound setup to search across all the different repos I pull from (bitbucket, gh, gitlab, gitea etc) but now I need to find a docker equivalent.

i know you're looking for first-party tools that is part of the whole package, but hound does this fantastically and is extremely easy to setup, and is ridiculously fast.

Especially if this is long term, this is a great tool:

https://github.com/hound-search/hound#hound

It would be great if someone integrated this with tree-sitter plus something to make the search semantics a bit smarter about usages of X:

https://www.etsy.com/codeascraft/announcing-hound-a-lightnin...

Screenshots:

https://jaxenter.com/hound-go-react-code-search-engine-15008...

Another trick I use for Java: javap all the Enums out of the compiled artifacts; these indicate weird things like "modes" that you can use to start asking questions relevant to the domain. Like "why are there four ways to reprice an invoice" or finding the "types" of fees or w/e in a billing system. (assuming enum classes are used)

Nice too that it's a compiled language, so you get the end tool in a nice static binary. As a non-Node dev, I hate the experience of hacking on some project and having to install a giant pool of NPM stuff just run some minifier or linter. Hound is an example of this— the guts of the project are golang, but it has a frontend that uses webpack, jest, etc: https://github.com/hound-search/hound

Which is fine, I guess; definitely use the right tool for the job. And maybe Node developers hate finding my Python projects and needing to set up a virtualenv to run them in. But all the same, I approve a direction where more of this kind of tooling is available without a build-time Node dependency.

[2] https://about.sourcegraph.com/

[3] https://oracle.github.io/opengrok/

[4] https://github.com/hound-search/hound

https://github.com/pyjarrett/septum

The hardest part about getting code search right imo is grabbing the right amount of surrounding context, which septum is aimed at solving on a per-file basis.

Another one I'm surprised hasn't been mentioned is stack-graphs (https://github.com/github/stack-graphs), which tries to incrementally resolve symbolic relationships across the whole codebase. It powers github's cross-file precise indexing and conceptually makes a lot of sense, though I've struggled to get the open source version to work

septum - interactive searching for contexts matching and excluding parameters

I do a lot of weird and experimental work in Ada. Some of it works, whereas a lot of it doesn't. While I have done this sort of work in Python, Ruby, Rust, C or C++ in the past, when I do it in Ada, I end up saving time later on since the language forces many "good practices."

I'd appreciate any issues or suggestions you want to report on GitHub to help me improve this.

Ada is another option without a GC. I wrote a search tool for large codebases with it (https://github.com/pyjarrett/septum), and the easy multitasking and pinning to CPUs allows you to easily go wide if the problem you're solving supports it.

There's very little allocation since it supports returning VLAs (like strings) from functions via a secondary stack. Its Alire tool does the toolchain install and provides package management, so trying the language out is super easy. I've done a few bindings to things in C with it, which is ridiculously easy.

I mentioned my project Septum in a HackerNews comment, which caused it to pick up over 200 GitHub stars. That seemed to give Ada some publicity since it's a general purpose tool, so I'll also publish a new up-to-date version (0.0.6) here soon.

I work on code bases with millions of lines, so I wrote a tool called Septum to help me (https://github.com/pyjarrett/septum/). This isn't to replace grep or ripgrep or silver searcher, those are all great tools you should have!

Septum is neighborhood based (context-based) search, so you can find contiguous groups of lines which contain specific things, but exclude other things. It's also interactive so you can add/remove filters as needed. This makes it useful for those cases where terms change based on their context so you can exclude terms related to the contexts you don't want to keep. It reads .septum/config which contains its normal commands to load directories and settings, so you can have different configs per project you're working on.

Here's a short demo video of his Septum tool mentioned in the article: https://asciinema.org/a/459292

I also did a few things: - Wrote an online e-book about Ada - Septum - context-based source code search for multi-million line codebases (I use this nearly every day at work. It's being submitted as my Ada crate of the year. - dir_iterators - library similar to the incredible walkdir. - project_indicators - library for spinners and progress bars. - trendy_terminal - library for cross-platform terminal setup, VT100 support, and GNU readline-like behavior. - trendy_test - library for simple unit testing, which runs tests in parallel. - Ada Ray Tracer - an Ada port of Ray Tracing in One Weekend. - dirs_to_graphviz - Make graphviz files from directory trees. - rst_tables - a tool to draw RST table outlines.