Como posso fazer o meu trabalho de desenvolvimento mais “enterprisey”?

https://stackoverflow.com/questions/413713

03-07-2019
|

Pergunta

Eu sou o único desenvolvedor para um consórcio acadêmico sediado em uma universidade no nordeste. Todo o meu trabalho de desenvolvimento envolve ferramentas internas, principalmente em Java, por isso nada que é liberado ao público. Agora, eu sinto como se meu desenvolvimento de fluxo de trabalho é muito "hobby" e não é nada como você veria em uma empresa de desenvolvimento de software experiente. Eu estaria inclinado a dizer que ele realmente não importa desde que eu sou o único desenvolvedor de qualquer maneira, mas não pode ferir a fazer algumas mudanças, se por nenhuma outra razão do que para fazer o meu trabalho um pouco mais fácil e obter alguns mais tecnologias no meu currículo. Agora meu trabalho é algo como isto:

Eu faço a maioria do meu trabalho de desenvolvimento em Eclipse no meu laptop. Tudo é salvo localmente no meu laptop, e eu não usar um VCS, nem eu realmente backup do meu código (exceto para e-mail ocasionalmente para mim para que eu possa vê-lo em um computador diferente - sim, eu disse que meu ambiente de desenvolvimento precisa de trabalho).
Quando eu sou feito com um projeto e quer implantá-lo ou se eu só quero testá-lo, eu uso o built-in ferramenta do frasco no Eclipse para fazer um .jar executável do meu projeto. Se eu usar bibliotecas .jar externos, eu uso o plugin Fat-Jar para incluir essas .jars no meu jar executável.
Depois de criar o .jar, eu carregá-lo manualmente para o servidor via SFTP e testá-lo com algo como java -jar MyProject.jar.

Oh yeah, eu fiz menção de que eu não fazer teste de unidade?

O problema mais gritantemente óbvio que eu gostaria de corrigir primeira é a minha falta de controle de origem. I como git porque ele é distribuído natureza, mas não parece integrar com Eclipse bem e eu ouvi dizer que ele não funciona muito bem no Windows, que é o meu OS desenvolvimento primário. Então, eu estou inclinado a SVN, que eu tenho alguma experiência com. Eu tenho meu próprio servidor pessoal, e eu acho que eu vou usar isso para o meu controle de origem, porque eu prefiro ser o meu próprio administrador que tem que lidar com a burocracia universitária. Eu tive alguma configuração problemas até SVN uma vez antes, mas vou dar-lhe outro tiro. Talvez eu também vai instalar algo como Trac ou Redmine para bug-tracking, lista de tarefas, etc?

O que sobre a construção e implantação? Tem que haver uma maneira melhor do que usar Fat-Jar e manualmente upload meu jar para o servidor. Eu ouvi sobre ferramentas como Ant e Maven - que estes se aplicam ao que eu quero fazer? Como posso começar a usar esses?

suponho eu, eventualmente, como para integrar os testes de unidade com JUnit também. Mesmo que ele provavelmente deve ser, que não é a minha principal preocupação agora, porque até agora meus aplicativos não são terrivelmente complexo. Eu realmente gostaria de trabalhar na simplificação e racionalização meu trabalho agora, e então eu vou facilitar para testes de unidade.

Desculpem a pergunta longa. Acho que minha pergunta se resume a, por um único desenvolvedor, quais ferramentas e metodologias podem / eu deveria estar usando para não só fazer o meu trabalho mais fácil, mas também apenas para expor-me a algumas tecnologias que seriam esperados conhecimentos necessários a um desenvolvimento dedicado casa?

Editar: Obrigado pelas grandes respostas até agora. Eu não quero sugerir que eu queria fazer meu trabalho "enterprisey" apenas por uma questão de fazê-lo, mas para fazer o meu trabalho mais simples e para obter algumas tecnologias sob a minha cintura que são normalmente utilizados em ambientes de desenvolvimento empresarial. Isso é tudo o que eu quis dizer com isso.

Solução

Parece-me que você realmente tem uma boa idéia muito do que você precisa fazer.

Usando Subversion (ou outro VCS) é uma obrigação. Embora possa ser sábio para configurar um repositório SVN separado para o código relacionado ao trabalho em vez de usar uma questão pessoal.

Você pode integrar Subversion com Eclipse usando um plugin como Subclipse, que eu encontrei funciona muito bem.

Eu definitivamente usar Ant ou Maven - minha preferência é Ant porque é mais flexível, e eu acho que ele iria se adequar ao seu estilo de desenvolvimento mais de Maven também. Mas você também pode querer olhar para Apache Ivy , que lida com a dependência-gestão.

