¿Qué causa el mal rendimiento en las aplicaciones de consumo? [cerrado]

Mi DVR Comcast tarda al menos tres segundos en responder a cada pulsación de tecla del control remoto, lo que hace que la simple tarea de ver televisión se convierta en una frustrante experiencia de combinación de botones. Mi iPhone tarda al menos quince segundos en mostrar mensajes de texto y se bloquea ¼ de las veces que intento abrir la aplicación del iPod; simplemente recibir y leer un correo electrónico a menudo lleva más de un minuto. Incluso la navcom en mi automóvil tiene controles blandos e insensibles, que a menudo se tragan entradas sucesivas si las separo con menos de unos segundos de diferencia.

Estos son todos los dispositivos de consumo final de hardware fijo para los cuales la usabilidad debe ser primordial, y sin embargo, todos fallan en la capacidad de respuesta y latencia básicas. Su software es demasiado lento .

¿Qué hay detrás de esto? ¿Es un problema técnico o social? ¿Quién o qué es responsable?

¿Es porque todos estos fueron escritos en lenguajes gestionados y recolectados de basura en lugar de código nativo? ¿Son los programadores individuales quienes escribieron el software para estos dispositivos? En todos estos casos, los desarrolladores de aplicaciones sabían exactamente a qué plataforma de hardware apuntaban y cuáles eran sus capacidades; ¿No lo tomaron en cuenta? ¿Es el tipo que anda repitiendo "la optimización es la raíz de todo mal", los llevó por mal camino? ¿Era una mentalidad de "oh, son solo 100ms adicionales" cada vez hasta que todos esos milisegundos suman minutos? ¿Es mi culpa, por haber comprado estos productos en primer lugar?

Esta es una pregunta subjetiva, sin una respuesta única, pero a menudo me siento frustrado al ver tantas respuestas aquí que dicen "oh, no te preocupes por la velocidad del código, el rendimiento no importa" cuando claramente en algún momento sí importa El usuario final que se atasca con una experiencia lenta, insensible y horrible.

Entonces, ¿en qué punto las cosas salieron mal para estos productos? ¿Qué podemos hacer nosotros como programadores para evitar infligir este dolor a nuestros propios clientes?

Buena pregunta. Lo que veo a diario es esto.

La gente trabaja en aplicaciones de buen tamaño. A medida que funcionan, los problemas de rendimiento se arrastran, al igual que los errores. La diferencia es que los errores son "malos", gritan "encuéntrame y arréglame". Los problemas de rendimiento simplemente se sientan allí y empeoran. Los programadores a menudo piensan "Bueno, mi código no tendría un problema de rendimiento. Más bien, la gerencia necesita comprarme una máquina más nueva / más grande / más rápida".

El hecho es que si los desarrolladores periódicamente buscan problemas de rendimiento (que en realidad es muy fácil ), simplemente podrían limpiarlos.

En cambio, el "estado del arte" es:

1. confíe en aforismos como "evitar la optimización prematura" y 90/10 hoo-haw.
2. hable con valentía sobre la creación de perfiles y, a veces, intente realmente hacerlo, a menudo con resultados decepcionantes, como puede ver en todas las preguntas SO al respecto.
3. recurrir a las viejas conjeturas, disfrazadas de experiencia y conocimiento.

Pero realmente, eso es negativo. Para ser positivo, este método funciona casi todo el tiempo, y no podría ser más simple. Aquí hay un ejemplo detallado .

Este no es un problema técnico, es un problema de marketing y gestión.

Puede estar rodando los ojos en este punto, pero por favor tengan paciencia conmigo.

Lo que una empresa vende es su "producto", y las personas que definen lo que son son "gerentes de producto". En las empresas de tecnología, muchas otras personas influyen en eso: expertos en experiencia de usuario, yadda yadda. Pero en última instancia, los gerentes de producto son responsables de escribir las especificaciones de lo que se supone que debe obtener el usuario.

Entonces, tomemos su DVR Comcast. Idealmente, las cosas funcionarían así:

1. El gerente de producto escribe en una especificación: "Cuando un usuario presiona un botón en el control remoto y está a menos de 25 pies del DVR, el DVR debe responder a la prensa dentro de 250 milisegundos".
2. Los técnicos construyen el hardware, escriben el software incorporado, etc.
3. Los evaluadores de control de calidad aprueban que el sistema cumpla con las especificaciones o lo devuelven al equipo técnico para que lo solucionen.

Por supuesto, muchas cosas pueden salir mal:

• El gerente de producto no puede poner la respuesta del botón en la especificación
• La gente de QA hace un trabajo mediocre de probar contra las especificaciones
• Alguien seleccionó tecnologías que no permiten que se cumplan las especificaciones, por lo que el requisito se aplica
• El personal técnico es corto de personal o alguien aceleró el cronograma, y ​​algún gerente dice: "Olvídese de la capacidad de respuesta, termine esta otra función".
• El gerente de producto no publica el requisito de capacidad de respuesta hasta tan tarde en el juego, no puede cumplirse para la fecha de envío
• La gerencia decide no enviar nada para la prueba de control de calidad hasta tan tarde, acelerar el código lento desestabilizaría el producto

¿Viste a todos los programadores irresponsables allí? No hubo ninguno.

No digo que no tengamos ninguna responsabilidad por el mal desempeño; a menudo, es tan fácil y rápido escribir un código bueno, robusto y eficiente como escribir basura.

Pero en realidad, si la administración del producto y el personal de control de calidad están todos dormidos al volante, los programadores no podemos compensar eso.

FWIW, estoy completamente de acuerdo con las interfaces abismales de la mayoría de los productos de consumo. Llevo unos 25 años escribiendo código UI y me esfuerzo por la elegancia y la simplicidad. En realidad es un problema porque lo pienso mucho, ahora soy pésimo para descubrir interfaces de usuario mal diseñadas, por lo que mi pobre esposa termina ejecutando la mayoría de los dispositivos en nuestro centro de medios.

Porque los programadores no son perfectos.

Soy programador de cosas incrustadas. Parte de mi código no es perfecto. La mayor parte de mi código incrustado es rápido.

Arreglar problemas de rendimiento al final de un proyecto es muy difícil.

A veces, para mantener las cosas simples (y por lo tanto comprobables, que se pueden desarrollar en un tiempo realista, no con errores fatales), colocamos elementos en capas, como la entrada remota a un "servicio" que no forma parte de la aplicación principal. Resultado final, latencia. La alternativa es poner todo en una aplicación monolítica es un desastre con errores en C o C ++ (los dos lenguajes incrustados más comunes).

A veces, su dispositivo incorporado tiene un programador de procesos que no hace lo que usted como usuario desea. Malditamente difícil de arreglar como desarrollador incrustado.

La complejidad causa el retraso, debido a la latencia en las capas. Usted solicitó las características. Pruebe un Nokia realmente antiguo, como el viejo 3210. IU rápida y rápida. No muchas características.

Estoy argumentando que los desarrolladores no se vuelven más inteligentes, por lo que el hardware más rápido se absorbe en las abstracciones para evitar que las características se maten entre sí. (O no, en el caso de tu iPhone)

El rendimiento de la interfaz de usuario debe ser un requisito que debe probar a medida que avanza el diseño.

Si no se especifica, el desarrollador se acostumbrará. Todos hacemos esto. "Mi bebé no es feo"

Y no son los lenguajes GC; Embedded Realtime Java es tan rápido que da miedo. (Python incrustado por otro lado es un perro total)

Escribo un programa de lectura que activa las entradas digitales como la interfaz de usuario. Todavía tengo que deshacer el interruptor, por lo que no es muy rápido mover el interruptor, porque el rebote es un par de capas hacia arriba. Lo ideal sería tener la lógica de rebote en la parte inferior de la pila de firmware, pero no es así como funciona el hardware.

Algunos reproductores de DVD simplemente ejecutan un script de "expulsión" para expulsar. Es posible que su DVR haya adoptado este enfoque para mantener los costos de desarrollo sanos. Luego escatima en CPU o RAM y apesta.

¿Es porque todos estos fueron escritos en lenguajes gestionados y recolectados de basura en lugar de código nativo?

No. El código lento funcionará mal independientemente. Claro, un idioma en particular puede introducir ciertas clases de problemas mientras resuelve otros. Pero los buenos programadores son bastante capaces de encontrar soluciones con el tiempo suficiente.

¿Son los programadores individuales quienes escribieron el software para estos dispositivos?

Parcialmente. En muchos casos es muy probable que sea al menos un factor contribuyente. Este es un efecto secundario desafortunado de una industria donde los buenos programadores tienen una gran demanda y escasez. También los abismos entre varios niveles de habilidad técnica pueden ser bastante grandes. Por lo tanto, es lógico que a veces los programadores encargados de implementar cierto software puedan ser felicitados solo por hacer que funcione (más o menos).

En todos estos casos, los desarrolladores de aplicaciones sabían exactamente a qué plataforma de hardware apuntaban y cuáles eran sus capacidades; ¿No lo tomaron en cuenta?

