Qual é a melhor experiência do usuário: aguardar uma vez na inicialização por um longo tempo ou aguardar com frequência por um curto período de tempo? [fechadas]

Atualmente, estou projetando um aplicativo que envolve muito cálculo. Agora, geralmente tenho duas possibilidades que testei:

1) Durante a inicialização do aplicativo, calculei apenas os valores mais importantes e esses que consomem muito tempo. Portanto, o usuário precisa aguardar aproximadamente 15 segundos durante a inicialização. Mas, por outro lado, muitas interações do usuário exigem recálculo, de modo que o usuário geralmente precisa esperar 2-3 segundos depois de clicar em algum lugar até que o aplicativo calcule e carregue todos os valores

2) Carrego tudo durante a inicialização. Isso leva de 90 a 120 segundos ... Isso é bastante tempo, mas a grande vantagem é que todas as interações do usuário são executadas imediatamente.

Então, o que você geralmente consideraria a melhor abordagem? Carregando todas as operações demoradas durante a inicialização ou quando necessário?

Inicialize o mais rápido possível, use um thread para fazer os cálculos mais importantes. Assim, o usuário recebe um feedback imediatamente e pode começar a trabalhar após 15 segundos. Em segundo plano, permita que outro thread calcule tudo; assim, após dois minutos, esses tempos de resposta de 2 a 3 segundos também desaparecem.

Use um encadeamento separado da GUI para fazer os cálculos necessários. Faça com que seu formulário assine um evento e, quando terminar, calcule o disparo desse evento para que seu formulário atue de acordo.

Não bloqueie a GUI, é muito, muito chato para os usuários finais e pode ser considerado um sinal de um produto ruim.

No seu caso, exiba algo para o usuário o mais rápido possível e faça todos os cálculos em segundo plano.

Definitivamente, nunca bloqueie o thread da interface do usuário para obter um feedback, se quiser manter o usuário esperando em situações inevitáveis.

Eu diria que nunca calcule ou busque o "todo" de algo em um aplicativo, a menos que você tenha certeza absoluta de que toda vez que eles usam o aplicativo, tenha certeza de que eles utilizarão totalmente todos esses dados.

Realmente também depende de quão voláteis os dados são. Se dificilmente muda, por que você precisa recalcular toda vez que o aplicativo é iniciado? Tenho certeza de que não há nada significativo sobre o início de um aplicativo. Portanto, esse cálculo pode ser armazenado em cache e atualizado somente quando os valores subjacentes dos dados são alterados?

Aguardar 1-2 minutos para carregar um aplicativo está fora de questão para a maioria das situações. Como eu disse antes, todos esses dados precisam estar disponíveis para todas as funções do aplicativo?

Mantenha-o responsivo o máximo que puder, mantendo os cálculos de dados como e quando precisar deles. Coloque os cálculos nos encadeamentos em segundo plano, se realmente forem sempre dados necessários globalmente. Considere algumas partes dos dados sendo carregadas / calculadas com preguiça.

Não acho que o que você declarou possa nos ajudar a fornecer uma resposta exata, porque não sabemos a natureza dos dados subjacentes ou os casos de uso do aplicativo.

Você não explica muito qual é a sua aplicação e por que é necessário calcular algo, por isso é difícil responder com precisão. Em todos os casos, você diz que pode escolher entre deixar o usuário esperar por 15 segundos ou 90 segundos . Nos dois casos, há um problema . Todos os aplicativos que eu usei carregaram em menos de dez segundos, exceto em algumas circunstâncias muito específicas (por exemplo, o Visual Studio pode levar de 30 a 40 segundos para carregar pela primeira vez após uma instalação limpa).

Em geral, o usuário não precisa esperar nem na inicialização nem durante o fluxo de trabalho. Se o aplicativo demorar 15 segundos para iniciar, a maioria dos usuários tentará nunca fechá-lo ou iniciá-lo quando sair tomar uma xícara de café. Em todos os casos, eles provavelmente pensarão: "Eu deveria investir mais na compra de um software correto, em vez de perder meu precioso tempo".

Os casos em que você realmente precisa de muito cálculo imediatamente são extremamente raros e podem ser facilmente removidos. Por exemplo, o Adobe Lightroom, ao iniciar, deve mostrar o último catálogo com as miniaturas das fotos. Quando inicio com um catálogo contendo várias centenas de fotos, 20 MB em disco por foto , é necessário muito disco rígido e CPU para carregar essas fotos, lê-las, fazer transformações (incluindo distorção de perspectiva etc.) e gerar uma miniatura . Na verdade, o Lightroom gasta menos de cinco segundos para carregar em um PC não tão novo, porque os dados são armazenados em cache de maneira inteligente e porque não mostram todas essas centenas de miniaturas imediatamente após a inicialização, mas uma por uma quando a janela principal já é exibido.

Portanto, no seu caso, você provavelmente deve pensar menos em quando o usuário deve esperar e mais em como evitar que seus usuários desperdiçam seu tempo.

Edit: claro, eu esqueci um grupo de aplicativos que podem se comportar de maneira diferente: videogames . Em um videogame, você pode deixar o usuário aguardar um minuto para carregar os gráficos. Isso é feito porque a renderização 2D / 3D pode consumir muita CPU e você não pode gastar recursos na máquina carregando e calculando coisas durante o jogo: o desempenho visual deve ser o melhor possível e a experiência do jogo deve ser extremamente suave.

Mas mesmo nesse caso, acho que esses aplicativos tentam gastar menos de um minuto carregando coisas. Ou eles carregam pequenos pedaços , permitindo que o usuário inicie o jogo muito rápido, jogue sem problemas, mas espere de graça por cinco segundos ao passar de um nível para outro (é o que eu vi na série Half Life, por exemplo).

Esses valores você precisa calcular como os utiliza? Você simplesmente quer exibi-los?

Você mencionou que pode calculá-los todos de uma vez, não pode armazená-los em algum lugar para que não precisem ser recalculados?

Se isso não for uma opção, eu optaria por usar o multithreading e mostrar uma animação 'calculadora' na qual você deseja exibir os valores. Uma vez calculados os valores, eles podem ser mostrados.

Dessa forma, a GUI não trava, o que é extremamente irritante. O usuário ainda pode optar por abortar e ir para outra tela, etc ...

Você não pode calculá-los conforme necessário e armazená-los para que não precisem ser calculados novamente?

Portanto, quando você precisar de um número, verifique se está armazenado; caso contrário, calcule-o e armazene-o.

Percepção é praticamente realidade. Esperar na fila parece demorar muito mais do que quando estamos realmente prestando serviços. É da natureza humana desenvolver uma mentalidade de que seu aplicativo é lento (e sempre será lento em tudo o que faz) se tivermos que esperar muito tempo para carregar no início.

Quebre os cálculos, se puder. Idealmente, muitos deles seriam executados em segundo plano ou feitos conforme a necessidade.

Se essas são minhas duas únicas opções, aproveito o tempo de inicialização lento. Não me importo de esperar um pouco para que algo comece, mas odeio quando meu sistema fica lento enquanto estou tentando fazer algum trabalho.

Obviamente, nenhum tipo de espera é uma boa experiência do usuário, e eu concordo com seus outros entrevistados que você deve investigar a multiencadeamento. Obviamente, se o seu aplicativo estiver quase pronto, você provavelmente não poderá "adicionar" multiencadeamentos com facilidade, então talvez veja a próxima versão.