O que você gostaria que os desenvolvedores fizessem diferente? [fechadas]

Como desenvolvedor, passo a maior parte do tempo pensando no código, na interface do usuário, nas estruturas de dados e assim por diante, mas (admito bravamente) não costumo considerar as implicações do meu aplicativo para administradores de sistemas e DBAs até a hora de implantar a aplicação.

Em primeiro lugar, me desculpe. Em segundo lugar, o que você gostaria que eu, e outros desenvolvedores com os quais você lida, faria diferente? Que coisas facilitariam sua vida, causariam menos problemas, incentivariam a cooperação e reduziriam falhas, problemas de desempenho e pesadelos de configuração?

1. Pense e crie segurança a partir do dia 0.
2. Use o controle de versão para tudo: código fonte, documentação, configuração etc.
3. Documentação, documentação, documentação.
4. Instalação e desinstalação limpas, usando o pacote nativo da plataforma
5. Separe os dados de configuração das bibliotecas e executáveis
6. Suporte para executar versões diferentes em paralelo para teste e migração
7. Registro robusto e configurável
8. Monitoramento leve, preciso e seguro
9. Ponto de verificação e backup de aplicativos
10. Como seu aplicativo reage a problemas: falta de memória, sistema de arquivos cheio, rede inativa, arquivos de configuração ausentes / corrompidos, tempo incorreto?
11. Sempre tenha ambientes separados de desenvolvimento, teste e produção. Com todo o software gratuito da VM, não há desculpa!

Lembre-se de que seu aplicativo provavelmente tem mais estados do que ativado ou desativado. Desenhe um diagrama de estado. A maioria dos aplicativos possui estados como:

• baixa
• inicializando
• recuperação
• trabalho-mas-não-aceita
• esperando
• ponto de verificação
• em processamento
• terminando
• desligando
• baixa

Pense no que acontece se o sistema travar durante cada estado. Como um administrador de sistema monitora e controla as transições de estado?

Distinguir o "usuário" da SA.

Um "usuário" precisa saber como usar seu software. Os usuários não se importam com coisas como instalar o software.

A SA não se importa com o uso do software, mas precisa conhecer alguns detalhes críticos sobre como instalar o software.

Escreva a documentação separadamente para cada uma dessas funções, incluindo as informações relevantes para cada uma delas.

Um dos meus desejos é a inclusão de mensagens apropriadas em exceções e códigos de erro. É completamente opaco para alguém que não desenvolveu o aplicativo, o que isso JimmyNotAtHomeException: it's late!significa.

Mas uma mensagem como esta Unable to find jimmy - initial manual call_mother procedureé muito útil.

Comunicação, comunicação, comunicação. Todo problema entre um administrador de sistemas e um desenvolvedor sempre pode ser rastreado até a falta de comunicação. Se antes de um projeto os administradores do sistema (ou um representante dos mesmos) e os desenvolvedores se reuniam e tinham uma boa discussão sobre o framework, SOOOOOOOOOO muitos problemas poderiam ser evitados na linha. Não sei dizer quantas coisas foram complicadas porque você desenvolve todo mundo em uma caixa em desenvolvimento apenas para vê-lo entrar em chamas no prod porque o aplicativo é separado no servidor de aplicativos + servidor de banco de dados + servidor de interface etc. Parabéns por abordar este tópico.

Envolva-nos no início do projeto. Como real bem cedo, no estágio de especificação funcional.

Outra pessoa mencionou ter que instalar manualmente em todos os PCs, mas o mesmo se aplica às alterações de configuração. Se você optar por armazenar algo como as strings de conexão do lado do cliente e precisar atualizá-las regularmente, provavelmente desejaremos matá-lo .

Escolha uma tecnologia que possa ser adequadamente gerenciada e configurada centralmente, pelo mesmo motivo. Verifique se ele se integra bem a quaisquer ferramentas de gerenciamento central que usamos.

Sempre teste usando o menor denominador comum. Isso significa que, como não administrador, no sistema operacional mais primitivo, na suíte de aplicativos e na plataforma do navegador em uso comum. Não gostamos de ter uma atualização necessária do navegador para todos os nossos usuários chegarem a nós no último minuto possível.

Não pule para nos culpar quando as coisas derem errado. No meu antigo emprego, toda vez que um aplicativo quebrava, os desenvolvedores apontavam instantaneamente o dedo para nós. "Você instalou um novo patch, não atualiza navegadores, sua segurança é muito rígida" ou o que for. Isso gera uma atmosfera destrutiva. Estamos do mesmo lado, realmente, e queremos trabalhar com você para consertá-lo, mas não podemos nesse tipo de circunstância.