Parcialmente. Para empezar, probablemente no se conozca la plataforma de hardware exacta , ya que a menudo se negocia con varios fabricantes en paralelo durante el desarrollo de software. De hecho, incluso puede haber cambios pequeños (pero no necesariamente insignificantes) en el hardware subyacente después del lanzamiento inicial. Sin embargo, estaría de acuerdo en que se conocerán las capacidades generales.

Parte del problema es que el software probablemente no se desarrolla en el hardware, se hace en emuladores. Esto hace que sea difícil tener en cuenta el verdadero rendimiento del dispositivo, incluso si los emuladores son 100% precisos, lo cual no es cierto.

Por supuesto, esto realmente no justifica pruebas insuficientes en el prototipo de hardware apropiado antes del lanzamiento. Esa culpa probablemente yace fuera del control de dev / qa.

¿Es el tipo que anda repitiendo "la optimización es la raíz de todo mal", los llevó por mal camino?

No. Estoy bastante seguro de que no lo escuchan de todos modos; de lo contrario, no se lo citaría tan a menudo (se supone que es " optimización prematura ..."). :-RE

Es más probable que demasiados programadores tomen uno de los 2 extremos con respecto a la optimización.

• O bien lo ignoran por completo.
• O se obsesionan con minucias que no tienen nada que ver con los requisitos de rendimiento reales . El efecto neto es que el presupuesto se agota y el código está demasiado ofuscado para optimizar los problemas de rendimiento real de forma segura.

¿Era una mentalidad de "oh, son solo 100ms adicionales" cada vez hasta que todos esos milisegundos suman minutos?

Posiblemente. Obviamente, si Sleep(100)se ha utilizado como el equivalente del papel de seda utilizado para retrasar el sangrado de una extremidad cortada, entonces es de esperar problemas. Sin embargo, sospecho que el problema es más sutil que eso.

La cuestión es que el hardware informático moderno (incluidos los dispositivos integrados) es mucho más rápido de lo que la gente les da crédito. La mayoría de las personas, incluso los programadores "experimentados" no aprecian cuán rápido son las computadoras. 100 ms es mucho tiempo, mucho tiempo . Y como sucede, este "tiempo muy largo" corta 2 maneras:

• La primera es que los programadores se preocupan innecesariamente por las cosas que una computadora hace extremadamente rápido. (Da la casualidad de que fue tal preocupación " incrementar un valor 300 veces por segundo " lo que me llevó aquí en primer lugar).
• El segundo es que a veces no muestran la debida preocupación cuando las cosas toman mucho tiempo (en la escala de tiempo de computación). Asi que:
  • si ignoran los efectos de la latencia cuando se comunican a través de una red o con un dispositivo de almacenamiento;
  • si ignoran el impacto de un hilo bloqueado y esperando otro hilo;
  • si olvidan que debido a que las computadoras funcionan tan rápido, es muy capaz de repetir una tarea con mucha más frecuencia de lo que debería, sin que el desarrollador sea consciente de un problema
  • ... si se produce una combinación de tales descuidos, una rutina se ejecutará inesperadamente muy lentamente (en la escala de tiempo de computación). Algunas repeticiones e incluso los humanos lo notarán, pero puede ser difícil de precisar porque cientos de cosas interconectadas se ejecutan rápidamente por sí mismas.

¿Es mi culpa, por haber comprado estos productos en primer lugar?

Sí definitivamente. Bueno, no a usted personalmente sino a los consumidores en general. Los productos se venden (y compran ) mediante listas de verificación de características. Muy pocos consumidores exigen un mejor rendimiento.

Para ilustrar mi punto: la última vez que quise comprar un teléfono celular, la tienda ni siquiera podía ofrecer un modelo de demostración para jugar en la tienda. Todo lo que tenían eran conchas de plástico con pegatinas para mostrar cómo se vería la pantalla. Ni siquiera puede sentir el peso de esa manera, y mucho menos el rendimiento o la usabilidad. Mi punto es que si suficientes personas se opusieran a ese modelo de negocio y votaran con sus billeteras para expresar su objeción, seríamos un pequeño paso en la dirección correcta.

Pero no lo hacen, así que nosotros no; y cada año los nuevos teléfonos celulares funcionan más lentamente en hardware más rápido.

(Las preguntas no se hacen).