Basicamente você configurar uma tarefa ant que executa seus passos de compilação, de construção e implementação - para que, quando você cria um pacote JAR final, você pode ter certeza de que tem sido unidade testada como que é parte do seu script ant. A melhor maneira de começar com formiga é olhar para alguns exemplos, e ler o href="http://ant.apache.org/manual/index.html" rel="nofollow manual do .

Como para o teste de unidade - você pode gradualmente construir com testes de unidade. Eu recomendaria usar JUnit em conjunto com uma ferramenta de cobertura de código, como Cobertura (o que é fácil de configurar) -. ele vai ajudar você a entender o quanto de código seus testes estão cobrindo e é um indicador sobre como eficaz seus testes são

Ele também pode valer a pena a criação de algo como Trac. - É importante ser capaz de manter o controle de bugs, e um wiki é surpreendentemente útil para documentação

Em outras palavras, tudo isso soa como você está no caminho certo, você só precisa começar a usar algumas destas ferramentas!

Outras dicas

Se você está realmente definido em controle de origem distribuído, eu recomendo que você olhar para Bazaar . Sua GIT-como controle de origem distribuída que é projetado em torno de realizar fusões de alta qualidade. Fora da caixa funciona em todas as plataformas, incluindo Windows e eles têm um TortoiseBzr cliente.

Realmente, porém, qualquer controle de origem é melhor do que nenhum. Se você é o único desenvolvedor então não há necessidade de algo mais complexo do que SVN. empresas e projetos grandes usar SVN o tempo todo com pequeno problema.

Tanto quanto o teste de unidade vai, você deve familiarizar-se com JUnit . O fato de que você está ciente de teste de unidade e sei que você deve fazer é ainda vários passos à frente da maioria dos desenvolvedores ad-hoc.

Use o controle de versão. Período. SVN tem grande intergration com Eclipse e Windows. Obter o cliente TourtisSVN para janelas e usar o subclipse plugin com Eclipse.

Eu recomendaria obter um HD externo ou usar um dos servidores de seus empresas para colocar seu repositório on e fazer backups com frequência. Subversion funciona muito bem com a implantação e modernização também. Basta aprender como fazê-lo e você nunca vai olhar para trás:)

Quanto Testes Unitários, algumas pessoas diriam que é o caminho a percorrer, mas eu não ter encontrado provas suficientes para iniciar a prática mesmo. Se sombody sobre esta questão pode me convencer do contrário, em seguida, por favor, faça!

Além disso, não olhe para "empresa" seu fluxo de trabalho - olhar para torná-lo melhor. Práticas que funcionam bem com grandes equipes e corperations pode não funcionar bem para você. Eu sou praticamente um único desenvolvedor mim mesmo e conhecer a situação em que está. Apenas tentar tudo e só manter o que sente natural depois de um tempo.

Mas certifique-se de apenas tentar SVN! Se sua empresa tem um servidor Linux com Apache ver se você pode configurar o servidor de lá usando DAV-SVN.

Eu acho que você respondeu a maioria de suas próprias perguntas.

Fonte: escolher SVN - fácil instalação, grande integração com o Eclipse (subclipse).
Use Ant para construir seu projeto e implantá-lo (SCP tarefa / SFTP)
Mantenha todas as suas configurações (configurações do projeto Eclipse, xmls construção, etc.) no SVN.
Use Bugzilla para manter o controle de seus bugs / problemas / solicitações / ideias.

Seria muito benéfico para começar a trabalhar com controle de versão. Comece agora, não demora! Git está se movendo muito rápido, e já existe um TortoiseGit sendo desenvolvido. SVN é ainda um grande padrão de trabalhar. E eu não trabalhei com Mercurial, mas isso é outra VCS que vale a pena olhar em.

Além disso, eu não vejo porque seu fluxo de trabalho tem que ser enterprisey. Ele só tem que ser eficiente e confortável. Dito isto, eu acho que você deve tentar trabalhar com um editor de texto simples e compilar a partir da linha de comando. A maioria dos melhores programadores do mundo ainda usar que em vez de uma IDE, e ele vai ajudar você a entender os processos debaixo de seu IDE favorito.

Confira as Pragmatic Programmers' Pragmatic Starter Kit .

escolas-lo sobre os princípios importantes de desenvolvimento de software que as universidades / etc. parecem passar-se, como controle de versão, testes unitários e automação de projeto (nessa ordem), e faz isso de uma forma muito acessível.

Ele lhe dará uma base sólida para continuar a partir daí.

Dê uma olhada @ appfuse de Matt Raible.

