Os novatos devem usar o preenchimento automático do IDE (Intellisense)? [fechadas]

Costumo encontrar isso quando estou ajudando alguém que é novo em programação e aprendendo pela primeira vez. Estou falando de novatos realmente novos, ainda aprendendo sobre OOness, construindo objetos, chamadas de métodos e coisas assim. Normalmente, eles têm o teclado e estou apenas oferecendo orientação.

Por um lado, o recurso de preenchimento automático dos IDEs ajuda a dar a eles o feedback de que eles estão fazendo o que é certo e eles rapidamente gostam e confiam nele.

Por outro lado, receio que a dependência precoce do preenchimento automático do IDE os faça realmente não entender os conceitos ou funcionem se um dia se encontrarem apenas com um editor simples.

Alguém com mais experiência nesse sentido pode compartilhar sua opinião? Qual é o melhor para um novato, preenchimento automático ou digitação manual?

Atualizar

Obrigado a todos pela contribuição!

Muitas respostas parecem focar no uso principal do preenchimento automático, como a conclusão de métodos, o fornecimento de pesquisa e documentação de métodos etc. Mas os IDEs hoje em dia são muito mais parecidos.

• Ao criar um objeto do tipo Lista, um IDE é preenchido automaticamente para o novo ArrayList no lado direito. Pode não ser imediatamente claro para um novato por que não pode ser uma nova lista, mas, ei, funciona, então eles seguem em frente.
• Parâmetros do método de preenchimento com base em variáveis ​​locais no contexto.
• Executando projeções de objetos
• Adicionando instruções 'import' ou 'using' automaticamente

e muito mais. Esses são os tipos de coisas que quero dizer. Lembre-se de que estou falando de pessoas que estão fazendo a Programação 101, realmente apenas começando. Eu assisti o IDE fazer essas coisas das quais eles não têm idéia, mas eles continuam.

Alguém poderia argumentar que isso os ajuda a focar no fluxo do programa e entender o que acontece antes de aprofundar e entender as nuances da linguagem, mas não tenho certeza.

Eu acho que usar o IDE ajuda no processo de aprendizado. Métodos, propriedades, parâmetros, sobrecargas e similares são descobertos. Com as enormes bibliotecas, o Intellisense ajuda a reduzir o conhecimento sobre JIT. No ambiente de codificação atual, é impossível aprender tudo de antemão, e o aprendizado JIT é frequentemente a única maneira prática de se tornar produtivo rapidamente.

Entendo que o uso de um IDE pode ser uma muleta se você o usar cegamente, mas acho que os benefícios superam os negativos.

Usar modelos sem entender o que foi pré-criado para você, por outro lado, é mais um problema. Acho que essas podem ser usadas como uma ferramenta de aprendizado se o desenvolvedor reservar um tempo para ler o código do modelo. Mas a maioria das pessoas não se incomoda. Poderia ser uma ótima ferramenta de aprendizado, no entanto.

Compreender os conceitos e memorizar dezenas de centenas de classes e métodos estúpidos de biblioteca são duas coisas completamente diferentes. O Intellisense ajuda a expulsar completamente todo esse conhecimento inútil de sua mente, e quanto mais cedo você o fizer, melhor. Deixe mais espaço para os conceitos úteis, não desperdice seus recursos limitados em APIs.

Para responder a uma parte atualizada de uma pergunta: pequenos detalhes de sintaxe, layout de arquivos, chamada do compilador e do vinculador também não são importantes em comparação com os conceitos genéricos de programação. Uma vez entendidos, um novato-não-mais pode entrar em uma compreensão mais profunda de como as coisas de baixo nível realmente funcionam. É melhor fazê-lo quando você já conhece o básico, caso contrário, é provável que você compre várias superstições mágicas perigosas.

Por exemplo, o DrScheme IDE tem um ótimo histórico no ensino de programação e seu sucesso se deve principalmente à sua capacidade de ajudar a se concentrar no que é realmente importante.

