Por que eles não ensinam essas coisas na escola? [fechadas]

Durante o verão, tive a sorte de entrar no Google Summer of Code. Aprendi muito (provavelmente mais do que aprendi na soma de todos os meus cursos universitários). Estou realmente me perguntando por que eles não ensinam algumas das coisas que aprendi antes na escola. Para nomear alguns:

• teste de unidade
• controle de versão
• desenvolvimento ágil

Parece-me que eles passam uma quantidade significativa de tempo ensinando outras coisas, como estruturas de dados e algoritmos, desde o início. Embora eu ainda ache que esses três são muito importantes para aprender desde o início, por que eles não ensinam mais desses três antes deles? Ou é apenas minha escola que não ensina muito dessas coisas?

Não me entenda mal, não acho que seja desejável que as universidades sempre ensinem os modismos da programação mais modernos, mas meus professores não deveriam estar me ensinando outra coisa além de "desenhar um diagrama antes de começar a programar?"

A resposta mais simples à sua pergunta é que os campos da ciência da computação e do desenvolvimento de software são muito novos e não muito bem compreendidos. Embora todas as disciplinas científicas e de engenharia estejam avançando mais rapidamente nos tempos modernos, outros campos têm muito mais experiência para se basear e há um entendimento compartilhado muito mais amplo de como funcionam.

Por exemplo, apesar dos avanços recentes na ciência dos materiais, os engenheiros civis sabem há cerca de 2.000 anos como construir um arco que não cai, e isso é algo que pode ser ensinado e aprendido na universidade com relativamente pouca controvérsia. Embora eu concorde totalmente com você sobre as técnicas que os desenvolvedores de software devem aprender, este contrato é baseado em experiência pessoal e raciocínio informal. Para ser uma "prática recomendada" socialmente aceita, precisamos de dados quantitativos que podem ser muito caros de coletar: quanto o controle de versão ajuda? Como isso ajuda? Teste de unidade? Podemos raciocinar sobre a eficácia de várias técnicas, mas realmente provar essa eficácia de forma conclusiva seria muito caro. Precisamos executar um projeto de software completo e realista do início ao fim, inúmeras vezes, com grupos de programadores com experiência equivalente, usando técnicas diferentes. No mínimo, precisaríamos de muitos dados sobre projetos existentes que esses projetos não estariam dispostos a liberar.

