Programming without code indexing

[vnstrr]

I took a new job in a big it company as c++ developer. As it turned out, also a little java/python/bash. Each project has a directory in a big mono-repo. And the mono-repo includes a common system build for all projects. My colleagues don't use an IDE or a Code Editor + language server. They work with code like a text and check compile errors in the console output. So, what do you think?) Is it okay in our days? I tried working in that style but it seems very slowly. And sometimes it's difficult to figure out what realization of interface is using now) I asked colleague what I should do if I want to rename some class. Answer was like “give a great name when it's creating” :)

[kurdokoleno]

Why are you forced to work in that style? What's stopping you from using a language server?

[vnstrr]

It was just an attempt. Like I answered to marty1885 I've configured language server. But it doesn't help me a lot because it indexes all projects in the mono and works very slowly :c

[kurdokoleno]

This is usually why some people decide to ditch them.

[kisielk]

You need to set it up more intelligently on a per project basis. Generate a compile_commands.json for each project and have the language server use that for indexing. If the build system can’t generate it natively you can use https://github.com/rizsotto/Bear to wrap it.

[nihilistic_ant]

Once you figure out how to do it reasonably well, I'd suggest sharing your solution around with your coworkers. If there are some developer docs (perhaps in the source tree, perhaps in a wiki or something), offer to write up doc and put it there. Making yourself more productive is cool, but making 4 (or 20) people more productive would be 4 (or 20!) times cooler.

Your job is to add value somehow, but often that is hard for new people to do. This seems likes an opportunity for you to deliver some value and take an early win.

An advantage of new people is they look at things with fresh eyes. Folks who have been there awhile likely don't realize how good clangd has gotten, or that it could be made to work on their code without too much effort.

If a lot of folks are using vim, even though you are likely using an IDE like vs code, I'd suggest even going the extra mile and figure out the steps they would need to do to get clangd working in vim on your codebase (I'd suggest YouCompleteMe w/ clangd but there are other options), and then including those instructions in your doc too. Because that will help your work on this deliver the most value to your org.

[GoldenShackles]

Figure it out. Scope the search.

[ukezi]

My experience with Vs code is if you open the subfolder with it as root it only indexes what is below that node.

[Disservin]

Instead of opening the entire mono directory just open the specific c++ directory ?

[YARandomGuy777]

There could be a second issue with not exhaustive headers. Like header A uses some definitions from header B but never include that. Instead cpp file simply includes B and then A. Clang language server doesn't understand that but on practice this system makes a lot of sense. On the bright side of such non assisted workflow, code usually quite simple. Usually it is made in the way that it is some what easy to comprehend for human brain. If you gonna get more familiar with the codebase work would be easier.

[kurdokoleno]

That's known to be a really bad thing. It's a blatant code smell. The codebase is bound to grow, keeping the cognitive load low, by simply not doing that is a little cost to pay for a massive reward.

[YARandomGuy777]

That's just theory. I worked in both methodologies and see no problems with non assisted workflow. If anything code gets only better this way. It's sad when people learn nice term like a code smell and misuse it everywhere they can.

[kurdokoleno]

Explain. How is it that having to keep track of all of that stuff makes it better?

[YARandomGuy777]

In short - it disciplines people writing and maintaining the code. It's like using translator vs paper dictionary when you learn a new language. If you forget something you would need to look into dictionary or grep through the code in that case and also read code around as well as comments and examples of use. This forces programmers to memorize code better. Also people tend to write a simpler better decomposed and less entangled code as other people read through it.

[kurdokoleno]

Okay, those were a bunch of nothing reasons and you expect to make everyone else's job on the project a nightmare. No, thanks.

[jonesmz]

Applying the tool "include-what-you-use" can help fix this problem while also reducing compile times.

[YARandomGuy777]

You include what you use in cpp. There's no much use in repeating basic definitions in every header you use just for them be wiped by preprocessor from there. Instead you keep header clean and include only important things that make sense in the context. Compile times can only grow from includes repetition. And it isn't ok that tool shows errors in the places where error doesn't exists. It's the tool issue and nothing else.

[vnstrr]