Usar o preenchimento automático não é uma coisa ruim.

É simplesmente por velocidade, e para mim seria um sinal de alguém começando a entender o IDE e usá-lo bem.

Eu não entendo como NÃO usá-lo os ajudaria a aprender OO, por exemplo.

Depois de ensinar e orientar alunos que são novos na programação, acho que o preenchimento automático / intelecto, às vezes, causa mais mal do que bem. Sim, eles podem escrever um programa usando-o. Sim, ele compila e roda e pode até fazer o que pedimos. Mas eles não entendem o que estão fazendo.

Quando eles não entendem o que está acontecendo, torna-se menos programação e mais uma solução de hackers para obter notas. Descobri que isso aconteceu muito com os alunos, pois o que pedimos para eles se tornarem mais difíceis, eles apenas invadiram até que algo funcionasse. Isso sempre ficava claro quando o meio do semestre chegava e os alunos eram solicitados a escrever métodos simples à mão ... eles não podiam.

Sim, o preenchimento automático / intellisense nos ajuda (desenvolvedores profissionais) muito b / c, nos acelera. Não precisamos memorizar todos os métodos e listas de parâmetros diferentes, mas ao mesmo tempo também podemos arriscar um palpite sobre quais parâmetros um método seguirá porque temos experiência em programação.

Novatos não. Eles esperam que o IDE crie uma lista de métodos, percorrem a lista até encontrar um que talvez seja o que precisam, analisam os parâmetros necessários e ver se os têm para passar. ..e no final eles terão hackeado algo juntos que podem entregar.

E, no final do curso, quando recebiam o passe, eles se afastavam da aula de programação com uma vitória rasa, muitos nunca mais participavam de outra aula de CS, porque não entendiam o que faziam ou por que o fizeram. isto.

O problema com IDEs e ambientes de desenvolvimento em geral não é tanto o preenchimento automático como o uso de soluções modeladas (arquivo | novo | projeto), onde muitas coisas "interessantes" já foram feitas por você e estão, em vários graus, ocultas .

Para alguém que, em geral, entende o que está acontecendo sob o capô, isso é útil - mas para quem aprende o que precisa é um pouco menor.

Há também a questão do tempo necessário para disparar um IDE pesado ...

Penso, portanto, que o uso de algo mais leve e a capacidade de executar aplicativos nos quais você mesmo escreveu todas as linhas de código têm mérito considerável - especialmente porque o uso de um editor de texto e um compilador demonstra o ponto importante de que você não precisa de um IDE etc para escrever software, mas isso não significa que eu queira usar um editor de texto por muito tempo e que apresenta desafios em termos de depuração - você deseja fazer pontos de interrupção e pode avançar passo a passo no código pois isso facilitará a compreensão do que está acontecendo.

É claro que podemos confundir ainda mais o problema considerando coisas como Python, nas quais você tem uma linha de comando "ao vivo" ...

Boa pergunta, nenhuma boa resposta - exceto que você deseja tornar o aprendizado uma progressão e começar com um editor de texto e um compilador (ou um interpretador de linha de comando) permitirá que você se concentre nos conceitos básicos de sintaxe e lógica antes de avançar para mais coisas complexas que serão mais fáceis de fazer com um ambiente de desenvolvimento mais poderoso.

Aprender da maneira mais difícil geralmente fica com você.

Como iniciante, NÃO use o IDE. Use a linha de comando, aprenda com seus erros. Isso também ajudará você a entender as opções de compilador e vinculador mais de perto.

Então, quando você usa o IDE? Quando você está projetando algo enorme ou trabalhando em uma enorme base de código com muitas classes, métodos e variáveis.

