Por que devo usar um IDE? [fechadas]

Em outra pergunta, Mark fala muito dos IDEs, dizendo que "algumas pessoas ainda não sabem" por que "deveriam usar um ...". Como alguém que usa o vim para programação e trabalha em um ambiente em que a maioria / todos os meus colegas usam o vim ou o emacs para todo o seu trabalho, quais são as vantagens dos IDEs? Por que eu deveria usar um?

Tenho certeza de que esse é um problema cobrado por algumas pessoas e não estou interessado em iniciar uma guerra de chamas; portanto , responda apenas com os motivos pelos quais você acredita que uma abordagem baseada em IDE é superior . Não estou interessado em saber por que não devo usar um IDE; Eu já não uso um. Estou interessado em ouvir "do outro lado da cerca", por assim dizer.

Se você acha que os IDEs podem ser adequados para alguns tipos de trabalho, mas não para outros, também estou interessado em saber o porquê.

Realmente depende de qual linguagem você está usando, mas em C # e Java acho os IDEs benéficos para:

• Navegando rapidamente para um tipo sem precisar se preocupar com espaço para nome, projeto etc.
• Navegando para membros tratando-os como hiperlinks
• Preenchimento automático quando você não consegue lembrar os nomes de todos os membros de cor
• Geração automática de código
• Refatoração (maciça)
• Organizar importações (adicionando automaticamente importações apropriadas em Java, usando diretivas em C #)
• Aviso ao digitar (ou seja, alguns erros nem exigem um ciclo de compilação)
• Passando o mouse sobre algo para ver os documentos
• Manter uma visualização de arquivos, erros / avisos / console / testes de unidade etc. e código fonte, tudo na tela ao mesmo tempo, de uma maneira útil
• Facilidade de executar testes de unidade na mesma janela
• Depuração integrada
• Controle de fonte integrado
• Navegando para onde ocorreu um erro em tempo de compilação ou exceção em tempo de execução diretamente dos detalhes do erro.
• Etc!

Tudo isso economiza tempo. São coisas que eu poderia fazer manualmente, mas com mais dor: prefiro codificar.

Conclusão de código. Isso ajuda muito na exploração de código.

A resposta curta para o motivo de eu usar um IDE é a preguiça.

Sou uma alma preguiçosa que não gosta de fazer as coisas de uma maneira difícil quando há uma maneira fácil de fazê-las. Os IDE facilitam a vida e, portanto, atraem a gente preguiçosa.

Enquanto digito o código, o IDE verifica automaticamente a validade do código, posso destacar um método e pressionar F1 para obter ajuda, clicar com o botão direito do mouse e selecionar "ir para a definição" para ir direto para onde está definido. Apertei um botão e o aplicativo, com o depurador anexado automaticamente, é lançado para mim. E assim a lista continua. Todas as coisas que um desenvolvedor faz diariamente são reunidas sob o mesmo teto.

Não há necessidade de usar um IDE. É apenas um trabalho muito mais difícil não.

Não acho justo fazer o clássico "editor de texto e janela do console versus IDE" quando "editor de texto" é realmente emacs. A maioria dos recursos típicos do IDE: s também está no emacs. Ou talvez até tenham se originado lá, e os IDE: s modernos são principalmente melhorias / simplificações de interface.

Isso significa que, para a pergunta original, a resposta não é tão clara. Depende de como as pessoas no site em questão usam o emacs, se o usam principalmente como editor de texto ou se usam tudo e usam scripts personalizados, aprendem os comandos para os modos relevantes, conhecem a marcação de código e assim por diante.

Chego a essa pergunta na direção oposta. Fui criado na programação com pouquíssimos pitstops nas terras do Makefile + Emacs. Do meu compilador mais antigo do DOS, o Microsoft Quick C, eu tinha um IDE para automatizar as coisas. Passei muitos anos trabalhando no Visual C ++ 6.0 e, quando me formei em Enterprise Java, trabalhei com o Borland JBuilder e depois decidi pelo Eclipse, que se tornou muito produtivo para mim.

Durante toda a minha carreira inicial de autodidata, faculdade e agora profissional, aprendi que qualquer grande desenvolvimento de software feito exclusivamente dentro do IDE se torna contraproducente. Digo isto porque desejos da maioria do IDE que você trabalhe em seuestilo peculiar de eu-controle-como-o-mundo-funciona. Você precisa dividir e dividir seus projetos ao longo de suas linhas. Você gerencia as construções do seu projeto usando suas caixas de diálogo ímpares. A maioria dos IDE gerencia mal dependências complexas de construção entre projetos, e pode ser difícil obter 100% de dependências. Eu já estive em situações em que os IDE não produziriam uma compilação funcional do meu código, a menos que eu fiz um Limpar / Reconstruir Tudo. Finalmente, raramente há uma maneira limpa de tirar o software de desenvolvimento e entrar em outros ambientes, como controle de qualidade ou produção, a partir de um IDE. Geralmente, é um evento difícil para criar todas as suas unidades de implantação, ou você tem uma ferramenta estranha que o fornecedor do IDE fornece para você agrupar as coisas. Mas novamente,

Aprendi que, para desenvolver em larga escala com uma equipe, podemos ser os mais produtivos se desenvolvermos nosso código usando um IDE e fizermos todas as nossas compilações usando scripts de linha de comando escritos manualmente. (Gostamos do desenvolvimento do Apache Ant para Java.) Descobrimos que executar nossos scripts a partir do IDE é apenas um clique de festa ou um pesadelo de automação para compilações complexas, é muito mais fácil (e menos perturbador) colocar alt + tab em um shell e execute os scripts lá.

Compilações manuais exigem que perdamos algumas das sutilezas do IDE moderno, como a compilação em segundo plano, mas o que ganhamos é muito mais crítico: compilações limpas e fáceis que podem viver em vários ambientes. O "one click build" de que todos aqueles caras ágeis falam? Nós temos isso. Nossos scripts de construção também podem ser chamados diretamente por sistemas de integração contínua. Ter as compilações gerenciadas por meio da integração contínua nos permite formalizar e migrar suas implantações de código para diferentes ambientes e nos informar quase imediatamente quando alguém faz o check-in de um código incorreto que interrompe a compilação ou os testes de unidade.

Na verdade, assumir o papel de construir longe do IDE não nos machucou muito. As ferramentas intellisense e refatoração no Eclipse ainda são completamente úteis e válidas - a compilação em segundo plano simplesmente serve para suportar essas ferramentas. E o corte peculiar de projetos do Eclipse serviu como uma maneira muito boa de quebrar mentalmente nossos conjuntos de problemas de uma maneira que todos possam entender (ainda que um pouco detalhados para os meus gostos). Eu acho que uma das coisas mais importantes sobre o Eclipse são as excelentes integrações de SCM, é isso que torna o desenvolvimento da equipe tão agradável. Usamos o Subversion + Eclipse, e isso tem sido muito produtivo e muito fácil de treinar nosso pessoal para se tornar especialista.

Sendo o autor da resposta que você destaca em sua pergunta e, admitidamente, chegando a essa questão um pouco tarde, eu diria que, dentre as muitas razões listadas, a produtividade de um desenvolvedor profissional é uma das mais habilidades altamente consideradas.

Por produtividade, quero dizer a capacidade de fazer seu trabalho com eficiência, com os melhores resultados possíveis. Os IDEs permitem isso em muitos níveis. Não sou especialista em Emacs, mas duvido que não possua nenhum dos recursos dos principais IDEs.

Design, documentação, rastreamento, desenvolvimento, construção, análise, implantação e manutenção, etapas fundamentais em um aplicativo corporativo, tudo isso pode ser feito dentro de um IDE.

Por que você não usaria algo tão poderoso se tivesse a opção?

Como um experimento, comprometa-se a usar um IDE por, digamos, 30 dias e veja como se sente. Eu adoraria ler seus pensamentos sobre a experiência.

Ter um IDE tem as seguintes vantagens:

• A compilação geralmente é "on the fly", o que significa que não há mais necessidade de alternar para a linha de comando para compilar
• A depuração é integrada, e tê-lo em um IDE significa que o depurador de etapas realmente usa seu editor local para mostrar visualmente qual código é executado
• Os IDEs geralmente têm mais conhecimento semântico do idioma em que você está trabalhando e podem mostrar possíveis problemas ao digitar. A refatoração é muito mais poderosa que a "substituição de pesquisa".

Há muito mais, talvez você deva tentar.

Os IDEs são basicamente:

• Editor com preenchimento de código, refatoração e documentação
• Depurador
• Explorador de sistema de arquivos
• Cliente SCMS
• Ferramenta de construção

tudo em um único pacote.

Você pode ter tudo isso (e um pouco mais) usando ferramentas separadas ou apenas um ótimo editor programável e ferramentas extras, como o Emacs (Vim também, mas com um pouco menos de IDEbility IMO).

Se você se alterna bastante entre um utilitário e o próximo que pode ser integrado ao ambiente ou se você está perdendo algumas das habilidades listadas aqui (e mais completamente em outras postagens), talvez seja hora de mudar para um IDE (ou para melhorar a IDEbility do seu ambiente adicionando macros ou não). Se você criou um 'IDE' (no sentido que mencionei acima) usando mais de um programa, não há necessidade de mudar para um IDE real.

Eclipse:

Tendo o código em destaque, compilando em segundo plano, apontando meus erros à medida que avança.

Integração com javadoc, sugerindo nomes de variáveis ​​com ctrl-Space.

Ao compilar, recebo erros ali. Posso clicar duas vezes em um erro e ele exibe a linha apropriada.

Muito bem integrado ao JUnit, o ctrl-F11 executa o teste, informa que os testes falharam. Se houver uma exceção na janela de saída, posso clicar duas vezes em uma linha e levar-me para a linha que falhou. Não apenas isso, mas o ctrl-F11 garante que tudo seja compilado antes de executar os testes (o que significa que nunca esqueço de fazer isso).

Integração com formiga. Um comando para criar e implantar o aplicativo.

Integração com depuradores, incluindo depuração remota de servidores web.

Ferramentas de refatoração FANTASTIC, procurando referências a uma seção de código. Me ajuda a conhecer o impacto de uma mudança.

Em suma, isso me torna mais produtivo.

Eu uso o Emacs como meu ambiente principal para desenvolvimento e correio / notícias há cerca de 10 anos (1994-2004). Descobri o poder dos IDEs quando me forcei a aprender Java em 2004 e, para minha surpresa, gostei do IDE ( IntelliJ IDEA ).

Não vou entrar em razões específicas, pois muitas delas já foram mencionadas aqui - lembre-se de que as pessoas diferentes amam características diferentes. Eu e um colega usamos o mesmo IDE, nós dois usamos apenas uma fração dos recursos disponíveis, e não gostávamos um do outro de usar o IDE (mas gostamos do próprio IDE).

Mas há uma vantagem nos IDEs nos ambientes relacionados ao Emacs / Vim nos quais quero me concentrar: você gasta menos tempo instalando / configurando os recursos que deseja.

Com o Wing IDE (para Python), estou pronto para começar a desenvolver 15 a 20 minutos após a instalação. Não faço ideia de quantas horas eu precisaria para obter os recursos que utilizo e funcionando com o Emacs / Vim. :)

