Um desenvolvedor deve argumentar contra recursos desnecessários ou prejudiciais?

Qual é uma boa atitude dos desenvolvedores ao discutir novos recursos e, principalmente, recursos não críticos / questionáveis?

Digamos que você esteja desenvolvendo algum tipo de linguagem semelhante à Java, e o chefe diz: "Precisamos de indicadores para que os desenvolvedores possam mexer diretamente na memória do objeto!"

O desenvolvedor deve derrubar a idéia porque acrescenta complexidade inimaginável e vulnerabilidades de segurança, ou deve fazer o que é pedido?

Este pode não ser um bom exemplo, mas e as coisas que estão mais em uma área cinzenta, como adicionar botões que interrompem o fluxo de trabalho ou vão contra a estrutura interna do programa etc.?

Qual é a distribuição ideal "posso fazer" vs. "não posso fazer" para um programador regular?

EDIT: A pergunta não é sobre um chefe ruim: D

Eu estava mais interessado em saber como as pessoas abordam novos problemas que adicionam uma quantidade notável de problemas enquanto talvez sejam marginalmente úteis.

A atitude geral deve ser:

1. sim vamos fazer isso, estragar a complexidade
2. talvez
3. não, o retrabalho geral e as implicações não justificam a mudança

Qual deve ser a reação de um bom desenvolvedor?

O melhor é ter uma reunião e apresentar os prós e contras como um grupo, e com base nisso discutir a melhor solução. Se você tem uma equipe, peça que eles concordem com a solução. Quando uma equipe concorda em algo, gerentes e "chefes" tendem a seguir a solução.

Se seu chefe ainda não concorda, então você fez tudo o que pode: reuniu sua equipe e gerentes e cobriu os prós e contras e, apesar disso, seu chefe escolheu uma solução potencialmente inferior.

A chave para isso é discutir os prós e contras como um grupo. Ao fazer isso, você está discutindo qual é a melhor solução para sua equipe e, ao mesmo tempo, está apontando a decisão do seu chefe (antes que ele tome) sem a reação política de evitar o fato de dizer às pessoas por que você acha que a decisão do seu chefe foi o errado.

Essa é uma situação delicada que envolve política de trabalho, mas pode ser tratada de forma amigável.

Se o seu chefe lhe disser para executar tarefas estúpidas, você deve (por favor) explicar por que é estúpido.

Se ele ou ela não entender, você é obrigado a fazer coisas estúpidas. É isso aí. Ele é o chefe. Nesse caso, você pode simplesmente fazer o que ele / ela diz, ou conversar com o chefe ou mudar de emprego.

Você poderia dizer ao chefe que, embora seja tecnicamente possível, custará X uma quantia em tempo e dinheiro gastos em esforços em análise, design, para reescrever códigos existentes, testes, testes de regressão ... E então perguntar se o recurso vale a pena . Às vezes a resposta será "sim! Precisamos ter isso!", Às vezes será "não, acho que não".

Se o recurso solicitado violar algum princípio central do aplicativo (como "Adicionar um botão azul!" A uma interface do usuário especificada e projetada para ter apenas botões vermelhos conforme a solicitação do cliente), acho que está OK para perguntar "por quê?" e mencione que contraria o design pré-estabelecido.

No final, quase tudo o que é "pode ​​fazer" (pode não ser difícil, do ponto de vista técnico, adicionar um botão vermelho a uma interface do usuário apenas azul), é mais uma questão de "deve fazer?"

Para responder à sua pergunta editada, acho que a resposta deve ser # 2, "Talvez", aguardando investigação e análise adicionais.

Você não deseja responder # 1 "Sim, incondicionalmente" porque pode ficar preso ao se comprometer com algo que não é capaz de entregar no prazo especificado.

Você não quer responder # 3 "Não, é muito trabalho", porque parece que você está sendo pouco cooperativo e desnecessariamente difícil.

Da perspectiva de um desenvolvedor: NUNCA diga a ninguém que paga as contas que não pode ter o que deseja. Em vez disso, você pode dizer a eles que eles não podem pagá-lo por esse preço, ou que não podem pagá-lo exatamente da maneira que o concebiam originalmente.