Os engenheiros civis têm milhares de anos de pontes para observar, com muitas informações. Os desenvolvedores de software, por outro lado, têm apenas algumas décadas de informações, a maioria das quais é mantida em segredo, uma vez que há pouca motivação para as organizações coletarem e publicarem informações sobre a eficácia de seus desenvolvedores, mesmo que estejam coletando (que a maioria não é 't).

Também há alguma confusão de campos. O desenvolvimento de software, ou "engenharia" de software, é realmente uma coisa diferente da ciência da computação. Os desenvolvedores de software precisam de um conhecimento prático da ciência da computação, mas trabalhar nos limites da complexidade algorítmica ou raciocinar sobre o paralelismo não é algo que um programador profissional fará todos os dias; da mesma forma, um verdadeiro "cientista da computação" escreverá toneladas de código descartável que simplesmente não funciona ou não faz nada de interessante e não se beneficiará tanto com o tipo de rigor que um produto de software real faria.

O surgimento da Internet e da comunidade de código aberto pode fornecer dados suficientes para começar a responder a essas perguntas de forma conclusiva, mas mesmo se as respostas estivessem disponíveis amanhã, provavelmente levará 100 anos para que elas permeiem a sociedade internacional a ponto de todos concordarem sobre o que deve ser ensinado nas escolas.

Finalmente, existem algumas considerações econômicas. Já faz um tempo relativamente curto desde que quase todos os envolvidos no desenvolvimento de software tiveram acesso fácil e barato a máquinas dedicadas para executar quaisquer ferramentas de desenvolvimento que desejassem. Algumas décadas atrás, dedicar completamente uma máquina apenas para executar seus testes, ou mesmo abrigar uma história infinita de código-fonte, teria parecido frivolamente caro para muitas pessoas.

Porque nossos professores:

1. Nunca tentei o teste de unidade,
2. Não sei como usar o controle de versão e
3. Nem ouvi falar de "desenvolvimento ágil".

Os alunos devem resolver o problema com as próprias mãos. Fizemos isso e ficou tudo bem, não foi?

Leonardo da Vinci escreveu,

Aqueles que se apaixonam pela prática sem ciência são como um piloto que entra em um navio sem leme ou bússola e nunca tem certeza para onde está indo. A prática deve sempre ser baseada em um conhecimento sólido da teoria.

As boas escolas ensinam tanto teoria (estruturas de dados, algoritmos, etc.) quanto prática (teste de unidade, controle de versão, etc.). Isso requer uma combinação apropriada de professores para que ambos os lados da moeda possam ser ensinados adequadamente. Um corpo docente composto inteiramente de tipos teóricos sem experiência real não servirá. Da mesma forma, um corpo docente composto inteiramente de profissionais não o fará. Você precisa de uma mistura, e as boas escolas têm isso.

A ciência da computação sempre foi um tanto contraditória; A parte que trata de computadores não é uma ciência, e a parte que é uma ciência não é sobre computadores.

As universidades tendem a se inclinar mais para o lado 'científico' (algoritmos, estruturas de dados, compiladores, etc.) porque essas coisas são muito mais 'atemporais' do que as melhores práticas atuais da indústria, que tendem a evoluir e mudar de ano para ano. O controle de versão, por exemplo, passou por mudanças surpreendentes nos últimos 5 ou 10 anos, mas big-O ainda é big-O, e hashing, btrees e recursão ainda são tão úteis quanto eram há 40 anos. A ideia deles é geralmente fornecer bases suficientes para que você possa pegar ferramentas como o git e entender o que significa quando você diz que a estrutura de dados subjacente é um gráfico acíclico direcionado de hashes SHA-1, e que os desenvolvedores trabalharam duro para otimizar o número de syscalls para que seja vinculado a io.

Agora, pense em onde você aprendeu todas as coisas que precisava saber para entender a última frase - se a resposta for 'universidade', eles estão fazendo um bom trabalho.

Tudo é uma moda passageira. Você aprenderá mais em seu primeiro ano fora da faculdade do que em todos os seus anos na faculdade. A ciência da computação não tem nada a ver com computadores.

A faculdade oferece uma caixa de ferramentas cheia de ferramentas. Esta é uma chave de fenda, uma chave inglesa. Você PODE começar a usar cada ferramenta uma vez na faculdade. É quando você entra no mundo real é que você realmente descobre o que tem. Você separa os úteis dos demais, os que quer deixar em casa na bancada, por precaução, e os que guarda no bolso todos os dias.

Tqm, Iso, Cmm, Agile, etc. Todos esses são modismos, eles virão e irão, nenhum dos bem-sucedidos é mais do que apenas bom senso. Todos os engenheiros e empresas de sucesso usam um pouco de bom senso, é isso que os tornou bem-sucedidos, poucos precisavam de um nome para isso. O problema é que você não pode vender bom senso, um gerente não pode provar seu valor para a empresa treinando e comprando bom senso sem um nome atraente. Coloque nele um nome que seus superiores tenham lido em alguma notícia ou revista e o gerente ficará com o emprego dele e você com o seu. Muito poucas empresas que afirmam seguir essas práticas realmente o fazem. A maioria passa um cheque para um consultor e recebe seu certificado anual e vitalício para algum clube, para que possa colocar uma imagem em seu site ou uma etiqueta na caixa de seu produto. Muitos vão argumentar que isso é raro ... estive lá, vi, isso acontece. Isso tudo faz parte do negócio, às vezes é preciso economizar para se manter lucrativo e manter as portas abertas e as luzes acesas. Os seguidores ferrenhos de todas essas práticas argumentaram que a última era uma moda passageira e esta não é, a última realmente era muito cara para seguir, esta não é. O último foi falso, você acabou de contratar um consultor, esse é real. Como as linguagens de programação, essas também evoluirão. O último foi falso, você acabou de contratar um consultor, esse é real. Como as linguagens de programação, essas também evoluirão. O último foi falso, você acabou de contratar um consultor, esse é real. Como as linguagens de programação, essas também evoluirão.

Sua capacidade de compreender a realidade dos negócios, o sistema universitário e seu papel nele é a chave. Como tudo na vida, escolha suas batalhas. Não é a universidade ou a empresa ou o governo ou o trabalho de qualquer outra pessoa para ensinar o que você precisa ou deseja saber. É seu trabalho cuidar do número um. Da mesma forma, você não pode culpar ninguém por lhe dar tempo para fazer isso, você tem que fazer. Você vai cair do cavalo, não é uma vítima, levante-se e volte a montar, sem desculpas, a vida não é justa com isso. Aproveite as apostilas, não finja ser independente. E com certeza pague suas dívidas, não esgote uma empresa de esmolas, sem dar a eles algo (o que você tem de melhor na hora?) Em troca.

Por que as pessoas acham que CM ou ágil ou qualquer um dos outros é uma moda passageira? Por que eles pensam que não são? Por que o professor ensinou você a programar dessa maneira? Para evitar gotos ou evitar constantes ou evitar isso e aquilo? É porque ele produz um código mais confiável? Código com melhor desempenho? Reduz o erro humano? Ou é porque é mais fácil classificar trabalhos / programas, dando-lhes mais tempo para fazer pesquisas? É porque não sabem programar e estão apenas seguindo o livro de outra pessoa sobre o assunto? Eles ensinaram que você não pode ter um código de alto desempenho, confiável e sustentável? Você não pode nem mesmo "escolher quaisquer dois" que possam ser mantidos tanto com confiabilidade quanto com alto desempenho? Às vezes, você sacrifica a confiabilidade pelo desempenho. Às vezes você não se preocupa com confiabilidade ou desempenho, você apenas deseja obter a partir da versão 117.34. 2 de outro programa de software de contabilidade para a versão 118.0.0. Seu modelo de negócios consiste na venda de atualizações de versão e suporte técnico e, na medida em que os desenvolvedores de software, qualquer robô antigo fará isso pode escrever o mesmo código da mesma maneira. Substitua o queimado pelo recém-saído da faculdade e continue vendendo atualizações.

Não existem respostas universais para essas perguntas, você tem que descobrir qual é a sua opinião, conviver com ela e defendê-la. Mude sua mente, viva com ela e defenda-a.

Questione tudo ... Será que realmente vou me queimar se tocar na panela quente no fogão? Os efeitos psicológicos de ter medo causarão mais danos do que apenas se queimar? Existe uma maneira segura de testar a resposta sem se machucar?

Quando eu podia pagar, eu comprava e, eventualmente, derretia transistores, capas, resistores, etc. no meu dormitório, todos com um odor ruim característico. É muito mais barato e fácil comprar apenas um amplificador para o seu aparelho de som do que tentar construí-lo no dia seguinte à sua primeira aula de transistor. Linus sendo a exceção, é claro, é mais fácil apenas comprar um sistema operacional do que escrever um ... Você pode fazer mais, embora o que você aprende naquela época seja diferente do que Linus aprendeu.

O mundo dentro e fora da universidade vai adotar essas fórmulas (cmm, ágil, etc) para resolver problemas e quando a próxima sair eles as abandonarão na mesma velocidade. Você não tem que usar o controle de versão para ter sucesso, existem tantos sucessos com ou sem (bem, na verdade, devido à idade da indústria, há muito mais sucessos sem controle de versão até agora). Da mesma forma, você pode ter sucesso com o mínimo de testes (veja os grandes nomes da indústria de computadores como exemplos). Você pode ter sucesso testando seu próprio código, bem como seguir a regra de que você nunca deve testar seu próprio código. Você pode ter sucesso usando emacs e você pode ter sucesso usando vi. Você tem que decidir qual mix funciona para você e, se tiver sorte, encontre um local de trabalho que combine com você.

Quando você sai da faculdade e entra no mundo real, ouça, trabalhe e discuta com os "veteranos". Eles têm décadas a séculos de experiência combinada, armadilhas em que caíram que você pode evitar ou testar por conta própria (talvez você perceba que não precisa tocar na panela quente para descobrir que ela vai queimar você). A maioria terá visto pelo menos um ou dois desses modismos irem e virem, e em particular como foram gravemente queimados e o que fizeram para se recuperar deles. Eles conhecem muitas maneiras diferentes de testar as coisas e os nomes dos estilos de teste que surgiram e desapareceram também. O que funciona, o que não funciona. Onde está o risco e como não perder tempo na tangente. Conforme você amadurece e se torna o veterano, passe adiante. Pague pelo que você aprendeu tentando ensinar seus seguidores. Lembre-se de ensiná-los a pescar, não dê apenas um peixe a eles. E às vezes você tem que deixá-los falhar antes que tenham sucesso, para evitar que se queimem muito.

O que eu realmente queria dizer aqui é que agora estamos em uma situação rara em que podemos testemunhar a evolução de um universo paralelo (e talvez influenciá-lo). Sim, a ciência da computação é uma ciência jovem em comparação com a física. Mas, ao mesmo tempo, evoluiu muitas vezes. Dependendo de onde você trabalha e com quem trabalha, você pode observar engenheiros de hardware. As linguagens de programação no mundo do hardware certamente não são novas, mas não evoluiu tão rapidamente quanto o mundo do software. O software teve algumas décadas de vantagem. Hardware sempre pensou nos engenheiros de software como cidadãos de segunda classe. Nosso trabalho é fácil, o trabalho deles é difícil. (Observe que, na verdade, sou engenheiro de hardware e software). O que é interessante é que agora eles ainda estão lidando com o que consideraríamos problemas elementares ou infantis. Por que eu precisaria usar o controle de versão, sou o único trabalhando neste chip. Sua experiência com o gcc ou outros compiladores baratos ou IDEs gratuitos não pode se comparar com as ferramentas caras que eu uso, se a empresa pensasse que você era digno de usá-lo ou mesmo saberia como usá-lo, eles comprariam uma cópia para você. E uma longa lista de outras desculpas. Tive o prazer de aprender vhdl e verilog e me tornar produtivo em ambos em uma semana, o que foi quase um desafio de um engenheiro de hardware (apesar de meu diploma dizer engenheiro elétrico, meu cargo é engenheiro de software). Eu queria aprender essas línguas, quando as ferramentas estivessem disponíveis para mim, eu ficava no escritório durante a noite e aprendia sozinho. A partir desse ponto, aquele engenheiro em particular percebeu que o que eu estava dizendo era verdade, as linguagens são apenas sintaxe, os fundamentos da programação são os mesmos, todas as ferramentas fazem a mesma coisa. São maçãs e maçãs, não maçãs e laranjas.

No entanto, em geral, ainda é difícil enviar a mensagem de que uma dessas duas indústrias paralelas tem muito mais experiência em linguagens, hábitos de programação, controle de origem, testes, ferramentas, ambientes de programação etc. do que a outra. O problema que estou tentando resolver é pegar os designs de hardware à medida que estão sendo desenvolvidos, criar simuladores funcionais acessíveis que podemos vincular a uma simulação (máquina virtual) do processador para que possamos começar a testar o hardware e desenvolver o teste e software de entrega muito antes de irmos para o silício. Não, não há nada de "novo" nisso, mas não temos nenhum mecanismo para obter o código mais recente, controlar as alterações no código para ver onde precisamos concentrar nosso tempo. Nenhum mecanismo para rastrear a documentação que define a interface do usuário (programação) para o hardware. A única cópia dourada está na caixa de entrada de e-mail de alguém em forma binária e só muda quando, bem, não é necessário ler o verilog para descobrir o que está acontecendo. Espere, esse verilog tem quantos anos? Aquele bug que passei a semana toda com você, descobri três semanas atrás e consertou? Então, vamos apenas voar para algum local de férias e festejar por seis meses esperando que o pessoal do hardware termine sua tarefa e jogue-o por cima do muro para nós, ou aproveitamos esta oportunidade para tentar ser pacientes e otimistas e ensinar-lhes que eles existem métodos de senso comum que não são tão intrusivos que permitem que eles façam seu trabalho, façam backup de seu trabalho, bem como compartilhem seu material para revisão por pares ... esse verilog tem quantos anos? Aquele bug que passei a semana toda com você, descobri três semanas atrás e consertou? Então, vamos apenas voar para algum local de férias e festejar por seis meses esperando que o pessoal do hardware termine sua tarefa e jogue-o por cima do muro para nós, ou aproveitamos esta oportunidade para tentar ser pacientes e otimistas e ensinar-lhes que eles existem métodos de senso comum que não são tão intrusivos que permitem que eles façam seu trabalho, façam backup de seu trabalho, bem como compartilhem seu material para revisão por pares ... esse verilog tem quantos anos? Aquele bug que passei a semana toda com você, descobri três semanas atrás e consertou? Então, vamos apenas voar para algum local de férias e festejar por seis meses esperando que o pessoal do hardware termine sua tarefa e jogue-o por cima do muro para nós, ou aproveitamos esta oportunidade para tentar ser pacientes e otimistas e ensinar-lhes que eles existem métodos de senso comum que não são tão intrusivos que permitem que eles façam seu trabalho, façam backup de seu trabalho, bem como compartilhem seu material para revisão por pares ...

Lembre-se de que os engenheiros de hardware saíram da faculdade com uma caixa de ferramentas novas e brilhantes, assim como você. Você aprendeu 17 linguagens de programação diferentes, das quais você só pode usar uma, as demais linguagens em sua carreira serão inventadas depois que você sair da faculdade. Quando eles saíram da faculdade, podem dizer o que sabem sobre cálculo e teoria da relatividade quantos elétrons existem em cada um dos elementos e calcular a carga em torno de uma superfície gaussiana. Mas a maior parte de sua carreira é um, zero e, ou e não (ei, temos aqueles em comum, tudo o que você realmente precisa saber sobre computadores, um, zero e, ou e não engenheiro de hardware ou software). Concedidas as leis fundamentais da física, do cálculo, os elétrons não vão mudar tão rápido quanto as linguagens de programação. Mas os fundamentos da programação são os mesmos em todas as linguagens e continuarão a ser no futuro. Você saiu da faculdade sabendo disso ou saiu pensando que java é diferente e melhor que C ++ por causa disso e daquilo e do outro?

Como qualquer outro negócio, o trabalho da universidade é se manter lucrativo. Eles precisam contratar os acadêmicos certos para trazer os alunos certos, os dólares certos para pesquisa e os tipos certos de pesquisa para tornar a universidade lucrativa. Eles têm que oferecer as aulas certas para trazer os alunos certos e produzir os graduados certos para que, com o passar das décadas, os empregadores próximos e distantes da universidade reconheçam que esta universidade produz funcionários produtivos e lucrativos. (sim, e às vezes você precisa atrair os atletas certos no esporte certo para obter a quantidade certa de tempo de TV e a quantidade certa de reconhecimento de nome e receita esportiva). Algumas universidades ensinarão C ++ e Java, outras nunca. Alguns inventarão o CMM, outros ensinarão Agile, outros não. Se a universidade tiver algum valor, há algo lá para você aprender. Eles não vão te ensinar tudo o que há para aprender, mas terão algo útil. Aprenda isso enquanto estiver lá, reúna um número razoável de várias formas de ferramentas em sua caixa de ferramentas. Saia da universidade e arrume um emprego. Se sua caixa de ferramentas for uma merda, talvez encontre outra universidade e nunca mencione a primeira. Se for uma caixa de ferramentas ok, use essas ferramentas e construa algumas novas no seu próprio tempo. Se for uma caixa de ferramentas muito boa, diga coisas boas sobre aquela universidade e os bons acadêmicos com os quais você aprendeu isso e aquilo e pague a escola pelo que eles lhe deram. Mesmo que você não tenha obtido todas as ferramentas possíveis no catálogo universal de ferramentas da universidade, você sairá com um certo subconjunto. Mesmo se você não se formar ...

Ensinei essas coisas quando era adjunto no Instituto de Tecnologia de Oregon. Eles são ensinados, apenas esparsamente.

A resposta mais simples é que você está estudando ciência da computação e as coisas que listou não estão realmente relacionadas ao campo acadêmico da ciência da computação. O desenvolvimento de software pode ser algo que você faz com a ciência da computação, algo que se baseia nos blocos do que você aprendeu ... mas Ciência da Computação e desenvolvimento de software não são a mesma coisa.

Aulas que ensinaram a você o controle de versão, ou como escrever testes de unidade eficazes ... que estariam ensinando a você um ofício , ou seja, (bom) desenvolvimento de software.

oh Deus, não me faça começar

Certa vez, o reitor da cs em uma universidade respeitável me disse que a programação orientada a objetos era apenas uma 'moda', então eles não ofereceram nenhuma aula sobre coisas passageiras como C ++

sobre por que eles não ensinam essas coisas, bem, a faculdade existe para ensinar os fundamentos da disciplina, não necessariamente as melhores práticas da indústria

Bem, o que acontece com as universidades é que elas precisam ensinar coisas que realmente são universais. Algo como o desenvolvimento ágil ainda é muito novo e, apesar de quanto é falado na Internet, não está sendo usado em todos os lugares, portanto, ensiná-lo a uma classe inteira de alunos beneficiaria potencialmente apenas algumas pessoas que acabaram em lojas agile.

O controle de versão, entretanto, é algo que hoje em dia é imperdoável. É algo que todos precisam entender que é uma ferramenta quase tão útil quanto um compilador e o CVS existe há cerca de 20 anos. Os conceitos pelo menos precisam ser compreendidos por qualquer programador que saia de uma universidade. Felizmente, se você fizer qualquer trabalho em grupo na universidade, pode ter a sorte de encontrar alguém que já conhece o controle de versão e convence seu grupo a usá-lo. Eu sei que estou feliz por essa pessoa estar no meu grupo.

O teste de unidade também é imperdoável. A única coisa que eu diria é que o livro ainda está disponível no desenvolvimento orientado a testes e ir para 100% de cobertura de código às vezes pode ser mais problemático do que vale a pena. Mas o teste de unidade é extremamente valioso e deve ser abordado em um curso de engenharia de software. Eu imagino que algumas dessas coisas estão chegando a algumas universidades, mas ainda não chegaram a todas elas.

Por que não? Minha experiência em obter meu diploma de CS foi praticamente a mesma. A razão é que as pessoas que ensinam programação não programam, pelo que eu sei. Não é obrigatório ensinar essas coisas para o credenciamento, os professores não estão familiarizados com isso e os alunos nunca desenvolvem projetos significativos como parte de seus cursos. Não há motivação para realmente ensinar programação, ao contrário de ensinar teoria CS ou sintaxe Java.

Os cientistas da computação pensam que são matemáticos, não engenheiros, por isso preferem ensinar as partes de matemática do que de engenharia. Teste, controle de versão e documentação não estão passando por modismos mais do que em qualquer outra disciplina de engenharia.

Depende da universidade. Eu me formei em 2003, em uma universidade australiana. Naquela época, aprendemos UML, Teste de Unidade, XP (e outras Metodologias Ágeis), junto com todas as coisas formais como Z, Algoritmos e Estruturas de Dados, Sistemas Operacionais, etc.

Eles não cobriram o teste de unidade em grandes detalhes, porém, apenas prestaram serviço de aprovação em uma palestra. Teria sido ótimo aprender a escrever testes de unidade eficazes, em vez de apenas "O que é um teste de unidade".

No que diz respeito ao controle de versão, nós o utilizamos (CVS) em nossos projetos de programação a partir do 2º ano em diante.

Também concordo totalmente com o que Glyph disse. O CS é um campo tão imaturo, realmente apenas por aí nos últimos 50 anos, que não sabemos o que devemos aprender e o que é apenas uma moda passageira. Dê 150 anos, então as coisas podem se acalmar mais. O número de projetos do mundo real que falharam torna óbvio que esta é uma indústria imatura. Imagine se 80% dos projetos de construção fracassassem!

Tudo isso pode ser facilmente abordado (superficialmente) em uma única aula sobre práticas de desenvolvimento de software. Não faz parte da maioria dos currículos de ciência da computação, porque não é disso que trata a ciência, embora eu ache que alguma cobertura dessas coisas seja útil. Minha escola tinha essa classe; não cobriu o controle de versão, mas cobriu UML, coleta de requisitos, metodologias de desenvolvimento (vários ágeis e cascata), teste de unidade, teste de integração, etc., e exigiu que trabalhássemos em equipes de 4 a 5 para desenvolver um projeto (um clue bastante simples em Java). Se você sentiu a necessidade de mais aulas de Engenharia de Software, elas estavam disponíveis como opcionais.

Apesar de nunca ter o controle de versão mencionado uma vez em qualquer aula que eu fiz, a maioria dos meus amigos estava usando-o para projetos pessoais, tarefas de aula e assim por diante, então não é como se não tivéssemos sido expostos a ele. As pessoas que não o pegaram por conta própria foram forçadas a usá-lo por um colega durante uma tarefa de equipe.

A universidade serve para ensinar conceitos e teorias, porque essas são coisas difíceis de aprender sozinho. O controle de versão é uma ferramenta muito fácil de aprender. Use-o um pouco, leia alguns tutoriais na web e está tudo pronto. Se você precisa de palestras e tarefas de casa para descobrir como verificar algo do SVN, terá muitos problemas com as coisas que realmente SÃO difíceis.

Lembre-se de que há muitas maneiras de aprender coisas na faculdade fora das aulas; tirar vantagem disso. Você está pagando muito para assistir às aulas e usar as instalações, então aproveite ao máximo e vá às reuniões LUG e ACM, participe de equipes de projeto (sempre há alguns MEs construindo um robô que precisa de um programador), ou obtenha um trabalho de administração do servidor do departamento de Humanidades. Escolha um computador da doca de carregamento do prédio de Engenharia de Materiais, baixe uma iso Linux com sua conexão rápida de internet do dormitório e brinque.

Acho que a questão é que as universidades não sentem que precisam ensinar você a ser um profissional, mas sim se concentrar no lado acadêmico da programação. Eu teria pensado que deveria haver pelo menos referência aos métodos e técnicas mais recentes usados ​​na indústria, já que essas coisas também são de interesse acadêmico.

Em nosso curso, aprendemos o Processo de software pessoal, que abrangia coisas como registrar o tempo gasto em projetos, bons comentários etc., mas nenhuma menção a fundamentos profissionais como controle de versão.

Você nomeou 3, alguns dos quais não acho que sejam tão importantes para a compreensão dos sistemas de computador (por exemplo, controle de versão). Essas coisas fazem parte de um trabalho e você pode se tornar um bom programador / cientista da computação sem precisar saber disso.

da mesma forma para o teste de unidade - por que escolher o teste de unidade? Certamente o teste de usabilidade, teste de sistema, teste de aceitação do usuário e teste de aceitação de fábrica são mais importantes? Bem, eles são, a menos que você considere seu trabalho concluído assim que o código for enviado para o departamento de manutenção :)

Pense nos outros conceitos que uso diariamente, que seriam de pouca utilidade para um aluno que está chegando a um acordo com os fundamentos de software e sistemas de computador:

• boas práticas de comentários
• conformidade de padrões (não apenas os internacionais, mas padrões de codificação de equipe)
• documentação
• controle de mudança (não necessariamente o mesmo que controle de versão, que trata do armazenamento de diferenças, trata-se mais do que e por que você mudou algo)
• desenvolvimento de usabilidade

O acima são todas "habilidades básicas" que você não precisa para escrever um bom código.

No entanto, se você está perdendo as habilidades "difíceis", como estruturas de dados e algoritmos, sua chance de escrever um bom código é quase impossível.

Aprendi tudo isso na universidade. Talvez dependa dos cursos que você escolher? Meus cursos eram muito diversos (Design de software, Design de interface do usuário, eCommerce, IA, programação funcional, etc.). O design de software teve exposição a padrões de design e testes de unidade (um grande projeto que envolveu várias coisas). UI Design ... éramos um grupo de três pessoas trabalhando em um projeto. Não podíamos fazer nada sem controle de versão, então conseguimos. E o desenvolvimento ágil era algo que nossos professores continuamente nos contavam, mas eles deixavam que cada grupo usasse.

Eu descobri que muitos estudantes universitários fizeram cursos "fáceis" ou cursos que dariam um alto GPA. Outros se concentram no que desejam aprender e estão explorando amplamente para descobrir que campo os interessaria. E tem quem sabe exatamente no que se interessa ... o que é bom, só que não tem a tendência de diversificar os cursos.

