Nos dias da computação moderna, em 'aplicativos de negócios típicos' - por que o desempenho importa? [fechadas]

Isso pode parecer uma pergunta estranha para alguns de vocês.

Eu sou um programador Java amador. Eu desenvolvi vários jogos, um programa de IA que cria música, outro programa para pintura e coisas semelhantes. Isso é para dizer que tenho experiência em programação, mas não no desenvolvimento profissional de aplicativos de negócios.

Eu vejo muita conversa neste site sobre desempenho. As pessoas costumam debater qual seria o algoritmo mais eficiente em C # para executar uma tarefa ou por que o Python é lento e o Java é mais rápido, etc.

O que estou tentando entender é: por que isso importa?

Existem áreas específicas da computação nas quais vejo por que o desempenho é importante: jogos, onde dezenas de milhares de computações acontecem a cada segundo em um loop de atualização constante ou sistemas de baixo nível nos quais outros programas dependem, como sistemas operacionais e VMs, etc.

Mas, para o aplicativo de negócios normal e de alto nível, por que o desempenho importa?

Eu posso entender por que isso importava, décadas atrás. Os computadores eram muito mais lentos e tinham muito menos memória; portanto, você precisava pensar cuidadosamente sobre essas coisas.

Hoje, porém, temos tanta memória de sobra e os computadores são tão rápidos: isso realmente importa se um algoritmo Java específico é O (n ^ 2)? Será que realmente fará diferença para os usuários finais desse aplicativo comercial típico?

Quando você pressiona um botão GUI em um aplicativo comercial típico, e nos bastidores, ele invoca um algoritmo O (n ^ 2), nos dias de hoje na computação moderna - você realmente sente a ineficiência?

Minha pergunta está dividida em duas:

1. Na prática, hoje em dia o desempenho importa em um programa de negócios normal típico?
2. Nesse caso, dê-me exemplos reais de lugares em um aplicativo em que o desempenho e as otimizações são importantes.

Você está certo, o desempenho em aplicativos de negócios não é realmente um assunto importante da maneira como é discutido pela maioria dos programadores . Geralmente, as discussões relacionadas ao desempenho que eu ouço dos programadores têm vários problemas:

• Eles são principalmente otimização prematura . Geralmente, alguém quer "o caminho mais rápido" para executar uma operação sem motivo aparente e acaba fazendo alterações no código que são feitas pela maioria dos compiladores de qualquer maneira (como substituir a divisão pela multiplicação ou incluir um método) ou passar dias fazendo alterações o que ajudará a ganhar alguns microssegundos em tempo de execução.

• Eles são frequentemente especulativos . Fico feliz em ver que no Stack Overflow e Programmers.SE, o perfil é mencionado frequentemente quando a pergunta está relacionada ao desempenho, mas também fico decepcionado quando vejo dois programadores que não sabem o que o perfil está discutindo sobre desempenho - alterações relacionadas que eles devem fazer em seu código. Eles acreditam que as mudanças tornarão tudo mais rápido, mas praticamente sempre não terão efeito visível ou retardarão as coisas, enquanto um criador de perfil as indicaria para outra parte do código que pode ser facilmente otimizada e desperdiça 80% do tempo.

• Eles estão focados apenas em aspectos técnicos. O desempenho de aplicativos orientados ao usuário é sobre o sentimento: ele se sente rápido e responsivo ou lento e desajeitado? Nesse contexto, os problemas de desempenho geralmente são resolvidos muito melhor pelos designers de experiência do usuário: uma transição animada simples pode ser a diferença entre um aplicativo que parece terrivelmente lento e o que parece responsivo, enquanto ambos gastam 600 ms. fazendo a operação.

• Eles são baseados em elementos subjetivos, mesmo quando estão relacionados a restrições técnicas. Se não é uma questão de se sentir rápido e receptivo, deve haver um requisito não funcional que especifique a rapidez com que uma operação deve ser executada em dados específicos, executando em um sistema específico . Na realidade, acontece mais assim: o gerente diz que encontra algo lento e, em seguida, os desenvolvedores precisam descobrir o que isso significa. É lento como em "deve estar abaixo de 30 ms. Enquanto atualmente gasta dez segundos" ou lento como "podemos talvez diminuir a duração de dez para nove segundos"?

No início de minha carreira como programador, eu trabalhava em um software para vários clientes. Eu estava convencido de que este software é a próxima grande coisa que trará felicidade ao mundo, então eu estava obviamente preocupado com o desempenho.

Já ouvi termos como "criação de perfil" ou "referência", mas não sabia o que eles queriam dizer e não me importava. Além disso, eu estava muito focado na leitura do livro sobre C, e especialmente no capítulo em que as técnicas de otimização foram discutidas. Quando descobri que os computadores realizam multiplicação mais rapidamente que a divisão, substituí a divisão pela multiplicação em qualquer lugar que puder. Quando descobri que chamar um método pode ser lento, combinei o máximo de métodos possível, como se os 100 métodos LOC anteriores não fossem um problema.

Às vezes, eu passava noites fazendo mudanças que, eu estava convencido, faziam diferença entre um aplicativo lento que ninguém quer e um rápido que todo mundo quer baixar e usar. O fato de dois clientes reais interessados ​​neste aplicativo solicitarem recursos reais não estava me incomodando: "Quem iria querer um recurso, se o aplicativo estiver lento?" - pensei.

Por fim, os únicos dois clientes pararam de usar o aplicativo. Não foi incrivelmente rápido, apesar de todos os meus esforços, principalmente porque quando você não sabe o que são índices e seu aplicativo consome muitos bancos de dados, há algo errado. De qualquer forma, quando eu estava fazendo apenas outra alteração relacionada ao desempenho, que estava melhorando em alguns microssegundos a execução do código que é usado uma vez por mês, os clientes não viam alterações. O que eles estavam vendo é que a experiência do usuário é terrível, a documentação está faltando, os recursos cruciais que eles estavam solicitando há meses não estavam aqui e o número de bugs a serem resolvidos crescia constantemente.

Resultado: esperava que este aplicativo fosse usado por milhares de empresas em todo o mundo, mas hoje você não encontrará nenhuma informação sobre esse aplicativo na internet. Os únicos dois clientes a abandonaram e o projeto também foi abandonado. Ele nunca foi comercializado, nem publicamente divulgado, e hoje nem tenho certeza se posso compilá-lo no meu PC (nem encontrar as fontes originais). Isso não teria acontecido se eu estivesse focando mais nas coisas que realmente importam.

Dito isto, o desempenho em geral é importante :

• Em aplicativos não comerciais, isso pode se tornar crucial. Existem softwares incorporados , softwares executados em servidores (quando você tem alguns milhares de solicitações por segundo, o que não é tão grande, o desempenho começa a ser uma preocupação), softwares executados em smartphones , videogames e softwares para profissionais (tente manipular um arquivo de 50 GB no Photoshop em uma máquina não muito rápida para se convencer) e até mesmo produtos de software comuns que são vendidos para muitas pessoas (se o Microsoft Word gasta o dobro do tempo para fazer todas as operações, o tempo perdido é multiplicado pelo número de usuários se tornará um problema).

• Nos aplicativos de negócios, há muitos casos em que um aplicativo que sente e é lento será odiado pelos usuários. Você não quer isso, aproveitando suas preocupações.

Sim. Sim. A velocidade em tempo de execução não é a única preocupação que você deve ter, e não é tão premente quanto em 1982, ou ainda em sistemas embarcados de baixa potência, mas é sempre uma preocupação e é importante que você entenda por que isso é assim?