Para o seu exemplo "ponteiro"; O .NET, um ambiente de código gerenciado, possui ponteiros. Eles são extremamente necessários para muita interoperabilidade com código não gerenciado. No entanto, o uso "seguro" deles é rigorosamente regulamentado e, se usado em código "não seguro", esse código exige permissões de segurança mais altas no tempo de execução. Se você estivesse desenvolvendo uma linguagem gerenciada que também exigisse acesso direto à memória por meio de ponteiros, poderia criar um esquema semelhante de organização dos bastidores onde pudesse, usando ponteiros gerenciados somente leitura, onde não era possível organizar automaticamente e permitir " verdadeiros "somente nas áreas mais confiáveis ​​da base de código.

Para seus exemplos de GUI: se você souber que um novo recurso "interromperá" o fluxo atual de código, poderá testá-lo e desenvolvê-lo com mais robustez para reverter qualquer trabalho anterior realizado pelo fluxo de trabalho. Seus clientes, e às vezes até seu gerente, geralmente não têm idéia ou interesse na estrutura do programa; se algo que eles querem é difícil devido à maneira como você estruturou o programa, por definição, a estrutura está errada porque não permite que você faça o que o cliente deseja.

Em todos os casos, esse novo recurso pode aumentar o escopo do trabalho necessário além do que o cliente pensava que seria. Por sua vez, isso exigirá uma extensão do cronograma, mais dinheiro e / ou uma redução de outro trabalho planejado.

No entanto, se você souber uma maneira de obter o mesmo resultado básico de uma maneira mais fácil ou lógica, isso poderá ser sugerido ao cliente. Embora eles definitivamente existam, felizmente ainda não vi um cliente que se recusou categoricamente a ouvir as opiniões dos desenvolvedores, especialmente em um ambiente Agile, onde há um "proprietário do produto" cuja única tarefa é conectar o desenvolvimento a vários detalhes necessários, como estes.

Se você passar muitos anos programando para aplicativos grandes, e pensar criticamente sobre isso ao longo do caminho, desenvolverá um senso aprimorado de quando um recurso causará problemas que superam sua utilidade. Outra palavra para isso é sabedoria , e assim como acontece com outros tipos de sabedoria, pode ser um desafio fazer com que aqueles que não têm percebam seu valor.

Outros pôsteres argumentaram que você deve tentar quantificar o custo do problema que será introduzido por um recurso problemático, e essa é uma boa idéia quando possível, mas geralmente não é. Geralmente, só é possível estimar custos de implementação imediatos. Mesmo isso geralmente é difícil para recursos maiores. Quanto aos custos futuros, você está em uma situação difícil. Você não sabe com certeza quais outros recursos serão necessários ou por quanto tempo o produto ficará em manutenção. O custo geralmente será muito maior do que você poderia fazer backup com uma estimativa baseada em fatos concretos.

Quanto mais competência você demonstrou no passado, mais margem de manobra terá para simplesmente declarar uma característica uma má ideia. Isso só pode vir com o tempo e um histórico demonstrado de sucesso. Dito isto, você deve sempre expressar vontade de atender à solicitação, pois é isso que seu cliente deseja. Você deve expressar reservas com base em sua experiência e, assim que possível, torna-se um não-problema em 90% dos casos, porque você iniciará uma conversa que chegará à raiz do problema, ou seja: Por que eles pediram para você adicionar esse recurso em primeiro lugar? Nesse ponto, você pode oferecer alternativas ou talvez concordar que, embora o recurso solicitado apresente problemas, ele ainda é necessário.

Claro que também é possível que você esteja errado. A engenharia de software não é divertida?

Como a pergunta é bastante vaga, vou generalizar um pouco com a minha resposta.

Sempre os questione, mas ouça o raciocínio deles. Às vezes, as pessoas esquecem a praticidade de um recurso ou quanto tempo a programação levaria. Por outro lado, às vezes nos prendemos à mentalidade de programador de ser eficiente / sem frescuras / etc, e esquecemos que o que consideramos não essencial para um projeto realmente não é para o cliente.