• ¿La gente de marketing tiene la culpa? Parcialmente. Necesitan fechas de lanzamiento. Y cuando se acerca dicha fecha, la elección entre "hacer que funcione" y "hacerlo más rápido" es obvio.
• ¿Son los vendedores los culpables? Parcialmente. Quieren más funciones en la lista de verificación. Exageran las listas de funciones e ignoran el rendimiento. Ellos (a veces) hacen promesas poco realistas.
• ¿Son los gerentes los culpables? Parcialmente. Los gerentes sin experiencia pueden cometer muchos errores, pero incluso los gerentes con mucha experiencia pueden (con bastante razón) sacrificar el tiempo para resolver problemas de rendimiento en favor de otras preocupaciones.
• ¿Son las especificaciones las culpables? Parcialmente. Si algo queda fuera de especificación, es mucho más fácil "olvidarlo" más tarde. Y si no se especifica específicamente, ¿cuál es el objetivo? (Aunque personalmente creo que si un equipo se enorgullece de su trabajo, se preocuparía por el rendimiento independientemente).
• ¿Es la educación la culpable? Tal vez. La educación probablemente siempre estará a la zaga. Ciertamente desapruebo la "educación" que rápidamente produce principiantes con un desarrollo de software de comprensión superficial. Sin embargo, la educación respaldada por la teoría e inculca una cultura de aprendizaje no puede ser mala.
• ¿Son las actualizaciones las culpables? Parcialmente. Nuevo software, hardware antiguo realmente es tentador destino. Incluso antes de que se lance la versión X, X + 1 está en planificación. El nuevo software es compatible, pero ¿el hardware antiguo es lo suficientemente rápido? ¿Fue probado? Se puede incluir una corrección de rendimiento particular en el nuevo software, fomentando una actualización de software desaconsejada.

Básicamente, creo que hay muchos factores que contribuyen. Entonces, desafortunadamente no hay una bala de plata para arreglarlo. Pero eso no significa que sea pesimismo. Hay formas de contribuir a mejorar las cosas.

Entonces, ¿en qué punto las cosas salieron mal para estos productos?

En mi humilde opinión, realmente no podemos identificar ningún punto único. Hay muchos factores contribuyentes que evolucionaron con el tiempo.

• Contadores de frijoles: reducción de costos, sincronización del mercado. Pero, de nuevo, ¿habríamos logrado los avances que hemos logrado sin la presión?
• Alta demanda y baja oferta de personas calificadas en la industria. No solo programadores, sino también gerentes, evaluadores e incluso vendedores. La falta de habilidades y experiencia conduce a errores. Pero, de nuevo, también conduce al aprendizaje.
• Tecnología de última generación. Hasta que una tecnología madure, morderá regularmente de maneras inesperadas. Pero, de nuevo, a menudo proporcionó una serie de ventajas en primer lugar.
• Complicación compuesta. Con el tiempo, la industria ha evolucionado: agregando más herramientas, tecnologías, capas, técnicas, abstracciones, hardware, idiomas, variaciones, opciones. Esto hace que sea algo imposible tener una comprensión "completa" de los sistemas modernos. Sin embargo, también somos capaces de hacer mucho más en un tiempo mucho más corto como resultado.

¿Qué podemos hacer nosotros como programadores para evitar infligir este dolor a nuestros propios clientes?

Tengo algunas sugerencias (tanto técnicas como no técnicas) que pueden ayudar:

• En la medida de lo posible, use su propio producto. No hay nada como la experiencia de primera mano para revelar cosas incómodas, lentas o inconvenientes. Sin embargo, deberá evitar conscientemente eludir las deficiencias debido al "conocimiento interno". Por ejemplo, si no tiene problemas para sincronizar contactos porque lo hace con un script de Python de puerta trasera, no está utilizando "el producto". Lo que trae el siguiente punto ...
• Escuche a sus usuarios (preferiblemente de primera mano, pero al menos de segunda mano a través del soporte). Sé que los programadores (en general) prefieren permanecer escondidos y evitar la interacción humana; pero eso no lo ayuda a descubrir los problemas que otras personas experimentan al usar su producto. Por ejemplo, es posible que no note que las opciones del menú son lentas, porque conoce todos los accesos directos y los usa exclusivamente. Incluso si el manual documenta completamente todos los accesos directos, algunas personas seguirán prefiriendo los menús, a pesar de ser insufriblemente lentos.
• Esfuércese por mejorar sus habilidades técnicas y conocimientos de forma continua. Desarrolle la habilidad para analizar críticamente todo lo que aprende. Vuelva a evaluar sus conocimientos regularmente. En algunos casos, prepárate para olvidar lo que creías saber. Lo que trae a colación ...
• Algunas tecnologías / técnicas pueden ser muy complicadas y llevar a malentendidos sutiles e implementaciones incorrectas. Otros, a través de la evolución del conocimiento común o las herramientas disponibles, pueden caer en desgracia (por ejemplo, Singletons). Algunos temas son tan complicados que generan un montón de "expertos hocus-pocus" que propagan una enorme cantidad de información errónea. Un error particular para mí es la información errónea que rodea a los subprocesos múltiples. Una buena implementación de subprocesos múltiples puede mejorar significativamente la experiencia del usuario. Desafortunadamente, muchos enfoques mal informados sobre subprocesos múltiples reducirán significativamente el rendimiento, aumentarán los errores erráticos, aumentarán los riesgos de bloqueo, complicarán la depuración, etc.
• Tomar posesión. (No, en serio, no estoy jugando al bingo de la sala de juntas). Negocie con gerentes, propietarios de productos y vendedores para obtener características de rendimiento que tengan prioridad sobre algunos elementos de la lista de verificación. Exija mejores especificaciones. No infantilmente, sino haciendo preguntas que hacen que las personas piensen en el rendimiento.
• Sé un consumidor exigente. Elija el teléfono que tiene menos funciones pero es más rápido. (No es una CPU más rápida, una IU más rápida). ¡ Entonces presume ! Mientras más consumidores comiencen a exigir un rendimiento, más contadores de frijoles comenzarán a presupuestarlo.