Não seja elitista.

"Não perca meu tempo, amigo. Você é apenas um administrador de sistemas; eu escrevo o software e você apenas o repara . Então cale a boca com suas preocupações mesquinhas e faça o que eu digo, ok?"

Um desenvolvedor realmente disse essas palavras para mim uma vez (1). Em email. CC'd para um grande grupo de distribuição. A implicação era clara: como desenvolvedor, ele era o senhor e mestre de todo o universo do software; e eu era simplesmente uma diarista contratada para lidar com tarefas triviais demais para ele desperdiçar seu precioso tempo. É claro que este é um exemplo do pior dos casos, mas você sabe, eu ouvi ecos fortes e fracos desse comentário de vários desenvolvedores antes e depois (2).

Você pode ganhar mais dinheiro do que eu (mas não assuma!). Mas é preciso uma equipe para construir, operar e manter os sistemas nos quais nossos usuários confiam. Em última análise , todos nós os servimos.

Entendo que seu trabalho e suas habilidades são diferentes das minhas. Eu respeito suas habilidades. Espero que você responda minhas perguntas, mesmo quando elas parecerem elementares e estúpidas para você. Eu retornarei alegremente esta cortesia!

Não estou em uma louca viagem de poder, como muitos desenvolvedores ruins (ou simplesmente indiferentes) disseram, pensaram e publicaram em vários fóruns. Mas minhas preocupações são diferentes das suas e minhas perguntas e sugestões não estão a serviço do meu ego. Na verdade, meu trabalho é fazer com que você pareça melhor, mantendo seus aplicativos em perfeitas condições de execução, disponíveis e receptivos a todos os usuários. Para fazer isso, tenho que manter o restante da rede e dos sistemas também funcionando em perfeitas condições.

Estou ciente de que você já encontrou administradores estúpidos, loucos por poder e / ou simplesmente preguiçosos. Estou tentando não ser um e não parecer um. Se você deixar espaço para essa possibilidade e a reconhecer quando a vir, tenho certeza de que conseguirá o que precisa enquanto os outros idiotas ainda estão furiosos com o idiota do administrador de sistemas.

(1) Ele também estava insistindo que seu programa (uma ferramenta para escrever e gerenciar requisitos de software) precisava de privilégios de administrador de domínio para instalar e executar. Foi um grande risco de segurança.

(2) Também trabalhei com muitos desenvolvedores incríveis que poderiam ensinar quando necessário e aprender quando necessário.

Respeite que os administradores de sistemas tenham um trabalho a fazer e deixe-os fazer seu trabalho. Muitas empresas têm administradores de sistema incompetentes e isso geralmente não é realista. Mas vi desenvolvedores arrogantes ignorarem o conselho de grupos de sistemas, mesmo depois que os administradores de sistemas provaram sua competência.

Discuta o design de um novo sistema com sysadmins. Muitas vezes há informações valiosas. Os desenvolvedores costumam analisar as discussões com os administradores de sistema e fornecer os requisitos iniciais como "otimização prematura". Na verdade, vi o chefe de um grupo de desenvolvimento dizer que era um desperdício de tempo discutir os requisitos para novos servidores de banco de dados com administradores de sistema e DBAs, até o ponto de descrever se é uma carga com muita gravação ou muita leitura, ou quanto armazenamento seria necessário.

Discuta problemas de desempenho com administradores de sistemas. Honestamente, apenas os administradores de sistemas são capazes de interpretar adequadamente as métricas de desempenho nos sistemas. Eu vi desenvolvedores decidirem que o Linux sempre vaza memória porque a memória livre relatada por "free" sempre diminui, mesmo após a décima vez, a saída de "free" é explicada.