Se eles tiverem um bom motivo, informe-os quanto tempo levará para programá-lo e todos os possíveis obstáculos que você encontrará durante a implementação e veja se eles ainda desejam continuar. Caso contrário, explique por que você não acha que é uma boa ideia e veja qual é a reação deles. Enxague e repita.

A maioria já foi dita, mas há uma coisa que eu enfatizaria no meu ambiente de trabalho atual. Eu trabalho para uma empresa contratada por outras empresas e nossas aplicações estão relacionadas a processos de negócios (a uma quantidade razoável de vendas e comunicação com o cliente).

Os processos de negócios e os produtos que acompanham podem ser (pelo menos se a empresa for grande o suficiente) muito complexos. Até certo ponto, se você estiver modelando algo complexo, o aplicativo resultante terá uma complexidade relacionada. Como a maioria dos indivíduos das pessoas de negócios vê apenas sua parte do processo, o aplicativo / processo completo se baseia em uma complexidade maior do que o visível para apenas um usuário.

O que quero dizer é que, quando surgir um novo requisito de negócios, ele funcionará para o pessoal de negócios, porque não aumenta muito a complexidade, mas pode ter um impacto maior em todo o sistema. Na minha opinião, este não é um motivo para argumentar contra essa mudança. É o ponto certo para discutir os esforços (e as despesas) com o cliente. Provavelmente, não impedirá que o cliente construa esse recurso, mas com o tempo eles terão uma ideia dos aplicativos e algumas discussões sobre "uuh, você é tão caro!" será muito menos exigente.

Não sei se você está em uma situação comparável, mas aprendi que a situação das partes interessadas não tem necessariamente a mesma complexidade iminente como a que os desenvolvedores e arquitetos do sistema de TI enfrentam. Nessa situação, a comunicação ajuda os dois lados.

Com licença, mas essa pergunta parece um menor pedindo conselhos paternais. Se for esse o caso, o bom desenvolvedor precisará adotar estes mandamentos:

• Permaneça fiel a si mesmo. Se seu intestino se sentir desconfortável com um recurso, manifeste suas preocupações de maneira audível. As chances são boas de que a equipe esteja apenas aguardando uma abertura.
• Não tente substituir a experiência pelas regras práticas do experiente. Para você, toda situação é diferente, todo recurso é novo. Este é um plus que seus idosos não têm.
• O desenvolvimento de software não é ciência exata, nunca será. Portanto, acumule sabedoria, não comportamento.
• Aceite a derrota. Se a equipe concordar com o contrário, não repita suas preocupações ad nauseam.
• Pense positivo. Se a idéia realmente está implorando por 'derrubá-la', tente encontrar e nomear aspectos positivos antes de listar suas deficiências.
• Aprenda a interagir com as pessoas. Nós desenvolvedores frequentemente colocamos conhecimento técnico sobre competência social. As habilidades técnicas atingem o pico no início da vida, mas a competência social pode continuar crescendo até a aposentadoria.

Eu acredito em adiar requisitos ruins. Mas também acredito que, quando você dá o seu melhor para explicar por que eles são ruins e ainda os querem, você concorda e faz seu trabalho.

Por exemplo, tive pessoas que desejam requisitos mutuamente exclusivos de algo que o aplicativo já faz. Se eu fizer isso, isso será 100% garantido. Então, eu envio o requisito de volta e digo a eles que isso violará essa outra regra de negócios que já temos em vigor e eles também querem mudar essa regra? Frequentemente, o pequeno grupo que cria um requisito específico não tem acesso à visão geral do que o restante do aplicativo pode fazer. Na maioria das vezes, quando eu enviei um desses de volta, o cliente percebeu que a regra inicial era mais crítica e decidiu que a mudança que eles desejavam não valia a pena. Quando eles decidiram fazer a alteração, fizeram isso depois de consultar as pessoas que pressionaram o requisito inicial.

Às vezes, apenas fazer perguntas de esclarecimento fará com que vejam que o problema não é tão simples quanto eles pensavam. Às vezes, você quer perguntar por que eles querem algo e chegar à necessidade real que está impulsionando a mudança. Depois de entender isso, geralmente é mais fácil ver uma solução alternativa que funciona para você como desenvolvedor e atende às suas necessidades. Se você pode apresentar essa solução em termos de como ela atenderá melhor às necessidades deles do que a sugestão original, você aumentou muito suas chances de aceitar sua alteração.