Por um lado, a complexidade assintótica mencionada descreve o comportamento de um programa à medida que seu tamanho de entrada aumenta . Um programa não linear que lida com 10 itens pode se safar ao fazer um trabalho supérfluo, mas o incomodará quando um dia você precisar lidar com 1000, porque não parecerá apenas mais lento, mas muito, muito mais lento. E você não sabe (sem análise e benchmarking extensivos) se esse ponto estará em 100 itens, em 1000 itens ou não, até atingir 100.000 itens. Pode ser difícil de acreditar, mas escolher o melhor algoritmo, é claro, é muito mais fácil do que estimar esse ponto para cada rotina e escolher sua implementação, dependendo dessa estimativa.

Além disso, leia os princípios básicos da experiência do usuário. Existem limites bem pesquisados ​​que determinam como a interação com um programa é percebida, dependendo de seus tempos de resposta (10 ms, 100 ms, alguns segundos etc.). Atravessar um desses limites fará com que os usuários se desliguem do seu aplicativo e, a menos que você esteja na posição feliz de escrever o software de monopólio que as pessoas precisam usar, os usuários desassociados se traduzem diretamente em valor comercial negativo, pois leva à perda de clientes.

Essas são apenas algumas das razões pelas quais um programador profissional deve conhecer a complexidade algorítmica e lidar com isso de forma responsável. Hoje em dia, geralmente não é necessário sair do seu caminho e programar um código especialmente otimizado e mal legível para qualquer coisa, a menos que seja um loop interno de tempo crítico, mas você nunca deve invocar uma classe de complexidade mais alta do que o obviamente necessário para fazer o trabalho.

Sim!

Como você pediu exemplos, várias situações cotidianas vêm à sua mente:

1. Manipulando big data : muitos aplicativos de negócios são apoiados por bancos de dados e, em muitos casos, esses bancos de dados transbordam de dados. E como o espaço em disco é barato, as quantidades de dados gravados e armazenados são insanas. Na semana passada, um cliente reclamou que sua aplicação é muito lenta, quando apenas exibia alguns números médios (consultas em mais de um milhão de linhas ...) - Também no uso diário, temos conversões e cálculos de dados em lote e tempos de execução na liga de vários horas. No ano passado, uma otimização algorítmica reduziu o tempo de processo de um lote de 8 para 4 horas, agora não colide com o turno do dia!

2. Capacidade de resposta : Houve estudos de usabilidade (se eu tiver tempo, adicionarei links para as questões relevantes no ux.se ...) que a satisfação do usuário está fortemente relacionada à capacidade de resposta. Uma diferença no tempo de resposta de 200 ms vs. 400 ms pode facilmente custar uma grande porcentagem de seus clientes, deixando você para seus concorrentes.

3. Sistemas embarcados : os computadores não estão ficando mais rápidos, estão ficando mais lentos e menores ^ _ ^ O desenvolvimento móvel tem um enorme impacto no desenvolvimento de aplicativos. Claro que podemos usar ciclos de memória e CPU como Jelly Beans em computadores desktop modernos, mas agora seu chefe pede que você implemente o algoritmo de análise do sono em um relógio ou em um cartão SIM ...

Na prática, hoje em dia o desempenho importa em um programa de negócios normal típico?

Não sei o que é um programa normal de negócios normal. O que eu sei é que os usuários sempre acabam alimentando nossos programas com muito mais dados do que planejamos (geralmente depois de lhes perguntar qual seria o tamanho e adicionar uma margem de segurança) e, nesse caso, esperam um aumento linear de em tempo de execução, aceite um comportamento de log n e reclame que o aplicativo congela quando algo mais acontece. E eles tendem a considerar o tamanho do resultado mais do que o tamanho da entrada, exceto no caso em que é óbvio pelo seu POV que todos os dados de entrada precisam ser processados.

Então, sim, o desempenho, pelo menos no nível de complexidade, é importante. A micro-otimização dentro de uma classe de complexidade realmente não importa, exceto se você é visivelmente pior que a concorrência (seja em benchmarks em alguns mercados ou por percepção bruta - alterando a classe na progressão "instantânea", "não instantânea, mas o usuário não mude para outra coisa "," lento o suficiente para que o usuário mude para outra coisa com risco de interromper o fluxo de ações "," lento o suficiente para que o usuário inicie a tarefa e verifique periodicamente "," lento o suficiente que o usuário planeja iniciar a tarefa durante o almoço, durante a noite, no final de semana ").

Em aplicativos de negócios modernos, os problemas de desempenho não estão na forma de falta de CPU ou memória. Mas eles estão na forma de latências de rede, desempenho de E / S e abstrações ocultando tudo isso. Tudo depende da qualidade do design e da experiência dos desenvolvedores. Até um aplicativo CRUD simples pode parar se estiver retirando do DB uma linha por vez, em vez de executar uma consulta (também conhecida como problema N + 1).

O problema é que ter um bom design e desenvolvedores experientes é caro. E geralmente é muito mais barato ter usuários irritados do que investir em otimizações de desempenho reais. Existem alguns casos em que os clientes exigem alto desempenho (por exemplo, navegadores da web), mas esses raramente se aplicam a aplicativos de negócios comuns.

Lembre-se de que, para aplicativos baseados em servidor, você pode ter centenas, milhares ou até milhões de usuários tentando fazer as coisas ao mesmo tempo. Uma pequena economia de eficiência em tal situação pode ter um grande impacto na quantidade de hardware necessária para atender às solicitações.

Certamente importa muito.

A questão principal não é nem mesmo sobre ser irritante para o usuário, como enfrentando atrasos desnecessários quando os elementos GUI estão a descoberto duas ou três vezes (que faz questão de gráficos integrados!) Ou simplesmente porque o programa leva tanto tempo para fazer ... o que quer que faz (principalmente coisas desinteressantes). Embora, é claro, isso também seja um problema.

Existem três conceitos errôneos importantes:

1. A maioria dos computadores comerciais típicos não é "muito mais poderosa" . O computador comercial típico não é um i7 de 8 núcleos com uma placa gráfica de ponta e 16 GB de RAM. É um notebook com um processador móvel de classe média, gráficos integrados, 2 GB de memória principal (4 GB se você tiver sorte), um disco de 5400 RPM e uma versão corporativa do Windows com uma variedade de antivírus em tempo real e software de aplicação de políticas em execução no fundo. Ou, para a maioria dos consultores, o "computador" é simplesmente o iPhone ...
2. A maioria dos "usuários comerciais típicos" não são técnicos, eles não entendem as implicações da criação de uma planilha com 10 a 12 guias de referência cruzada, 150 colunas e 30.000 linhas (esses números não são tão irrealistas quanto você pode imaginar!) E eles também não quero saber. Eles vão fazer isso.
3. Uma segunda perda não custa é uma suposição flagrantemente errada.

Minha esposa trabalha na extremidade superior de um "ambiente típico de negócios". O computador que ela está usando custa cerca de 3,5 horas do seu tempo de trabalho. O início do Microsoft Outlook leva - em um bom dia - cerca de 3 minutos até que esteja pronto (6-8 minutos no final do trimestre, quando os servidores estão sob carga pesada). Algumas dessas planilhas de 30 mil linhas mencionadas levam de 2 a 3 segundos para atualizar um valor durante o qual o computador está "congelado" (sem mencionar quanto tempo leva para o Excel inicializar e abri-las!). É ainda pior ao compartilhar a área de trabalho. Nem me faça entrar no SAP.
Certamente importa se cem mil pessoas perdem 20 a 25 minutos por dia de trabalho sem esperar nada. Esses são milhões perdidosque você poderia, em vez de perdê-los, pagar como dividendos (ou pagar salários mais altos).
Claro, a maioria dos funcionários está na extremidade inferior da escala de pagamento, mas mesmo na extremidade inferior, o tempo é dinheiro .

Eu posso entender por que isso importava, décadas atrás. Os computadores eram muito mais lentos e tinham muito menos memória; portanto, você precisava pensar cuidadosamente sobre essas coisas.

Você parece subestimar a rapidez com que N ^ 2 cresce. Digamos que temos um computador e nosso algoritmo N ^ 2 leva 10 segundos quando N = 10. O tempo passa, agora temos um novo processador que é 6 vezes mais rápido que o original, portanto, nosso cálculo de 10 segundos agora é menor que dois segundos. Quanto maior N pode ser e ainda cabe no tempo original de 10 segundos? Agora podemos lidar com 24 itens, um pouco mais do que o dobro. Quão mais rápido seria o nosso sistema para lidar com 10 vezes mais itens? Bem, teria que ser 100 vezes mais rápido. Os dados crescem muito rapidamente e mais do que limitam o progresso do hardware dos algoritmos N ^ 2.

Você não acreditaria na quantidade de programas de negócios de terceiros que usamos no trabalho e muitos deles são ridiculamente lentos em relação aos meus padrões pessoais. Se os programas fossem algo que uso em casa, eu os teria substituído por outro há muito tempo.

Em alguns casos, a diferença se aplica diretamente aos custos, pois alguns programas afetam diretamente quantas tarefas eu posso realizar durante um dia e, portanto, diminuem minha produtividade e montamos itens faturáveis. Então, eu diria que é muito importante que os programas de negócios também tenham pelo menos desempenho suficiente para não serem o item limitador da renda.

Um exemplo é o gerenciamento de incidentes, em que o trabalho é medido em intervalos de 15 minutos (central de atendimento). Se o programa for lento o suficiente para enviar um ticket por mais de 15 minutos (incluindo o trabalho real), o processo será mais lento. Uma causa pode ser um acesso lento ao banco de dados que simplesmente "espera por um tempo" sempre que o usuário executa uma ação (preencha os detalhes da resolução, atualize as informações do trabalho ou similares). Eu posso imaginar que há casos em que programas lentos podem até afetar coisas mais críticas, como detalhes de pacientes hospitalizados em casos de envenenamento urgente - talvez alergias a medicamentos ou algo assim?

Muitas das outras respostas abrangem o tópico completamente, por isso eu as adoro pelas razões e razões. Em vez disso, quero dar um exemplo da vida real para mostrar como uma escolha algorítmica pode ter implicações reais.

http://windowsitpro.com/windows-xp/svchost-and-windows-update-windows-xp-still-problem

O artigo vinculado descreve um erro no algoritmo para calcular as atualizações do Windows XP. Durante a maior parte da vida do Windows XP, o algoritmo de atualização funcionou bem. O algoritmo calcula se um patch foi substituído por um patch mais recente e, portanto, não precisa ser instalado. No final, porém, a lista de atualizações substituídas cresceu muito *.

O algoritmo de atualização era exponencial, onde cada nova atualização levava o dobro do tempo para calcular como a anterior ( ). Quando as listas chegaram ao intervalo de 40 atualizações (* longas ), demorou 15 minutos, funcionando com capacidade total, para verificar atualizações. Isso bloqueou efetivamente muitas máquinas XP durante a atualização. Pior ainda, quando alguém instalaria as atualizações, o algoritmo seria executado novamente , levando outros 15 minutos. Como muitas máquinas tinham as Atualizações Automáticas definidas, isso poderia travar as máquinas por 15 minutos a cada inicialização e, potencialmente, novamente a uma certa periodicidade.O(n) = 2n

A Microsoft usou hacks de curto prazo (removendo itens da lista de atualização) e correções de longo prazo para solucionar esse problema. Isso foi importante porque as versões mais recentes do Windows também estavam usando o mesmo algoritmo e podem um dia enfrentar o mesmo problema.

Aqui podemos ver que a escolha de um algoritmo teve implicações reais. O algoritmo errado, embora seja bom para a maior parte da vida útil do produto, ainda pode ter impactos negativos no caminho.

Acho que você está interpretando a quantidade de perguntas sobre desempenho como uma indicação de que os requisitos de desempenho para aplicativos de negócios são importantes em vez de reconhecer que é difícil melhorar o desempenho. . A simples execução do trabalho pode ser realizada por técnicas de força bruta, tentativa e erro ou cópia e colagem de código de exemplo.

Qualquer um pode ter sorte e continuar fazendo alterações até que algo corra mais rápido, mas isso raramente funciona. Devido à falta de experiência, os desenvolvedores verão ajuda externa. Em alguns ambientes, as melhorias de desempenho são problemas únicos, portanto, fazer uma pergunta específica em um site como o StackOverflow pode ser a única opção. Além disso, muitos consultores ganham dinheiro ao serem capazes de intervir e corrigir esses tipos de problemas.

Depende muito de como você define "bom desempenho". Seus algoritmos sempre devem usar a melhor complexidade possível. Abuse brechas para acelerar sua gaiola média. Buffer e pré-carregamento / pré-compilação sempre que possível em um programa interativo.

Há outra definição de "bom desempenho": otimizando as constantes da sua classe de complexidade. É aqui que o C ++ recebe seu título, onde as pessoas começam a chamar Java de lento, onde 5% menos tempo de execução parece ser o santo graal. Usando esta definição, você está certo. O hardware do computador fica mais complicado com o tempo, enquanto os compiladores ficam cada vez melhores. Em algum momento, você não pode otimizar melhor o código low-end melhor do que o compilador - então deixe estar e se concentre em seus algoritmos.

Nesse ponto, usar Java / Haskell / C ++ se torna apenas mais uma decisão de design. O processamento de números pode ser feito via OpenCL na sua GPU. As interfaces do usuário precisam de algoritmos de tempo constante e são boas. A saída e a modularidade são mais importantes do que alinhar suas classes para uma utilização 20% melhor do cache. O multithreading se torna importante, porque as pessoas não querem um aplicativo rápido, elas querem um responsivo. O que não é importante é que seu aplicativo seja constantemente 10% mais lento do que poderia ser. Até 50% é bom (mas as pessoas começam a fazer perguntas). Concentre-se na correção, capacidade de resposta e modularidade.

Adoro programar em Haskell ou pelo menos de forma funcional (mesmo em C ++). Ser capaz de escrever testes facilmente para todo o programa é muito mais importante do que ser um pouco mais rápido em trabalhos em lotes.

Muito simples: custo

Meu empregador anterior tinha um sistema de gerenciamento de aprendizado hospedado em servidores físicos como modelo SaaS. O heap da JVM foi configurado para 2 GB para as máquinas mais antigas e 3 GB para as máquinas mais recentes e executamos várias instâncias por máquina. Você pensaria que isso seria suficiente.

Antes de começar, havia uma equipe de desempenho responsável por tornar o sistema responsivo e escalável. Eles descobriram que havia certos dados que consultávamos constantemente do banco de dados. Havia uma tabela na qual participamos até a maioria das consultas para recuperar uma coluna. Esses dados raramente mudavam.

O problema é que tínhamos 2 GB para trabalhar. Portanto, a solução óbvia é começar a armazenar em cache todos os dados lidos com frequência. Então tivemos problemas de memória, começando logo antes de eu embarcar.

Havia duas escolas de pensamento sobre isso:

1. Memória e hardware em geral são baratos hoje em dia. Basta comprar mais RAM para poder armazenar em cache mais.
2. Por que um sistema de gerenciamento de aprendizado precisa de mais de 3 GB de RAM? Tudo isso emite consultas SQL, envia redirecionamentos para iniciar cursos e avalia o progresso dos alunos através dos cursos.

