Mucho antes de que se inventara la fotocopiadora (1959), antes de que en el MIT empezaran a usar mensajes electrónicos para compartir información (1965), antes de que Ray Tomlinson incorporara el uso de la arroba para poder enviar mensajes a usuarios de otras máquinas (1971), el método más popular para hacer copias de los escritos era el papel carbón o papel de calco.

Quizás lo hayas visto usar, por ejemplo, a la hora de escribir un cheque, aunque su uso hoy en día es casi testimonial. Básicamente consiste en una hoja con carbón o tinta impregnada en una de sus caras que se coloca entre la hoja en que escribiremos y una hoja en blanco, de forma que la tinta se traspase a la hoja en blanco por la simple presión de la escritura.

La etiqueta de la época dictaba que las copias así conseguidas incluyeran los nombres de las personas que iban a recibirlas, precedidos de la abreviatura “cc”, costumbre que se trasladó a los correos electrónicos.

Si, como a mí, te encantan estas disertaciones inútiles con un toque de humor geek, también te encantará el último artículo del Departamento de Física y Astronomía de la Universidad de Leicester, en el que calculan cuánta energía necesitaría la Estrella de la Muerte para destruir un planeta, y si el malvado Imperio podría utilizarla para destruir la Tierra. Ya os adelanto que sí: no estamos seguros. Tendremos que mudarnos a un planeta algo mayor que Júpiter.

Sí, lo habéis adivinado; aunque quizás estéis más familiarizados con su derivado lumi, lumia no tiene nada que ver con la luz. Al menos en castellano. Según la RAE, lumia es una palabra en desuso, de orígen incierto, que significa prostituta, meretriz, cortesana, fulana, furcia, ramera o mesalina. En una palabra: puta.

Lo más curioso es que la compañía estaba al tanto del significado de este término en castellano, gracias a su equipo de lingüistas, que estudia las posibles connotaciones negativas de todas las marcas propuestas, pero decidieron seguir adelante después de un estudio de mercado en el que el 60% de los españoles encuestados afirmaron que era un gran nombre para un móvil.

En comparación, la Canon EOS 600D, premio TIPA 2011 a la mejor réflex para principiantes, cuenta con un sensor de 18 megapíxeles, sensibilidad máxima de 6400 ISO (12800 forzados) y rango dinámico de 11,5 pasos.

Este tipo de programas que se imprimen a sí mismos como salida (aunque en este caso, con una peculiaridad extra) se conocen con el nombre de quines, en honor al filósofo estadounidense Willard Van Orman Quine.

import Data.List

langs = [Haskell, Perl, Python, Ruby, C, Java]

data Languages = Haskell | Ruby | Perl | C | Python | Java

sequenceFromString Haskell s = "map toEnum[" ++ (intercalate "," $
    map (\c -> show (fromEnum c)) s) ++ "]"
sequenceFromString Perl s    = (intercalate "," $
    map (\c -> "chr(" ++ show (fromEnum c) ++ ")") s)
sequenceFromString Python s  = (intercalate "+" $
    map (\c -> "chr(" ++ show (fromEnum c) ++ ")") s)
sequenceFromString Ruby s    = (intercalate "+" $
    map (\c -> show (fromEnum c) ++ ".chr") s)
sequenceFromString C s       = concatMap
    (\c -> "putchar(" ++ show (fromEnum c) ++ ");") s
sequenceFromString Java s    = concatMap
    (\c -> "o.write(" ++ show (fromEnum c) ++ ");") s

paramList' Haskell = intercalate " " . map (\n -> "a" ++ show n)
paramList' C       = intercalate "," . map (\n -> "char *a" ++ show n)
paramList' Python  = intercalate "," . map (\n -> "a" ++ show n)
paramList' Ruby    = intercalate "," . map (\n -> "a" ++ show n)
paramList' Java    = intercalate "," . map (\n -> "String a" ++ show n)

paramList Perl    _ = ""
paramList lang n = paramList' lang [0..n-1]

driver l args = defn l ++ intercalate (divider l) args ++ endDefn l

divider C       = "\",\""
divider Perl    = "','"
divider Ruby    = "\",\""
divider Python  = "\",\""
divider Haskell = "\" \""
divider Java    = "\",\""

