Menéame: comentarios [3050107]

#162 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Tue, 04 Dec 2018 19:43:34 +0000

#158 quizás nos hemos visto en algún sitio, el mundo es un pañuelo!

» autor: --23321--

#161 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--543878-- — Tue, 04 Dec 2018 19:01:50 +0000

#96 Que conste que en general tienes razón en tu comentario, pero es que si te pasa eso, seguro que hay cambios insignificantes que tienen mayor impacto en tu juego. De hecho si te pones a optimizar cualquier cosa en ensamblador seguramente consigas arañar alguna operación más y algún nanosegundo más.

» autor: --543878--

#160 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--543878-- — Tue, 04 Dec 2018 18:59:09 +0000

#60 Suscribo tu comentario, pero es que aunque este problema sea algo apreciable, lo más probable es que tu programa haga aguas por cualquier otra parte por otro motivo y con un mayor impacto. En general en este meneo se cae en una falacia de agregar números insignificantes hasta llegar a cantidades monstruosas.

Ejemplo: si todas las personas del mundo dejan un arroz en su plato sin comer, si sumamos un arroz por toda la población mundial, cada día, a lo largo de un año tendrás toneladas de comida... sin embargo, eso no significa que realmente puedas alimentar a nadie con ese grano de arroz.

» autor: --543878--

#159 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Tue, 04 Dec 2018 14:15:25 +0000

[Usuario deshabilitado]

» autor: --540692--

#158 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Tue, 04 Dec 2018 14:14:54 +0000

[Usuario deshabilitado]

» autor: --540692--

#157 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Tue, 04 Dec 2018 14:14:22 +0000

[Usuario deshabilitado]

» autor: --540692--

#156 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Tue, 04 Dec 2018 12:39:12 +0000

#149 por cierto, te he agregado a LinkedIn

He visto allí tu experiencia profesional, si te molan los temas de alto rendimiento creo que no estás en los entornos adecuados y te sugiero cambiar de empresas.

En Everis no vas a aprender muchas cosas de calidad, sinceramente.

» autor: --23321--

#155 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Tue, 04 Dec 2018 12:35:59 +0000

#120

No, no tenemos razón los dos. El rendimiento no se obtiene buscando hacks del compilador o esquivando errores del compilador. Si optimizas así, estás ligado a una versión específica del compilador y esos comportamientos no forman parte del contrato del compilador, por lo que van a cambiar.

El rendimiento se obtiene a través de una buena arquitectura, no de hacks.

» autor: --23321--

#154 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Tue, 04 Dec 2018 12:34:17 +0000

#139 exactamente, estoy totalmente de acuerdo.

» autor: --23321--

#153 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Tue, 04 Dec 2018 12:32:58 +0000

#149

CC #120

#120 Lee mi post bien. El que no tiene razón es él. Mi comentario dice lo mismo que el tuyo. Las importantes son todas. No sólo lo que dice @jcarlosn que parece que le han hecho ayer analista y se le ha subido a la cabeza...

Analista? Pero qué máquina del tiempo has usado para volver del pasado?

Hace muchos años que no creo en la figura de los analistas, etc. Trabajo en entornos de investigación y en entornos startup, y en ninguno existe la figura del analista.

Mira, creo que te has metido en camisa de once varas.

Este es mi blog: jcarlosnorte.com

También te he dado enlaces a códigos de altísimo rendimiento desarrollado por mi.

En serio, creo que hace rato que esta estrategia tuya de llamarme cuñado y menospreciar lo que digo con ataques personales, no está dando resultados.

Si quieres podemos volver al debate del rendimiento, que creo que es mucho más interesante que los ataques personales con los que estás quedando en evidencia.

Te insisto, el rendimiento no consiste en detalles del compilador, salvo en contadas excepciones. El rendimiento es consecuencia estructural de la arquitectura y el diseño del programa, y normalmente incluso cuando optimizas casos, lo haces optimizando contra computadores electromagnéticos modernos con sus limitaciones, no es inteligente optimizar contra el compilador, por qué esos detalles implementativos cambian, y tú programa se vuelve más lento.

Mucha gente se ha pillado ya los dedos con estas cosas en el pasado, y podemos aprender de ello: el rendimiento viene como consecuencia del buen diseño de software, no es consecuencia de detallitos que van a cambiar

» autor: --23321--

#152 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Tue, 04 Dec 2018 12:23:14 +0000

#148 no hace falta que le faltes al respeto a nadie.

Yo estoy intentando tener este debate se forma respetuosa y constructiva, deja de decir que voy de listo y tonterías así, que no tenemos 15 años y decir ese tipo de cosas no te hace más inteligente no te hace tener razón.

A mí me da igual a lo que te dediques, te he pegado el link por qué has insinuado que no tengo ni idea de esto, en un ad hominem de libro, entonces he decidido compartir cosas que he programado yo para que puedas verlas.

Cuando dices que ese link no dice nada, se nota que no sabes leer código.

github.com/eyeos/spice-web-client/blob/master/lib/images/lz.js

Eso es una implementación de lz que descomprime 8mb de datos en menos de 10ms. Picado en js. Supera a algunas implementaciones en C de lz, y a prácticamente todas las implementaciones de lz que vas a encontrar en JavaScript.

Con esto no intento demostrar nada, simplemente me defiendo de tus ataques ad hominem continuados.

Me lo vas a decir tu que llevo 15 años trabajando en sistemas de tarificacion de movil...... Me lo vas a decir tu que he diseñado el sistema de intercambio de datos de factura de vodafone.. me lo vas a decir tu que he estado en la fusión ono vodafone...

Y a mi que me importa donde has trabajado? Lo importante es el debate, no que me digas que voy de listo o que me digas que has trabajado en x empresa. Si quieres pásame enlaces a códigos, como he hecho yo, para debatir sobre el tema.

Que trabajes en Vodafone no significa nada.

Llegó el listo, hablándome de MongoDB.... llegó el cuñado...

El cuñao en Menéame suele ser el que más usa esa palabra, y tu caso no es una excepción.

He sacado mongodb a la palestra por qué aunque probablemente no lo sabes, mongodb incluye un motor de map reduce muy potente, que tú puedes utilizar para distribuir tareas de computación intensiva paralelizable entre múltiples computadores .

» autor: --23321--

#151 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Tue, 04 Dec 2018 12:13:38 +0000

#146 si, me dedico a optimizar rendimiento entre otras muchas cosa.

Si quieres te explico en que suele consistir , y verás que este tipo de detalles de compilador nunca son importantes.

» autor: --23321--

#150 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

javito118 — Tue, 04 Dec 2018 10:56:01 +0000

#111 Quien ha dicho eso, he dicho que los principales CMS están desarrollados en PHP esto conlleva todo una comunidad de desarrolladores que crean modulos, plugins adicionales para estas plataformas.

» autor: javito118

#149 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Tue, 04 Dec 2018 10:38:05 +0000

[Usuario deshabilitado]

» autor: --540692--

#148 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Tue, 04 Dec 2018 10:35:56 +0000

[Usuario deshabilitado]

» autor: --540692--

#147 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Tue, 04 Dec 2018 10:33:01 +0000

[Usuario deshabilitado]

» autor: --540692--

#146 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Tue, 04 Dec 2018 10:30:28 +0000

[Usuario deshabilitado]

» autor: --540692--

#145 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Tue, 04 Dec 2018 10:29:56 +0000