Não tire conclusões sem discutir com os administradores de sistemas. Vi desenvolvedores ficarem presos a teorias como "os bancos de dados estão sempre conectados ao disco" (eles nem sabiam que o iostat sequer existia), "o RAID 5 é mais rápido para cargas de trabalho transacionais" (com base na lembrança de um sistema de banco de dados que foi movido de uma plataforma de hardware para outra - era uma carga de trabalho com muita leitura, a solução RAID5 tinha unidades cada vez mais rápidas espalhadas por mais controladores.

Não projete uma solução para um problema de sistema sem discuti-lo com os administradores de sistemas. Trabalhei em um ambiente patológico em que os desenvolvedores projetavam uma solução e vinham pedir pequena assistência à implementação. Os membros do grupo Unix, além de mim, o chefe do grupo Unix e seu chefe, queriam tratar os desenvolvedores como "clientes", não como colegas de trabalho que tentam fazer uma infraestrutura geral funcionar. Estar sempre certo significava não questionar o que estava fazendo ou por quê. Eu era o único que insistiria em ter o problema descrito para que uma solução correta pudesse ser determinada. Não aja de maneiras que criem ambientes patológicos como esse. Isso não resulta em um benefício líquido - em vez disso, os gerentes de sistemas agirão defensivamente e todos sofrerão.

Você não está mais na escola. Estes são sistemas do mundo real e eles não agem da maneira ideal. Por exemplo, nem tudo tem latência zero. Quando um administrador de sistemas avisa que as soluções de cluster são apenas para fins políticos e a complexidade adicional do sistema diminui a confiabilidade geral, leve isso a sério. Você precisa criar modos de falha no mundo real; por exemplo, quando você perde o servidor com o qual está falando via TCP, a conexão provavelmente não será redefinida para você. Os administradores de sistemas compreendem os modos de falha do mundo real.

Ouça o que o administrador do sistema lhe diz ou reclame à gerência que seus administradores são incompetentes e precisam ser demitidos. Ignorar o administrador do sistema não faz sentido.

Considere como você implementará seu aplicativo. Perceba que discutir isso com seus administradores de sistemas faz sentido. Se você tiver 100 servidores idênticos, diferindo apenas com base em um único arquivo de configuração, considere armazenar as cópias principais desses arquivos de configuração em um local central. Perceba o quão melhor é para todos se o seu aplicativo for fácil de reimplementar. Se houver um problema com um sistema, você prefere reimplementá-lo em menos de um minuto para um sobressalente ou esperar por séculos enquanto o quebrado é reparado? Se você puder reimplantar seu aplicativo, o sistema operacional poderá ser atualizado com mais facilidade e segurança. Você pode se preocupar com isso no futuro.

Se você tiver um problema que acha que pode ser devido ao sistema operacional, faz sentido chamar imediatamente o administrador do sistema para fazer o check-out. Mas depois que uma investigação superficial não revela nada, você tem o dever de explicar o problema.

Entenda que existe uma diferença entre "responder devagar" e "não responder nada".

Configure e expanda as coisas de maneira previsível, com maneiras previsíveis de alterá-las para o SO que você está desenvolvendo. Isso significa tudo. Por exemplo: o OpenLDAP possui uma maneira estranha de executar níveis de log; certos servidores IMAP nem sequer possuem arquivos de configuração, mas devem ter opções compiladas; alguns pacotes desejam que suas coisas estejam em um caminho de diretório específico, o que inevitavelmente quebrará as convenções de um sistema operacional específico. Todas essas coisas se destacam como verrugas nas minhas configurações habituais.

É uma regra geral, mas não assuma que você é especial e, portanto, abençoado por violar as convenções gerais de como os pacotes de software geralmente funcionam em sua plataforma, a menos que haja uma boa razão inerente ao seu software que o exija. "Eu sinto fortemente que isso deve ser assim" não é bom o suficiente para quebrar a configuração usual de todos; deve ser um motivo conectado à função que seu software está tentando executar.

Quando houver comunicação entre servidores envolvida com o aplicativo, inclua pelo menos um administrador de sistema na fase de design. Além disso, documente claramente as dependências de outros serviços: SQL, SMTP, HTTP, etc ... Não nos faça adivinhar o que você está fazendo ou não podemos ajudá-lo quando algo não está funcionando como o esperado.

Torne possível implantar seu software em dezenas ou centenas de sistemas de maneira automatizada. Se uma organização precisa de um pacote de software, os administradores de sistemas quase certamente não têm tempo para instalá-lo manualmente em todas as caixas. Se um arquivo precisar ter informações de licenciamento, documentar como fornecê-lo seria um grande benefício.

A Adobe historicamente teve alguns instaladores que eram uma verdadeira dor de se trabalhar ; por favor, mire mais alto que isso!

Pense em dimensionar desde o primeiro dia. Os administradores de sistemas podem fazer maravilhas jogando dinheiro / hardware em um problema de desempenho, mas algumas vezes nenhuma quantidade ajudará - em particular pensar em bloqueio - às vezes você não pode se livrar de um problema de bloqueio. Obrigado por perguntar :)