Às vezes, quando uma mudança cria estragos em um nível básico no seu design, basta fornecer a nova estimativa de horas que a mudança levará para que seja desativada. Se você combinar isso com uma avaliação de risco que indique em que funcionalidade crítica você pode estar introduzindo novos bugs e diga a eles que serão necessárias seis semanas de esforço dedicado por três pessoas, de repente não será mais tão importante.

Mas às vezes você diz a eles que essa não é uma boa ideia e por que, e eles ainda dizem: "Pena que precisamos disso". Você ganha alguns e perde alguns e, às vezes, as necessidades da empresa realmente mudaram e o aplicativo deve acomodar isso. Uma vez finalizada a decisão, não é mais o momento de questionar o que você está fazendo e o tempo de fazê-lo. Se você documentou suas objeções, você ainda deve estar em um bom lugar quando exceder o orçamento e causar erros novos e mais interessantes. E eles podem até estar mais dispostos a ouvi-lo na próxima vez que você criar um histórico de estar certo nesse tipo de coisa.

A chave para vencer muitas dessas discussões (ninguém vence todas elas) é o primeiro a criar um histórico de conhecimento do que você está falando. Em seguida, envie um documento escrito que indique as preocupações que você tem (muitos gerentes são adversos ao risco, é mais provável que eles não desejem que alguém tenha um documento que os comprove errado mais tarde, para que prestem mais atenção ao que você coloca por escrito) e finalmente para garantir que eles entendam todos os custos (não apenas horas, mas riscos de segurança, introdução de novos bugs, prazos ausentes etc.) de fazer a alteração. A mudança não é gratuita e eles precisam entender isso. A próxima chave é fazer isso como um adulto e não como uma criança chorona ("mas eu não quero usar ... porque não gosto"). Faça um argumento comercial para não fazer isso e você terá muito mais em adiar um requisito ruim.

Se eu o leio corretamente, a verdadeira questão é sobre complexidade desconhecida. Inicialmente, li sua pergunta como: "Vejo o risco extremamente provável de excesso de complexidade, mas o chefe não." Mas você está dizendo que o chefe não é um problema, então suponho que não tenha certeza dos riscos. de adicionar complexidade inaceitável são.

Nesse caso, eu recomendaria algum tipo de estratégia de mitigação de riscos. Imagem que você está pensando em adicionar serviços WCF / web à sua API, o que pode ser incrível ou com muita complexidade sem recompensa:

• adicione o recurso em uma ramificação. Se funcionar, mescle-o. Se ele se transformar em um ninho de ratos, mate-o.
• inicie um novo projeto de uma página e faça uma prova de conceito. Se você não puder fazer uma prova de conceito em pouco tempo, solte-a. Se a prova de conceito funcionar, aumente e integre-a ao seu
• vasculhe a web em busca de pessoas que se interessam por esse recurso ou tecnologia. Onde há muitas dificuldades, uma tecnologia pode apresentar alguns riscos reais de complexidade excessiva. O Java Beans e o COM + são provavelmente antigos, mas bons exemplos de recursos que realmente aumentaram a complexidade e podem ou não ter sido fornecidos no lado dos benefícios da equação

Argumente não. Discuta possivelmente sim. Mas deve ser tratado como um complemento à especificação e priorizado com outros recursos. Se você souber que a solicitação incluirá uma quantidade razoável de tempo e complexidade para implementar, informe-a com antecedência. Não como oposição a fazer a solicitação, apenas como uma explicação do que você acha que será necessário para implementar.

Depende muito da solicitação. A implementação do ponteiro é grande o suficiente para efetivar um projeto inteiro; portanto, seus méritos devem ser ponderados se for possível.

Implementando um botão que interrompe o fluxo. Talvez não seja tão importante se o formulário puder ser organizado de forma que o botão seja opcional. Eu fiz exatamente isso de fato. Eu adicionei o botão, mas também coletei informações suficientes antes da mão para que o botão se tornasse opcional. Os usuários que esperavam que ele estivesse lá o usavam e aqueles que percebiam que era apenas redundante não.

