Etiqueta de código aberto

Comecei a trabalhar no meu primeiro projeto de código aberto no Codeplex e me deparei com um código terrível. (Aprendi que o C # ainda tem a instrução "goto"). Comecei a adicionar recursos que o "proprietário" queria, e depois de explorar a base de código e ver como era uma bagunça (por exemplo, usando "goto"), eu queria limpá-la. um pouco. Mas estou um pouco preocupado e é por isso que estou me voltando para todos vocês: é uma etiqueta adequada para eu "consertar" o "código incorreto" ou devo deixar para lá e trabalhar em novos recursos? Como eu disse antes, sou novo em toda a cena do OSS e trabalho em uma equipe em geral, então eu gostaria de não estragar tudo.

Não há problema em fazer isso, se você é modesto e não quebra nada . Você não pode reformatar código e introduzir bugs. Tem bons testes de unidade? Caso contrário, eu começaria a contribuir adicionando testes de unidade e depois consertaria a estrutura mais tarde.

O objetivo do código aberto é atrair mais olhos para um projeto e melhorá-lo. Isso inclui melhorar o código. Dito isto, é uma boa forma anunciar na lista o que você pretende fazer. Você pode receber um empurrão para trás ou pode receber vários +1. Essas gotodeclarações podem estar lá porque o autor original não conseguia pensar em uma maneira melhor de fazer o trabalho. Se você for pressionado, é bom entrar em uma caixa de diálogo para descobrir de onde vem a pressão. Tente não deixar isso pessoal e tente abordar as preocupações.

Resumindo, os testes unitários falam mais alto que o dogma. Se você puder provar que o código não funcionará corretamente em alguns casos do jeito que está agora, você receberá o polegar ou o autor original entrará e consertará as coisas.

Lembre-se, em código aberto, a comunidade é mais importante que o código. Se não houver comunidade (usuários e desenvolvedores), não haverá projeto.

As pessoas que são zelosamente defensivas sobre seu código geralmente não o publicam para que o mundo examine, e se o fizerem, a comunidade ao redor dele não durará muito. Seja diplomático, mas não se preocupe, pois você machucará os sentimentos.

Apenas diga a eles o que você deseja fazer antes de investir muito tempo nisso. Às vezes, existem razões históricas para coisas que não são óbvias. A razão pela qual os gotos são evitados é que eles podem produzir caminhos imprevistos através do código. Consequentemente, o perigo de remover gotos é que você não percebe um dos caminhos benéficos e o omite acidentalmente do refator.

Por outro lado, talvez o autor original não tenha conseguido pensar em uma maneira mais limpa de escrevê-lo na época. É aqui que o código fala mais alto que as palavras, porque elas podem não acreditar que isso pode ser feito de maneira mais limpa até que você as mostre. Uma das minhas primeiras contribuições de código aberto foi uma correção de desfazer pilha que melhorou significativamente o desempenho, mas que alguns dos principais desenvolvedores disseram que parecia muito complexo quando o descrevi pela primeira vez. Um exemplo de código curto os trouxe a bordo.

Se, na verdade, houver boas razões para deixar isso de lado, eu recomendaria pelo menos um comentário explicando essas razões.

Falando por experiência própria ...

O primeiro projeto de código aberto em que contribuí, estava cheio de mijo e vinagre quando comecei também.

O que eu fiz imediatamente foi passar por vários arquivos de origem e começar a estilizar as coisas de acordo com minhas preferências pessoais, criar um patch enorme e enviá-lo.

Se você estiver trabalhando com alguém que é 'bom' (como eu), ele imediatamente rejeitará o patch. Principalmente porque, quando você contribui para um projeto de código-fonte aberto, é esperado que você divida suas correções em pedaços pequenos, que abordam um único problema. 'Removido todos os gotos' não é um bom exemplo de confirmação atômica. Mesmo se você dividi-lo em confirmações menores e bem documentadas primeiro, ele ainda poderá ser rejeitado.

O motivo é que, como o código é trabalhado por várias pessoas (com estilos diferentes) ao longo do tempo, não é realmente possível aceitar alterações em toda a biblioteca para se adequar ao estilo de um desenvolvedor. Se a mudança de estilo por causa do estilo fosse viável, todos os projetos de código aberto nunca avançariam porque o código seria constantemente editado para se adequar a diferentes estilos de desenvolvedores.

A refatoração do código e a adição de funcionalidade (ou remoção de detritos obsoletos) geralmente têm precedência sobre o código de 'limpeza'.

A parte mais difícil e gratificante de se trabalhar em um projeto de código aberto é que você será perguntado por que está se propondo a fazer as alterações que está enviando. Se você puder dar uma boa razão, há uma chance maior de que seu patch seja enviado.

Meu conselho é fazer algumas dessas alterações em um arquivo de origem para dar uma amostra do que você está tentando fazer primeiro. Se as alterações forem bem justificadas e aceitas, pergunte se mais alterações como essa melhorariam a qualidade do projeto. Dessa forma, você não desperdiçará muito esforço por nada se seus patches forem rejeitados no futuro.

Desenvolver código aberto é mais do que escrever código. Você está trabalhando para criar um relacionamento de confiança, porque os gatekeepers (desenvolvedores que controlam o acesso push) farão o que for necessário para proteger a integridade do projeto. À medida que você envia mais patches, o gatekeeper terá uma sensação melhor do seu estilo e você não precisará justificar suas alterações.

É um processo que leva tempo, mas é muito gratificante. Você não apenas aprenderá muito ao poder olhar e criticar o código de alguém, mas também será criticado em seu próprio estilo.

Antes de você perder muito tempo tentando "corrigir a injustiça dos erros do estilo de codificação de outros", pergunte a si mesmo:

As mudanças que você está propondo se baseiam em agregar valor ao projeto ou são baseadas em sua própria religião estilística interna.

Existe muita religião no Stack Overflow (e sites relacionados ao Stack Exchange). Quero dizer um monte . As pessoas pensam e falam sobre o estilo infinitamente, como se quanto mais você fala sobre ele, mais perto você fica do estilo de codificação "perfeito, ideal, indestrutível, infalível". Eu falo muito sobre isso principalmente porque é divertido.

No mundo do código aberto, o estilo não é tão importante. Função é .

Nota: Todas essas orientações pressupõem que o seu gatekeeper seja um programador razoável e talentoso. Se ele é, considere-se sortudo por não ter ficado preso com uma das choronas e chorões cuja única preocupação é proteger o 'bebê' deles. Eles não existem em estado selvagem, por isso não se surpreenda se você encontrar um.

Qualidade> Etiqueta

Na minha opinião, você não deve se preocupar em editar o código de outras pessoas assim que descobrir que tem baixa qualidade. Para obter uma boa qualidade de software, basta cuidar de um código limpo. Não vejo nenhum problema em confirmar melhorias no código de outras pessoas, outras devem estar cientes e agradecidas por que existem codificadores que trabalham em seu código.

Se você puder descobrir uma maneira melhor de resolver o problema sem usar "goto", sugiro que siga em frente. Um pouco de esforço para melhorar o código hoje pode economizar muito mais esforço no futuro.

Comunicar com o autor original também é uma boa ideia.

Não há nada implicitamente errado goto. Veja o código de montagem - muitos gotos (saltos e galhos) em todo o lugar.

A razão pela qual o gotonome é ruim hoje em dia é por causa da declaração Go To do documento de Dijkstra , considerada prejudicial, que identificou a declaração goto como uma coisa muito ruim.

Observe que isso foi há 50 anos em que a engenharia de software ainda não havia sido mencionada, e a maioria das linguagens de programação eram essencialmente abstrações da máquina subjacente, assim como a linguagem da máquina continha goto, o mesmo acontecia com elas. Você pode tentar programar alguns no Microsoft Basic (o original, na Apple] [ou Commodore 64) para ter uma idéia de como era essa mentalidade.

O que Dijkstra estava argumentando era que, para manter as coisas simples, não saltam por toda parte, mas, em vez disso, mantenha um caminho mais simples do programa com um final comum. Por exemplo, um retorno de um método. Em outras palavras - apenas saltos locais, não globais.

Este foi um passo para trazer coisas como chamadas de método com argumentos, modularização de código, pacotes etc., todos introduzidos para domar a complexidade do desenvolvimento de software. A declaração goto foi apenas o primeiro espectador daquela guerra.