Eu seria o primeiro a dizer que os IDEs são um benefício para a produtividade, mesmo que eu frequentemente reclame de suas peculiaridades. No entanto, aprendi BASIC, C, C ++, Java, Python, Perl, PHP e várias outras linguagens sem nada além de um editor de destaque de texto e o compilador / intérprete da linguagem. Na verdade, eu aprendi Java no bloco de notas!

Aprender um IDE propicia "mágica" - a idéia de que "funciona; não importa como". Abstração é boa; magia é ruim. Um programador deve saber ou ser capaz de descobrir tudo o que está acontecendo em um projeto. Um bom IDE foi projetado para cuidar da contabilidade, não controlando o projeto. Usado corretamente, é uma ótima ferramenta. Mas que artesão começa usando um roteador CNC?

Eu acho que o jeito que aprendi (ter que digitar tudo e conhecer bem o compilador para criar um projeto) me ajudou imensamente quando finalmente comecei a usar IDEs. Por exemplo, um projeto Java não é uma pequena pasta no projeto Eclipse, mas uma coleção de classes em uma estrutura de pacote com alguns arquivos XML para caminhos, configuração e implementação. Eu não gostaria de criar um aplicativo corporativo grande sem um IDE, mas posso criar aplicativos pequenos. Isso facilita a compreensão da estrutura das grandes, e quando eu quero um comportamento específico na compilação, digamos, eu sei como o javac funciona, para que eu possa ajustar o prompt de compilação real em vez de tentar encontrar a combinação mágica que não ' não existe na configuração da compilação. Também acredito que tenho uma compreensão mais profunda das mensagens de erro e como localizá-las e corrigi-las.

Eu não ensinaria usando um IDE. Eu acho que os projetos iniciais são pequenos o suficiente para que os argumentos para gerenciar a complexidade sejam discutíveis. Se você estiver ensinando Java, por exemplo, poderá colocar todas as suas aulas na mesma pasta e javac *.java. Você não precisa de um IDE para isso! Isso defende a manutenção de projetos pequenos, pouco mais que prova de conceitos. Minimize a sobrecarga e concentre-se em ensinar o conceito que os alunos precisam. Projetos maiores nos quais um IDE seria útil pertencem a classes SE mais avançadas ou a projetos dedicados.

Quanto à ajuda para encontrar classes e pesquisa de API, novamente, acredito que isso seja discutível se os projetos forem mantidos pequenos. Novamente em Java, o javadoc é muito fácil de ler. De qualquer maneira, ninguém pode manter toda a API lá dentro, e haverá um momento em que você precisará pesquisar uma API sem o benefício de um IDE. Como em outros idiomas, ou se estiver remotando em um servidor em que você não pode abrir o IDE. Ensine como encontrar documentação, não "pressione '.' e você pode ver quais são os métodos de um objeto ".

Qualquer programador pode aprender um IDE, mas conhecer um IDE não o torna um bom programador. Humor negro à parte, "mágica" nunca é uma boa palavra para um programador usar.

Talvez um novato deva simplesmente estar trabalhando em problemas mais fáceis primeiro. E não, esses problemas não devem exigir ou incentivar o uso de um IDE para concluir a tarefa. Há mais a ganhar a longo prazo, entendendo os conceitos básicos. As ferramentas devem vir depois.

Nenhum artesão de madeira iria direto ao uso de uma plaina de superfície de alta potência sem entender primeiro os meandros do tipo de madeira e do plano manual.

(Nota: autocomplete e intellisense são duas coisas drasticamente diferentes).

O Intellisense, por si só, não é ruim. Só é ruim quando é usada uma muleta para adivinhar a funcionalidade sem ler ou entender a documentação ou implementação subjacente.

Ponto lateral: se a linguagem exigir que um IDE codifique para você, provavelmente ela está no nível errado de abstração para os problemas que você está tentando resolver.

Quando crescemos quando criança, não nos dizem que devemos entender as intrincadas regras do idioma inglês antes que possamos falar. Não nos dizem que devemos entender completamente o uso adequado de preposições, conjunções e evitar fragmentos de frases. Nós aprendemos fazendo. Aprendemos através do sucesso e do fracasso.