Para responder por que essas coisas não são as primeiras coisas a serem ensinadas: os programas de graduação normalmente treinam você para se tornar um aluno de mestrado. Somente depois de começar a escolher seus próprios cursos (o que normalmente acontece nos últimos anos), você pode escolher aprender sobre coisas usadas fora da academia. É por isso que eles se concentram em algoritmos, estruturas de dados, apresentando problemas não resolvidos, etc.

Pessoalmente, acho que é bom que eles estejam fazendo isso. Programar não é tão fácil quanto muitos de nós fazem parecer; muitas pessoas lutam contra isso. Eu preferiria que essas pessoas primeiro entendessem como um loop for funciona antes de descobrir o monstro que é o Perforce.

Eles não ensinam esses tópicos porque a maioria das escolas é acadêmica, não comercial. Ou seja, eles são projetados para ensinar idéias e teorias, não treiná-lo para uma carreira. Todo o conceito de QA não tem nada a ver com a ciência da computação além de passar por uma prova matemática. Além disso, as práticas de controle de qualidade e os fluxos de trabalho de desenvolvimento variam enormemente de uma casa de desenvolvimento para outra, então ensiná-los na escola é uma perda de tempo e dinheiro.

Aprendi tudo isso no primeiro ano, com exceção do desenvolvimento ágil.