Su primer error, y probablemente por qué tiene un voto negativo, merece la exageración descaradamente obvia. ¿Realmente esperas creer que el iPhone y el iPad son tan malos?

En última instancia, el cliente es responsable. Todo se reduce al costo y lo que el cliente está dispuesto a pagar y lo que recibe a cambio. Si eligen características sobre la velocidad, eso es lo que obtienen. Si eligen el precio sobre la velocidad, eso es lo que se construye y se vende. Si la imagen de marca es más importante ... En última instancia, el cliente decide con su billetera, qué es importante y qué no. Usted tiene la opción de ser una prostituta de marca y comprar productos porque todos los demás lo hacen, o ser un pensador independiente, mirar detrás del brillo y el bombo publicitario, y comprar algo que satisfaga sus necesidades.

Estás culpando a los programadores. Escribieron el código, claro, pero no definieron, y no deberían definir, los requisitos de los clientes, el hardware, el costo de la lista de materiales, el costo de I + D, el presupuesto de marketing ... todo lo que se necesita para hacer un producto , eso no es software.

Las tecnologías utilizadas, los idiomas utilizados, etc., no tienen nada que ver con esto. Malos vs buenos desarrolladores, nada que ver con eso. Cualquier programador medio decente puede hacer que un código se ejecute más rápido, sea más receptivo y sea lo último que pueda. Mi experiencia es que los programadores decentes no quiebran el negocio cuando tienen que tomar las decisiones, mientras que los que son medio decentes se quejan de lo "mejor" que debería "ser".

La optimización prematura a veces es mala, pero no cuando se requiere para una buena experiencia del usuario o una buena duración de la batería en un sistema suficientemente limitado. La falla es la falla de dar una mayor prioridad a la limpieza de la ingeniería de software mantenible sobre la cocción en lo que sea necesario para proporcionar una buena experiencia del usuario y una vida útil de la batería como una prioridad más alta al comienzo de un proyecto, incluso si es mucho más difícil de mantener y corto circuitos de una pila y metodología de software de arquitectura limpia.

Si tiene un iPhone 3G, Apple lanzó un par de actualizaciones del sistema operativo que solo fueron optimizadas para dispositivos más nuevos. Las actualizaciones posteriores del sistema operativo para el 3G pueden proporcionar un rendimiento ligeramente mejor en el 3G.

Su DVR tarda tanto en cambiar canales porque primero tiene que volcar los datos almacenados en el búfer y luego poner en cola otro búfer lleno de datos para el nuevo canal que está viendo. Es muy probable que este búfer se almacene en el disco duro, por lo que estas operaciones llevan tiempo (además, solo puede llenar el búfer en tiempo real). Con un DVR nunca está viendo programación "en vivo", siempre se retrasa (no es coincidencia, se retrasa al mismo tiempo que su retraso percibido al cambiar de canal). Esto puede verificarse fácilmente viendo un programa deportivo al mismo tiempo que lo escucha en una radio.

Creo que la razón es que la mayoría de las aplicaciones dirigidas al consumidor son controladas y comercializadas por personas que no saben nada sobre software, y contratan desarrolladores en función de sus currículums o las recomendaciones de algún administrador de nada, en lugar de sus habilidades y conocimientos reales. .