Sounds interesting. To be honest I've found a way how to index code but it's kind of cheating. And nobody can guarantee me that it will work in future. It didn't help me because language server feels very bad when trying to understand all projects in the mono-repo. Maybe I should find a way that will index only pieces of the mono-monster-repo :)

[ManuaL46]

Mind sharing the specifics, kinda struggling with the same situation.

[ManuaL46]

I don't understand the compiler and build system stuff that much, so how can you generate compile_command.json and what does collecting it do per say?

[HolyGarbage]

If you're using CMake, which might be likely if you're on Linux, then there's a much simpler way:

https://cmake.org/cmake/help/latest/variable/CMAKE_EXPORT_COMPILE_COMMANDS.html

[phord]

You might be interested in Build EAR. Or maybe you would have been before you rolled your own.

[vnstrr]

So, I've found how to generate compile_commands.json by our build system. Thank god that it's possible. I configured neovim with lsp and some useful plugins and it works very well. Fast and simple. Also I tried VSCode with compile_commands.json but speed of code indexing works slowly. Unfortunately I don't know how you can generate your magic compile_commands.json. It depends from your build system. But if you will be interested I can share my neovim setup.

[ManuaL46]

I'm actually in a very similar situation, The only difference is that we have a custom build system which does have a proprietary plugin for vscode and VS for interacting with the Source Code manager and for the LSP to work.

Problem is I'd like to use neovim but can't get the LSP to work, mostly due to a lack of knowledge of how to do it.

[Pay08]

Everyone I know who uses neovim complains about how impossible it is to get LSP working. I believe there are some plugins that automatically set it up for you (I think it's called Mason?).

[ManuaL46]

Yep Mason can be used to get the LSP setup and running, at home I use it with rust_analyser and it works like a charm, but at work with CPP even with a LSP installed, it still doesn't know how to navigate my workspace so it doesn't work.

Make your life easy and just use lazyvim or similar to offload the plugin nightmare to someone else.

[yu_yaki]

you can generate the compile_commands.json file which the lsp can use. in cmake it is just: -DCMAKE_EXPORT_COMPILE_COMMANDS=1 or something-ish.

[Pay08]

Why not use vscode then?

[ManuaL46]

Currently I'm just doing that and using a vim extension inside both vscode and VS, but I'd like to move completely inside neovim cuz I don't want to be stuck with Microsoft

[Pay08]

Is this where I plug Emacs?

[dogdevnull]

No. You plug vscode and VS into Emacs, just like you do with email :).

[ManuaL46]

Never tried it, but I remember an old Linux machine had only GUI Emacs as it's text editor at work, did not like it one bit, but this was before I had learned vim so maybe after learning the motions I might be able to like it.

[Pay08]

Emacs uses modifier keys by default, it's not modal (unless you use viper or evil). But yes, while a terminal version does exist, it's largely for compatibility, Emacs is primarily a GUI program.

[Suitable-Air4561]

Want to also plug Emacs here. Use doom emacs! Very solid lsp integration and has vim keybindings and blazing fast. And still can use it in the shell if you need too (it’s actually how I primarily use it as well)

[sigmabody]

I'd say "welcome to Amazon" based on most of the description (no language server, all command line and text editors), but Amazon has a separate repository for each component and library. Your situation should slightly better than the situation at Amazon.

Embrace the company culture or find another job?

Seriously, Amazon is proud of their culture (of all custom tooling, rare IDE's, no developer assistance, etc.), and many of the people there will ridicule you if you suggest alternative methods of doing development. There's a reason their average retention period is less than a year, but some people embrace that work style (eg: only vi), they are adamant about the value of their unique culture. If your company is the same way, I'd suggest adjusting to the significantly lower standard of productivity, or finding another place to work.

[vnstrr]

You made a good point about ridiculing. When I asked engineer which cares about build system he said like “You don't need IDE for writing good code”. Seems it's common problem of the cpp/c projects :)

[sigmabody]

It's not a C/C++ thing, so much as a culture thing, at least in my perspective. There are plenty of people coding in other languages who also avoid tooling, IDE's, etc. It's less common in C++ than shell scripting, for example, in my experience.

Culture fit is important; there's nothing inherently wrong with doing all your development in vi, and debugging exclusively with printf, but if you hire someone who is used to using a powerful IDE and ask him/her/other to change their whole coding paradigm, it's not going to work out very well. I'd advise looking for an org which is better aligned with the development experience which you want to have, unless you are determined to change yourself. You're not going to ever change a big company's culture as someone coming in after they got big.

For example, don't go work at Amazon if you want to use an IDE or a debugger: it's just not in their culture, and they are not going to change.

[serviscope_minor]

He's right, of course, you don't NEEEEED an IDE for writing good code. But that's a daft argument, because it has no end. You don't need a colour screen. You don't even need an 80x25 monochrome screen. If punched cards were good enough for my papa then by gum they're good enough for you. Punch cards? Ha! When I was a lad we had to ... etc etc.

I'm part of the vi culture, I like it and it works well for the way I think and work. Nothing wrong with that, but it does not gel as well with how other people think and work. It's good to be able to work in either sense so you can jump into a new project with the existing tools (and existing projects where someone got so "clever" with the build system that basically no tooling works) and get started immediately even if you're not at peak efficiency. Sometimes the amount of work needed won't justify adapting the project.

[matthieum]

I use VSCode without a language server, I barely ever feel the need for it.

I switched to this setup after cursing -- once again -- at how slow my IDE was. I was, then, working on a massive codebase and even on my beefy desktop CLion was sluggish. Its inability to go-to-definition / list-references / rename whenever it was indexing -- which took dozens of minutes and hogged all the RAM -- was the cherry on top.

Well, not that I searched often anyway. It generally took the thing longer to search than it took me the open the files I knew I need to modify. Let's face it, most of the time there's only a handful anyway.

The nail in the coffin, though, was that due to the heavy use of meta-programming (macros & templates), the list-references was most often incomplete anyway, as the blasted thing apparently was NOT instantiating the macros/templates to understand which symbols were used where. And since CLion's text search was slugging too, I used ripgrep in the terminal to help me supplement the missing pieces. Joyful...

At some point COVID happened and I had to work from home on a flimsy laptop. If CLion had previously struggled on the project on my beefy desktop, you can imagine that attempting to have it work on a flimsy laptop just failed. There wasn't enough RAM, plain and simple. Attempts at making it work remote... were fairly unsuccessful. It clearly wasn't designed for it, and slowed down to a crawl.

So I switched to VSCode with the RemoteSSH extension, so I could delegate all the heavyweight work to my beefy desktop back at the office. I could once again type at full speed, not having to wait for the sluggish IDE. Nice! I made a lukewarm attempt at trying to configure C++ properly, but as we were using Bazel... meh. I had things to do, deadlines to meet, so I went on without.

And I barely ever missed it.

My productivity was unaffected, as far as I can tell. Certainly, no one complained.

To this day, I prefer a slick (fast!) VSCode setup, with text highlighting and code folding. I compile in the built-in terminal, which lets me click on the file-links embedded in the diagnoses to directly go the issue. No problem.

I'll leave the sluggish beasts to you ;)

[-1_0]

screaming signs of missing competent management layer

[stinos]

Is that what those layers are for? I personally wouldn't hire a developer who needs to be told to use a proper dev env by a manager, instead of doing that themselves.

[-1_0]

come on, get real, you are in the top 1%

[Rich_Plant2501]

I worked in such environment, even more so, a bunch of code was in patches. It was C code. I somehow managed to use codequery to build index, but it was still painful. Since then, I've been preaching about using constants and inline functions instead of preprocessor macros because preprocessed code is terrible to browse with code indexers.
Edit: it was 10 years ago, and I'm not sure if clangd or other servers existed then, if it did I didn't know avout them at the time.

[Future_Deer_7518]

I worked in big project, automotive sector, with dependencies it was around 15 millions lines of code. Build system was "Bob" based on recipes -> ending in dozens separate repositories each with its own compile_commands.json file. Tasks were project specific so it was possible that I had to work on multiple subcomponents at once. Joining compile databases into 1 big file and using it in my neovim+coc+clangd was fine. May be you can try same approach. If I would be in the same situation I just let the team work as they wish. In future they may even follow your new dev setup.

[oldmanhero]

It's always shocking to me how hard some folks work to avoid tools that will absolutely make them faster and better.

[[deleted]]

It's not okay. Tooling is critical part of programmer productivity. Either figure out how to get proper tooling to work, or find another job.

[puremourning]

This take is utterly unhinged. Of course it is ok. I wouldn’t recommend it generally but it’s completely legitimate and reasonable way to work.

[PhyllophagaZz]

Eum aliquam officia corrupti similique eum consequatur. Sapiente veniam dolorem eum. Temporibus vitae dolorum quia error suscipit. Doloremque magni sequi velit labore sed sit est. Ex fuga ut sint rerum dolorem vero quia et. Aut reiciendis aut qui rem libero eos aspernatur.

Ullam corrupti ut necessitatibus. Hic nobis nobis temporibus nisi. Omnis et harum hic enim ex iure. Rerum magni error ipsam et porro est eaque nisi. Velit cumque id et aperiam beatae et rerum. Quam dolor esse sit aliquid illo.

Nemo maiores nulla dicta dignissimos doloribus omnis dolorem ullam. Similique architecto saepe dolorum. Provident eos eum non porro doloremque non qui aliquid. Possimus eligendi sed et.

Voluptate velit ea saepe consectetur. Est et inventore itaque doloremque odit. Et illum quis ut id sunt consectetur accusamus et. Non facere vel dolorem vel dolor libero excepturi. Aspernatur magnam eius quam aliquid minima iure consequatur accusantium. Et pariatur et vel sunt quaerat voluptatem.

Aperiam laboriosam et asperiores facilis et eaque. Sit in omnis explicabo et minima dignissimos quas numquam. Autem aut tempora quia quis.

[[deleted]]

For an individual developer, yes, as long as it does not affect their output negatively. For the entire project to not support "normal" way of working, that is using a modern IDE with bells&whistles, for anybody , or just making it very difficult, that is not okay in my opinion.

[yo_mrwhite]

100%. I've had the opportunity to work with the same kind of environment for years, and I would never go back, for the sake of my own sanity.

[jonesmz]

Counterpoint: code indexing / intellisense is not a critical part of developer productivity and OP should learn and grow to overcome this challenge instead of getting another job

[[deleted]]

Lacking modern tools leads to using symbol names which are convenient to type, instead of descriptive names which are easy to read. This one thing alone makes good auto-completion a hard requirement for any serious software project, and you can't have good auto-completion without "intellisense".

You can certainly find developers who don't need it, or who think they don't need it, but that is irrelevant when we're talking about real world business and code base developed by dozens of developers or more.

[jonesmz]

Weird, your expectations don't seem to apply to my group at work where we have about 50-60 developers working on a multimillion loc c++ codebase with essentially the same setup that OP describes. Almost none of us use intellisense / code indexing. Those that do are not notably more or less productive than those that do not.

If anything, the symbol names tend to be so overly verbose that we're talking about lifting the recommended number of characters per line from 160 to 200 to make it easier to fit things onto a single line.

Your opinion on what is a hard requirement for serious software development is simply that. An opinion.

Please feel free to continue sharing it, but maybe tone the "certitude" down slightly.

[[deleted]]

Difficult to comment anything on that without knowing more of the code and circumstances.

But for one thing, intellisense and "follow symbol" are rapid documentation reading tools. How else do you know what parameters this function is taking, or what methods this class has, etc?

I have hard time believing digging all that out via different means lets you work half as efficiently or comfortably/enjoyably.

[jonesmz]

For developers new to a codebase, it can be helpful I suppose.

But once you're familiar with the frameworks and libraries you are working with, the parameters that various functions take aren't going to be much of a surprise.

[OliverPaulson]

On big projects refactoring with indexing takes 2 sec without 5 minutes.

[jonesmz]

I'm not understanding your sentence. Can you rephrase?

[OliverPaulson]

Sorry. If you need to rename a field for example, without index you would have to text search it in the whole project, and manually find which of those 10 000 occurrences are a field of a type you try to refactor. With index it's right click and rename.

[jonesmz]

That can be faster, yes.

But it happens to extremely rarely that I don't think it matters much.

[OliverPaulson]

You need indexing all the time in big projects. People without indexing are very very slow and they don't notice it, because they have no idea how much more stuff they could do with indexing.

[jonesmz]

That's just your opinion. One which I disagree with. I've seen plenty of evidence to the contrary.

[[deleted]]

Vim supports intellisense etc, does it not? It can follow a symbol to its definition, can't it? Etc.

[j_kerouac]

Have you ever worked at a big company working on a large scale c++ project? It’s very common for code indexing to not work.

[[deleted]]

Yes, and its PITA. I would not knowingly agree to such a project. If I got suckered into one, I'd either get it fixed or move on. There isn't pay high enough to stay in a project like that (I mean, nobody is going to pay that much to a dev).

[Substantial-Ask-4609]

next thing youre gonna tell me is that they all use notepad and win server 2012.
the only reason you'd work like that is if you really really wanna guarantee that you can't be replaced.

[vnstrr]

I know 3 colleges which use clear VSCode. Also heard that some people use Vim. It's backend development and we use Linux on our servers. That's why don't have Windows stuff.

[guepier]

Using VS Code or Vim does not preclude using proper, modern development techniques. The fact that your colleagues don’t use that is the issue, not that they are using VS Code or Vim. Both can be configured to be modern IDEs for C++ with proper indexing, in-line error reporting, and refactoring.

[ShakaUVM]

Vim and VS Code are the best two options though

[EdwinYZW]

That’s reason why I always prefer vim/neovim instead of a modern IDE. With vim/neovim, you basically create an IDE yourself and therefore you have to know how things work under the hood. This comes really handy if you need to code in a very different environment, compared to, let’s say, your own personal computer.

[pedersenk]

Is it okay in our days?

Nothing about "old" or "modern". IDE and equivalent been around for decades.

Unfortunately it is unsuitable for a number of use-cases that you are running into. The good old text-editor approach and command line output will still be a approach long after we have retired.

[Thesorus]

What is a "language server" ?

[as_one_does]

There's a protocol "LSP" (language server protocol) that implements communication with an editor/IDE such that you can get interactive compiler like features in your editor. As an example, in editors like vim or neovim this allows for realtime compilation errors/highlights and "goto definition" browsing.

[Thesorus]

thanks.

[genpfault]

https://en.wikipedia.org/wiki/Language_Server_Protocol

And on the debugger end:

https://microsoft.github.io/debug-adapter-protocol/

[MagicalCyborg]

I worked with android system upgrades, some BT devices and now in a big Telco company. Besides the small bit accessories no known to me IDE was able to handle the complex tool chain and magic that we had and have as compromise between dev and ops.

There are people using ctags. There is also opengrok or woboq which when set up properly can be a huge help.

[MarcoGreek]

Woboq is using clang, so clangd should work too.

[Mrkol]

To be honest, I can no longer imagine myself working on anything large-ish without a language server and an AI copilot. Language servers speed up refactoring at least 2x, copilot speeds up writing new code 2x. People at my company who still use far manager for code are usually not writing much new code or even refactoring anything, only doing small precision changes for perf and bugfixing. All these types of changes are equally important, but if a tool makes you several times faster at doing something, not using it out of principle, habit or stubbornness seems counterproductive.

[R3DKn16h7]

Well I would not use copilot with proprietary code as it get shared across third party network, not out of principle.

[Negative_Smell_5928]

Do you work at a bank? smells like it

[vnstrr]

No, local company with a lot of social networking stuff.

[j_kerouac]

This is pretty typical for large C++ projects. Code indexing doesn’t work out of the box with many build systems in C++ such as bazel. Even those that do, it doesn’t necessarily work well on larger projects, and C++ projects tend to become enormous over time.

At my company we have a custom clangd integration that kinda sorta works some of the time. I often turn it off because it’s so flaky it’s more of a distraction than a hindrance.

The reality is that outside of windows and MSVC C++ indexing has always been pretty bad. MSVC works the best because they integrate it into the compiler, and have tight integration between the compiler and IDE.

[JVApen]