É tudo uma questão de escolher a escola certa, IMHO. Se você chegar ao top 10, aprenderá tudo isso rapidamente.

No que diz respeito à educação em ciência da computação em geral, estamos basicamente pedindo aos professores que ensinem muito (linguagens de todos os tipos, estruturas de dados, eficiências de tempo de execução, como as coisas realmente funcionam no nível de bits). Eu gostaria de levantar a questão: por que as crianças não se encarregam de aprender mais sobre engenharia de software?

Assim como os alunos, cada faculdade é diferente. Algumas faculdades, ou mais precisamente, alguns professores resistem a mudanças ou são preguiçosos. Felizmente, a maioria não. Teorias, conceitos, história etc. são importantes e vitais para qualquer currículo de ciência da computação. Mas também está preparando o aluno para seu ambiente de trabalho. Não é surpreendente que as faculdades comunitárias em minha área oferecem cursos de ciência da computação muito atuais e aplicáveis. Não tanto com uma universidade grande, estabelecida e de prestígio.

Simplesmente porque as estruturas de dados e algoritmos constituem o núcleo da computação e, portanto, são muito mais importantes. O teste de unidade, o controle de versão e a metodologia ágil são apenas ferramentas do mercado (e, se necessário, espera-se que você os aprenda no trabalho).

