Tutti conoscono la frase "Le regole sono fatte per essere infrante!", Quindi ecco il tuo compito:

Scrivi del codice in qualsiasi lingua che rompa uno standard. Questo può essere qualsiasi cosa, dal mettere 240 volt in un cavo USB, al ping del router ( NON il sito Web di qualcun altro!) Con un pacchetto da 10 MB! (Non avere alcuna idea, entrambi probabilmente causeranno ogni sorta di destino!)

La risposta più votata dopo 10 giorni (ovvero la violazione più grave) vincerà!

Regole:

1. Il codice deve essere spiegato.
2. Lo standard a cui stai violando deve essere collegato e devi spiegare cosa stai facendo (implica 1) per romperlo. Altrimenti le risposte non saranno accettate.
3. Le risposte che bloccano semplicemente l'interprete o lo fanno smettere di funzionare non saranno accettate. Vorrei alcune risposte creative, non solo incollare qualcosa di simile 𐒢a IDLE (che lo blocca)
4. Lo sfruttamento dei bug non è consentito, a meno che non infrangano uno standard. Altrimenti le risposte non saranno accettate

Inizia e divertiti!

Pitone

print 'Hello World'

Spiegazione:

Lo standard dello scambio di stack di programmazione e codice Golf Stack è

Leggi attentamente la domanda. Qual è, in particolare, la domanda? Assicurati che la tua risposta lo fornisca

Questo codice non risponde alla domanda, quindi infrange lo standard.

C
Ecco un programma fattoriale che si compila ed esegue con successo (con gcc4.6.3 su Ubuntu 12.04), ma invoca il maggior numero di comportamenti indefiniti secondo lo standard C che potrei stipare. Molti sono ispirati da qui . Gran parte del codice legale rimanente è semplicemente negativo.

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>

Le specifiche del W3C ( http://www.w3.org/TR/html-markup/p.html#p ):

p - paragrafo

L'elemento p rappresenta un paragrafo.

Contenuti consentiti

Contenuti di frase

Oh mi sento sporco!

Modifica: @xfix ha sottolineato che l'errore che stavo visualizzando era in realtà XHTML. L'errore HTML che questo provoca è più interessante e meno ovvio tale che:

<p><div></div><p>diventa <p /><div></div></p>perché <div>causa la <p>chiusura di se stessi. Ne risulta quindi un errore perché stiamo tentando di chiudere un paragrafo che non esiste.

HTTP / 1.1: Risposta - Codice di stato e frase motivo

L'elemento Status-Code è un 3 cifre ...

Devo andare oltre? Questo codice di stato non è uno dei codici definiti nello standard. Non inizia nemmeno con una delle cifre della categoria richieste. Non ha nemmeno 3 cifre.

Il mio browser riesce ancora a caricare bene la pagina.

Inoltre, questa risposta rompe uno degli "standard" di questo sito :)

Uscita (riga di stato):

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)

Quanti standard ho appena infranto?

Ho fatto davvero una programmazione terribile qui.

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;

Easter Egg: le echolettere ed, se lette in verticale, leggeranno just killed standarDs!.

Sidenote: L' esecuzione di questo programma produrrà il nome di un ragazzo che ha amato davvero gotos.

C # - rompere Unicode

Algoritmo semplice per invertire una stringa:

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();
}

Ciò rompe lo standard Unicode , perché non mantiene correttamente insieme le coppie surrogate, creando una stringa non valida. In .NET e molte altre piattaforme / linguaggi di programmazione, a charnon è proprio un carattere, ma un'unità di codice UTF-16 .

NB: cambia anche quale lettera è combinata con segni di combinazione successivi (ad esempio segni diacritici), che possono o meno essere intesi.

JavaScript

Eseguilo nella console in questa pagina.

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)
}

Ispirato da

La maggior parte delle risposte su questo sito viola almeno uno standard di codifica ... - Comintern 1 ora fa

Quello che fa è generare una risposta casuale tra i primi 1000 votati da codegolf.SE (ovvero, risolvere il problema in un modo molto meta!), Completo di formattazione e tutto, sulla tua pagina!

Sfortunatamente, questo tecnicamente non soddisfa le regole, poiché l' output è il codice con gli standard rotti, quindi ho infranto uno standard in questo codice - ho usato document.write(ewwww). Devo anche fornire un link, quindi qui: Perché document.write è considerato una "cattiva pratica"?

Se ciò non conta come "infrangere gli standard", per ogni evenienza, ho inserito la mia stringa unescape(escape()), che è obsoleta, come da MDN .

Nota che sto davvero facendo tutto questo per aggirare le regole e il punto principale di questa risposta è il suo output.