É tudo uma questão de equilíbrio e saber quando escolher suas batalhas. Algumas coisas são mais fáceis de implementar de qualquer maneira versus lidar com os aspectos sociais de não incluí-la.

O problema que vejo é o uso da palavra argumentar.

Você deve trazer à tona questões de design e o raciocínio por trás delas, mas tenha cuidado, pois os programadores tendem a ficar na defensiva em relação às posições que assumiram e argumentam pontos apenas para argumentar (Às vezes). Eu tenho que parar de discutir um pouco - e nem sempre tenho sucesso. Além disso, à medida que envelheço, percebo que estou errado com mais frequência do que costumava ser - ou pior, não reconheci com que frequência estava errado :)

Se você tiver declarado requisitos claramente (o idioma deve ser seguro, precisamos de indicadores para acessar rotinas herdadas), você poderá apresentar como os dois requisitos conflitam e perguntar qual é o mais importante. Depois de ter os requisitos e as razões por trás deles, você poderá até encontrar uma solução completamente diferente que suporte os dois requisitos (JNI - mais ou menos).

Se não, bem, talvez seja um bom momento para codificá-los!

1. Perceba que você não sabe tudo e não pode fazer tudo.

2. Se você tem certeza de que é uma má ideia, diga o que é ruim.

3. Se eles tentarem pressionar você, diga: - Precisa de mais tempo para analisar, se precisar de mais tempo ou diga que não encontramos uma boa solução para esse problema.

4. Se eles ainda insistirem em implementar a má ideia, peça a eles que você o aconselhou, incluindo seus motivos. Você pode até enviar um email resumindo a discussão com uma cópia para o seu gerente. Isso pode salvar seu a ** mais tarde.

Em um cenário ideal, você teria um desenvolvedor líder que toma decisões finais no lado técnico e um líder comercial que toma decisões finais no lado comercial. Isso responderia às duas perguntas principais:

1) O que? O que o cliente quer?

2) como? Como podemos fazer isso do ponto de vista da tecnologia.

O que o cliente quer é o tomador de decisão final, pois é ele quem paga as contas

Como desenvolvedor, você realmente não deve se importar com os requisitos que devem ser implementados.

No entanto, você deve explicar se algo não é realista e se existem maneiras melhores.

Às vezes, é realmente o pedido do cliente (vindo da política interna do cliente). Então, é impossível e deve ser feito (mas a gerência também deve considerar se continua esse projeto ou se deve renegociar o preço).

Isso é quase uma tarefa do dia a dia para mim e, de fato, estou feliz que seja.

Se você tiver a alteração para opinar sobre se determinado requisito deve ou não fazer parte do aplicativo, pessoas não técnicas esperam que você preencha seu conhecimento técnico (por exemplo, "usar ponteiros tornaria o aplicativo instável" ou "usar um parâmetro GET para X é um risco à segurança "). Os técnicos também gostariam de receber seus comentários sobre alguma vantagem ou desvantagem específica sobre a qual eles talvez não tenham pensado.

É claro que é difícil quando todo mundo quer o recurso X e você acaba dizendo "pode ​​não ser bom", mas no final, todo mundo está tentando criar um aplicativo seguro, robusto e estável (sustentável, flexível, etc ... ) e toda voz deve contar.

Respondendo à sua pergunta, não faz parte do trabalho de um desenvolvedor (ou seja, desenvolver), mas é um "extra" que oferece qualidade e trabalho em equipe.

Se você está em posição de entender os contras de fazê-lo (complexidade, falta de usabilidade etc.), é do interesse de todos que você o explique da melhor maneira possível. Geralmente, os não desenvolvedores não entendem os problemas de adicionar novos recursos. É fácil para eles, porque eles não precisam fazer nada ou sequer pensar nisso.

No entanto, se os poderes decidirem que o novo recurso será adicionado, você deverá fazer o melhor trabalho possível. É um desafio.

E, se o novo recurso é muito estúpido ou o ambiente de trabalho é muito ruim, é hora de encontrar outro emprego.