Sobre produtividade e SLOC
O problema com o SLOC
O problema com a métrica SLOC é que ela mede uma aproximação da quantidade de código gravado, sem levar em consideração:
- a qualidade do código (por exemplo, e se, para cada 100 SLOC, você tiver que adicionar outros 90 SLOC por causa de bugs, mas que você não sabe no momento em que seu código é entregue?)
- os objetivos alcançados com o código (por exemplo, o SLOC de 10K lida com todos os casos de uso ou histórias de usuários esperados? ou apenas com um pequeno subconjunto?)
- a manutenção do código (ou seja, você precisará adicionar 1% ou 50% a mais de código para ajustar o código aos requisitos em evolução esperados?).
Em outras palavras, a produção de código espaguete não-sustentável, suscetível a erros e com muitas peças coladas, será considerada mais produtiva do que o código reutilizável cuidadosamente projetado.
Portanto, o SLOC definitivamente não é a melhor maneira de medir a produtividade.
Que produtividade estamos considerando?
A produtividade é medida para um processo. Portanto, o SLOC pode ser um indicador perfeitamente válido apenas para o processo de codificação.
Se, por exemplo, você não entende os requisitos ruins, gasta cinco meses para produzir o software, mostra ao usuário, descobre que está errado e gasta mais 5 meses para reescrevê-lo para o zero, você teria a mesma produtividade no SLOC / mês, uma equipe que escreveu o código logo na primeira vez, por exemplo, porque usou um processo ágil que reduz mal-entendidos por meio de feedback frequente. Essa produtividade aparentemente aparente esconde enormes problemas.
Portanto, medir a produtividade do desenvolvimento de software precisa levar em consideração todo o processo, incluindo a análise de requisitos, o design do código, a codificação, o teste, a depuração e a verificação de que as expectativas do usuário são atendidas. Como todas essas atividades são muito diferentes, o melhor é medir o único pensamento que importa: software em funcionamento, ou seja, o que o software produzido significa para o usuário .
Como medir as entregas de software?
Existem várias abordagens:
- A abordagem típica na engenharia clássica de software é o Function Points (FP). Os pontos de função são medidos com base nos requisitos a serem preenchidos (por exemplo, número de formulários, número de campos em cada formulário, etc ...). A produtividade é então medida em PF por unidade de tempo e por pessoa. Algumas empresas ainda têm dados que informam quantos pontos de função um desenvolvedor pode produzir por unidade de tempo em um determinado idioma para um determinado domínio. O problema com o FP é que ele exige requisitos muito detalhados antecipadamente e consome muito tempo.
- Uma abordagem mais moderna e pragmática é o story points (SP). Eles são usados para avaliar a complexidade do código a ser produzido e são rotineiramente usados para avaliar a velocidade das equipes de desenvolvimento. No entanto, SP é uma medida de estimativa do trabalho realizado antes que todos os detalhes sejam conhecidos. Não é uma medida final do que realmente aconteceu. Portanto, alguns cuidados devem ser tomados ao usá-lo como uma medida de produtividade, pois podem sair pela culatra no processo de estimativa .
Sobre a produtividade da digitação estática versus dinâmica
Tenho que confessar que sou pessoalmente fã de linguagens de tipo estaticamente, porque no meu íntimo sei que é mais confiável (anos de codificação me provaram isso).
Então, uma coisa que eu tenho certeza é que a linguagem de tipo estaticamente é capaz de evitar muito mais erros / bugs em tempo de compilação (por exemplo, erros de digitação, incompatibilidade nos tipos esperados, etc ...) do que as línguas de tipo não estaticamente. Mas, com toda objetividade, eu não ousaria generalizar abusivamente isso como uma produtividade mais alta.
Seu arquiteto está certo?
Talvez talvez não.
Mas seus argumentos não parecem válidos: o ganho de produtividade da linguagem de tipo estaticamente vem de um número significativo de erros que são detectados antecipadamente pelo compilador.
Consequentemente, não é possível descobrir esse ganho "mais alto" de produtividade observando apenas o SLOC sem observar o retrabalho necessário para linguagens de tipo dinâmico. Portanto, a comparação dele não pode ser justa.
O argumento de circunstâncias comparáveis também não é válido. Algumas linguagens de tipo dinâmico permitem algumas construções de nível superior que exigem menos código do que fazer o mesmo em uma das linguagens de tipo estaticamente clássicas. Portanto, você pode precisar de menos tempo, escrever menos código, mas adicionar a mesma sobrecarga de análise, teste e verificação. Portanto, medir a produtividade pelo SLOC diluiria os possíveis ganhos de produtividade, criando assim um viés contra a linguagem digitada dinamicamente.
Algum estudo para apoiar essa afirmação?
Existem vários estudos acadêmicos recentes sobre o tema. Embora alguns deles vejam uma vantagem da digitação estática, em geral se limita a uma finalidade específica (documentação, reutilização de código ou API mal documentado, etc.). As palavras prudentes também são usadas porque o IDE moderno reduziu significativamente os riscos relacionados à digitação dinâmica: