Como lidar com grandes projetos Linux / makefile de forma eficaz?

Desenvolvo aplicativos Windows em C ++ há 10 anos. E recentemente comecei a pesquisar em alguns projetos Linux, e não suporto o quão improdutivo sou ...

Sou um aprendiz rápido e uso o Linux como plataforma principal há algum tempo. E eu me sinto muito confortável com shell, princípios de SO e GUI. Mas quando se trata de desenvolvimento, parece que estou de volta à escola.

Assim que eu abro um projeto maior, eu estou preso. A maioria deles é baseada em makefile, então, basicamente, quando tento navegá-los com QT ou CodeBlocks, na melhor das hipóteses, posso usar o intellisense por arquivo. E na maioria das vezes as variáveis ​​vazam do escopo.

Depois, há um material para definição, que parece inexistente, tente ingressar em um projeto maior do sourceforge, e você ficará preso por dias, porque navegar para definições é tão difícil ... grep -r "this_def" . --include "*.cpp" --include "*.h"parece tão lento e desajeitado.

E então, a depuração gdb funciona, mas não importa o que eu faça, parece que está anos-luz atrás do depurador do WinDbg ou VisualStudio.

E essas coisas estão me deixando desesperada, quero escrever código, mas fica tão lento ... Estou começando a pensar que os desenvolvedores do Linux aprendem definições de funções de cor e analisam o código pelos olhos, mas não acredito que seja assim.

Alguém já passou por isso? Há algo que estou perdendo que poderia me tornar mais produtivo?

Curiosamente, periodicamente, tenho o mesmo problema na direção oposta. Sou principalmente um codificador UNIX, mas periodicamente tenho que portar coisas para o Windows. Não sei dizer quantas vezes desejei arrancar meus cabelos, porque não consigo encontrar a caixa de seleção apropriada para uma opção de compilador escondida em uma das 35 páginas de configuração de preferência de um projeto. Prefiro abrir o arquivo proj e adicionar o XML.

Movendo-se em qualquer direção, o segredo é ter paciência e aprender o conjunto de ferramentas para a plataforma em que você está tentando trabalhar. É claro que você ficará frustrado, é novo e não é familiar, e você será reduzido ao status de novato tudo de novo. Não há como evitar isso.

No seu caso particular, existem algumas ferramentas adicionais que você deve conhecer. O primeiro é o DDD , um front end da GUI para o gdb. Não é tão liso quanto o Visual Studio, mas vai segurar sua mão. No entanto, eu realmente recomendo morder a bala e começar a aprender os meandros do gdb. Na verdade, se você é um usuário comum, não há muita diferença entre memorizar quais comandos digitar e memorizar qual caixa de diálogo você precisa abrir para alterar uma configuração.

Você também precisa conhecer ferramentas como CScope e CTags . Por mais que você resista, sugiro aprender VIM ou EMACS . Eles se integram bem às ferramentas de tags que acabei de mencionar. Quando em Roma, faça como os romanos. Você pode encontrar extensões para VIM e EMACS que farão a conclusão do código para você. Minha própria experiência com ferramentas que oferecem conclusão de código é que sim, economizando digitação, mas, em geral, é fácil. Pensar é o que é difícil. Sua opinião pode ser diferente, principalmente se você tiver síndrome do túnel do carpo.

Quanto ao make. Make é reconhecidamente horrível, mas você provavelmente só vai ter que aprender e aprender.

Desenvolvo aplicativos Windows em C ++ há 10 anos. E recentemente comecei a pesquisar em alguns projetos Linux, e não suporto o quão improdutivo sou ...

Há algo que estou perdendo que poderia me tornar mais produtivo?

Desenvolva no Windows, implemente no Linux.

Isso inclui a execução de testes de unidade na sua própria máquina (Windows) e no servidor de construção (Linux).

Como efeito colateral, você aprenderá a escrever código portátil.

Outro efeito positivo é que o uso de diferentes compiladores gerará mais avisos e, assim, capturará mais erros.

ATUALIZAÇÃO : Para todos os fãs do Linux que votaram contra esta resposta: Eu não digo que todos deveriam desenvolver no Windows! Mas usar a plataforma que você conhece muito bem é mais produtivo do que gastar muito tempo aprendendo uma nova plataforma.

Seu problema foi resolvido várias vezes no mundo Linux; no entanto, diferentemente das ferramentas Windows / Microsoft, ele não será entregue em uma placa de prata com um prato de extras. Você pode precisar fazer algum trabalho para obtê-lo.

Eu uso um editor comercial (Visual Slick Edit, que é considerado caro por aqueles que não valorizam tanto seu tempo quanto eu) para esse problema exato. O Eclipse com o plug-in CDT é um caminho de código aberto que tem muitos seguidores justificáveis. (Não é bom para mim, pois muitas vezes preciso do suporte da ADA)

O que eu não faço é tentar fazer engenharia reversa dos makefiles em algum tipo de projeto. Eu uso a compilação do IDE nos sistemas e adiciono / removo manualmente os arquivos, conforme necessário. Tenho certeza de que poderia escrever o roteiro, mas provavelmente o tempo não vale a pena. Por isso, achei o eclipse um pouco menos utilizável que o Slickedit (isso poderia facilmente (e provavelmente mudou) desde que eu olhei pela última vez)

O Linux tem uma vasta gama de ferramentas, caras que sabem que me superam em todos os aspectos da edição, têm pesquisas de referências etc., apenas uma curva de aprendizado acentuada. Estou certo de que o Emacs também pode fazer tudo, embora nunca o tenha usado.