O segundo argumento venceu e passei mais de um ano ajustando nosso uso de memória.

Meu empregador atual também hospeda um sistema de gerenciamento de aprendizado, mas o hospeda de maneira um pouco diferente. A escalabilidade é tão baixa que uma única instalação (dividida em 4 servidores virtuais com carga balanceada) pode lidar apenas com 80 clientes. Alguns de nossos clientes maiores ainda têm seu próprio conjunto de servidores. A maioria dos problemas que levam a isso são problemas de desempenho, como consultas SQL que sobrecarregam todos os ciclos da CPU, vazamentos de memória, código redundante que faz a mesma coisa várias vezes. Temos até um aplicativo interno criado, cujo único objetivo é reiniciar os servidores quando eles não apresentam um desempenho ruim. Há um funcionário que mantém essa ferramenta (junto com outras responsabilidades).

Eles assinaram a primeira escola de pensamento que mencionei acima: jogue mais hardware porque os custos de hardware são mais baratos que os salários dos desenvolvedores.

Isso não funcionou tão economicamente quanto o esperado. Entre hardware, licenciamento de software e equipe de suporte para lidar com os servidores, gastamos milhões todos os anos para evitar que um desenvolvedor gaste tempo criando perfis de código.

Quando entrei, fui responsável por corrigir nossos problemas de disponibilidade. Como a maioria dos nossos problemas de disponibilidade ocorreu devido ao baixo desempenho, eu ajustei nosso código de desempenho e a escalabilidade é substancialmente aprimorada, com muito mais tempo de atividade. Estamos prontos para começar a aumentar a densidade. Escusado será dizer que meu salário não chega nem perto de um milhão (eu desejo!), Portanto, gastar dinheiro em fazer com que eu melhore o desempenho do código acabará economizando milhões por ano.

TL; DR

Se você fizer uma análise completa de custo / benefício, verá que é mais barato apenas corrigir o código. Um problema de desempenho conhecido que você ignora se transforma em dívida técnica .

Entendi sua pergunta assim: para obter desempenhos suficientemente bons (ou seja, os usuários estão felizes e meu back-end não se encolhe), preciso entender a teoria da complexidade algorítmica?

Depende do que você entende por aplicativo de negócios "típico". Em muitos casos, especialmente sistemas simples de informação tipo CRUD, a resposta seria não. Para isso, você "simplesmente" (às vezes é realmente difícil) precisa ser capaz de rastrear os gargalos de desempenho: perdi um índice no meu banco de dados? Envio muitos dados pela rede? Tenho mil $ watch no meu front-end angular.js? Trata-se de construir uma arquitetura sólida, conhecendo bem sua pilha de tecnologias e evitando o absurdo. Você pode conseguir isso se for um bom artesão, não necessariamente um cientista da computação. Outra maneira de dizer isso é que os caras que criaram o otimizador de consultas Oracle lidaram com as coisas de complexidade algorítmica, você só precisa usar adequadamente o que elas forneceram a você.

Agora há exceções. Se estamos falando de big data ou aprendizado de máquina, você precisa saber o que está fazendo e não apenas usar os algoritmos padrão disponíveis para você. Mesmo no front-end, se você começar a criar visualizações avançadas de dados, algumas delas poderão implicar um custo de complexidade não linear (por exemplo, gráficos de layout de força).

Atualmente, essas exceções estão se tornando cada vez mais comuns e o mercado está bastante seco quando você procura pessoas que possam lidar com elas. Então: sim, você pode ser bem-sucedido sem formação em ciência da computação, mas será ainda mais com alguns.

Os outros respondedores abordaram a maioria dos pontos básicos, mas, para tarefas que podem ser paralelizadas, um software ineficiente leva ao aumento dos custos de hardware na forma de mais servidores, que consomem mais energia e exigem mais espaço e manutenção.