[Usuario deshabilitado]

» autor: --540692--

#144 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23457-- — Tue, 04 Dec 2018 09:35:10 +0000

#132 Y el horse typing.

- Si camina como un caballo, galopa como un caballo y suena como un caballo. ¿Qué es?
- Unos cocos.

» autor: --23457--

#143 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--507899-- — Tue, 04 Dec 2018 08:52:23 +0000

#116 argumenta por favor.

» autor: --507899--

#142 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

scalvo — Tue, 04 Dec 2018 08:50:42 +0000

#112 En ese ejemplo no creo que sea por tema de eficiencia, sino por ámbito de variable...

» autor: scalvo

#141 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

scalvo — Tue, 04 Dec 2018 08:49:24 +0000

#80 La lógica, en tu ejemplo, es, a mi juicio, mucho menos problemática que no declarar los enteros como constantes con un nombre descriptivo para saber a qué se refieren....

» autor: scalvo

#140 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

scalvo — Tue, 04 Dec 2018 08:45:04 +0000

#134 Si tanto te importa la diferencia entre i*i respecto a (i*i) entiendo que tú sólo programas en ensamblador aplicaciones de altísimo rendimiento en tiempo real y en la vida te acercas a malignas cosas tales como lenguajes de alto nivel que usen un compilador (o VM) o, herejía, lenguajes interpretados.

Sin acritud.

» autor: scalvo

#139 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

scalvo — Tue, 04 Dec 2018 08:41:53 +0000

#97 De hecho, a mi juicio, esto sólo es importante para los que hacen compiladores...

» autor: scalvo

#138 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--32677-- — Tue, 04 Dec 2018 08:40:56 +0000

#137 calva!

» autor: --32677--

#137 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--330392-- — Tue, 04 Dec 2018 08:31:17 +0000

#12 Los mayores no usamos juguetes.

» autor: --330392--

#136 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

celyo — Tue, 04 Dec 2018 08:20:33 +0000

#123 No se porque pero me ha recordado a Mars Attack!!!

» autor: celyo

#135 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

scalvo — Tue, 04 Dec 2018 08:19:10 +0000

#74 Correcto. Algo parecido digo en #60.
Pero no implica que en la grandísima mayoría de ocasiones la diferencia es despreciable.

Más aún, si tienes que analizar todos los problemas del compilador (probablemente esto es un problema del compilador ya que no hay ninguna razón lógica para ello) para casi cualquier operación del programa nunca acabarías el programa.

Premature optimization is the root of all evil.

» autor: scalvo

#134 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--544691-- — Tue, 04 Dec 2018 08:03:03 +0000

#47 si te la pela el i * i como desarrollador, no creo que hayas dado importancia al resto del código, así que imagínate.

» autor: --544691--

#133 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

triturator — Tue, 04 Dec 2018 07:09:24 +0000

#115 Que dos expresiones tan sencillas y equivalentes tengan rendimientos tan diferentes, yo creo que sí se puede considerar un fallo. Pero ya nos metemos en un tema filosófico

» autor: triturator

#132 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

ochoceros — Mon, 03 Dec 2018 23:56:47 +0000

#126 No, no falta. Monty Python sale perfectamente referenciado en la primera viñeta de PHP

cc/ #15

» autor: ochoceros

#131 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

heffeque — Mon, 03 Dec 2018 23:09:22 +0000

#15 Yo sí voy a añadir algo (los "=" se ven un poco mal)

» autor: heffeque

#130 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

mcfgdbbn3 — Mon, 03 Dec 2018 23:03:57 +0000

#15: Deberían parodiar a Phyton también, que tiene mucho que pwnear, por ejemplo, que la estructura va en la indentación, ideal para copiar y pegar en según que entornos, además de que es más fácil liarse si tienes que añadir cosas anidadas.

» autor: mcfgdbbn3

#129 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

KimDeal — Mon, 03 Dec 2018 20:51:49 +0000

#1 mis dieses.

» autor: KimDeal

#128 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--543878-- — Mon, 03 Dec 2018 20:46:52 +0000

#5 Sé que no lo has dicho, pero como bien dices entre líneas esto es lo que pasa cuando se permite que un populista llegue a venezuela como presidente. Disfruten lo votado.

» autor: --543878--

#127 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--543878-- — Mon, 03 Dec 2018 20:45:41 +0000

#13 Estoy seguro cualquier aplicación hará aguas por muchísimas partes antes que esto sea un problema real. Esto tiene un nombre y es el de micro optimizaciones.

» autor: --543878--

#126 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23457-- — Mon, 03 Dec 2018 20:40:59 +0000

#15 Falta Python:

from castle import Princess

Y te sobra una viñeta para escribir un readme y un script de instalación con más líneas que la propia aplicación y subir el paquete a PyPI para que no lo descargue nadie

» autor: --23457--

#125 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Ovidio — Mon, 03 Dec 2018 20:12:45 +0000

#113 El único lenguaje que no es basura es C. Bueno, y Fortran

» autor: Ovidio

#124 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

akeko — Mon, 03 Dec 2018 19:55:11 +0000

#99 Yo creo que no me he liado...
Yo he entendido perfectamente la mejora de rendimiento que se expone, pero ahora te pregunto, si cambiasemos el rango de esa ecuación, ¿podría esta mejora de rendimiento afectar al resultado? ¿Confiarías en el resultado de esa sencillísima fórmula?

» autor: akeko

#123 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Razhan — Mon, 03 Dec 2018 19:44:39 +0000

#30 El problema no viene por ahi. Estoy convencido que estoy pasa tambien si en vez de multiplicar por dos multiplicadas por tres. Internamente, la JVM esta pensada como una maquina de pila, no de registros. Cuando conviertes ese código a código nativo, acabas generando código que utiliza una cantidad muy pequeña de registros.

Muy por encima (en pseudoensamblador), imagino que la opción rápida hace:
MOV RAX [i]
MUL RAX, RAX, RAX
MUL RAX, RAX, 2

Mientras que la opción lenta hace:
MOV RAX, [i]
MUL RAX, RAX, 2
MOV RBX, [i]
MUL RAX, RAX, RBX

En el primer caso, se esta haciendo una única llamada a [i] (traer el valor de i desde memoria), mientras que en el segundo, se trae el valor de [i] dos veces. Incluso si en el segundo fragmento juegas un poco con el orden:
MOV RBX [i]
MUL RAX, RBX, 2
MUL RAX, RAX, RBX

Aunque ahora solo usas una llamada a [i], sigues utilizando dos registros. Lo que significa que tienes que guardar el contenido de dichos registros antes en la pila, lo cual también te lleva tiempo.

No me he puesto a mirar en serio la verdad, pero por lo que me conozco de la JVM (basicamente mi trabajo), apostaria dinero a que viene por ahi

» autor: Razhan

#122 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--287400-- — Mon, 03 Dec 2018 19:38:11 +0000

#33 Pues no sabría qué decirte, el compilador lo puedes configurar para que se comporte de muchas maneras al compilar. Por ejemplo en una evaluación tipo (funcion1() && funcion2() && funcion3()) en la que cada una de las fuciones devolviese un booleano puedes hacer que el compilador ejecute las 3 funciones y después ejecutar la evaluación, pero también puedes configurarlo para que vaya ejecutando ambas cosas a la vez y en ese caso en ciertas ocasiones funcion3 no llegaría a llamarse nunca dando lugar a un código con mejor rendimiento (pero que te puede perjudicar si las necesidades de tu programa necesitases que las 3 funciones se ejecutasen siempre, en cuyo caso te verías obligado a escribir el código de otra manera.

No digo que se el caso de ejemplo, pero en la práctica en el primer ejemplo el programador no le da ninguna pista al compilador de forma que primero hace 2*i y luego el resultado *i. En el segundo caso sin embargo le estas dando una pista i*i tiene que ejecutarse antes de multiplicar por 2. El compilador puede entonces deducir que i*i es lo mismo que i^2. Si el compilador, por el mecanismo que sea, fuera capaz de calcular operaciones tipo n^2 más rápido que a*b el resultado es un código más optimizado.

» autor: --287400--

#121 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Razhan — Mon, 03 Dec 2018 19:29:05 +0000

#23 No, java no usa el byte shift para esa multiplicación. Todo se resume a que en (2 * i) * i se lee el valor i dos veces, mientras que en 2 * (i * i) solo hace falta leer i una vez.

» autor: Razhan

#120 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

selufett — Mon, 03 Dec 2018 19:00:58 +0000

#67 Tenéis los dos razón.. ambas prácticas son buenas. Y no necesariamente hacer hincapié en una u otra te hace mejor o peor programador.

» autor: selufett

#119 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

iampiti — Mon, 03 Dec 2018 18:59:24 +0000

#1 Aplaudo su detallada argumentación

» autor: iampiti

#118 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Juan_Garcia — Mon, 03 Dec 2018 18:52:08 +0000

#114 0,1 segundos son 100ms, rehaz los tuyos.

» autor: Juan_Garcia

#117 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--541279-- — Mon, 03 Dec 2018 18:43:07 +0000

[Usuario deshabilitado]

» autor: --541279--

#116 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

demostenes — Mon, 03 Dec 2018 18:01:21 +0000

#37 Discrepo

» autor: demostenes

#115 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Razhan — Mon, 03 Dec 2018 17:58:59 +0000

#57 No se si se puede llamar un fallo. Es mas bien una falta de optimización durante la compilación

» autor: Razhan

#114 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

leitzaran — Mon, 03 Dec 2018 17:58:23 +0000

#50 Es 0,1 segundos en 10^9 iteraciones. Rehaz tus cálculos.

» autor: leitzaran

#113 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

scalvo — Mon, 03 Dec 2018 17:30:26 +0000

#109 Java es mucho más rápido que los siguientes lenguajes:

- Ruby
- PHP
- Python
- Javascript.

Cuatro lenguajes que son muy, muy, muy usados.
Entiendo que esos cuatro lenguajes son basura también no?

» autor: scalvo

#112 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

parrita710 — Mon, 03 Dec 2018 17:27:54 +0000

#62 Pues parece que en Java es un poco mas eficiente el caso de declarar las variables dentro del for
stackoverflow.com/questions/407255/difference-between-declaring-variab

» autor: parrita710

#111 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

blacar — Mon, 03 Dec 2018 17:11:52 +0000

#32 Que sepas que configurar un CMS y tocar un poco las plantillas no se puede llamar desarrollo web.

» autor: blacar

#110 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

blacar — Mon, 03 Dec 2018 17:09:30 +0000

#29 Otro? ... Java no es de tipado debil.

» autor: blacar

#109 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Ovidio — Mon, 03 Dec 2018 16:28:46 +0000

#49 Java es lento, lento como el solo. Y que tengas que declarar una clase para hacer un puto hola mundo lo convierte automáticamente en basura

» autor: Ovidio

#108 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

abercrombie — Mon, 03 Dec 2018 16:23:24 +0000

#96 el problema no es que un juego pida mucha máquina (que también) El verdadero problema es que una web con 3 divs y dos .js te piden 8 núcleos

» autor: abercrombie

#107 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Selection — Mon, 03 Dec 2018 16:12:18 +0000

#106 Oops! typo! Al revés los tiempos.

» autor: Selection

#106 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Selection — Mon, 03 Dec 2018 16:10:20 +0000

Todo el mundo comentando acerca de la operación aritmética pero ninguno parece que haya abierto el programa y lo haya visto.

El programa tarda entre 0.50s y 0.55s en ejecutarse con 2 * i * i.
El programa tarda entre 0.60s y 0.65s en ejecutarse con 2 * (i * i).

¿Y qué es el programa? Mil millones de iteraciones de esa multiplicación.

Mil millones. Y la diferencia es 0.15s contando todas las operaciones.

Obviamente es importante la optimización y está muy bien saber que Java es más rápido haciendo este tipo de cosas.
Pero no es tanta la diferencia entre hacer esto o no hacerlo. En el 99.99% de los programas, no lo será.

» autor: Selection

#105 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--148836-- — Mon, 03 Dec 2018 15:41:30 +0000

#102 Generalmente para una tasa de 60fps necesitas 1 seg / 60 cuadros (16.666 ms o 33 ms si es 30 cuadros). Efectivamente la GPU puede hacer los cálculos concurrentes por fuerza bruta en hilos separados para digamos físicas, pero hay muchos otros factores que inciden en la escena como backface culling, el frustrum etc. en virtud de los cuales ciertas optimizaciones, por ejemplo en los BSPs, octrees o quadtrees para colisiones 2D , sí pueden hacer que no se pierdan cuadros por el camino y hacer que todo el conjunto se represente en esos 16.6 ms, lo que ya es jodido.

» autor: --148836--

#104 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

noises — Mon, 03 Dec 2018 15:35:13 +0000

#1 ¿Tu programas en Trollscript?

github.com/tombell/trollscript/blob/master/examples/hello_world.troll

» autor: noises

#103 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Mon, 03 Dec 2018 15:27:28 +0000

#102 asociar la fisica a los fotogramas es una decisión cuestionable, ya que el motor no sería viable sin modificaciones para plataformas de hardware donde el refreso sea determinante (como oculus rift) pero incluso aunque algún juego lo haga, en esos juegos son optimizaciones mas de alto nivel las que están haciendo funcionar el juego, no la diferencia entre 2*i*i vs 2*(i*i).

100ms es mucho para muchos programadores. a 60fps tienes 16ms por frame. En una petición a una API, quieres siempre respuestas por debajo del segundo, al menos en los casos habituales.

Nadie discute que 100ms es mucho, lo que estoy diciendo es que para que un juego, api, o programa X vaya rápido o lento, el factor determinante es la arquitectura y como de optimizado está para un computador electromagnético con hardware específico.

2*i*i vs 2+*(i*i) no es lo que hacer ir rápido o lento a un programa informático.

» autor: --23321--

#102 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Juan_Garcia — Mon, 03 Dec 2018 15:15:19 +0000

#97 Ya te puse en el anterior comentario que era solo un ejemplo, y que no hablaba de esta optimización en particular, sino de que 100ms para una persona común puede parecer una cantidad de tiempo ínfima, pero por ejemplo, en un videojuego puede ser la diferencia entre una tasa de fotograma estable o no.

En cuanto al motor de física, hay todavia juegos que van asociados a la tasa de fotogramas, ejemplo? La saga fallout, la saga dark souls. No son juegos indie precisamente.

» autor: Juan_Garcia

#101 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--507899-- — Mon, 03 Dec 2018 15:11:50 +0000

#98 hay muchísimas en gittheprincess,esta me marco en la uni,es una versión algo mas antigua.

» autor: --507899--

#100 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Mon, 03 Dec 2018 15:10:52 +0000

#81 Resumen de #95

El rendimiento importa y yo me dedico a ello, pero nunca el rendimiento depende de microoptimizaciones de maquina virtuales o compiladores, sino de gestiones adecuadas de los datos a nivel conceptual, y adaptar un poco el programa a las capacidades y forma de funcionar de una computadora electromagnética.

» autor: --23321--

#99 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--148836-- — Mon, 03 Dec 2018 15:10:03 +0000

#93 No se, creo que te estás liando un poco.
Lo que aquí se está exponiendo es la ligera mejora de rendimiento que supone factorizar la multiplicación del ejemplo propuesto dentro de un bucle en Java. Lo cual se debe probablemente a una mayor optimización del bytecode por parte del JIT al hacer el desenroscado del bucle (loop unrolling) en el primer caso, quizá por tener un stack separado como resultado de dicha factorización y no tener que hacer tantas llamadas a stack para conservar los resultados intermedios que generaría 2 * i * i

» autor: --148836--

#98 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

court — Mon, 03 Dec 2018 15:08:50 +0000

#15 Falta la version en ASM, donde cambia una A por una B y acaba matando a la princesa y follandose al dragon.

» autor: court

#97 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Mon, 03 Dec 2018 15:08:35 +0000

#96 el motor de física no se mueve como respuesta al movimiento de la camara. El motor de física es siempre un bucle aparte, en un thread aparte. Si no fuese así, cuando la escena se redenriza mas rápido, la física se movería mas rápido, lo cual no tiene sentido.

El movimiento de la camara del que hablas en #74 es claramente un mal ejemplo.

Si de lo que hablas es de los cálculos de física de un juego, de nuevo, nunca va a tener millones de entidades en la pantalla, por que antes de tener problemas solventables con 2*(i*i) vs 2*i*i, has petado por miles de otros problemas, como el recolector de basura o mil problemas mas. Por eso, en cualquier engine moderno millones de entidades se gestionan a través de sistemas de partículas acelerados via gpu con physx o gestionados con otro tipo de estrategias aproximativas.

En serio, 2*(i*i) vs 2*i*i es irrelevante para la inmensa mayoría de personas del planeta, programadores incluidos.

Piensa que poner 2*(i*i) por que va mas rápido es hacer un programa a medida del compilador/vm. Y hacer un programa a medida del compilador es algo caro de mantener. El compilador cambia, y para que tu programa siga igual de rápido, tendrás que seguir adaptandolo a medida de cada versión del compilador/vm.

Por eso, la mayoría de programas solo necesitan estar hechos a medida de una computadora digital electromagnética moderna, y no a medida de una versión superespecifica de una máquina virtual o un compilador.

De hecho, al imensa mayoría de programas informáticos no necesitan ni estar hechos a medida de un computador digital electromagnético, sino simplemente mover los datos de forma lógica y con sentido común, y entender bien como gestionar la entrada/salida. Solo con eso, puedes acelerar programas cientos de veces, y ganar una fortuna de ello en consultoría.

Entiendeme, para los que nos dedicamos profesionalmente al rendimiento, esto es irrelevante, para los que se dedican a crear programas normales, es también irrelevante.

» autor: --23321--

#96 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Juan_Garcia — Mon, 03 Dec 2018 14:58:12 +0000

#95 Que la cámara la mueva la GPU no quiere decir que la CPU no haga nada, por ejemplo, calcula colisiones, físicas, IA, lógica en cada draw call. Sino los juegos de ahora, no estarían pidiendo monstruos de 4 nucleos a frecuencias altas.

Yo no estoy discutiendo que este ejemplo se vaya a dar en el mundo real o merezca la pena esa optimización (sinceramente casi nadie programa juegos en Java ya, quitando Android, pero incluso en Android me suena que existe otra api alternativa). Lo que estoy diciendo es que aunque 100ms puedan parecer poco tiempo, es mucho en algunos ámbitos como pueden ser los juegos.

» autor: Juan_Garcia

#95 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Mon, 03 Dec 2018 14:54:06 +0000

#74

la camara no la mueve la cpu, la mueve la gpu, ya que los calculos relacionados con la camara y la perspectiva son altamente paralelizables. Son operaciones de matrices que realiza la gpu en paralelo de forma masiva.

Que en java 2*(i*i) sea mas rapido que 2*i*i es irelevante para la programación de la imnesa mayoría de los programas informáticos, juegos incluídos.
Incluso en el procesado masivo de datos, en la lista de cosas a invertir el tiempo para reducir el coste del procesado, esto estaría por el final, compardo con problemas de I/O, estructuras, etc.

#81

PD: Tú nunca conseguirás mejorar el rendimiento de un programa Java, por lo que parece,.....

Me dedico entre muchas otras cosas, a mejorar el rendimiento de programas informáticos a cambio de dinero.

github.com/eyeos/spice-web-client

Eso es una tarjeta gráfica 2d programada por mi en javascript, alcanza 60fps procesando llamadas similares a gdi (otra api, pero es lo mismo). Algo de rendimiento se, y creeme, 2*i*i vs 2*(i*i) es completamente irrelevante.

stackoverflow.com/questions/43513975/awk-gawk-performance

El problema de ese tipo de posts, es que ese no es el caso de uso de la mayoría de la gente, y para la gente que ese es el caso de uso, hacen las cosas bien. Es ridículo que un programador cree un programa a mano en java para parsear un xml de gigabytes.

Obviamente lo estás haciendo muy mal si acabas haciendo eso. Gestionar grandes volumenes de datos es algo que ya está inventando, y si lo estás reimplementando en tu programa en lugar de utilizar spark+hadoop/mysql/mongo/etcetcetc es que lo estás haciendo muy, muy mal.

Por no hablar del hecho de que las máquinas no escalan verticalmente hasta el infinito, y que esas soluciones ya implementadas de las que te hablo, permiten ser distribuidas horizontalmente, además de resolverte muchos otros problemas, para que tu te centres en hacer algo útil, y no en reinventar la informática básica.

Sobre tu segundo post:

brenocon.com/blog/2009/09/dont-mawk-awk-the-fastest-and-most-elegant-b

Conozco muy bien las bondades de awk, pero que tiene que ver eso con microptimizaciones tipo 2*(i*i) vs 2*i*i que además luego se rompen, y se vuelve mas lenta la que era rápida, y rápida la que era lenta?

En resumen:

1. la mayoría de programadores no tienen que reinventar programas ya inventados de manipulación másiva de datos. Solo necesitan reutilizar servicios/librerias de terceros para ese tipo de operaciones de escala. De hecho, de hacerlo en tu programa seguramente lo estás haciendo mucho peor que los programas ya hechos que hacen eso.

2. Si en tu programa aparece el problema de trabajar con xml de gigas, planteate bien como estás haciendo las cosas. Probablemente lo mas inteligente no sea probar si con 2*i*i ganas unos segundos, sino dejar de hacer las cosas de forma que termines con problemas tan poco reducidos en una sola máquina

3. Cuando tus problemas no sean reducibles, y tengas que afrontar esos volumenes, no solo vas a necesitar programas ya hechos que te ayuden a mover ese volumen de datos de forma eficiente, sino que además vas a necesitar escalar en horizontal, y ahí es donde spark te va a ir muy bien (o mongodb, que tiene un map reduce bastante bueno, aunque casi nadie lo use)

Es decir, que en para un programador medio, 2*i*i vs 2*(i*i) es algo intrascendente en los problemas que tiene que resolver, e incluso para un programador trabajando con grandes volumenes de datos, es igual de intrascendente.

» autor: --23321--

#94 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

mariopg — Mon, 03 Dec 2018 14:51:45 +0000

#2 que esto llegue a portada significa que menéname son "machos" informáticos en un 80%

» autor: mariopg

#93 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

akeko — Mon, 03 Dec 2018 14:38:10 +0000

Llevo años pensando que en informática se estudia muy poco acerca del funcionamiento interno de los lenguajes de programación, y me parece preocupante la gran sorpresa que este problema supone, ya que es solo la punta del iceberg de un problema de verdad importante.
Estudio ingeniería de obras públicas y mis conocimientos de programación son ridículos, puedo programar más o menos bien en Fortran90, y un poco en C, pero tanto si hago desde una hoja de excell hasta un programa propio, ensayo primero la fórmula que vaya a implementar en el orden exacto que el programa siga (incluyendo subrutinas, como una raíz cuadrada).
Es importante ya que una simple operación como (a-b)/c, por ejemplo, puede dar un resultado muy distinto de (a/c) - (b/c), debido a la propagación del error de máquina. Esto sucede con mucha frecuencia, entre ciertos rangos de números según cada situación pueden darse facilmente errores de un 5%, y con rangos de operaciones muy concretas, el error será abismal.
Entiendo que esto se estudie a fondo solo para trabajar con bases de datos muy grandes o con cálculos que duren minutos o horas en un ordenador, pero debería darse un poco más cuando se estudian los lenguajes de programación para saber que el problema está ahí.
Dejo un ejemplo de ecuación problemática, puede probarse con la típica calculadora que se usa en la secundaria:
(10^60 )·[(a+x) - (a-x)]
a=1
x=10^-50
Esta operación con esos valores dará como resultado = 0 en una calculadora, en una hoja de cálculo, en java, y en casi cualquier otro lenguaje de programación, a pesar de que la solución analítica es 2·10^10. Me parece un problema importante que no se insista más en esto, luego todos a decir que el lenguaje es una mierda, mientras se programa como se programa, dando palos de ciego con respecto a las matemáticas.

» autor: akeko

#92 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--44189-- — Mon, 03 Dec 2018 14:23:04 +0000

Nadie dice nada del PUTO AMO que da la respuesta en stackoverflow ?

» autor: --44189--

#91 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Juez_Falcone — Mon, 03 Dec 2018 14:17:04 +0000

#52 No lo escribió él. Pero me parece muy elegante la solución.

» autor: Juez_Falcone

#90 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Poignard — Mon, 03 Dec 2018 14:16:04 +0000

#4 Seguro que trabajas haciendo webs para algun organismo público, eh gañan!

» autor: Poignard

#89 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

pip — Mon, 03 Dec 2018 14:16:01 +0000

#40 En C en ambos casos se generan los siguientes opcodes de 80x86 (gcc 8 con -O3 -m64)

imul edi, edi
lea eax, [rdi+rdi]

Punto final.

» autor: pip

#88 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

skaworld — Mon, 03 Dec 2018 14:10:22 +0000

#86 "JacaScript.net" ...

Si esto no es motivo de strike por incitacion al odio, yo ya no entiendo esta web

» autor: skaworld

#87 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

triturator — Mon, 03 Dec 2018 14:09:58 +0000

#84 Ya he dicho que si te sales del rango la cosa puede cambiar, pero aquí hablamos de un int que, en Java, es un mundano número entero de 32 bits. Dos multiplicaciones de dos números de 32 bits tardan exactamente lo mismo, independientemente del valor, en cualquier procesador desde el 386 hasta un Core i9.

Otra cosa es que hablemos de números muy tochos, en plan BigInteger y tal, que ya son objetos y la cosa puede depender de la implementación. Pero con tipos básicos no hay diferencia, al circuito le da igual si de esos 32 bits usas todos o sólo unos pocos. Él multiplica todos igual, en paralelo.

» autor: triturator

#86 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Mon, 03 Dec 2018 14:07:54 +0000

[Usuario deshabilitado]

» autor: --540692--

#85 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

skaworld — Mon, 03 Dec 2018 14:05:12 +0000

#82 Eso está muy bien, un primer paso es reconocerlo, pero no debería quedarse ahí y deberías buscar ayuda.

» autor: skaworld

#84 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Mon, 03 Dec 2018 14:04:50 +0000

[Usuario deshabilitado]

» autor: --540692--

#83 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

pip — Mon, 03 Dec 2018 14:02:59 +0000

#40 viendo el assembly monstruoso que genera el JIT para esa chorrada (ver respuesta de stackoverflow) te quedas corto con 5 veces.
En el assembly del C para esa operación serán 2 o 3 opcodes.

» autor: pip

#82 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Mon, 03 Dec 2018 14:02:19 +0000

[Usuario deshabilitado]

» autor: --540692--

#81 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Mon, 03 Dec 2018 13:58:07 +0000

[Usuario deshabilitado]

» autor: --540692--

#80 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Mon, 03 Dec 2018 13:55:20 +0000

[Usuario deshabilitado]

» autor: --540692--

#79 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Mon, 03 Dec 2018 13:51:42 +0000

[Usuario deshabilitado]

» autor: --540692--

#78 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Mon, 03 Dec 2018 13:51:16 +0000

[Usuario deshabilitado]

» autor: --540692--

#77 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--540692-- — Mon, 03 Dec 2018 13:49:58 +0000

[Usuario deshabilitado]

» autor: --540692--

#76 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

skaworld — Mon, 03 Dec 2018 13:38:09 +0000

#75 Creo que le debes un poco de respeto a la coprofagia acondroplasica germana, un género lleno de matices y sutilezas que no se merece tal desprecio

» autor: skaworld

#75 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

progreame — Mon, 03 Dec 2018 13:34:57 +0000

#17 me imagino que #14 lo dira porque javascript a palo seco es mas guarro que una peli porno alemana de enanos cagandose en el pecho. Con estas librerias como que se queda el lenguaje un poco mas apañado, aunque siga siendo el hermano feo de frankenstein.

» autor: progreame

#74 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Juan_Garcia — Mon, 03 Dec 2018 13:32:02 +0000

#68 Imagina que en vez de mover la fresita, estas moviendo la cámara de un juego 3D, y no tienes una fresita sino un millón, y el calculo es similar pero mas complejo.

» autor: Juan_Garcia

#73 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--507899-- — Mon, 03 Dec 2018 13:22:30 +0000

#71 facebook usa una extensión de Php llamada hack.
De yahoo ni idea de donde lo has leido,es dificil encontrar información de algo que esta muerto.

» autor: --507899--

#72 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--507899-- — Mon, 03 Dec 2018 13:15:58 +0000

#65 buena pelicula

» autor: --507899--

#71 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

SiCk — Mon, 03 Dec 2018 12:43:11 +0000

#37 Como Facebook, la wikipedia, yahoo.... no sé, cosas de empresas pequeñas y medianas.

» autor: SiCk

#70 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--148836-- — Mon, 03 Dec 2018 12:35:12 +0000

Probablemente al factorizar la multiplicación, el JIT optimice mejor el desenroscado del bucle en el bytecode al tener un stack separado que no necesita preservar.

» autor: --148836--

#69 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Mon, 03 Dec 2018 12:29:10 +0000

java como plataforma o como lenguaje?

» autor: --23321--

#68 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Mon, 03 Dec 2018 12:26:48 +0000

#50 la Fresita no creo que haga mil millones de operaciones aritméticas como la descrita, no es realista y significaría que el juego está muy mal hecho.

» autor: --23321--

#67 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--23321-- — Mon, 03 Dec 2018 12:24:46 +0000

#3 me dedico a esta industria hace mucho tiempo, y este tipo de cosas no solo no diferencia a un buen programador de un mal programador, sino que suele ser al revés.

Los buenos programadores saben que lo más importante es estructurar el programa de forma correcta, y que como consecuencia de una buena estructura, se obtiene mayor rendimiento, escalabilidad y seguridad, simplemente por qué un programa estructurado correctamente, cambiar cosas es muy fácil, y donde ponia 2*I*I mañana pone otra cosa, sin casi ningun coste.

Mientras tanto, el programador Junior hace programas de mierda, que no se pueden mantener ni extender según se necesite, pero habitualmente habla del rendimiento y de este tipo de trucos específicos de la plataforma.... Como si ese tipo de cosas, fuesen a cambiar el hecho de que mantener y extender su programa es un infierno, y que cuando aparezcan nuevos truquitos de la plataforma, el no podrá aplicarlos fácilmente a su programa, mientras que los programadores expertos con programas mantenibles y extensibles si podrán.

» autor: --23321--

#66 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

triturator — Mon, 03 Dec 2018 12:22:58 +0000

#64 shl (shift left) desplaza a la izquierda y por tanto multiplica por dos, y shr desplaza a la derecha y divide por dos. Puedes multiplicar dividir por una potencia de 2 (2, 4, 8...) a coste casi cero. En cambio, multiplicar son unos cuantos ciclos.

Obviamente el tema sólo vale para enteros, para floats y compañía no cuela el truqui.

» autor: triturator

#65 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--544691-- — Mon, 03 Dec 2018 12:22:41 +0000

#37 Django ...

» autor: --544691--

#64 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

albandy — Mon, 03 Dec 2018 12:20:04 +0000

#58 #55 Y si no recuerdo mal la instrucción era shl o algo así, la que no rota (hace muchos años ya que hice ensamblador en ingeniería informática).

» autor: albandy

#63 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

triturator — Mon, 03 Dec 2018 12:19:20 +0000

#58 Sí, multiplicar por dos se resuelve con un desplazamiento, pero en este caso esa no puede ser la solución, ya que, con paréntesis o sin ellos, tienes que hacer las mismas operaciones: un desplazamiento y una multiplicación. Y la multiplicación tarda lo mismo, sea con números grandes o pequeños.

Al final, la respuesta está en el propio enlace: simplemente el optimizador de código es mierder y en un caso no optimiza lo suficiente. Probablemente en alguna versión posterior lo mejoren, y se resolverá el tema.

» autor: triturator

#62 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

squanchy — Mon, 03 Dec 2018 12:18:27 +0000

#3 Hombre, este ejemplo quizás sea un poco excesivo, pero sí que ves mala praxis a diario. Gente que declara variables dentro de bucles que se ejecutan miles de veces o que concatenan cadenas enormes con el operador +=

» autor: squanchy

#61 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--569461-- — Mon, 03 Dec 2018 12:16:12 +0000

#1 Ya me jodería odiar el lenguaje que se ha convertido en el estándar de la industria....

» autor: --569461--

#60 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

scalvo — Mon, 03 Dec 2018 12:15:44 +0000

#50 el milisegundo me lo he sacado de la manga. La diferencia de 0.10 segundos se da en 1000 millones de iteraciones. Si tú mueves la fresita cambiando la "x" y la "y" en una cuadrícula 2D de píxeles, y la calculas en un bucle que tenga en cuenta todos los píxeles de la imagen a mover, tendrás unos pocos cientos (miles como mucho) de iteraciones. Por tanto la diferencia será prácticamente despreciable y por eso me saco de la manga el milisegundo en una app. En realidad el movimiento de X e Y lo tendrás parametrizado de algún modo, así que ni tendrás que iterar sobre la matriz de píxeles.

Si tú estás trabajando en un juego en HD para video consola ese desfase quizá, sólo quizá, fuera apreciable en casos muy extremos... pero dudo mucho que lo fuera. Francamente lo dudo... además, nunca hemos visto en videojuegos cosas como que haya monigotes que atraviesen paredes o se queden "atorados" en bordes geométricos...

Y si estás trabajando en determinados proyectos muy, muy concretos que exijan un enorme número de operaciones matemáticas en tiempo real (francamente, no se me ocurre ninguno...) pues tal vez se note.

» autor: scalvo

#59 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

dr_psy — Mon, 03 Dec 2018 12:12:39 +0000

#52 Carmack podría haber usado 1/sqrt() clásico. los ordenadores x86 tiene una instrucción dedicada para la raiz cuadrada, pero es mucho más lenta que un desplazamiento binario, una resta y un par de multiplicaciones. Aunque es una aproximación, con ello ganaban rendimiento. El hecho de que la ñapa se haga con ese código o con otro por temas de patentes no es el punto de mi comentario. A lo que iba es que ganando rendimiento en una sola función que se usa millones de veces puede tener un incremento de rendimiento bestial en la aplicación final

» autor: dr_psy

#58 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

albandy — Mon, 03 Dec 2018 12:12:28 +0000

#55 Cuando multiplicas por 2 solo haces 1 mov

1 --> 1 * 2 --> 10
2 --> 10 *2 --> 100
3--> 11 * 2 --> 110
4-->100 *2 --> 1000

» autor: albandy

#57 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

triturator — Mon, 03 Dec 2018 12:09:43 +0000

#3 Teniendo en cuenta que es un fallo de la máquina virtual, más que dedicar tiempo a optimizar esto lo eficiente es reportarlo, y esperar a la siguiente versión de la máquina virtual que arregle el problema.

» autor: triturator

#56 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

triturator — Mon, 03 Dec 2018 12:08:57 +0000

#9 Si tienes que hacer semejante número de operaciones en bucle como para notar este tipo de cosas, me da a mí que el buen programador buscaría una herramienta mejor para hacerlo que a pelo en Java. Algo tipo CUDA, o alguna librería para cálculo masivo.

» autor: triturator

#55 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

triturator — Mon, 03 Dec 2018 12:07:29 +0000

#30 Salvo que te estés saliendo de rango y necesites un tipo más gordo, cuesta el mismo tiempo/recursos multiplicar 2x2 que 2.000.000x2.000.000. Los circuitos no funcionan así.

» autor: triturator

#54 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

garuse — Mon, 03 Dec 2018 12:07:17 +0000

El problema viene cuando el servidor de turno (tomcat, ihs, was) empieza a devorar recursos.

Entonces si dices, f*ck java x''DDDD

» autor: garuse

#53 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

xavigo — Mon, 03 Dec 2018 12:07:03 +0000

¿Nadie pregunta porqué multiplicar por 2 cuando puedes shiftar un cero por la derecha y ser más eficiente?

» autor: xavigo

#52 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

triturator — Mon, 03 Dec 2018 12:05:10 +0000

#51 No permitió que funcionase, permitió liberar el código sin problemas legales, porque el algoritmo "clásico" tenía una patente en vigor.

Lo cual demuestra que John Carmack es el puto amo, básicamente.

» autor: triturator

#51 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

dr_psy — Mon, 03 Dec 2018 11:58:41 +0000

#4 en.wikipedia.org/wiki/Fast_inverse_square_root

float Q_rsqrt( float number )
{
long i;
float x2, y;
const float threehalfs = 1.5F;

x2 = number * 0.5F;
y = number;
i = * ( long * ) &y; // evil floating point bit level hacking
i = 0x5f3759df - ( i >> 1 ); // what the fuck?
y = * ( float * ) &i;
y = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
// y = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed

return y;
}

Esa ñapa permitió que quake 3 funcionara en los pcs de la época. No subestimes el incremento de rendimiento que te da acelerar una simple función

» autor: dr_psy

#50 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Juan_Garcia — Mon, 03 Dec 2018 11:58:41 +0000

#47 no se que medidas tomas tu, pero 0,10 no es un miliseguno, es 1/10 segundos o lo que es lo mismo 100 milisegundos. En juego a 30 frames/segundo (33ms cada frame) estamos hablando de 3 frames que pierdes en mover la fresita.

» autor: Juan_Garcia

#49 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

scalvo — Mon, 03 Dec 2018 11:52:56 +0000

#46 Qué lenguaje no lo es?
Se me ocurren motivos por lo que casi todos los lenguajes más usados son una puta mierda.
También se me ocurren motivos por los que casi todos son estupendos.

P.D: No me gusta java, pero decir que es una puta mierda es una gilipollez.

» autor: scalvo

#48 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

delsegura — Mon, 03 Dec 2018 11:50:18 +0000

#1 programa en Rails!!!

» autor: delsegura

#47 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

scalvo — Mon, 03 Dec 2018 11:49:48 +0000

#44 0.10 en mil millones de iteraciones.
Vamos, lo que viene siendo una diferencia al mover una fresita en un juego de mover frutas de quizá un milisegundo.
Optimiza ahora todos los i*i para pasarlos a (i*i) para ahorrar ese milisegundo...

» autor: scalvo

#46 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Ovidio — Mon, 03 Dec 2018 11:42:07 +0000

¿Porque Java es una puta mierda de lenguaje?

» autor: Ovidio

#45 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--424445-- — Mon, 03 Dec 2018 11:38:21 +0000

Viene al caso

» autor: --424445--

#44 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Juan_Garcia — Mon, 03 Dec 2018 11:36:13 +0000

#38 en la noticia ya esta en un loop, pero 0,10 segundos puede ser mucho dependiendo de lo que estes calculando. Por ejemplo, en un videojuego, 0,10 segundos en tus cálculos es mucho tiempo.

» autor: Juan_Garcia

#43 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--549461-- — Mon, 03 Dec 2018 11:35:27 +0000

#1 #13 a ver, que estamos hablando de 0.10 segundos en 1000000000 iteraciones, el tiempo de 1000 millones de multiplicaciones

» autor: --549461--

#42 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Juan_Garcia — Mon, 03 Dec 2018 11:33:41 +0000

#4 0,10 segundos en un algoritmo iterativo complejo con muchos cálculos, se pueden convertir en algunos segundos ;).

0,10 segundos en un calculo en tiempo real necesario en un videojuego es ralentización segura.

» autor: Juan_Garcia

#41 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--32677-- — Mon, 03 Dec 2018 11:31:32 +0000

#22 hay que revindicarlo más. Eso, o seguir con noticias de VOX

» autor: --32677--

#40 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--164239-- — Mon, 03 Dec 2018 11:30:14 +0000

Lo gracioso, o no tanto, es como el programa simplemente compilado en C puede ir 5 veces más rapido, y sin tener que cargar una maquina virtual ni implementar un jit.

» autor: --164239--

#39 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

clstrife — Mon, 03 Dec 2018 11:26:59 +0000

Me encanta como todos los comentarios intentan encontrarle una razón y todos se equivocan porque no se han leído la respuesta de stackoverflow.
Desde luego da la sensación que la mayoría aquí para solucionar sus problemas entra en stackoverflow, copian y pegan la solución y a ver si funciona, total para qué leer primero de qué va la solución.

» autor: clstrife

#38 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

StrgAttractor — Mon, 03 Dec 2018 11:22:42 +0000

#6 o metido en un loop.

» autor: StrgAttractor

#37 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--507899-- — Mon, 03 Dec 2018 11:22:15 +0000

#32 wordpress tiene mas agujeros de seguridad que un queso gruyere.
Para ERPS Java->todo.
PHP esta muy bien para empresas medianas y pequeñas,pero las grandes van a Java,ya que les da igual las pelas que cuesten los servidores,se ahorran mucho con lo fácil que es implementar el proyecto en Java.

» autor: --507899--

#36 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Kenzoryyy — Mon, 03 Dec 2018 11:22:10 +0000

#20 y que tal iria esta? > ||*|| mas rápido no se, pero igual tu aplicación se independiza en cuanto no te des cuenta

» autor: Kenzoryyy

#35 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--544457-- — Mon, 03 Dec 2018 11:19:40 +0000

# su gusto está fuera de duda...salvo por esa manía de repudiar a Charlize Theron...por lo demás de acuerdo en todo.

» autor: --544457--

#34 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

MarcusStern — Mon, 03 Dec 2018 11:19:32 +0000

#20 He cambiado 2 * i * i por 2* (i*i) en mi aplicación y ahora mis relaciones con las mujeres son mucho más fructiferas, mi cabello tiene más fuerza y volumen y resucitó a mi gatito. Nunca podré agradecer del todo esta mejora.

» autor: MarcusStern

#33 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

aqeloutro — Mon, 03 Dec 2018 11:19:23 +0000

#3 Totalmente en desacuerdo. Aquí el mal programador sería en tal caso el que hizo el compilador, ya que no existe ninguna justificación lógica para que 2 * (i * i) genere distinto bytecode que 2 * i * i.

» autor: aqeloutro

#32 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

javito118 — Mon, 03 Dec 2018 11:18:33 +0000

#15 Lo que tu quieras con PHP pero es uno de los lenguajes mas utilizados para desarrollo web. Los CMS mas populares ya sea wordpress, drupal, joomla o para ecommerce prestashop, magento estan desarrollados en php

» autor: javito118

#31 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--32677-- — Mon, 03 Dec 2018 11:17:09 +0000

#29 cariño me sumo a las modas, y la moda ahora es odiar Java. Pues no se hable más, odio Java.

jajaajaj

» autor: --32677--

#30 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

albandy — Mon, 03 Dec 2018 11:16:55 +0000

Basicamente porque multiplicar por 2 es extremadamente fácil y cuanto más grande sea el número a multiplicar por 2 más tiempo ahorrará.
Supongamos que multiplicar x2 es un 10% más rápido que multiplicar por cualquier otro número.
La multiplicación tiene un coste (hay bastantes mov, push cambios de registro etc...)
Si yo multiplico 2x500x500 primero hago 2x500=1000 y luego 1000*500 Nos queda que el numéro más grande no se ultiplica por dos
En cambio si yo multiplico (500x500) tengo 250000 y luego lo multiplico por 2 por lo que la operación más costosa la hago con el multiplicador más fácil para la máquina.

» autor: albandy

#29 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

skaworld — Mon, 03 Dec 2018 11:16:37 +0000