Definitivamente, leva a uma melhoria na produtividade para mim. Até o ponto em que eu até codifico aplicativos Linux no Visual Studio no Vista e depois uso uma máquina virtual Linux para construí-los.

Você não precisa memorizar todos os argumentos para uma chamada de função ou método, assim que começar a digitar, o IDE mostrará quais argumentos são necessários. Você obtém assistentes para definir propriedades do projeto, opções do compilador, etc. Você pode procurar itens em todo o projeto, em vez de apenas o documento ou arquivos atuais em uma pasta. Se você receber um erro do compilador, clique duas vezes nele e o levará diretamente para a linha incorreta.

Integração de ferramentas como editores de modelos, conexão e navegação em bancos de dados externos, gerenciamento de coleções de "trechos" de código, ferramentas de modelagem de GUI etc. Todas essas coisas podem ser realizadas separadamente, mas tê-las todas no mesmo ambiente de desenvolvimento economiza muito. tempo e mantém o processo de desenvolvimento fluindo com mais eficiência.

Pode haver razões diferentes para pessoas diferentes. Para mim, essas são as vantagens.

1. Fornece uma sensação integrada ao projeto. Por exemplo, terei todos os arquivos de projetos relacionados em exibição única.
2. Fornece maior produtividade de código, como
   1. Realce de sintaxe
   2. Referência de montagens
   3. Intellisense
   4. Visualização centralizada do banco de dados e arquivos de interface do usuário relacionados.
   5. Recursos de depuração

