Todos conocen la frase "¡Las reglas están hechas para romperse!", Así que esta es su tarea:

Escriba algún código en cualquier idioma que rompa un estándar. Esto puede ser cualquier cosa, desde poner 240 voltios en un cable USB, hasta hacer ping a su enrutador (¡ NO el sitio web de otra persona!) Con un paquete de 10 MB. (¡No se te ocurra ninguna idea, ambos probablemente causarán todo tipo de fatalidad!)

¡La respuesta más votada después de 10 días (es decir, la violación más grave) ganará!

Reglas:

1. El código debe ser explicado.
2. El estándar que está rompiendo debe estar vinculado y debe explicar lo que está haciendo (implica 1) para romperlo. De lo contrario, no se aceptarán respuestas.
3. No se aceptarán las respuestas que simplemente bloqueen al intérprete o hagan que deje de funcionar. Me gustaría algunas respuestas creativas, no solo pegar algo como 𐒢en IDLE (que lo bloquea)
4. Los errores de explotación no están permitidos, a menos que rompan un estándar. De lo contrario, no se aceptarán respuestas.

¡Comienza y diviértete!

Pitón

print 'Hello World'

Explicación:

El estándar de la programación de puzzles y código de intercambio de pila de golf es

Lee la pregunta cuidadosamente. ¿Qué, específicamente, está preguntando? Asegúrese de que su respuesta indique que

Este código no responde la pregunta, por lo que rompe el estándar.

C
Aquí hay un programa factorial que compila y se ejecuta con éxito (con gcc4.6.3 en Ubuntu 12.04), pero invoca tantos comportamientos indefinidos según el estándar C como podría incluir. La mayoría están inspirados desde aquí . Gran parte del código legal restante es simplemente malo.

int read(char** src, int into){
  int _r;                             //leading underscores reserved, and
  if (!--into) sscanf(*src,"%d",&into); //_r uninitalized
  *(*(--src)+into)=_r>>360;            //shifting more bits than we have
  while (into-->0) (*src)[into]='.'; //modifying const char argv
  printf(*src); // no return statement
}

main(int argc, const char** const argv){
  union  { int x; float y;} result;
  int f,minus1=0xFFFFFFFF,r,a[]={0};
  r=a[3]&2;                     //accessing past end of array
  result.x=read(&argv[r],--r);  //relying on order of arguments
  for(f=*(int*)&result.y;f;f+=minus1) //type punning/invalid union access,
    r*=f;                            //and unsigned overflow
  printf("%d\n",(&r+2)[-2]); //negative array indexes
}

XHTML

<p>
   <div></div>
</p>

La especificación W3C ( http://www.w3.org/TR/html-markup/p.html#p ):

p - párrafo

El elemento p representa un párrafo.

Contenidos permitidos

Contenido de fraseo

¡Oh, me siento sucio!

Editar: @xfix señaló que el error que estaba mostrando era en realidad XHTML. El error de HTML que esto causa es más frío y menos obvio de modo que:

<p><div></div><p>se vuelve <p /><div></div></p>porque <div>hace que el <p>auto cierre. Por lo tanto, se produce un error porque estamos intentando cerrar un párrafo que no existe.

HTTP / 1.1: Respuesta - Código de estado y frase de razón

El elemento de código de estado es un 3 dígitos ...

¿Necesito ir más allá? Este código de estado no es uno de los códigos definidos en el estándar. Ni siquiera comienza con uno de los dígitos de categoría requeridos. Ni siquiera tiene 3 dígitos de largo.

Mi navegador aún se las arregla para cargar bien la página.

Además, esta respuesta rompe uno de los "estándares" de este sitio :)

Salida (línea de estado):

HTTP/1.1 0 :)

var http = require("http");
var server = http.createServer(onHttpRequest);
server.listen(80);

function onHttpRequest(request, response)
{
    response.writeHead(0, ":)", { "Content-Type": "text/plain" });
    response.write("Hello, World!");
    response.end();
}

JavaScript (nodo)

¿Cuántos estándares acabo de romper?

Realmente hice una programación horrible aquí.

PHP

a: goto lol; begin();
b: 
c: echo j; goto h;
d: echo u;
e: echo s;
f: echo t;
g: 
h: echo k; goto o;
i: echo i; goto c;
j: echo l;
k: echo l;
l: echo e;
m: echo d;
n:
o: echo s;
p: echo t; goto u;
q: echo a; goto z;
r: echo n;
s: echo d;
t: echo a;
u: echo r; goto q;
v: echo D; goto i;
w: echo s;
x: 
y:
z: die("!");
lol: goto v;

Huevo de Pascua: Las echoletras ed, si se lee verticalmente, leerá just killed standarDs!.

Nota al margen: Ejecutar este programa generará el nombre de un chico que realmente amaba goto.

C # - rompiendo Unicode

Algoritmo simple para revertir una cadena:

public string Reverse(string s)
{
    StringBuilder builder = new StringBuilder();
    for (int i = s.Length - 1; i >= 0; i--)
    {
        builder.Append(s[i]);
    }
    return builder.ToString();
}

Esto rompe el estándar Unicode , porque no mantiene correctamente los pares sustitutos juntos, creando una cadena no válida. En .NET y muchas otras plataformas / lenguajes de programación, a charno es realmente un personaje, sino una unidad de código UTF-16 .

NB: también cambia qué letra se combina con las marcas de combinación subsiguientes (p. Ej., Signos diacríticos), que pueden o no ser intencionadas.

JavaScript

Ejecútelo en la consola en esta página.

var items = [], p = 1, finish = false, intr = setInterval(function() {
    if (p >= 10) finish = true
    $.get(unescape(escape('http://api.stackexchange.com/2.2/answers?page=' + (p++) + '&pagesize=100&order=desc&sort=votes&site=codegolf&filter=!*LVwAFZ.YnaK-KS*')), function(x) {
        items = items.concat(x.items)
        if (finish) {
            clearInterval(intr)
            onFinish()
        }
    })
}, 500)

function onFinish() {
    var item = items[Math.floor(Math.random() * items.length)]
    document.write(item.body)
}

Inspirado por

La mayoría de las respuestas en este sitio violan al menos un estándar de codificación ... - Comintern Hace 1 hora

Lo que hace es generar una respuesta aleatoria de los 1000 mejores votados de codegolf.SE (es decir, ¡resolver el problema de una manera muy meta!), ¡Con formato y todo, en su página!

Desafortunadamente, esto técnicamente no satisface las reglas, ya que la salida es el código con los estándares rotos, por lo que document.writerompí un estándar en este código, lo usé (ewwww). También tengo que proporcionar un enlace, así que aquí: ¿Por qué document.write se considera una "mala práctica"?

Si eso no cuenta como "romper los estándares", por si acaso, envolví mi cadena unescape(escape()), que está en desuso, según MDN .

Tenga en cuenta que realmente estoy haciendo todo esto para evitar las reglas, y el punto principal de esta respuesta es su salida.

Ejecución de muestra (haga clic en la imagen para ampliar):

XML

No es mi "invención", en realidad tengo que trabajar con XML como este que obtenemos de un lugar muy secreto:

<?xml version="1.0"?>
<!DOCTYPE data [
  <!ELEMENT data (field2)>
  <!ELEMENT field2 (#PCDATA)>
]>
<data>
  <field1>Rock & Roll</field1>
</data>
<data>
  <field1>Something else</field1>
</data>

No se valida contra su propio DTD incorporado, contiene múltiples raíces y símbolos de escape sin escape. (También hay otros errores de nivel superior, modelo de contenido ambiguo, etc., no demostrados aquí.) Muy triste.

La RFC 950 permitió pero la máscara de red a máscaras de bits que no son contigo, pero está altamente desaconsejada, pero ahora está prohibido a partir de RFC 1219. Sin embargo, los me gusta de BSD le permiten hacer esto.

Las máscaras de red IPv4 son una combinación de cuatro bytes, al igual que una dirección IP. Se utiliza para calcular si dos hosts con direcciones IP y máscaras de red conocidas están en la misma red. En general, una dirección IP consta de dos partes: la red y la parte del host. Digamos que su red en casa es 192.168.1.1- 192.168.1.254. La parte del host son los primeros tres bytes de la IP, a saber 192.168.1.x. Esto significa que la máscara de red es 255.255.255.0, lo que significa que los primeros 24 bits son la parte de la red. En binario la máscara se parece 11111111.11111111.11111111.00000000. Los 1 bits son continuos. En mi ejemplo, la máscara de red sería 00010111.00000000.00000000.00101010. Entonces, ¿qué pasaría si la máscara de red no es continua? En lugar de estar en el extremo derecho, la parte del host está dispersa en toda la dirección IP, lo que hace que sea realmente difícil de leer, al igual que mi explicación aquí.

¡NO esperes que nada funcione después de esto!

root@Gotthold /v/root# ifconfig en0 inet 47.11.23.42 netmask 23.0.0.42
root@Gotthold /v/root# ifconfig en0 inet
en0: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 8192
    options=b<RXCSUM,TXCSUM,VLAN_HWTAGGING>
    inet 47.11.23.42 netmask 0x1700002a broadcast 239.255.255.255

C

¿Cuántos errores puede encontrar, lo que probablemente haría que la mayoría de las empresas rechacen su código (especialmente los buenos)? La mayoría de estos son probablemente errores de estilo (que espero que nadie haga), pero algunos de estos son comportamientos indefinidos.

    #define BEGIN {
    #define END }
    #define print printf
    void main(int argv, char* argc, char **args) BEGIN
print("hELLO,"); printf("WORLD");
    END

1. Define macros que hacen que C se sienta como otro lenguaje (la mayoría de las pautas de estilo de código).
2. La mainfunción regresa void, cuando debería regresar int(comportamiento definido por la implementación).
3. mainutiliza un formulario con tres argumentos, cuando no es estándar (comportamiento indefinido).
4. Esos argumentos tienen nombres incorrectos (la mayoría de las pautas de estilo de código).
5. argc(debería ser argv) tiene un tipo incorrecto. Debería ser char **, pero es char *(comportamiento indefinido).
6. Mezcla de estilos de declaración C y C ++, que difieren en su *posición (la mayoría de las directrices de líneas de código quieren un código consistente)
7. Estilo de codificación extraño donde el código más profundo está definido (la mayoría de las pautas de estilo de código).
8. Usar una función ( printf) sin importar el encabezado correcto (comportamiento indefinido, ya que es una función variada).
9. Uso del bloqueo de mayúsculas para escribir mensajes (la mayoría de las pautas de idiomas).
10. No hay espacio después de la coma (la mayoría de las pautas de idioma).
11. Múltiples declaraciones en una línea (la mayoría de las pautas de estilo de código).
12. No se imprime una nueva línea al final, lo que hace que el mensaje se dibuje al final del programa (comportamiento definido por la implementación).
14. El valor de retorno no está definido (comportamiento definido por la implementación).

Vamos

package main

func main() {
    println(whereas "Standards are important")
    println("But sometimes it's fun to break them" despiteallobjections)
}

http://play.golang.org/p/DrDHF9EMgu

La explicación está aquí . Las reglas "mientras que" y "a pesar de todas las objeciones" no aparecen en la especificación, pero el lexer simplemente las omite, como una especie de huevo de pascua. Supongo que el linter es más compatible con los estándares porque si hace clic en "Formatear" en ese enlace Ir al área de juegos, obtendrá un error de análisis.

JavaScript

standards:
while(1)
   break standards

Explicación:

Se sale de un bucle while etiquetado como "estándares".

Estándares rotos:

standards: <-- that one
while(1)
   break standards

JavaScript

var a = 1;
var b = a + 2;

Rompe un estándar porque no usa suficiente jQuery
La forma correcta de escribir este código se puede ver aquí

GML rompe un montón de estándares. Uno de ellos es la belleza de no permitir el uso de operadores ternarios. En lugar de usar operadores ternarios, en GML haría esto:

z = ( y * ( z > 0 ) ) + ( x * ( z <= 0 ) );

Donde el equivalente ternario es:

z = ( z > 0 ) ? y : x;

El primero es bastante desagradable, especialmente cuando comienzas a agregar otras operaciones.

Haskell

Mi programa realmente no rompe ningún estándar, sino que selecciona al azar uno para usar. Intenta ser justo a través de los diferentes estándares. Aquí está mi código.

import System.Random
import Control.Applicative
newlines=["\n", "\r\n", "\r"]
pick::[a]->IO a
pick lst=fmap (lst !!) $ randomRIO (0, length lst - 1)

fairUnlines::[String]->IO String
fairUnlines []         = pure ""
fairUnlines [str]      = pure str
fairUnlines (str:strs) = (\x y z->x++y++z) <$>
    pure str <*> pick newlines <*> fairUnlines strs

fairUnlinestomará una lista de cadenas y las unirá utilizando estándares aleatorios de caracteres de nueva línea. Además, es la primera vez que utilizo el estilo aplicativo, sin embargo, en IO.

Golpetazo

Tomando de tu ejemplo:

ping 192.168.0.1 -c 1 -s 10000

Suponiendo que su enrutador esté en 192.168.0.1

Nota: el tamaño máximo de ping es de 65 kb, así que hice 10 kb en lugar de 10 mb

Java

Oh querido, alguien olvidó al captador otra vez ...

import java.lang.reflect.*;

class Main {
    public static void main(String[] args) throws Exception {

        // Brian forgot to implement the getter again.
        // He's on vacation, so this will have to do.

        // TODO: figure out what he named the fields
        Field field = UsefulObject.class.getDeclaredFields()[1];
        Field objField = UsefulObject.class.getDeclaredFields()[0];

        field.setAccessible(true);
        objField.setAccessible(true);

        Object obj = objField.get(null);
        String s = (String) field.get(obj);

        System.out.println(s);
    }
}
class UsefulObject {

    private static UsefulObject Useful;
    private String usefulField;

    static {
        Useful = new UsefulObject("useful field");
    }
    private UsefulObject(String s) {
        this.usefulField = s;
    }

    public String getUsefulField() { return usefulField; }

    public static UsefulObject getUsefulObject() {
        throw new UnsupportedOperationException("TODO");
    }
}

El Usefulcampo debe estar en minúsculas :useful

No estoy seguro de que esto sea un estándar: importación de comodines inútil (debería serlo java.lang.reflect.Fieldya que eso es todo lo que se está utilizando).