Esempio di esecuzione (fare clic sull'immagine per ingrandirla):

XML

Non è la mia "invenzione", in realtà devo lavorare con XML come questo che otteniamo da un posto molto segreto:

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

Non convalida con il proprio DTD incorporato, contiene più radici e e commerciali senza caratteri di escape. (Ci sono anche altri errori di livello superiore, modello di contenuto ambiguo, ecc., Non dimostrato qui.) Molto triste.

L'impostazione della maschera di rete su maschere di bit non contigue era consentita ma fortemente scoraggiata da RFC 950, ma ora è vietata a partire da RFC 1219. Tuttavia, i Mi piace di BSD ti consentono di farlo.

Le maschere di rete IPv4 sono una combinazione di quattro byte, proprio come un indirizzo IP. Viene utilizzato per calcolare se due host con indirizzi IP e maschere di rete noti si trovano sulla stessa rete. In generale un indirizzo IP è composto da due parti: la rete e la parte host. Supponiamo che la tua rete domestica sia 192.168.1.1- 192.168.1.254. La parte host sono i primi tre byte dell'IP, vale a dire 192.168.1.x. Questo significa che la maschera di rete è255.255.255.0 , il che significa che i primi 24 bit sono la parte di rete. In binario appare la maschera 11111111.11111111.11111111.00000000. Gli 1 bit sono continui. Nel mio esempio, la maschera di rete sarebbe 00010111.00000000.00000000.00101010. Quindi cosa accadrebbe se la maschera di rete non fosse continua? Invece di essere all'estremità giusta, la parte host è sparsa sull'intero indirizzo IP, il che rende davvero difficile la lettura, proprio come la mia spiegazione qui.

NON aspettarti che funzioni dopo questo!

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

Quanti errori puoi trovare, il che probabilmente farebbe rifiutare al tuo codice la maggior parte delle aziende (specialmente quelle buone). La maggior parte di questi sono probabilmente errori di stile (che spero non facciano nessuno), ma alcuni di questi sono comportamenti indefiniti.

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

1. Definisce le macro che fanno sembrare C un'altra lingua (la maggior parte delle linee guida per il codestyle).
2. La mainfunzione ritorna voidquando dovrebbe tornare int(comportamento definito dall'implementazione).
3. mainutilizza un modulo con tre argomenti, quando non è standard (comportamento indefinito).
4. Tali argomenti hanno nomi errati (la maggior parte delle linee guida per il codestyle).
5. argc(dovrebbe essere argv) ha un tipo errato. Dovrebbe essere char **, ma è char *(comportamento indefinito).
6. Mescolare gli stili di dichiarazione C e C ++, che differiscono in 8. Utilizzo di una funzione ( ) senza importare l'intestazione corretta (comportamento indefinito, in quanto è una funzione variadica).* posizione (la maggior parte delle linee guida codeline vuole un codice coerente).
7. Strano stile di codifica in cui viene deinteso il codice più profondo (la maggior parte delle linee guida di codestyle).
printf
9. Utilizzo di Caps Lock per scrivere messaggi (la maggior parte delle linee guida linguistiche).
10. Nessuno spazio dopo la virgola (la maggior parte delle linee guida linguistiche).
11. Dichiarazioni multiple su una riga (la maggior parte delle linee guida per il codestyle).
12. Nessuna nuova riga stampata alla fine, causando il richiamo del prompt alla fine del programma (comportamento definito dall'implementazione).
14. Il valore restituito non è definito (comportamento definito dall'implementazione).

Partire

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 spiegazione è qui . Le regole "considerando" e "despiteallobjections" non appaiono nelle specifiche, ma il lexer le salta semplicemente sopra, come una specie di uovo di Pasqua. Immagino che la linter sia più conforme agli standard perché se fai clic su "Formato" sul link Go Playground, ricevi un errore di analisi.

JavaScript

standards:
while(1)
   break standards

Spiegazione:

È uscito un ciclo while etichettato "standard".

Standard infranti:

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

JavaScript

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

Si rompe uno standard perché non usa abbastanza jQuery
Il modo corretto di scrivere questo codice può essere visto qui

GML infrange moltissimi standard. Uno è la bellezza di non consentire l'uso degli operatori Ternari. Invece di usare Ternary Operators, in GML farei questo:

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

Dove l'equivalente ternario è:

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

Il primo è piuttosto brutto soprattutto quando inizi ad aggiungere altre operazioni.

Haskell

Il mio programma in realtà non infrange alcuno standard, ma ne seleziona solo uno a caso. Cerca di essere equo tra i diversi standard. Ecco il mio codice

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

fairUnlinesprenderà un elenco di stringhe e si unirà a loro usando standard di caratteri casuali di nuova riga. Inoltre, è la prima volta che uso effettivamente lo stile applicativo, su IO comunque.

bash

Prendendo dal tuo esempio:

ping 192.168.0.1 -c 1 -s 10000

Supponendo che il router sia attivo 192.168.0.1

Nota: la dimensione massima del ping è 65kb, quindi ho fatto 10 kb invece di 10 mb

Giava

Oh caro, qualcuno ha dimenticato di nuovo il getter ...

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");
    }
}

Il Usefulcampo deve essere minuscolo :useful

Non sono sicuro che questo sia uno standard: inutile importazione di caratteri jolly (dovrebbe essere solo java.lang.reflect.Fieldperché è tutto ciò che viene utilizzato).