#24 Lo se pero amos quejarse de java desde otro lenguaje de tipado debil

» autor: skaworld

#28 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--388484-- — Mon, 03 Dec 2018 11:16:29 +0000

#15 No soy informatico y de lenguajes se mas bien poco. Pero, y lo que me he reido

» autor: --388484--

#27 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--584702-- — Mon, 03 Dec 2018 11:16:06 +0000

[Usuario deshabilitado]

» autor: --584702--

#26 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--507899-- — Mon, 03 Dec 2018 11:15:41 +0000

#25 Java es para dummies,conviértete,ven al lado oscuro.

» autor: --507899--

#25 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--32677-- — Mon, 03 Dec 2018 11:14:28 +0000

#15 demasiado subjetivo . Está hecho por alguien que ama Java, se ve.

» autor: --32677--

#24 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--32677-- — Mon, 03 Dec 2018 11:13:32 +0000

#17 homeeeeeeeeee, no tiene nada que ver uno con el otro eh!

» autor: --32677--

#23 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

kucho — Mon, 03 Dec 2018 11:13:28 +0000

yo diria que porque multiplicar 2i por i es mas lento que i*i y desplazar un bit a la izquierda.

» autor: kucho

#22 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

hamahiru — Mon, 03 Dec 2018 11:10:48 +0000

Me encanta el olor a Meneame Classic^TM por la mañana.

» autor: hamahiru

#21 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--453740-- — Mon, 03 Dec 2018 11:08:02 +0000

#4 Depende de lo que programes.

Yo estoy ahora mismo con aplicaciones donde hay un tiempo de ciclo de 20ms.
100 milisegundos es una aplicación que no funciona.

» autor: --453740--

#20 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Pecinejo — Mon, 03 Dec 2018 11:06:43 +0000

He cambiado 2 * i * i por 2* (i*i) en mi aplicación y ahora consume un 20% menos de CPU, un 25% de memoria y sin más, acaba de ganar a Alpha 0 al ajedrez mientras conducía un Tesla camino a Venus.

#lo_del_i*i

» autor: Pecinejo

#19 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Caresth — Mon, 03 Dec 2018 11:05:33 +0000

#11 Corrigiendo mi comentario y el tuyo, la diferencia la mide al correr un programa que hace la operación mil millones de veces. Vamos, que para cada iteración viene siendo bastante desdeñable. Eso no quita, como dice #13, que sea una diferencia en un programa muy sencillo, y que en temas complicados sí sea apreciable.

» autor: Caresth

#18 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--582338-- — Mon, 03 Dec 2018 11:05:11 +0000

» autor: --582338--

#17 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

skaworld — Mon, 03 Dec 2018 11:03:04 +0000

#14 Tiene cojones que se queje la reinona de java y esté mirando javascript

» autor: skaworld

#16 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--419859-- — Mon, 03 Dec 2018 11:02:57 +0000

#4 Todo depende de qué estés progamando, y de cuantas veces realices operaciones similares.

» autor: --419859--

#15 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--507899-- — Mon, 03 Dec 2018 11:02:47 +0000

#12 i.redd.it/3w74rvpac2911.jpg
Nada mas que añadir.

» autor: --507899--

#14 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--32677-- — Mon, 03 Dec 2018 11:02:04 +0000

#13 me he liado con REACT al final jajaja

» autor: --32677--

#13 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

skaworld — Mon, 03 Dec 2018 11:01:15 +0000

#2 #5 #3 #4 La diferencia en tiempo de ejecucuion puede ser de 0,10 segundos ahora bien en un proceso iterativo que recorra mierda esos 0,1 segundos igual son 45 minutos de proceso en vacio del cpd y ahi si que se empieza a notar la cosa.

No subestimeis las bajadas de rendimiento para estas movidas, para una app para usuario normal claro que te la pela, para procesos que corren en backend en job con miles de operaciones igual no.

#1 Y usted, haga el favor de reciclarse en un lenguaje ya y dejar de insultarlos todos

» autor: skaworld

#12 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--32677-- — Mon, 03 Dec 2018 11:01:00 +0000

#7 PHP y JavaScript te envían un abrazo.

» autor: --32677--

#11 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

numero — Mon, 03 Dec 2018 11:00:57 +0000

#4 No es una diferencia de 0,05 segundos, es una diferencia del 8% del tiempo.

Si esa operación se ejecuta 1.000 veces a lo largo de un programa, es una diferencia considerable.

» autor: numero

#10 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--507899-- — Mon, 03 Dec 2018 11:00:56 +0000

#4 quizás esta de mantenimiento,entonces tiene tiempo de sobra para hacer eso,si se descuenta algo de tiempo de su hora de café(8 horas al día)

» autor: --507899--

#9 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Caresth — Mon, 03 Dec 2018 11:00:01 +0000

#4 Bueno, si la operación está en un bucle o una consulta tocha, se va acumulando esa mejora. Y eso sí es de buen programador. Si los nuevos programadores optimizasen como los del principio, igual no habría que estar multiplicando la potencia de las máquinas cada 2 años.

» autor: Caresth

#8 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--507899-- — Mon, 03 Dec 2018 10:59:52 +0000

#2 tortilla de patatas con grafeno y cebolla dentro de un opel corsa,eso no fallaría nunca.

» autor: --507899--

#7 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--507899-- — Mon, 03 Dec 2018 10:59:16 +0000

#1 antes me caías bien,pero veo que eres un tio con un gusto cuestionable.

» autor: --507899--

#6 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--430178-- — Mon, 03 Dec 2018 10:59:13 +0000

#4 Despues nos quejamos de los recursos que requieren ciertos juegos y que a pesar de tener un pepino de maquina aun hay lag. Seran 0.1 seg aqui, pero solo en esta linea de codigo, ahora piensa en una aplicacion con 100.000 lineas de codigo.

» autor: --430178--

#5 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

ElLocoDelMolino — Mon, 03 Dec 2018 10:57:38 +0000

#2 ya es hora de que la sociedad despierte y coja el toro por lo cuernos. A los niños no se les puede seguir contando historias edulcoradas de cigüeñas que vienen de París. No podemos seguir haciendo como si aquí no pasase nada mientras 2*i*i tarda más que 2*(i*i) y miramos hipócritamente hacia otro lado mientras egoistamente nos dedicamos a lo nuestro sin preocuparnos por el vecino.

» autor: ElLocoDelMolino

#4 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--595012-- — Mon, 03 Dec 2018 10:56:34 +0000

#3 La diferencia de tiempo de ejecución es de 0,10 segundos; eso no es ser un buen programador, es tener demasiado tiempo libre.

» autor: --595012--

#3 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

numero — Mon, 03 Dec 2018 10:54:50 +0000

Muy bueno. El tener conocimiento de estas cosas, y ahorrar varios segundos de ejecución en un programa, diferencia de un programador de un buen programador.

» autor: numero

#2 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

Pecinejo — Mon, 03 Dec 2018 10:54:45 +0000

Siempre me lo habría preguntado pero nunca me atreví a hacerlo. Gracias.

Si esto no llega a portada yo ya no sé que va a llegar.

» autor: Pecinejo

#1 ¿Por qué es 2 * (i * i) más rápido que 2 * i * i en Java? (Eng)

--32677-- — Mon, 03 Dec 2018 10:54:20 +0000

porque java apesta

#killJava

» autor: --32677--