Ele incorpora Maven e Testes Unitários.

http://raibledesigns.com/rd/tags/appfuse

Embora você colocá-lo como a última coisa, eu acho que você deve começar a usar jUnit sem demora.

A razão é, é provavelmente o mais fácil das ambições que você identificou, e as ferramentas são quase certamente já incorporados a sua construção Eclipse.

Criar uma nova pasta em seu projeto chamado 'jUnit'.

Vamos dizer que você tem uma classe Employee, com setAnnualSalary () e getMonthlySalary () métodos.

Botão direito do mouse sobre a pasta jUunit, novo -> "caso de teste JUnit". Isso fará com que uma nova classe. Chamá-lo TestEmployee. Eclipse gera o material clichê para você, como de costume.

Adicionar um método vazio com um nome que começa com 'teste':

public void testSalaryCalc() {
    Employee emp = new Employee("John Doe");
    emp.setAnnualSalary(12000);
    assertEquals(1000,emp.getMonthlySalary());
}

Botão direito do mouse, "Executar como" -> "teste JUnit". (A primeira vez Eclipse pode pedir-lhe para fazer alguma configuração para o projeto. Basta fazer o que ele diz.)

Se Employee funciona corretamente, você verá uma barra verde. Sabotar a classe Employee, execute o teste novamente, e você verá uma barra vermelha, bem como a saída dizendo o que a falha foi.

Parabéns: você é o teste de unidade

clique com o botão direito do mouse no diretório pai e escolher "Executar como teste JUnit" irá executar todas as classes Testcase no diretório. Mais tarde você pode incorporar jUnit em seu processo de construção, mas não se preocupe com isso por enquanto.

Autocomplete irá mostrar-lhe todas as variações sobre assert() você pode usar. Você pode ler sobre ele, e aponta para práticas onde escrever os casos de teste antes da implementação que lhes passa. Mas apenas fazendo as coisas simples acima você obtém grandes benefícios.

Uma vez que você tem uma configuração de controle de versão e algumas unidades-testes, eu consideraria um servidor de integração contínua (que queria ser enterprisey, certo?).

Mesmo se você for e permanecer o único desenvolvedor, isso pode ajudá-lo a descobrir alguns erros. Coisas que você esqueceu de check-in ou os gostos. A CI-servidor regularmente verificações fora todas as suas fontes, faz uma compilação limpa uma roda todos os testes. Também você contactos em caso de erros.

Isso lhe dá a garantia de que você (ou qualquer outra pessoa) é capaz de verificar se o seu código e build / executar seus projetos.

Eu recomendo dar uma olhada Hudson

Como já foi dito, você já sabe claramente o que você precisa fazer. A VCS é uma obrigação, CI ou bug-tracking pode ser um exagero (para um único desenvolvedor uma planilha pode ser suficiente para bug-tracking).

Uma coisa que pode beneficiar muito você está mantendo um product backlog organizado. No desenvolvimento de solo, eu acho manter focado nas características de alta prioridade e evitando fluência característica de ser um dos meus maiores desafios. Manter um backlog ajuda imensamente. Ele não tem que ser muito mais do que uma lista priorizada de características com algumas notas sobre o alcance de cada um. No meu local de trabalho, podemos manter esta informação no Trac, mas aqui novamente, uma planilha pode ser tudo o que você precisa.

E eu quero colocar em uma ficha para testes unitários, particularmente Test Driven Development (TDD). de Kent Beck livro é um bom lugar para começar. Acho que TDD ajuda a manter-me honesto e focado no que eu realmente precisa fazer, especialmente em um projeto-desenvolvedor único sem QA. Às vezes parece que o código escreve-se.

Você tem algumas respostas muito sólidas tão curto pós acrescentando um link para um artigo sobre Test Driven Development, que é uma prática ágil que vai ficar bem em seu currículo. TDD

Se você estiver executando um Windows Server onde você quer colocar o seu servidor SVN, use Visual SVN como o servidor. É super fácil de configurar e usar, ele suporta autenticação e janelas autenticação básica. Ele também é livre para usar.

Eclipse tem alguns módulos para integração com um servidor SVN, portanto, use um desses, ou o já sugeriu Tortoise SVN.

Todos os comentários anteriores cobriu quase tudo o que você pode precisar :-)

Eu quero adicionar uma outra abordagem sobre como desenvolver (o fluxo de trabalho de desenvolvimento).

Eu sugiro que você leia o seguinte artigo e embora seja um git fluxo de trabalho que você pode usar a mesma idéia para qualquer outra ferramenta que você pode estar usando.

http://nvie.com/posts/a-successful-git -branching-modelo /

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow