O que causa um desempenho ruim nos aplicativos de consumo? [fechadas]

Meu Comcast DVR leva pelo menos três segundos para responder a todas as teclas pressionadas no controle remoto, tornando a tarefa simples de assistir televisão em uma experiência frustrante de pressionar botões. Meu iPhone leva pelo menos quinze segundos para exibir mensagens de texto e travar ¼ das vezes que tento abrir o aplicativo iPod; simplesmente receber e ler um email geralmente leva mais de um minuto. Até o navcom no meu carro tem controles moles e sem resposta, geralmente engolindo entradas sucessivas se eu as separar com menos de alguns segundos de diferença.

Esses são todos os aparelhos de consumidor final de hardware fixo para os quais a usabilidade deve ser fundamental e, no entanto, todos falham na capacidade de resposta e latência básicas. O software deles é muito lento .

O que há por trás disso? É um problema técnico ou social? Quem ou o que é responsável?

É porque todos eles foram escritos em idiomas gerenciados e coletados pelo lixo em vez de código nativo? Foram os programadores individuais que escreveram o software para esses dispositivos? Em todos esses casos, os desenvolvedores de aplicativos sabiam exatamente qual plataforma de hardware eles estavam alvejando e quais eram seus recursos; eles não levaram isso em conta? É o cara que anda por aí repetindo "a otimização é a raiz de todo mal", ele os desviou? Era uma mentalidade de "oh, são apenas 100ms adicionais" a cada vez, até que todos esses milissegundos somam minutos? É minha culpa, por ter comprado esses produtos em primeiro lugar?

Esta é uma questão subjetiva, com resposta única, mas estou muitas vezes frustrada ao ver tantas respostas aqui dizer "oh, não se preocupe com a velocidade de código, o desempenho não importa" quando claramente em algum momento ele faz questão de o usuário final que fica preso a uma experiência lenta, sem resposta e terrível.

Então, em que ponto as coisas deram errado para esses produtos? O que nós, como programadores, fazemos para evitar infligir essa dor a nossos próprios clientes?

Boa pergunta. O que eu vejo diariamente é isso.

As pessoas trabalham em aplicativos de bom tamanho. Enquanto trabalham, os problemas de desempenho aparecem, assim como os bugs. A diferença é - os erros são "ruins" - eles gritam "me encontre e me conserte". Os problemas de desempenho ficam lá e pioram. Os programadores costumam pensar "Bem, meu código não teria um problema de desempenho. Em vez disso, a gerência precisa me comprar uma máquina mais nova / maior / mais rápida".

O fato é que, se os desenvolvedores periodicamente apenas procurarem problemas de desempenho (o que é realmente muito fácil ), eles podem simplesmente limpá-los.

Em vez disso, o "estado da arte" é:

1. confiar em aforismos como "evitar otimização prematura" e 90/10 hoo-haw.
2. fale corajosamente sobre criação de perfil e, às vezes, tente, geralmente com resultados decepcionantes, como você vê em todas as perguntas sobre SO.
3. recorrer a boas velhas adivinhações, disfarçadas de experiência e conhecimento.

Mas sério, isso é negativo. Para ser positivo, esse método funciona quase o tempo todo e não poderia ser mais simples. Aqui está um exemplo detalhado .

Este não é um problema técnico, é um problema de marketing e gerenciamento.

Você pode estar revirando os olhos neste momento, mas por favor, tenha paciência comigo.

O que uma empresa vende é o seu "produto", e as pessoas que definem o que é isso são "gerentes de produto". Nas empresas de tecnologia, muitas outras pessoas avaliam isso - especialistas em experiência do usuário, yadda yadda. Mas, em última análise, os gerentes de produto são responsáveis ​​por escrever as especificações para o que o usuário deve obter.

Então, vamos levar o seu Comcast DVR. Idealmente, as coisas funcionariam assim:

1. O gerente de produto escreve em uma especificação: "Quando um usuário pressiona um botão no controle remoto e fica a menos de 6 metros do DVR, o DVR deve responder à impressora em 250 milissegundos".
2. O pessoal técnico constrói o hardware, escreve o software incorporado, etc.
3. Os testadores de controle de qualidade aprovam que o sistema atenda às especificações ou devolvem à equipe técnica uma correção.

Obviamente, muitas coisas podem dar errado:

• O gerente de produto falha ao colocar a resposta do botão na especificação
• O pessoal do controle de qualidade faz um trabalho medíocre de teste contra as especificações
• Alguém selecionou tecnologias que não permitem que as especificações sejam atendidas, de modo que o requisito é reduzido
• A equipe técnica é insuficiente ou alguém acelerou o cronograma e algum gerente diz: "Esqueça a capacidade de resposta - conclua esse outro recurso".
• O gerente de produto não publica o requisito de capacidade de resposta até tão tarde no jogo, que não pode ser atendido na data de envio
• A gerência decide não enviar nada para o teste de controle de qualidade até tão tarde, a aceleração do código lento desestabilizaria o produto

Você viu todos os programadores imprudentes lá? Não havia nenhum.

Não estou dizendo que não temos nenhuma responsabilidade pelo desempenho ruim - geralmente, é tão fácil e rápido escrever código bom, robusto e eficiente quanto escrever lixo.

Mas, realmente, se o gerenciamento de produtos e a equipe de controle de qualidade estão todos dormindo ao volante, nós programadores não podemos compensar isso.

FWIW, concordo plenamente sobre as interfaces abismais da maioria dos produtos de consumo. Eu escrevo o código da interface do usuário há cerca de 25 anos e me esforço por elegância e simplicidade. Na verdade, é um problema, porque eu penso muito nisso, agora estou péssimo em descobrir interfaces de usuário mal projetadas, para que minha pobre esposa acabe executando a maioria dos dispositivos em nossa central de mídia.

Porque programadores não são perfeitos.

Eu sou um programador de coisas incorporadas. Parte do meu código não é perfeito. A maior parte do meu código incorporado é rápida.

Corrigir problemas de desempenho no final de um projeto é muito difícil.

Às vezes, para manter as coisas simples (e, portanto, testáveis, desenvolvíveis em tempo realista, e não fatais), colocamos camadas de coisas, como a entrada remota em um "serviço" que não faz parte do aplicativo principal. Resultado final, latência. A alternativa é colocar tudo em um aplicativo monolítico - um desastre de buggy em C ou C ++ (as duas linguagens incorporadas mais comuns).

Às vezes, seu dispositivo incorporado possui um agendador de processos que não faz o que você deseja como usuário. Muito difícil de corrigir como desenvolvedor incorporado.

A complexidade causa o atraso, devido à latência em camadas. Você pediu os recursos. Experimente um Nokia realmente antigo, como o antigo 3210. UI rápida e compacta. Não há muitos recursos.

Estou argumentando que os desenvolvedores não ficam mais espertos, então o hardware mais rápido é absorvido pelas abstrações para impedir que os recursos se matem. (Ou não, no caso do seu iPhone)

O desempenho da interface do usuário precisa ser um requisito para o qual você testa à medida que o design avança.

Se não for especificado, o desenvolvedor se acostumará. Todos nós fazemos isso. "Meu bebê não é feio"

E não são os idiomas do GC; Java em tempo real incorporado é tão rápido que é assustador. (Python incorporado, por outro lado, é um cão total)

Eu escrevo um programa que as leituras alternam nas entradas digitais como a interface do usuário. Ainda temos que retirar o controle do switch, de modo que pressionar muito rapidamente o switch não funcionará, porque o cancelamento é um par de camadas acima. Idealmente, eu teria uma lógica de rejeição na parte inferior da pilha de firmware, mas não é assim que o hardware funciona.

Alguns aparelhos de DVD simplesmente executam um script "ejetar" para fazer ejetar. O DVR pode ter adotado essa abordagem para manter os custos de desenvolvimento saudáveis. Então você economiza na CPU ou RAM e é uma merda.

É porque todos eles foram escritos em idiomas gerenciados e coletados pelo lixo em vez de código nativo?

Não. O código lento terá um desempenho ruim, independentemente. Certamente, um idioma específico pode introduzir certas classes de problemas enquanto resolve outros. Mas bons programadores são capazes de encontrar soluções alternativas, com tempo suficiente.

Foram os programadores individuais que escreveram o software para esses dispositivos?

Parcialmente. Em muitos casos, é bem provável que seja pelo menos um fator contribuinte. Esse é um efeito colateral lamentável de um setor em que bons programadores têm alta demanda e pouca oferta. Também os abismos entre vários níveis de habilidade técnica podem ser bastante grandes. Portanto, é lógico que, às vezes, os programadores encarregados de implementar determinado software podem ser parabenizados apenas por fazê-lo funcionar (mais ou menos).

Em todos esses casos, os desenvolvedores de aplicativos sabiam exatamente qual plataforma de hardware eles estavam alvejando e quais eram seus recursos; eles não levaram isso em conta?

Parcialmente. Para começar, a plataforma de hardware exata provavelmente não é conhecida, pois é frequentemente negociada com vários fabricantes em paralelo durante o desenvolvimento do software. De fato, pode haver pequenas alterações (mas não necessariamente insignificantes) no hardware subjacente após o lançamento inicial. No entanto, eu concordo que as capacidades gerais serão conhecidas.

Parte do problema é que o software provavelmente não é desenvolvido no hardware, é feito em emuladores. Isso dificulta a contabilização do verdadeiro desempenho do dispositivo, mesmo que os emuladores sejam 100% precisos - o que não é.

Obviamente, isso realmente não justifica testes insuficientes no hardware de protótipo apropriado antes do lançamento. Essa culpa provavelmente está fora do controle dev / qa.

É o cara que anda por aí repetindo "a otimização é a raiz de todo mal", ele os desviou?

Não. Tenho certeza de que eles não o escutam; caso contrário, ele não seria citado com tanta frequência (isso deveria ser " otimização prematura ..."). :-D

É mais provável que muitos programadores tomem um dos dois extremos com relação à otimização.

• Ou eles o ignoram completamente.
• Ou eles se obcecam com minúcias que nada têm a ver com os requisitos reais de desempenho. O efeito líquido é que o orçamento se esgota e o código é ofuscado demais para otimizar com segurança os problemas reais de desempenho.

Era uma mentalidade de "oh, são apenas 100ms adicionais" a cada vez, até que todos esses milissegundos somam minutos?

Possivelmente. Obviamente, se Sleep(100)foi usado como o equivalente ao papel de seda usado para retardar o sangramento de um membro cortado - então os problemas são esperados. No entanto, suspeito que o problema seja mais sutil do que isso.

O problema é que o hardware de computação moderno (incluindo dispositivos incorporados) é muito mais rápido do que as pessoas lhes dão crédito. A maioria das pessoas, mesmo os programadores "experientes", não conseguem avaliar a rapidez com que os computadores são. 100ms é muito tempo - muito tempo . E, por assim dizer, esse "tempo muito longo" corta duas maneiras:

• A primeira é que os programadores se preocupam desnecessariamente com as coisas que um computador faz com extrema rapidez. (Acontece que foi apenas uma preocupação " incrementar um valor 300 vezes por segundo " que me levou aqui em primeiro lugar.)
• A segunda é que, às vezes, deixam de mostrar a devida preocupação quando as coisas demoram muito tempo (na escala de tempo da computação). Tão:
  • se eles ignoram os efeitos da latência ao se comunicar através de uma rede ou com um dispositivo de armazenamento;
  • se eles ignoram o impacto de um encadeamento bloqueado e aguardam outro encadeamento;
  • se eles esquecerem que, como os computadores funcionam tão rapidamente, é muito capaz de repetir uma tarefa com muito mais frequência do que deveria, sem que o desenvolvedor esteja ciente de um problema
  • ... se ocorrer uma combinação dessas omissões, uma rotina será executada inesperadamente muito lentamente (na escala de tempo da computação). Algumas repetições e até serão perceptíveis pelos seres humanos - mas pode ser difícil de definir porque centenas de coisas interconectadas estão correndo rapidamente sozinhas.

É minha culpa, por ter comprado esses produtos em primeiro lugar?

Sim definitivamente. Bem, você não pessoalmente, mas os consumidores em geral. Os produtos são vendidos (e comprados ) por listas de verificação de recursos. Poucos consumidores estão exigindo melhor desempenho.

Para ilustrar meu argumento: a última vez que eu quis comprar um telefone celular, a loja não conseguiu nem oferecer um modelo de demonstração para brincar na loja. Tudo o que tinham eram conchas de plástico com adesivos para mostrar como seria a tela. Você não pode nem sentir o peso dessa maneira - muito menos desempenho ou usabilidade. O que quero dizer é que, se um número suficiente de pessoas se opuser a esse modelo de negócios e votar com suas carteiras para expressar sua objeção, seríamos um pequeno passo na direção certa.

Mas eles não, então não somos; e todos os anos, os novos telefones celulares ficam mais lentos em hardware mais rápido.

(As perguntas não foram feitas.)