Acho que bons programas de CS devem ensinar os fundamentos que servirão de base para toda a educação de programação futura. Metodologias de desenvolvimento como Agile e ferramentas de controle de versão são como modismos; eles vêm e vão. Além disso, eles tendem a ser usados ​​em ambientes industriais e não acadêmicos, então acho que é raro as universidades cobrirem coisas como aquelas que você provavelmente aprenderá no trabalho. Não estou dizendo que está certo, mas essa provavelmente é a mentalidade acadêmica.

Eu concordo com o que você está dizendo. Recentemente comecei a trabalhar no mundo do desenvolvimento de software e já comecei a aprender sobre desenvolvimento ágil, algo que nunca fui ensinado na universidade.

O fato é que os professores universitários não acompanham as novas técnicas de desenvolvimento tanto quanto deveriam. Eles também podem sentir que há outras coisas mais importantes em seu currículo.

Os professores universitários não sabem escrever software, eles apenas pesquisam, ensinam e, ocasionalmente, exibem algum código que só precisa funcionar até que o artigo seja publicado.

É só por causa de pessoas como Tito que estamos recebendo acadêmicos que realmente grocam a programação - Leia os comentários dele sobre esse tópico aqui

Quando eu era estudante, li livros na biblioteca sobre Programação Extrema e discutíamos isso bruscamente nas aulas - as mesmas aulas que exigiam que nos conformassemos ao "Modelo em Cachoeira" de desenvolvimento de software, onde a "compilação" é uma etapa de sua próprio.

