Liberando software de código aberto muito cedo [fechado]

Qual é a responsabilidade moral de lançar software de código aberto muito cedo? Por exemplo, um produto quase completo que ainda não foi totalmente testado.

Qual é a expectativa do programador? Aguarde até que ele seja totalmente testado ou libere para o código aberto e continue com o desenvolvimento, teste e avanços?

O medo é que o software seja de código aberto e possa levar a problemas para os consumidores.

Esse é um medo infundado?

Acredito, pelo contrário, que você deve lançar um software de código aberto o mais rápido possível. Não existe "muito cedo" para isso (mas deve ser compilado).

^{Ou, pelo menos, publique o código fonte muito cedo e continuamente (por exemplo, pressionando frequentemente o github ), sem fazer lançamentos formais .}

No entanto, é muito importante sinalizá-lo como estágio alfa ou beta e, se possível, dizer (por exemplo, em um arquivo READMEou TODOem algum blog, etc ...) o que está faltando, não testado ou em mau estado. Você também deve usar o número da versão para transmitir essas informações.

Com o software livre , o melhor que deve acontecer é que alguém examine o código-fonte e proponha um pequeno patch para aprimorá-lo. É por isso que você torna seu software livre!

^{Portanto, você precisa tornar visível o seu trabalho diário no seu software livre! Os contribuidores externos ficariam chateados se o patch deles não funcionasse ou é uma duplicata do seu código-fonte recente de software.}

O que você deve ter medo é que ninguém se interesse pelo seu software (e contribua com ele). Atrair interesse externo para um software livre (em particular, atrair colaboradores externos) é uma longa jornada.

TL; DR:

Lançamento antecipado. Lançamento frequentemente.

Anedota pessoal:

Fiquei realmente empolgado com o projeto em que estava trabalhando. Tipo, muito animado. Eu não conseguia dormir animado à noite. Então, forcei meu co-dev a lançar a v1.0 mais rápido do que ele queria.

Foi terrível. Nada funcionou como deveria. Havia bugs a cada passo, mas nós os registrávamos e os corrigíamos. Até alguns adotantes iniciais enviaram bugs que talvez não tivéssemos encontrado. Uma ou duas semanas depois, lançamos um novo release que abordava muitos problemas e voltamos a criar novos recursos.

Lançar cedo foi a melhor coisa que poderíamos ter feito. Ele colocou nosso produto na frente de usuários reais. Fazendo esses bugs expostos, podemos ou não ter encontrado e aperfeiçoado nosso projeto. Também permitiu que os primeiros usuários saibam que levamos a sério esse projeto. Haverá mais lançamentos e desenvolvimento ativo.

Poderia facilmente ter ido para o outro lado também. Poderíamos ter ignorado esses relatórios de erros. Ou não poderíamos ter reagido rapidamente. Poderia ter sido uma história diferente se levássemos três meses para lançar a versão 1.1 em vez de algumas semanas.

É o mesmo que com o software de código fechado. A comunicação é importante.

Informe aos usuários qual é o estado do software e por que ele está disponível para download.

O software sempre levará a problemas do cliente, independentemente de ser totalmente testado ou não. A maioria dos clientes aceita esse fato, e alguns nunca. Mas se o software levar a mais problemas do que seria razoavelmente esperado, há uma obrigação moral de informar o cliente sobre o risco que está assumindo. As informações devem estar no formato abreviado (rótulos "Alpha / Beta / EarlyAccess") * e em detalhes: Uma lista de problemas conhecidos, soluções alternativas e considerações especiais, por exemplo, se é provável que os dados possam estar corrompidos.

* Esteja ciente de que os usuários foram treinados por algumas grandes empresas de software para pensar em "Beta" como um estado em que o software é bastante sólido; portanto, informar ao usuário que o software é "Beta" geralmente não é informação suficiente.

Não há responsabilidade moral alguma. Ninguém está sendo forçado a usar seu software pela metade.

A única coisa com que se preocupar seria sua credibilidade.

Minha experiência é que há um equilíbrio a ser alcançado.

No momento, estou trabalhando (no sentido de responder perguntas e fornecer sugestões de desenvolvimento, sem ver nenhum código) com um desenvolvedor que está produzindo o que parece ser um projeto FOSS muito emocionante que utiliza o código que eu escrevi. O lançamento público foi repetidamente atrasado pelas realizações de alterações no design que tornarão o projeto muito melhor a longo prazo, mas que exigem reescritas significativas de código que já foram escritas e que já estavam "funcionando". Minha opinião é que, se um lançamento imperfeito, mas imperfeito, tivesse sido feito assim que houvesse algo a ser mostrado, as idéias para mudanças (e correções reais) poderiam ter surgido da comunidade em geral que estava interessada neste projeto, acelerando-o para a frente em vez de ter os problemas aparecem lentamente, um de cada vez, enquanto o desenvolvedor pensa neles e pede feedback de design de mim e de outros membros interessados ​​da comunidade. Portanto, desse ponto de vista, sou muito defensor da "liberação antecipada, liberação frequente".

Por outro lado, lançamentos de baixa qualidade podem fazer com que um novo projeto pareça ruim antes mesmo de decolar. Algumas armadilhas que eu já vi incluem:

• Árvores de esqueleto com definições de interface, mas sem código.
• Código que não é compilado com êxito para ninguém além do desenvolvedor.
• Nenhuma instrução sobre como criar / executar o programa.
• Nenhuma documentação de quais aspectos podem funcionar.
• Descrição pouco clara do que o programa faz ou fará.
• Falta de qualquer demonstração de utilidade.

Para o último ponto, estou pensando em coisas como:

• Compilador / intérprete que não pode nem compilar / executar um programa do tipo hello-world.
• Emulador que não pode pelo menos executar um programa de amostra de algum tipo ou demonstrar que está fazendo alguma coisa.
• Ferramenta de processamento de imagem que não pode fazer nada além de carregar e salvar novamente a imagem não modificada.
• Jogo com nada além de uma tela de título.

Esse tipo de problema leva a uma imagem de "vaporware" que pode ser difícil de abalar, a menos que você esteja muito aberto sobre a falta de código de trabalho para começar.

Por fim, faça sentido os números de versão. Não chame seu projeto de "1.0" até que ele faça o que os usuários esperam que ele faça sem travar. Eu sempre tive sorte com o uso de números de versão em torno de "0,5" para o lançamento público inicial e a partir daí, mas também vi coisas como "0,1" ou "0,10" que fazem sentido.

Há um caso em que o lançamento de software livre pode ter consequências negativas. Algumas especificações são licenciadas ao público com a condição de que todas as implementações distribuídas ao público estejam em conformidade com a especificação completamente quando publicadas pela primeira vez. O editor proíbe-o legalmente de distribuir uma implementação de trabalho em andamento da especificação. Sem uma licença negociada específica do editor da especificação, você deve compartilhá-la com ninguém até que ela passe em todos os testes. Isso força um "modelo de catedral" (como Eric S. Raymond o chamou) nas implementações das especificações.

Uma especificação sob essa licença é a Java Language Specification . Essa restrição se aplica aos desenvolvedores de máquinas virtuais compatíveis com a JVM, mas, felizmente, não aos desenvolvedores de aplicativos executados em uma JVM.

O artigo " 4 Shifty Details About 'Open Source' .NET da Microsoft " de Liu Qihao & Ciaran O'Riordan menciona a possibilidade de interpretar a Promessa de Patentes da Microsoft para Bibliotecas .NET e Componentes de Tempo de Execução para excluir implementações incompletas do CLR de maneira semelhante . Mas, novamente, isso não se aplica a aplicativos executados no CLR.