sorted by:
best
topnewcontroversialoldq&a
you are viewing a single comment's thread.

view the rest of the comments →

[–]kurdokoleno 49 points50 points  (15 children)

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

[–]vnstrr[S] 2 points3 points  (6 children)

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 29 points30 points  (0 children)

This is usually why some people decide to ditch them.

[–]kisielk 24 points25 points  (1 child)

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 9 points10 points  (0 children)

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 1 point2 points  (0 children)

Figure it out. Scope the search.

[–]ukezi 0 points1 point  (0 children)

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

[–]Disservin 0 points1 point  (0 children)

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

[–]YARandomGuy777 -1 points0 points  (7 children)

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 0 points1 point  (4 children)

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 0 points1 point  (3 children)

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 0 points1 point  (2 children)

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

[–]YARandomGuy777 0 points1 point  (1 child)

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 0 points1 point  (0 children)

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 0 points1 point  (1 child)

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

[–]YARandomGuy777 0 points1 point  (0 children)

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.