Tudo de bom com sua carreira, espero que se gradue, é bom ter letras depois do seu nome. :)

Todas as três coisas que você mencionou (teste de unidade, controle de versão, desenvolvimento ágil) são ensinadas até certo ponto no programa de Ciência da Computação da Universidade de Groningen. Se isso é bom ou não, deixarei como uma questão em aberto; mas não é verdade que nenhuma universidade ensina "coisas práticas".

Eles se baseiam em minhas experiências limitadas em um programa de ciência da computação antes de mudar de curso e em minha experiência como estagiário em uma grande empresa de software. O teste de unidade não é ensinado porque a maioria dos programas que você precisa criar não são grandes o suficiente para precisar de testes automatizados, você garante um conjunto específico de entradas para que possa testar tudo manualmente. Ensinar como automatizar o teste também pode interagir com a classificação de seu projeto, já que a maioria dos projetos é avaliada com scripts que executam testes automatizados, com uma rápida olhada no código para se certificar de que você não tem int foo1; int foo2; e você usa indentação adequada.

Não sei por que o controle de versão não seria ensinado, mas provavelmente parte disso é o tamanho dos projetos. Nunca tive nenhum projeto grande o suficiente para controle de versão e, no geral, quero dizer mais de 1000 linhas de código e levei um semestre inteiro para escrever. Eu acho que eles acham que você vai ensinar a si mesmo, se precisar. Quaisquer projetos em grupo que eu tive deveriam ser projetos de programação em pares, e por que usar o controle de versão se vocês dois estão no mesmo computador?

Não sei por que o desenvolvimento ágil não seria ensinado, mas provavelmente volta à mesma coisa com o tamanho do programa. Embora o desenvolvimento do adgile seja comum com novos softwares executados em computadores pessoais e pequenos servidores, geralmente não é usado em sistemas como mainframes IBM ou em domínios de problemas, como bancário ou médico, onde a documentação é rei. Provavelmente também tem a ver com o fato de que o adgile development não existia há cerca de 20 anos, quando muitos professores eram treinados.