• O pessoal de marketing é o culpado? Parcialmente. Eles precisam de datas de lançamento. E quando essa data se aproxima, a escolha entre "fazê-lo funcionar" e "torná-lo mais rápido" é fácil.
• Os vendedores são os culpados? Parcialmente. Eles querem mais recursos na lista de verificação. Eles exageram nas listas de recursos e ignoram o desempenho. Eles (às vezes) fazem promessas irreais.
• Os gerentes são os culpados? Parcialmente. Gerentes inexperientes podem cometer muitos erros, mas mesmo gerentes muito experientes podem (com razão) sacrificar tempo para resolver problemas de desempenho em favor de outras preocupações.
• As especificações são as culpadas? Parcialmente. Se algo for deixado de fora da especificação, será muito mais fácil "esquecê-lo" mais tarde. E se não for indicado especificamente, qual é o objetivo? (Embora eu pessoalmente acredite que, se uma equipe se orgulha de seu trabalho, ela se preocupa com o desempenho, independentemente disso.)
• Culpa a educação? Talvez. Provavelmente, a educação sempre estará no pé traseiro. Eu certamente desaprovo a "educação" que produz rapidamente iniciantes com um desenvolvimento superficial de software de entendimento. No entanto, a educação que é apoiada pela teoria e instila uma cultura de aprendizado não pode ser ruim.
• As atualizações são as culpadas? Parcialmente. Novo software, hardware antigo realmente é destino tentador. Mesmo antes do lançamento da versão X, X + 1 está em planejamento. O novo software é compatível, mas o hardware antigo é rápido o suficiente? Foi testado? Uma correção de desempenho específica pode ser incorporada no novo software - incentivando uma atualização de software não recomendada.

Basicamente, acredito que existem muitos fatores que contribuem. Infelizmente, não há bala de prata para consertá-lo. Mas isso não significa que é desgraça e melancolia. Existem maneiras de contribuir para melhorar as coisas.

Então, em que ponto as coisas deram errado para esses produtos?

IMHO não podemos realmente identificar nenhum ponto único. Existem muitos fatores contribuintes que evoluíram ao longo do tempo.

• Contadores de feijão: redução de custos, timing do mercado. Mas, novamente, teríamos feito os avanços que alcançamos sem a pressão?
• Alta demanda e baixa oferta de pessoas qualificadas na indústria. Não apenas programadores, mas também gerentes, testadores e até vendedores. A falta de habilidades e experiência leva a erros. Mas, novamente, isso também leva ao aprendizado.
• Tecnologia de ponta. Até uma tecnologia amadurecer, ela irá morder regularmente de maneiras inesperadas. Mas, novamente, muitas vezes fornecia várias vantagens em primeiro lugar.
• Complicação composta. Com o tempo, a indústria evoluiu: adicionando mais ferramentas, tecnologias, camadas, técnicas, abstrações, hardware, idiomas, variação, opções. Isso torna um tanto impossível ter uma compreensão "completa" dos sistemas modernos. No entanto, também somos capazes de fazer muito mais em um tempo muito menor como resultado.

O que nós, como programadores, fazemos para evitar infligir essa dor a nossos próprios clientes?

Tenho algumas sugestões (técnicas e não técnicas) que podem ajudar:

• No sofar possível, use seu próprio produto. Não há nada como a experiência em primeira mão para revelar coisas estranhas, lentas ou inconvenientes. No entanto, você precisará evitar conscientemente contornar as deficiências devido ao "conhecimento interno". Por exemplo, se você não tiver problemas para sincronizar contatos porque o faz com um script Python backdoor - você não está usando "o produto". O que traz o próximo ponto ...
• Ouça seus usuários (de preferência em primeira mão, mas pelo menos em segunda mão através do suporte). Eu sei que programadores (geralmente) preferem ficar escondidos e evitar a interação humana; mas isso não ajuda a descobrir os problemas que outras pessoas enfrentam ao usar seu produto. Por exemplo, você pode não perceber que as opções do menu são lentas, porque você conhece todos os atalhos e os utiliza exclusivamente. Mesmo que o manual documente completamente todos os atalhos, algumas pessoas ainda preferem os menus - apesar de serem insuportavelmente lentos.
• Esforce-se para melhorar continuamente suas habilidades e conhecimentos técnicos. Desenvolva a habilidade de analisar criticamente tudo o que aprender. Reavaliar seu conhecimento regularmente. Em alguns casos, esteja preparado para esquecer o que achou que sabia. O que traz à tona ...
• Algumas tecnologias / técnicas podem ser muito complicadas, levando a mal-entendidos sutis e implementações incorretas. Outros, através da evolução do conhecimento comum ou das ferramentas disponíveis, podem cair ou desvalorizar (por exemplo, Singletons). Alguns tópicos são tão complicados que geram um monte de "especialistas em hocus-pocus" que propagam um enorme corpo de informações erradas. Um dos meus erros em particular é a desinformação em torno da multithreading. Uma boa implementação multithread pode melhorar significativamente a experiência do usuário. Infelizmente, muitas abordagens desinformadas do multi-threading reduzirão significativamente o desempenho, aumentarão erros erráticos, aumentarão os riscos de bloqueio, complicarão a depuração etc.
• Tomar posse. (Não, sério, eu não estou jogando bingo na sala de reuniões.) Negocie com gerentes, proprietários de produtos, vendedores para recursos de desempenho que tenham precedência sobre alguns itens da lista de verificação. Exija melhores especificações. Não infantil, mas fazendo perguntas que levam as pessoas a pensar em desempenho.
• Seja um consumidor exigente. Escolha o telefone que possui menos recursos, mas é mais rápido. (Não é mais rápido CPU, UI. Rápida) brag Então sobre isso ! Quanto mais os consumidores começarem a exigir desempenho, mais contadores de feijão começarão a fazer orçamentos.

Seu primeiro erro, e provavelmente por que você recebeu uma votação negativa, merece o exagero flagrantemente óbvio. Você realmente acredita que o iPhone e o iPad são tão ruins assim?

Em última análise, o cliente é responsável. Tudo se resume ao custo e o que o cliente está preparado para pagar e o que recebe em troca. Se eles escolherem recursos acima da velocidade, é isso que eles recebem. Se eles escolherem o preço acima da velocidade, é isso que é construído e vendido. Se a imagem da marca é mais importante ... Em última análise, o cliente decide com a carteira, o que é importante e o que não é. Você tem a opção de ser uma prostituta de marca e comprar produtos, porque todo mundo faz, ou é um pensador independente, olha por trás do brilho e da propaganda de marketing e compra algo que atenda às suas necessidades.

Você está culpando os programadores. Eles escreveram o código, com certeza, mas não definiram nem devem definir os requisitos dos clientes, o hardware, o custo da BOM, o custo de P&D, o orçamento de marketing ... todas as coisas necessárias para criar um produto , isso não é software.

As tecnologias usadas, os idiomas usados ​​etc. não têm nada a ver com isso. Maus vs bons desenvolvedores, nada a ver com isso. Qualquer programador decente pode fazer com que um pedaço de código seja executado mais rapidamente, seja mais ágil, seja o máximo possível. Minha experiência é que os programadores decentes não quebram o negócio quando tomam as decisões, enquanto os meio decentes reclamam de quão "melhor" deveria "ser".

A otimização prematura às vezes é ruim, mas não quando necessária para uma boa experiência do usuário ou uma boa duração da bateria em um sistema suficientemente restrito. A falha é a falha em dar uma prioridade mais alta à limpeza da engenharia de software sustentável sobre o cozimento, para fornecer uma boa experiência do usuário e uma vida útil decente da bateria como uma prioridade mais alta no início de um projeto, mesmo que seja muito mais difícil de manter e curto circuitos alguns pilha e metodologia de software limpo arquitetado.

Se você possui um iPhone 3G, a Apple lançou algumas atualizações do sistema operacional que foram otimizadas apenas para dispositivos mais recentes. Atualizações posteriores do sistema operacional para o 3G podem oferecer um desempenho um pouco melhor no 3G.

O seu DVR leva tanto tempo para mudar de canal porque precisa despejar os dados em buffer e, em seguida, colocar em fila outro buffer cheio de dados para o novo canal que você está assistindo. É provável que esse buffer seja armazenado no disco rígido, portanto, essas operações levam tempo (além de poderem ser preenchidas apenas em tempo real). Com um DVR, você nunca assiste à programação "ao vivo", ela sempre fica atrasada (não por coincidência, ela é atrasada ao mesmo tempo que o atraso percebido ao trocar de canal). Isso pode ser facilmente verificado assistindo a um programa esportivo ao mesmo tempo em que você o ouve no rádio.

Eu acho que o motivo é que a maioria dos aplicativos direcionados ao consumidor é controlada e comercializada por pessoas que não sabem nada sobre software e contratam desenvolvedores com base em seus currículos ou nas recomendações de algum gerente sem nada, em oposição às habilidades e conhecimentos reais .