Pelo que vale a pena, no Linux você tem sistemas de construção melhores do que o GNU antigo simples (que geralmente acompanha o horrível autoconf ), por exemplo, omake e muitos outros ( cmake, scons...).

uma sugestão sobre o quão tedioso é usar o grep para procurar código: configure aliases do bash no seu arquivo .bashrc. Então, é apenas um único comando:

alias searchCode='find -iname \*.cpp | xargs grep $1'
alias searchCodeHeaders='find -iname \*.h | xargs grep $1'

provavelmente há maneiras melhores de escrever o comando, mas a ideia é a mesma. Deseja pesquisar código? escreva um alias chamado searchCode. Lembre-se de que, embora sejam tediosas e complicadas, ferramentas unix também podem ser usadas para facilitar sua vida.

Meu 2c como alguém que desenvolveu C ++ em ambas as plataformas e gosta das duas.

1) Makefiles são dolorosos - o melhor conselho que posso dar é tentar mudar para outro sistema de compilação, se possível.

2) Para edição e navegação de código, existem algumas ferramentas bastante úteis. Claro, eles não estão integrados, mas isso realmente não importa quando se trata de fazer as coisas. O vim + ctags + grep o levará até lá. Claro, também existem IDEs, mas, francamente, não gostei de nada que tentei: Eclipse + CDT, KDevelop, Code :: Block. Você pode chegar a uma conclusão diferente, no entanto.

3) Para depuração, mantenha o gdb da linha de comando. Certamente, está bem atrás do Windbg quando se trata de recursos, mas para a maioria dos propósitos está ótimo. Os front-ends gráficos (ddd, KDbg) foram bastante problemáticos na última vez que os experimentei, mas novamente as coisas podem ter mudado :)

A linha inferior é - sim, você precisa colocar algum esforço de aprendizado, mas depois disso será tão produtivo quanto no Windows.

Para todo o restante dos bons conselhos que você já recebeu, gostaria de adicionar alguns links, respectivamente, para ack e pss .

Eles são direcionados a programadores que precisam se preocupar especificamente com o código-fonte, tentando melhorar o grep.

Ótimas respostas. Adicionando a eles,

Quando tomei essa decisão, o erro que cometi foi tentar entrar no código sem dar a devida diligência ao sistema de compilação GNU, que voltou a me morder quando eu queria fazer alterações no código. Passe alguns dias para entender como o AutoMake / AutoConf / Make suite de ferramentas funciona, você será muito rápido depois disso.

Em relação às ferramentas - Eclipse + CDT / GDB + DDD realmente percorre um longo caminho.

Aqui estão alguns conselhos para facilitar o trabalho:

1. Comece do começo. Isso significa que você usará o script bash como uma substituição de makefile primeiro e, em seguida, makefiles simples assim que precisar de dependências. Mantenha as coisas simples no começo. Seu makefile não precisa lidar com 15 plataformas unix diferentes - basta compilar com dependências. (seu makefile inicial terá a seguinte aparência: all: g ++ -o main main.cpp) (exemplo mais complexo pode ser encontrado em http://sivut.koti.soon.fi/~terop/Makefile - ao iniciar do zero , basta copiar o arquivo para o projeto, alterar nomes de arquivos, diretório mkdir objs, alterar bibliotecas desejadas)
2. Esqueça o IDE. Isso só vai torná-lo mais lento. Aprenda a ler o código e lembre-se da hierarquia de arquivos do seu projeto. Ferramentas normais de linha de comando como 'cd dir' e 'emacs foo.cpp' precisam ser tão automáticas que você nem pensa em digitá-lo duas vezes.
3. Esqueça o realce da sintaxe e o intellisense. Nunca vai funcionar da mesma maneira que funciona no visual studio, e as dicas que ela dá só o confundirão, pois é diferente do que você costumava fazer. Aprenda a não confiar neles.
4. Gdb é um bom depurador. Você receberá uma pilha de chamadas. Nem tente contornar o código, não vai funcionar muito bem. Use valgrind também. Os pontos de interrupção também são bons, mas não confie neles demais; usado raramente com gdb.
5. Se a sua compilação não for mais do que simples 'make' no shell, você precisará repensar a sua edição-compilação-depuração-edição-ciclo.
6. Aqui está um truque que o visual studio não pode fazer: Mostrar o arquivo de cabeçalho e o arquivo .cpp na tela ao mesmo tempo - para que ambos fiquem visíveis sem alternar entre eles com guias. O Emacs pode fazer isso. Então, pode bloco de notas. O Visual Studio ou IDE não pode.
7. Aprenda as combinações de teclas do emacs. Isso vai torná-lo mais rápido. Uma boa dica é que todas as teclas estão localizadas muito próximas ao teclado. As sequências de comando são mais longas, mas ainda é mais rápido digitá-las.
8. Existe um truque fácil para substituir a go-to-definition: escreva o código no mesmo arquivo e use esc- <e Cs :: myfunction no emacs para encontrar a função que você deseja. O processo é diferente se você já usou muitos arquivos curtos - seu código terá uma aparência diferente. (aprenda ctrl-f no bloco de notas e você entenderá). Mas você definitivamente não precisa fazer isso com casca.
9. O tempo de inicialização do editor de texto é muito importante. Se demorar mais de 1 segundo para abri-lo, não será bom. Todo IDE está quebrado por causa desse requisito. O bloco de notas e o emacs estão ok.
10. goto-line no emacs é um recurso importante para a programação. Ligue-o a alguma chave. Eu uso Cx g