O principal motivo é que muitas (a maioria?) Universidades consideram ter um objetivo diferente de uma escola de comércio. Como tal, eles querem ensinar aos alunos como aprender e os princípios fundamentais da disciplina. Além disso, algoritmos e estruturas de dados se aplicam a qualquer linguagem de programação, e não dependem de ferramentas específicas (que podem ou não estar em uso na graduação).

Na Ciência da Computação, isso significa algoritmos, estruturas de dados, teoria do computador, teoria do compilador, etc. O que você está listando tem menos a ver com a compreensão de como programar, como resolver problemas, etc. É sobre a prática de programação (que, aliás, é um livro incrível para qualquer pessoa na faculdade com a intenção de trabalhar como programador). Agora, muito disso não será usado em uma posição de macaco de código de nível de entrada, levando algumas pessoas a pensar que não é útil. Discordo. Acho que pode ser extremamente útil. No entanto, isso não significa que depois de obter seu diploma em CS, você saberá tudo de que precisará para trabalhar como programador.

O que também não quer dizer que as coisas que você mencionou não sejam úteis. Eles são. Você terá dificuldade em trabalhar como programador se não aprendê-los, e eu realmente acho que eles deveriam ser ensinados na faculdade, pelo menos até certo ponto. Eu examinaria o ensino de controle de versão, teste de unidade, etc., da mesma forma que olharia para uma programação de graduação em arte, e o ensino do que são pincéis e quais devem ser usados ​​em vários casos.

Eu acho que depende de que tipo de programa de Ciência da Computação você está, existem aqueles que visam o lado da Pesquisa e Ciência e há aqueles voltados para o lado da Implementação. Recusei especialmente certas escolas que só tinham professores que permaneceram no mundo acadêmico. Se você não tem professores que não têm "usado" o que ensinam, está tudo na cabeça deles, literalmente.

Plug: Tendo feito BS em Comp Sci e MS em Soft Eng na DePaul University, fui ensinado principalmente por instrutores / professores que davam aulas em meio período, o que foi bom para mim porque eu preferia que eles viessem com uma anedota do dia anterior e relacionar com a classe. Além disso, sendo uma escola predominantemente de trabalho / meio período, a maioria dos alunos trabalha usando o que estão aprendendo.

O processo de aprendizagem ainda começa com toda a teoria, mas então normalmente somos questionados "quantos de vocês realmente usam isso em seu trabalho?" e a resposta típica é "nós o usamos, mas de uma maneira simplificada ou mais simples" e então vamos para os cenários práticos do mundo real.

Durante minha escolaridade, o teste de unidade estava sempre presente. Mesmo que eles o iniciem em Java, eles nos fizeram usar ANT e JUnit para todos os projetos. O que foi um bom começo na configuração da compilação e testes de unidade.

E Extreme Programing foi incluído em cerca de 3 ou 4 das aulas que fiz. Lembro que todos começaram com 12 aspectos diferentes, desde a programação em pares até o teste de unidade (veja acima). E agora parece que o foco está no Agile.

Portanto, a resposta rápida é sim, existem escolas que têm uma abordagem mais pragmática do que outras.

Teste de unidade e controle de versão foram ensinados em cursos de Ciência da Computação do segundo ano, onde fui para a universidade. O teste de unidade caiu na parte de teste que também incluiu diferenças entre a caixa branca e preta e uma boa parte das marcas nas atribuições de programação do terceiro ano foi para um bom tratamento de erros que pode facilmente vir de testes de unidade.

O desenvolvimento ágil pode ser bastante difícil de ensinar em um ambiente acadêmico, eu acho. Embora eu tenha aprendido sobre o método em cascata em teoria, não pude vê-lo em campo até depois de me formar e me mudar para o mundo real que pode ser bem diferente da academia, por exemplo, no terceiro ano eu cometo todos os erros estranhos casos e quase passei em uma designação em que nunca toquei o cerne do que a designação tentou me ensinar sobre Semáforos.

Além disso, há quanto tempo o Agile existe e qual forma de Agile você quis dizer? Existem muitas implementações diferentes do que tenho visto.

Não acho que a programação ágil seja uma moda passageira, mas ao mesmo tempo seria difícil pensar em uma maneira que um professor poderia dar a você projetos para permitir que você aprendesse. A menos que eles lhe dessem o projeto A build a, o projeto B se expande em a. O problema é tempo e escopo. Em um curso de 4 meses seria difícil.

Os métodos de controle de versão e teste de unidade estão sempre mudando e dependem do idioma ou da pessoa que os define.

As estruturas de dados e algo's são algo que pode ser trabalhado em uma configuração de classe. Honestamente, eles exigem um pouco mais de esforço para entender o teste de unidade e o controle de versão. Tente se lembrar que parte da universidade é ensinar você a aprender sozinho. A colagem não tem exatamente o mesmo mandato. Ou pelo menos não na mesma medida. NA MINHA HUMILDE OPINIÃO.