Um IDE com preenchimento automático ajuda o novo programador a ganhar confiança, facilitando a criação de programas, sem se esforçar para lembrar todas as inúmeras funções de uma vasta multidão de bibliotecas.

Se alguém realmente extrapolar a visão de que o preenchimento automático prejudica o novo programador porque torna muito fácil para eles, você pode argumentar que os livros de referência não devem ser usados durante a programação, porque os conceitos contidos devem ser comprometidos primeiro com a memória, como não tê-los memorizados os torna mais lentos e não lhes permite entender completamente os conceitos primeiro.

O preenchimento automático é uma ferramenta, é usada para tornar o programador mais produtivo. Assim como aprendemos um idioma pela primeira vez, depois de ganharmos confiança e obter um nível de sucesso com o que estamos aprendendo, trabalhamos para melhorar nosso conhecimento.

No começo, é difícil o suficiente criar algo que funcione, então qualquer coisa que ajude a marca a melhorar. Um novo programador precisará de alguém mais experiente para fazer com que eles pensem se as listas vinculadas por array ou listas vinculadas serão a melhor correspondência para o problema em questão. Cada um deles tem seus pontos fortes e fracos.

Quer o novato tenha um IDE ou esteja navegando online nos documentos da API, não haverá nenhuma diferença real entre o código que cria. Embora lidar com a dor de escrever erros de sintaxe possa ser uma experiência de aprendizado, há muito para aprender a se preocupar com isso desde o início.

Você não aprende a andar na corda bamba indo direto para o fio condutor sem rede. Você começa andando por uma corda a centímetros do chão. Atrevo-me a dizer que a maioria de nós trabalha com um IDE e algum tipo de script de compilação (o script de compilação do Visual Studio é criado pelo IDE, mas está lá). A maioria de nós não cria nossas classes manualmente com um editor de texto e depois invoca o compilador manualmente. Por que deveríamos impor isso a um novato que tem muito mais a aprender?

Não vejo necessidade de sofrer com as ferramentas anteriores, mesmo quando um desenvolvedor está aprendendo. Acredito que o tempo e o esforço extra necessários para escrever o código sem as ferramentas seriam mais bem gastos aprendendo a escrever testes de unidade e depuração. Quando um usuário sabe como testar seu código e executá-lo durante a execução, ele aprenderá bastante sobre o que está realmente fazendo.

Além disso, não é como usar um IDE, o código se escreve. Um desenvolvedor inepto ou iniciante vai escrever um código que não funciona, independentemente de usar um IDE ou não.

Eu apenas vejo o IDE como outro nível de abstração ao codificar. Se estou escrevendo Java, geralmente não preciso entender como o bytecode gera. Se um novo programador estiver usando bibliotecas Java, ele não precisará saber em que pacote está se o IDE puder adicioná-lo automaticamente para eles. Em qualquer um dos casos, se um erro ou problema no nível mais baixo puder surgir (por exemplo, conflito de nome de classe) que causa um erro, é hora do desenvolvedor analisá-lo manualmente.

Muitas outras boas respostas, portanto, não considere esta uma resposta completa, mas é bom para iniciantes e usuários experientes verem uma imagem completa de quais funções eles têm à sua disposição.

No Delphi, posso pressionar ctrl-j e vou ver uma lista de todas as coisas possíveis que eu poderia sintaticamente esperar que funcionassem.

Não concordo necessariamente, mas li argumentos no sentido de que os programadores não deveriam nem olhar para membros de classes privadas de objetos que eles usam e, dessa forma, o preenchimento automático fornece a todos os usuários uma referência instantânea à API.

Os IDEs mais recentes permitem que os usuários e desenvolvedores de linguagem coloquem meta-dados em seu intelecto, o que aprimora ainda mais a capacidade de ler e entender o que as funções fazem, sem ler a fonte (o que é algo que eles não deveriam fazer de qualquer maneira).