No final do dia, isso me ajuda a codificar mais rapidamente do que consigo em um bloco de notas ou wordpad. Essa é uma boa razão para eu preferir um IDE.

Um IDE pode ser uma escolha 'superior', dependendo do que o desenvolvedor está tentando realizar.

Um editor de texto pode ser 'superior' porque os IDEs são tipicamente voltados para um (ou uma pequena seleção) de idiomas.

Se um desenvolvedor passa a maior parte do tempo em um único idioma ou em um 'cluster' de linguagens relacionadas (como C # e T-SQL), em um sistema operacional, as ferramentas de design, depuração, intellisense, refatoração etc. da GUI oferecidas por um bom IDE pode ser muito atraente. Se, por exemplo, você passa a maior parte do tempo trabalhando no VB.NET, talvez com um pouco de T-SQL de vez em quando, em um ambiente Windows, seria uma tolice não olhar para o Visual Studio ou um IDE comparável. .

Não tenho preconceito com aqueles que preferem IDEs ou editores de texto; ambos podem ser muito produtivos e úteis se bem aprendidos !

Eu acho que isso tem a ver principalmente com o escopo de conscientização do desenvolvedor. O IDE fornece uma visão macroscópica do contexto de trabalho do desenvolvedor. Você pode ver simultaneamente hierarquias de classe, recursos referenciados, esquemas de banco de dados, referências de ajuda do SDK, etc. E com tantas coisas afetadas e afetando as teclas digitadas e o volume crescente de arquiteturas e interseções arquitetônicas, fica cada vez mais difícil trabalhe exclusivamente a partir de uma ilha de código por vez.

OTOH, "apenas eu, vim e as páginas de manual", me dá uma visão microscópica muito mais enxuta - mas intensa e precisa - do meu trabalho. Tudo bem se eu tiver uma base de código altamente coesa, bem projetada, com particionamento e escassamente acoplada, construída em um idioma com um conjunto de bibliotecas estáticas para trabalhar - não na sua situação típica, especialmente quando os tamanhos das equipes de desenvolvimento aumentam e reformulam a estrutura de código ao longo do tempo, distância e preferência pessoal.

Atualmente, estou trabalhando em projetos no Flex e .NET. Uma das coisas mais agradáveis ​​sobre o Flex é o quão poucas maneiras diferentes existem para realizar uma coisa padrão - extrair dados de um banco de dados, abrir / fechar / ler / gravar um arquivo etc. (No entanto, estou usando o IDE do Flex Builder / Eclipse - um exemplo típico de peso pesado, como o VS, porque ainda estou aprendendo o básico e preciso das rodinhas de treinamento. Espero voltar ao vim quando estiver confiante em meus padrões.) Nesta visão, posso fazer o que Eu preciso fazer profissionalmente sabendo muito bem algumas coisas.

OTOH, não consigo imaginar chegar a esse ponto com o .NET porque a visão que devo manter continua se expandindo e mudando. Há muito menos integridade conceitual e, ao longo de vários desenvolvedores em um projeto, durante vários meses, muito menos consistência - mas o IDE suporta isso, talvez o incentive. Portanto, o desenvolvedor realmente precisa (e pode mais facilmente) saber muito mais coisas adequadamente. O que também tem o benefício de ajudá-los a responder (ou até entender) uma porcentagem muito maior de perguntas no StackOverflow. Ou seja, podemos ter uma pilha de conhecimentos mais profunda. E podemos responder a uma variedade maior de anúncios de ajuda.

As coisas podem ir longe demais em ambas as direções. Talvez com o escopo "somente editor", seja "se você tiver um martelo, tudo parecerá um prego". Com a abordagem IDE, para o que você deseja fixar, você tem uma ampla seleção de fixadores e séries de ferramentas à sua escolha - nals / martelos, parafusos / chaves de fenda, parafusos / chaves, adesivos / pistolas de cola / braçadeiras, ímãs , e assim por diante - tudo ao seu alcance (com um assistente para ajudá-lo a começar).

Não pense nisso como exclusivo. Use o IDE para obter os benefícios que ele oferece e alterne para o editor de texto vim / preferido quando precisar de um foco sério.

Acho o IDE melhor para refatoração, navegação e depuração e para descobrir o que fazer. Pequenas coisas são feitas exatamente no IDE, grandes coisas que eu viro para vim para concluir o trabalho.

Além das outras respostas, adoro combinar o poder de desenvolvimento de um IDE com o poder de edição do Vim usando algo como o ViPlugin for Eclipse .

O IntelliSense , o depurador integrado e a janela imediata me tornam enormemente mais produtivo ( Visual Studio 2008 ). Com tudo na ponta dos dedos, posso manter a grande maioria de um projeto enorme dentro da minha cabeça enquanto escrevo código. A Microsoft pode deixar cair a bola em seus sistemas operacionais, mas o Visual Studio é um dos melhores produtos já desenvolvidos.

Eu não entendo o que você está perguntando. Você pergunta "Devo usar um IDE em vez de ...", mas não entendo qual é a alternativa - o Vim e o Emacs cumprem muitas funções que qualquer IDE fornecerá. O único aspecto que eles não lidam com o fato de um IDE maior poder ser como designers de interface do usuário. Então sua pergunta se resume a simplesmente "qual IDE devo usar" com argumentos a serem feitos para o domínio mais simples do Vim e do Emacs.

Para mim, um IDE é melhor porque permite uma navegação mais rápida no código, o que é importante se você tiver algo em mente para implementar. Supondo que você não use um IDE, leva mais tempo para chegar ao destino. Seus pensamentos podem ser interrompidos com mais frequência. Isso significa que mais cliques / mais teclas devem ser pressionadas. É preciso concentrar-se mais no pensamento de como implementar as coisas. Obviamente, você também pode anotar as coisas, mas é preciso pular entre o design e a implementação. Além disso, um designer de GUI faz uma grande diferença. Se você fizer isso manualmente, pode levar mais tempo.

IDEs baseados em GUI, como Visual Studio e Eclipse, têm várias vantagens sobre IDEs baseados em texto, como Emacs ou vim, devido a seus recursos de exibição:

• Visualização WYSIWYG e edição ao vivo para design de GUI
• Editores de propriedades eficientes (por exemplo, seleção de cores usando uma paleta da GUI, incluindo gradientes de posicionamento, etc.)
• Representação gráfica de contornos de código, inter-relações de arquivos, etc.
• Uso mais eficiente do espaço na tela para mostrar pontos de interrupção, indicadores, erros, etc.
• Melhor suporte para arrastar e soltar com SO e outros aplicativos
• Edição integrada de desenhos, imagens, modelos 3D, etc.
• Exibição e edição de modelos de banco de dados

Basicamente, com um IDE baseado em GUI, você pode obter informações mais úteis na tela de uma só vez e pode visualizar / editar partes gráficas de seu aplicativo tão facilmente quanto partes de texto.

Uma das coisas mais legais para experimentar como desenvolvedor é editar um método que calcula alguns dados e ver a saída ao vivo do seu código exibida graficamente em outra janela, assim como o usuário verá quando você executar o aplicativo. Agora isso é edição WYSIWYG!

IDEs baseados em texto como Emacs e vim podem adicionar recursos como conclusão de código e refatoração ao longo do tempo, portanto, a longo prazo, sua principal limitação é o modelo de exibição baseado em texto.

Também quase uso exclusivamente o Vim (quase porque estou tentando aprender o emacs agora) para todas as minhas coisas de desenvolvimento. Eu acho que pura intuição (da GUI, é claro) é a principal razão pela qual as pessoas gostam de usar IDEs. Por ser intuitivo, pouca ou nenhuma sobrecarga de aprendizado da ferramenta é necessária. Quanto menor a sobrecarga de aprendizado, mais eles podem realizar o trabalho.

Um IDE permite que você trabalhe mais rápido e com mais facilidade ... Percebi que passei muito tempo navegando no código em um editor de texto simples ...

Em um bom IDE, esse tempo diminui se o IDE suportar saltar para funções, para a posição anterior de edição, para variáveis ​​... Além disso, um bom IDE reduz o tempo para experimentar diferentes recursos e projetos de linguagem, como o tempo de inicialização pode ser pequeno.

Algumas razões pelas quais posso pensar em usar um IDE:

• A ajuda integrada é uma das favoritas.
• O Refator interno com visualização do Visual Studio
• IntelliSense , destaque de sintaxe, facilidade de navegação para grandes projetos, depuração integrada etc. (embora eu saiba com suplementos, você provavelmente pode obter muito disso com o Emacs e o Vim ).
• Além disso, acho que os IDEs atualmente têm uma base de usuários mais ampla e provavelmente mais pessoas desenvolvendo suplementos para eles, mas posso estar errado.

E, francamente, eu gosto do meu mouse. Quando eu uso editores puros baseados em texto, eles ficam solitários.

Economiza tempo para desenvolver
Facilita a vida, fornecendo recursos como depuração integrada, intellisense.

Existem muitos, mas recomendamos o uso de um, eles são mais do que óbvios.

Não sei se há uma linha divisória clara entre um editor de texto e um IDE. Você tem o gosto do bloco de notas em uma extremidade da escala e os melhores IDEs modernos na outra, mas há muitas coisas no meio. A maioria dos editores de texto possui destaque de sintaxe; editores voltados para programadores geralmente têm vários outros recursos, como fácil navegação por código e preenchimento automático. O Emacs ainda permite integrar um depurador. Os IDEs de até dez anos atrás tinham muito menos recursos para ajudar os programadores do que você esperaria de um editor de texto sério hoje em dia.

Meu principal motivo para usar um é quando o código ultrapassa 100 arquivos.

Embora as ctags possam fazer o trabalho, alguns IDEs têm uma maneira muito boa de navegar pelos arquivos facilmente de forma super rápida.

Isso economiza tempo quando você tem muito trabalho a fazer.

Para mim, é apenas a versão GUI de tudo o que fizemos nos bons e velhos tempos do terminal. Eu sempre concordo que o IDE não é muito superior porque oculta muitas coisas, principalmente no que se refere à vinculação, mas elas têm uma vantagem notável em alguns casos, por exemplo, em certas plataformas de desenvolvimento como o Qt.

Alguns IDE, como o visual de outras pessoas, parecem analisar seu código enquanto você o digita e detectar erros antes mesmo de compilar: parece lógico que apenas um IDE pode trabalhar em estreita colaboração com um compilador para detectar imediatamente problemas na fonte digitada.

Minha resposta selvagem de que a guerra de chamas IDE / linha de comando existe é apenas porque o edifício executável C / C ++ não é muito bem tratado de um ponto de vista padronizado, ao contrário da linguagem D; toda plataforma lida com a compilação / vinculação / etc do seu próprio jeito, para torná-lo menos confuso, eles criam um IDE.

Do seu ponto de vista, pode ser mais simples usar a linha de comando; se houvesse apenas um compilador com opções padrão, teria sido fácil, mas a verdade é que o C / C ++ é flexível; portanto, no final, toda a plataforma faça do seu jeito, daí o IDE não perder explicando como fazê-lo.

Se você pode aprender como um executável se comunica com o kernel ou se conhece alguma coisa sobre o design do compilador, talvez haja uma maneira de trabalhar com uma linha de comando adequada, mas duvido que sim.

A Microsoft ou a Apple, por mais más que sejam, precisam propor uma maneira direta de criar aplicativos sem entrar em detalhes, e como a criação de um aplicativo depende diretamente da arquitetura do sistema operacional, dificilmente será "padrão" como o linha de comando é

Para simplificar, aplicativos grandes e complexos, nos quais você não deseja se aprofundar no que faz -> IDE, pequenos pedaços de software ou simples design de software do sistema -> linha de comando. Exceto, é claro, as bibliotecas bacanas que incorporam um Makefile, mas isso é outra história.

Também acho que o IDE é usado quando o aplicativo entregue tem algo a ver, ironicamente, com uma GUI ou algo que tem uma interface ou está diretamente vinculado a um sistema operacional; então, novamente, também é para pessoas que usarão uma UI / GUI sem saber como funciona, enquanto as pessoas que programam sistemas não precisam de tudo.

O IDE é uma merda moderna, mas acho que em 100 anos a linha de comando ainda existirá.

Eu gosto de um IDE porque coloca muita funcionalidade na ponta dos meus dedos. Edição / compilação / visibilidade de arquivos no projeto são tudo o que valorizo ​​em um IDE. Eu uso o Visual Studio agora, mas em uma vida anterior eu usei o SlickEdit e descobri que isso tornava meu processo de desenvolvimento mais otimizado do que quando eu não estava usando.

Há apenas uma coisa a considerar ao decidir se deve usar um IDE ou não, e se isso o torna mais produtivo ou não.

Pergunta curta resposta tão curta :)

Depende muito do que você está fazendo e do idioma em que está fazendo. Pessoalmente, costumo não usar um IDE (ou "meu IDE consiste em 3 xterms executando o vim, um executando um cliente de banco de dados e outro com um prompt do bash ou logs finais ", dependendo de quão amplamente você define" IDE ") para a maior parte do meu trabalho, mas, se eu estivesse desenvolvendo uma GUI nativa da plataforma, procuraria um IDE apropriado à linguagem em um instante - IMO, IDEs e edição gráfica de formulários são claramente feitos um para o outro.