defn C       = "main(){q(\""
defn Perl    = "&q('"
defn Python  = "q(\""
defn Ruby    = "q(\""
defn Haskell = "main=q \""
defn Java    = "public static void main(String[]args){q(\""

endDefn C       = "\");}"
endDefn Perl    = "')"
endDefn Python  = "\")"
endDefn Ruby    = "\")"
endDefn Haskell = "\""
endDefn Java    = "\");}}"

arg Haskell n = "a" ++ show n
arg Perl n    = "$_[" ++ show n ++ "]"
arg C n       = "printf(a" ++ show n ++ ");"
arg Python n  = "a" ++ show n
arg Ruby n    = "a" ++ show n
arg Java n    = "o.print(a" ++ show n ++ ");"

argDivide Haskell l = "++" ++ sequenceFromString Haskell (divider l) ++ "++"
argDivide Perl l    = ","    ++ sequenceFromString Perl (divider l) ++ ","
argDivide C l       = sequenceFromString C (divider l)
argDivide Python l  = "+" ++ sequenceFromString Python (divider l) ++ "+"
argDivide Ruby l    = "+" ++ sequenceFromString Ruby (divider l) ++ "+"
argDivide Java l    = sequenceFromString Java (divider l)

argList lang1 lang2 n = intercalate (argDivide lang1 lang2) $
    map (arg lang1) ([1..n-1] ++ [0])

fromTo Haskell l n = "q " ++ paramList Haskell n ++ "=putStrLn$a0++" ++
    sequenceFromString Haskell ("\n" ++ defn l) ++ "++" ++
    argList Haskell l n ++ "++" ++ sequenceFromString Haskell (endDefn l)
fromTo Perl    l n = "sub q {" ++ "print $_[0]," ++
    sequenceFromString Perl ("\n" ++ defn l) ++ "," ++ argList Perl l n ++ "," ++
    sequenceFromString Perl (endDefn l ++ "\n") ++ "}"
fromTo Python  l n = "def q(" ++ paramList Python n ++
    "): print a0+" ++ sequenceFromString Python ("\n" ++ defn l) ++
    "+" ++ argList Python l n ++ "+" ++ sequenceFromString Python (endDefn l)
fromTo Ruby    l n = "def q(" ++ paramList Ruby n ++
    ") print a0+" ++ sequenceFromString Ruby ("\n" ++ defn l) ++
    "+" ++ argList Ruby l n ++ "+" ++ sequenceFromString Ruby (endDefn l ++ "\n") ++ " end"
fromTo C       l n = "q(" ++ paramList C n ++ "){" ++ "printf(a0);" ++
    sequenceFromString C ("\n" ++ defn l) ++ argList C l n ++
    sequenceFromString C (endDefn l ++ "\n") ++ "}"
fromTo Java    l n = "public class quine{public static void q(" ++
    paramList Java n ++ "){java.io.PrintStream o=System.out;o.print(a0);" ++
    sequenceFromString Java ("\n" ++ defn l) ++ argList Java l n ++
    sequenceFromString Java (endDefn l ++ "\n") ++ "}"

main = do
    let n = length langs
    let langs' = cycle langs
    putStrLn $ fromTo (head langs') (head (tail langs')) n
    putStrLn $ driver (head langs') $ zipWith (\lang1 lang2 -> fromTo lang1 lang2 n)
        (take n (tail langs')) (tail (tail langs'))

Vía Hacker News

“¿Y por qué hebreo?”, se preguntará alguno. El motivo es sencillo, y es que, como ya vimos en Una no tan breve historia de PHP, Zeev Suraski y Andi Gutmans, los dos programadores que crearon el Zend Engine, son ambos israelíes.

Os podéis encontrar con este nombre tan críptico, por ejemplo, al utilizar el operador condicional ternario y repetir el carácter de dos puntos por accidente. Si probáis a ejecutar el siguiente código:

<?php
$modo = $_SERVER['SERVER_NAME']!=='localhost'?'Debug'::'Producción';

PHP os responderá con un mensaje parecido a este:

Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM in /usr/local/apache/htdocs/ejemplo.php on line 2

Más detalles y fotografías en VicioJuegos, cuyos redactores pasaron la mañana inspeccionando las setas y las tuberías de la zona.