Ah, e tente ser de 64 bits, sempre que possível, e multi-threaded também :)

Design para operações.

Além de tudo aqui ...

• Solicite um ambiente de produção simulado (um servidor de desenvolvimento ou VM com a mesma configuração do servidor ativo) e use-o para testar o processo de liberação. Em seguida, forneça esse processo de liberação, incluindo uma lista de alterações e a ordem em que elas devem ser aplicadas (por exemplo: 1. Entre no modo de manutenção, 2. aplique a atualização SQL, 3. atualize a fonte para a versão X, 4. deixe o modo de manutenção, 5. rezar)
• Verifique se você possui um modo de manutenção que pode expulsar os usuários para manter a integridade dos dados. Você não quer que executemos uma grande atualização do sistema em vários servidores com usuários conectados e executando transações ... essa é uma receita para falhas na maioria dos casos.
• Use um modelo de desenvolvimento que seja um pouco padronizado. Por exemplo, todos os nossos novos aplicativos no trabalho (grupo da web) usam o Zend Framework.
• Forneça-nos os registros de alterações que podemos ler, incluindo uma lista de bugs corrigidos que podemos procurar para ter uma idéia do escopo das alterações. Às vezes, podemos identificar problemas em potencial apenas porque temos um ponto de vista diferente.

Embora irrealista, seria útil se os desenvolvedores fossem forçados a trabalhar em um sysadmin de produção ou função dba antes de serem lançados no mundo.

Tantas aplicações especializadas com as quais eu lido não têm idéia da instalação em um ambiente gerenciado ou cometem atrocidades no design do banco de dados.

1) O arquivo de log que registra os erros em detalhes. ou um bom sistema de rastreamento de erros como o ELMAH.

2) A documentação detalhada para instalação, implementação e guia de SA.

3) Além do material mencionado acima de outras SAs incríveis. :)

É tudo o que consigo pensar agora.

O livro Release It! tem uma boa seleção de histórias de horror sobre o que pode dar errado na produção. A leitura pode fornecer inspiração / idéias para o design, com as operações em mente. (Foi escrito por Michael Nygard, que trabalhou nos setores de desenvolvimento e operações.)

• Não desenvolva sem especificações
• Documento (ou garantir que aqueles que o documentam o façam com precisão)
• Não tenha medo de oferecer suporte ao cliente (como um nível de suporte de nível superior)

Na minha experiência, o que faria mais diferença é se os desenvolvedores pensassem na implantação a partir do dia 1. Assim que você começar a conceber um novo recurso no ambiente de produção / cliente, comece a pensar em como ele será implantado nesse ambiente e como ele será executado.

Depois que eles entram no processo de desenvolvimento, não é tarde demais, mas pode levar algum tempo até que eles possam mudar sua perspectiva até agora; eles não percebem o quão abstratamente estão visualizando a base de código até serem forçados a enfrentá-la. Na mente deles, é apenas um "componente". De particular interesse é como ele será implantado em um ambiente pré-existente , executando a versão anterior (ou mais antiga!) Do software. As discussões de implantação podem ter um impacto significativo sobre como a arquitetura é ajustada para acomodar o novo recurso.

Algo que gosto que ainda não vi é Configurável. Se você possui um aplicativo que usa qualquer tipo de arquivo de configuração, torne tudo configurável.
Na minha empresa, escrevi um aplicativo simples que exportará um pedaço do banco de dados. Na semana seguinte, eu estava reescrevendo-o para permitir que uma pequena parte fosse desligada. Toda semana, desde então, tive que reescrever partes e reconstruí-las apenas para alterar um pequeno recurso. Acabei de adicionar apenas um arquivo de configuração xml e agora é muito mais fácil reimplementar.
Eu amo arquivos de configuração.

Desejo que os desenvolvedores tenham uma melhor separação das tarefas de QA. Eu acho que é bom quando um desenvolvedor é capaz de criar alguns casos de teste de unidade para um projeto em que está trabalhando, mas seria bom se esses testes fossem passados ​​para o controle de qualidade. De fato, é bom quando os desenvolvedores dão uma pequena ajuda aos engenheiros de controle de qualidade, pois beneficia o DEV no final.

Verifique se ele é suportável: além de tudo o mais mencionado aqui, consulte esta postagem no SO - https://stackoverflow.com/questions/205374/what-are-the-core-elements-to-include-in-support- documentação/