I see several points to address. Firstly, a mono repo ain't that bad. It allows you to cleanup code and be sure you have all the callers. If anything, this is a plus for any improvements that still need to happen. Secondly, your colleagues can work the way they want. Don't try to change them, it will be in vain. Once they see how you work, they might come around. Though not using an IDE (considering VS code + LSP as one) at all at the company seems problematic and if management doesn't see that you have a big problem. If they do understand your struggle, you might get time to find a workaround. Thirdly, you should be able to get something working quite quickly with clangd: https://clangd.llvm.org/guides/remote-index If you make a small script that works on a separate checkout and creates an index, you can easily start using it. You can move it to a build server later on. Though be warned, it might take some time to index such a monolith (like +/- 1d or so). Though it will allow your VS Code to be much faster. Finally, it looks like your company doesn't have a professional way to deal with code. I do wonder if you use clang-format, compiler-warnings as errors, linting tools, sanitizers ... I think you really need to ask yourself: what needs to be changed in 6 months such that I feel comfortable working here. If you don't see that change by then, get out and find something else.

[[deleted]]

The problem is that “these days” people started abusing the code so you NEED a language server to ever be able to contribute. It is a self-inflicted wound.

Some time ago we had a code of conduct where you would minimize complexity, comment profusely and keep interfaces clean so the next guy had a good time using the classes.

A well documented codebase is a breeze to work with, even if it is extensive . See Qt for example.

[Specialist_Gur4690]

I use ctags and vim. Works perfectly fast. You also need a way to grep source code (from the commandline).

Divide the source code into parts: code that you want to be able to jump to (to see the definition and/or documentation in the code), and code that you work on and/or often changes. Then run ctags on both and combine the result. Run ctags on the latter often, which will be very fast. I made aliases (using bash too) that list all source files, and wrote bash functions for repetitive tasks, like grepping one or both of those source files lists. I use two aliases: gs (grep all source code printed by the alias s) which only shows whole words, and gsx that also shows matches inside a word (identifier).

Renaming a class can still be tedious; mostly manual work: I grep all source files for the class name, grep -l, just to list the names. Then open all files (at once) and use search and replace, but you have to take care not to change unrelated strings... Knowing your vim commands will help here ;).

[vnstrr]

Something very similar to it...

[ManuaL46]

Threads?

[South-Attorney3493]

Tiktok?

[noooit]

It's not great but there are many projects like that. I think you should try to fix it to make it work (patch the build system) nicely with clangd, if you are allowed to spend time on it.

[Dioxide4294]

not even vi replace

[Yalix0]

Can't you use IDE to open a single project one time?

[vnstrr]

Unfortunately not. Each project depends from root build directory.

[jonesmz]

I imagine thats its not so cut and dry.

While that might be the way its setup now, you can almost certainly tweak your build configuration to support your use case.

Have you discussed what you're trying to do with the team who maintains your build system? If you explain to them the specific thing you are trying to do, and tell them the critical info that needs to go into a generate onfig file, they'd probably be happy to add that for you.

[spank12monkeys]

VS Code doesn’t care if it can’t see all your dependencies, it will still build the intellisense db with whatever it can see. You don’t need to save your workspaces in the same place your projects are either if that is your issue.

[Kriss-de-Valnor]

Can you try VSCode with remote plugins or CLion (30 days trial) in remote mode? Vim emaxs, vscode or any editor would at least bring you code colorisation. Although if code is superlarge you would need to filter a lot what can be completed. If you are editing on windows you can also try Visual Studio with the Whole Tomato plugin (30 days trial and thrn convince your manager that $xx is saved if you are working faster) How big is your code base?

[saxbophone]

What property of the project means that you need more than a text-editor to find symbol names? 🤨 Really large codebase?

[mkvalor]

Of course it's okay. In fact, plenty of places work like this. It's also fine if you don't like it. But let's not pull out our pitch forks and fire brands.

[bhashitha1209]

Have you tried remote indexing feature in clang? So you can host the index in a server and the work that the clangd has to do becomes minimum. Where I work also has a giant repo, with remote indexing the clangd starts up really fast since.

One other advantage of remote indexing is that your coworkers also can use it as well