Menéame: comentarios [2685492]

#52 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

manalalo — Tue, 18 Oct 2016 10:26:42 +0000

Soy novato en esto. Pero supongo que empleará una función recursiva muy potente.

» autor: manalalo

#51 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

slowRider — Tue, 18 Oct 2016 08:34:35 +0000

mira que he tirado líneas de C pero nunca se me hubiera ocurrido algo como esto!

» autor: slowRider

#50 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

uname — Mon, 17 Oct 2016 23:30:51 +0000

#48 Aquí está lo que han hecho los demás por si te pica la curiosidad:

codegolf.stackexchange.com/questions/69189/build-a-compiler-bomb

El de python 3 es mejor según la reglas, pero se gana por votaciones.

» autor: uname

#49 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

jmpep — Mon, 17 Oct 2016 23:24:57 +0000

#3 Con 29 bytes de Boost no has acabado ni el primer #ifdef

» autor: jmpep

#48 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--143520-- — Mon, 17 Oct 2016 21:29:18 +0000

Habrán ganado por las reglas, así que no discuto su victoria pero me ha parecido poco creativo, habría que ver que han hecho los demás.

» autor: --143520--

#47 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--14466-- — Mon, 17 Oct 2016 20:13:46 +0000

#39 Tiene gracia. Casi me peta el PC de la risa
Disclaimer. Me he pasado el finde con el UNK6 de pokemon (Superfriki)

» autor: --14466--

#46 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

Sandler — Mon, 17 Oct 2016 17:29:24 +0000

No os basta con el propio Windows como ejemplo de compilado enorme con no demasiado sentido?

» autor: Sandler

#45 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

stygyan — Mon, 17 Oct 2016 16:56:34 +0000

#29 yo siempre he dicho que la gente no hetero somos menos aceptados en el mundo de IT porque follamos más y tal. Pero en plan coña, ojo.

» autor: stygyan

#44 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

pedrobz — Mon, 17 Oct 2016 15:32:33 +0000

#42 Los distingo perfectamente, solo aprovecho la fama que tiene Java de tragamemoria para meter un chiste con calzador.

» autor: pedrobz

#43 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

pawer13 — Mon, 17 Oct 2016 13:58:53 +0000

#41 Si quieres ejecutarlo sin instalar el JRE pues es normal, sobre todo si usas JFX que es una librería que no venía en las versiones anteriores, pero si asumes que vas a tenerlo en la máquina el JAR generado son unos pocos KB

» autor: pawer13

#42 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

elzahr — Mon, 17 Oct 2016 13:46:43 +0000

#18 Ese es el nivel. Se atreve a criticar a Java alguien que no sabe diferenciar entre espacio de memoria y espacio de compilado.. anda ya..

» autor: elzahr

#41 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

pedrobz — Mon, 17 Oct 2016 13:43:39 +0000

#40 O una simple calculadora en un ejecutable, que el instalador que te crea por defecto la jdk 8 ocupa 150mb, y eso que solo es una triste ventana de javaFX sin imágenes...

» autor: pedrobz

#40 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

pawer13 — Mon, 17 Oct 2016 13:15:22 +0000

#18 hombre, si por "cualquier cosa" te refieres a un contenedor j2ee con un EAR con unas pocas miles de clases, pues sí.

» autor: pawer13

#39 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--519574-- — Mon, 17 Oct 2016 11:43:57 +0000

#30 La primera vez me dio un error y tuve que escribir el mensaje de nuevo :o

» autor: --519574--

#38 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

Dalocer — Mon, 17 Oct 2016 11:36:44 +0000

codegolf.stackexchange.com/questions/69189/build-a-compiler-bomb/69811

» autor: Dalocer

#37 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

Marinmenyo — Mon, 17 Oct 2016 11:04:04 +0000

#15 Los flags usados al compilar tmb cuentan

» autor: Marinmenyo

#36 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

angelitoMagno — Mon, 17 Oct 2016 10:48:34 +0000

#35 ¿Tu también eres tonto?

» autor: angelitoMagno

#35 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

porcorosso — Mon, 17 Oct 2016 10:47:48 +0000

#26 ¿Tu también eres virgen?

» autor: porcorosso

#34 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

uname — Mon, 17 Oct 2016 10:42:31 +0000

Con gcc compila, lo he probado para el standard 89 y también para el 11. Lo que si da es el warning típico de no especificar el tipo de main, habría que añadir cuatro bytes más para que la compilación sea limpia, lo que dejaría el fuente en 19 bytes con salto de línea al final:

int main[-1u]={1};

» autor: uname

#33 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

redjhawk — Mon, 17 Oct 2016 10:41:39 +0000

A mi me da un error "/usr/bin/ld: final link failed: Memory exhausted"

» autor: redjhawk

#32 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

fcruz — Mon, 17 Oct 2016 10:39:56 +0000

#29 Este se quedó en los 80.

» autor: fcruz

#31 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

pawer13 — Mon, 17 Oct 2016 10:38:58 +0000

#15 más 13 de parámetros en la línea de comandos al compilar.

» autor: pawer13

#30 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

Heimish — Mon, 17 Oct 2016 10:35:31 +0000

#24 #23 ¿Lo puedes volver a explicar? Es que con dos veces no me ha quedado claro

» autor: Heimish

#29 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--505393-- — Mon, 17 Oct 2016 10:34:18 +0000

#14 Pues no sé si el chaval es virgen o no, pero yo soy informático y ha habido épocas en mi vida que tenía la polla envuelta en paños calientes de tanto follar (y sin pagar).

Que pasa ¿que una cosa es incompatible con la otra?

Es decir: ¿No puedes ser virtuoso en tu trabajo y el fin de semana dedicarte a follar con todas las chicas que puedas?

#16

» autor: --505393--

#28 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

Heimish — Mon, 17 Oct 2016 10:34:13 +0000

#21 ¿No todos lo somos?

» autor: Heimish

#27 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--506045-- — Mon, 17 Oct 2016 10:29:29 +0000

#15 cierto.

0xffffffff tampoco es 500000, como dice el artículo.

» autor: --506045--

#26 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

angelitoMagno — Mon, 17 Oct 2016 10:29:14 +0000

#14 ¿Eres tonto?

» autor: angelitoMagno

#25 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

rcorp — Mon, 17 Oct 2016 10:28:37 +0000

#17 la prueba era generar el MAYOR número de bytes con el MÍNIMO de bytes de código
muy currado, bien por el tío este

» autor: rcorp

#24 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--519574-- — Mon, 17 Oct 2016 10:26:12 +0000

#17 Al contrario, estas suponiendo que la máquina destino implementa los negativos en complemento a 2, cuando no es necesariamente cierto.

» autor: --519574--

#23 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--519574-- — Mon, 17 Oct 2016 10:24:48 +0000

#17 Al contrario, estas suponiendo que la máquina destino implementa los negativos en complemento a 2.

Suele ser lo habitual, pero nadie te lo garantiza.

» autor: --519574--

#22 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

fuynfactory — Mon, 17 Oct 2016 10:23:40 +0000

#20 lo usaba para cargarme los disquetes powerbasic y hay que compilar para ejecutarse

» autor: fuynfactory

#21 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

rcorp — Mon, 17 Oct 2016 10:20:51 +0000

#16 jajjajaj @rafaojosverdes ha convertido esto en un Pregúntame de tipo: Soy informático, respondo preguntas
(pero su pregunta no tiene sentido, porque me parece que todos los informáticos somos vírgenes, no?)

» autor: rcorp

#20 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

timokotipelto — Mon, 17 Oct 2016 10:17:12 +0000

#7 Ademas no has entendido la "prueba", tiene que ser algo compilado, no la salida de la ejecucion del programa, un bucle infito generaria infita memoria.
La gracia esta en que esos 29 bytes, al compilarse (no al ejecutarse) generan un ejecutable de 16GB!

» autor: timokotipelto

#19 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

mefistófeles — Mon, 17 Oct 2016 10:16:48 +0000

Cabrones! Me hacéis viejo y torpe. Os odio a todos muy democráticamente (es decir, sin distinción de sexo, credo, raza ni nada)

No me he enterado de nada, ni de vuestros comentarios tampoco. Esta os la guardo, pandilla de ratreasanguijuelas

» autor: mefistófeles

#18 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

pedrobz — Mon, 17 Oct 2016 10:07:13 +0000

Bah, a mi no me sorprende. Cualquier programador Java ya esta acostumbrado a que cualquier cosa mas compleja que el Hola Mundo le ocupe gigas de espacio en memoria...

» autor: pedrobz

#17 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

asdfg — Mon, 17 Oct 2016 10:06:12 +0000

#12 bueno, usar -1 en unsigned es muy habitual en programación en c por que es independientemde la arquitectura (8, 16, 32 o 64 bits) y mas portable que max_int.

» autor: asdfg

#16 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--30529-- — Mon, 17 Oct 2016 10:00:27 +0000

[Usuario deshabilitado]

» autor: --30529--

#15 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

chavi — Mon, 17 Oct 2016 09:59:12 +0000

Yo solo cuento 16 bytes de código...

» autor: chavi

#14 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--270157-- — Mon, 17 Oct 2016 09:54:32 +0000

#6 eres virgen?

» autor: --270157--

#13 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--513049-- — Mon, 17 Oct 2016 09:53:46 +0000

Cuando se enteren los del Norton Antivirus se mueren de envidia,

» autor: --513049--

#12 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

rostro — Mon, 17 Oct 2016 09:51:37 +0000

#11 y no usar 0xffffffff, max_int o similares

» autor: rostro

#11 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

asdfg — Mon, 17 Oct 2016 09:50:37 +0000

#5 la gracia es hacerlo sobre main y no dentro de main.

» autor: asdfg

#10 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--505393-- — Mon, 17 Oct 2016 09:48:44 +0000

#7 Eso te pasa por saltarte la "valla".

» autor: --505393--

#9 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

teskmon — Mon, 17 Oct 2016 09:37:48 +0000

Corrección a mi comentario en #6: no es verdad que el array quede inicializado con el mismo valor en todas las componentes. Lo que dice el estándar es que las posiciones para las cuales no se especifique valor se inicializarán con cero. Estaba pensando en el caso particular en el que uno especifica como primera componente un cero, que produce como efecto lo que comentaba en #6. Sobre lo de que se admita que "main" sea un array en vez de una función: stackoverflow.com/a/34764930

» autor: teskmon

#8 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

rafran — Mon, 17 Oct 2016 07:47:53 +0000

Pero a que paginas nos enviais... que el firewall de la empresa no me deja entrar en la pagina (digo que será por la palabra 'hack')

» autor: rafran

#7 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

fuynfactory — Mon, 17 Oct 2016 07:43:31 +0000

//byte byte disk
1 shell "mkdir a"
2 shell "cd a"
3 goto 1

valla me paso de 29 bytes ... me quito el sombrero ...

» autor: fuynfactory

#6 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

teskmon — Mon, 17 Oct 2016 07:32:42 +0000

#2 El sufijo "u" hace que el número -1 se interprete como un "unsigned", que es un entero sin signo usando (al menos) 4 bytes. La representación en binario de -1 interpretado como un número sin signo corresponde al número 4294967295 (el mayor entero sin signo representable con 4 bytes). Por otra parte, el estándar de C dice que si inicializas un array dando valor solo a la primera componente, se usa el mismo valor para el resto de posiciones. Es una forma de forzar a reservar memoria estática.

» autor: teskmon

#5 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

Mister_Lala — Mon, 17 Oct 2016 07:31:41 +0000

No digo que no sea algo ingenioso, pero asignar memoria estáticamente no tiene mucho mérito. No pasa de mera curiosidad.

» autor: Mister_Lala

#4 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--78579-- — Mon, 17 Oct 2016 07:18:57 +0000

#2 sep, eso es. Es una forma abreviada de escribir 0xffffffffu.

No tengo el compilador delante, pero debo admitir que ser me hace raro que no acepte un número con signo como índice. ¿Alguien con un PC cerca para probar lo que pasa?

» autor: --78579--

#3 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

ur_quan_master — Mon, 17 Oct 2016 07:14:42 +0000

Bah.... Usando cualquier librería de la boost te peta el compilador igual y el executable queda tan grande o más.

» autor: ur_quan_master

#2 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

--58072-- — Mon, 17 Oct 2016 06:45:26 +0000

No acabo de entender que significa -1u

¿Infinito unsigned?

» autor: --58072--

#1 Veintinueve bytes de código que se convierten en 16 GB al compilar (compiler bomb)

rostro — Mon, 17 Oct 2016 06:30:16 +0000

Acabo de probarlo y funciona perfectamente. No he tenido que usar ningún flag a mayores. Menudo crack!

» autor: rostro