Talvez seja melhor que os novatos leiam e compreendam tudo o que implementam. Mas talvez seja uma pergunta melhor se os iniciantes devem ou não incluir ou importar quaisquer espaços de nomes ou unidades que desejarem, sem documentar por que estão incluindo.

Na minha experiência, o uso de um IDE para aprender o básico do OO é ótimo porque esconde um pouco da complexidade de escrever código, permitindo ao novo desenvolvedor se concentrar na lógica do programa. No entanto, logo depois de aprender a programar e os princípios básicos de OO, fui forçado a entender com mais precisão quais peças precisavam interagir entre si nos arquivos de origem (sem esquecer as instruções de importação, instanciar as classes corretas etc.) por um curso de programação onde tivemos que usar apenas máquinas Unix terminais.

Isso é possível na escola porque alguém tem a 'autoridade' para forçá-lo a usar ferramentas de lo-fi. Seria muito mais difícil conseguir em um ambiente de negócios ou corporativo.

Eu tenho dois pensamentos sobre isso. A primeira é que, para realmente aprender algo, acredito que você precisa saber o que realmente está acontecendo. E com a qualidade do IntelliSense, ele pode esconder parte disso para um novo desenvolvedor. Por exemplo, eu tive uma aula de engenharia da Web na faculdade, na qual construímos nossas próprias estruturas da Web para criar nossos aplicativos finais. Eu saí dessa classe com a capacidade de se adaptar a quase qualquer estrutura da Web porque eu tinha o entendimento do que estava por trás de tudo isso, para começar. Usar um IDE não chega a esse nível, mas acredito que o ponto ainda está lá.

No entanto, o uso de um IDE também pode fazer coisas como abrir APIs para novos desenvolvedores. Quando comecei a codificar seriamente, o IDE que eu usei me ajudou muito, porque fazia coisas como digitar um objeto, usava o preenchimento automático para ver quais métodos ele possuía e depois pesquisava-os usando os documentos disponíveis. Tudo isso foi feito no IDE e foi uma ótima ferramenta de aprendizado.

Então, sim, acredito que não há problema em usar um, desde que você também dedique algum tempo para entender o que está acontecendo. Apenas usar uma conversão de objeto sem entender por que você fez isso é muito ruim, mas, se um novo desenvolvedor perceber que você pode usar uma conversão de objeto e depois ver por que não vejo nada errado.

Aprender requer prática. A programação pode ser uma tarefa muito frustrante quando você não tem idéia do que pode fazer nem como as coisas funcionam.

É impraticável, por exemplo, ler muitos livros sobre princípios de programação sem escrever uma única linha de código; não se aprende nada dessa maneira.

O Intellisense é muito útil para fornecer aos novos programadores a ajuda necessária para continuar a programar, continuar praticando e, assim, aprendendo.

Como já foi dito, aprender APIs específicas não é o mesmo que aprender princípios de programação. O que, sem dúvida, acontecerá é que os novos programadores cometerão erros (independentemente do Intellisense), e como eles escolherão corrigir esses erros é o que os levará a se tornarem bons programadores ou pobres.

Se você está tentando ensinar alguém a programar, eu os aconselho a usar o Intellisense e a brincar até que fiquem presos. Foi quando eu tentei construir uma fundação ensinando a eles o motivo pelo qual eles ficaram presos.

IMO, os IDEs tornarão você mais produtivo. Mas para iniciantes, geralmente não é uma boa ideia começar a programar com o IDE. Editores de texto como o bloco de notas ++, o bloco de notas etc. seriam suficientes.

Além disso, geralmente não é considerado uma boa idéia começar a aprender a programação com linguagem de alto nível. Eu sugiro que você comece com a linguagem assembly. Isso ensinará a você o básico e a paciência.