Tout le monde connaît l'expression "Les règles sont faites pour être enfreintes!", Voici donc votre tâche:

Écrivez du code dans n'importe quelle langue qui enfreint une norme. Cela peut être n'importe quoi, de mettre 240 volts sur un câble USB, à cingler votre routeur ( PAS le site Web de quelqu'un d'autre!) Avec un paquet de 10 Mo! (N'ayez pas d'idées, les deux causeront probablement toutes sortes de malheurs!)

La réponse la plus votée après 10 jours (c'est-à-dire la violation la plus grave) l'emportera!

Règles:

1. Le code doit être expliqué.
2. La norme que vous brisez doit être liée à, et vous devez expliquer ce que vous faites (implique 1) pour la briser. Sinon, les réponses ne seront pas acceptées.
3. Les réponses qui font planter l'interpréteur ou le font cesser de fonctionner ne seront pas acceptées. Je voudrais des réponses créatives, pas seulement coller quelque chose comme 𐒢IDLE (ce qui le plante)
4. L'exploitation des bogues n'est pas autorisée, sauf s'ils enfreignent une norme. Sinon, les réponses ne seront pas acceptées

Commencez et amusez-vous!

Python

print 'Hello World'

Explication:

La norme de la programmation des puzzles et du code Golf Stack Exchange est de

Lisez attentivement la question. Que demande précisément la question? Assurez-vous que votre réponse indique que

Ce code ne répond pas à la question, il enfreint donc la norme.

C
Voici un programme factoriel qui compile et s'exécute avec succès (avec gcc4.6.3 sur Ubuntu 12.04), mais invoque autant de comportements indéfinis selon la norme C que je pourrais y entrer. La plupart sont inspirés d' ici . Une grande partie du code juridique restant est tout simplement mauvais.

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 spécification W3C ( http://www.w3.org/TR/html-markup/p.html#p ):

p - paragraphe

L'élément p représente un paragraphe.

Contenu autorisé

Contenu de la formulation

Oh je me sens sale!

Modifier: @xfix souligné que l'erreur que était en fait XHTML. L'erreur HTML que cela provoque est plus froide et moins évidente, par exemple:

<p><div></div><p>devient <p /><div></div></p>parce que les <div>causes de l' <p>auto-fermeture. Il en résulte donc une erreur car nous tentons de fermer un paragraphe qui n'existe pas.

HTTP / 1.1: Réponse - Code d'état et phrase de motif

L'élément Status-Code est un code à 3 chiffres ...

Dois-je aller plus loin? Ce code d'état n'est pas l'un des codes définis dans la norme. Il ne commence même pas par l'un des chiffres de catégorie requis. Il ne fait même pas 3 chiffres.

Mon navigateur parvient toujours à charger la page correctement.

De plus, cette réponse casse l'une des "normes" de ce site :)

Sortie (ligne d'état):

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 (nœud)

Combien de normes ai-je simplement enfreint?

J'ai fait une programmation horrible en effet ici.

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;

Oeuf de Pâques: les echolettres ed, si elles sont lues verticalement, se lirontjust killed standarDs! .

Sidenote: L' exécution de ce programme affichera le nom d'un gars qui a vraiment aimé gotos.

C # - rupture Unicode

Algorithme simple pour inverser une chaîne:

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

Cela rompt la norme Unicode , car il ne conserve pas correctement les paires de substitution, créant une chaîne non valide. Dans .NET et de nombreuses autres plates-formes / langages de programmation, a charn'est pas vraiment un caractère, mais une unité de code UTF-16 .

NB: Il modifie également la lettre qui est combinée avec les marques de combinaison suivantes (par exemple les signes diacritiques), qui peuvent ou non être prévues.

Javascript

Exécutez-le dans la console sur cette page.

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

Inspiré par

La majorité des réponses sur ce site viole au moins un standard de codage ... - Komintern il y a 1 heure

Ce qu'il fait, c'est sortir une réponse aléatoire parmi les 1000 premiers votés par codegolf.SE (c'est-à-dire, résoudre le problème d'une manière très méta!), Avec mise en forme et tout, sur votre page!

Malheureusement, techniquement, cela ne satisfait pas aux règles, car la sortie est le code avec les normes brisées, j'ai donc brisé une norme dans ce code - j'ai utilisé document.write(ewwww). Je dois également fournir un lien, alors voici: Pourquoi document.write est-il considéré comme une "mauvaise pratique"?

Si cela ne compte pas comme «enfreindre les normes», juste au cas où, j'envelopperais ma chaîne unescape(escape()), qui est déconseillée, selon MDN .

Notez que je fais vraiment tout cela pour contourner les règles, et le point principal de cette réponse est sa sortie.

Sample run (cliquez sur l'image pour agrandir):

XML

Pas mon "invention", je dois travailler avec des XML comme celui-ci que nous obtenons d'un endroit très secret:

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

Ne valide pas par rapport à sa propre DTD intégrée, contient plusieurs racines et esperluettes non échappées. (Il existe également d'autres erreurs de niveau supérieur, un modèle de contenu ambigu, etc., non démontré ici.) Très triste.

La définition du masque de réseau sur des masques de bit non contigus a été autorisée mais fortement découragée par la RFC 950, mais est désormais interdite à partir de la RFC 1219. Néanmoins, les likes BSD vous permettent de le faire.

Les masques de réseau IPv4 sont une combinaison de quatre octets, tout comme une adresse IP. Il est utilisé pour calculer si deux hôtes avec des adresses IP et des masques de réseau connus sont sur le même réseau. En général, une adresse IP se compose de deux parties: le réseau et la partie hôte. Supposons que votre réseau à domicile soit 192.168.1.1- 192.168.1.254. La partie hôte sont les trois premiers octets de l'IP, à savoir 192.168.1.x. Cela signifie que le masque de réseau est 255.255.255.0, ce qui signifie que les 24 premiers bits sont la partie réseau. En binaire, le masque ressemble 11111111.11111111.11111111.00000000. Les bits 1 sont continus. Dans mon exemple, le masque de réseau serait00010111.00000000.00000000.00101010 . Alors, que se passerait-il si le masque de réseau n'est pas continu? Au lieu d'être à l'extrémité droite, la partie hôte est dispersée sur toute l'adresse IP, ce qui la rend très difficile à lire, tout comme mon explication ici.

Ne vous attendez pas à ce que quoi que ce soit fonctionne après cela!

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

Combien d'erreurs pouvez-vous trouver, ce qui entraînerait probablement la plupart des entreprises à rejeter votre code (en particulier les bonnes). La plupart d'entre elles sont probablement des erreurs de style (que j'espère que personne ne fait), mais certaines sont des comportements indéfinis.

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

1. Il définit les macros qui font que C se sent comme un autre langage (la plupart des directives de codestyle).
2. La mainfonction retourne void, quand elle devrait retourner int(comportement défini par l'implémentation).
3. mainutilise un formulaire avec trois arguments, lorsqu'il n'est pas standard (comportement indéfini).
4. Ces arguments ont des noms incorrects (la plupart des directives de codestyle).
5. argc(devrait être argv) a un type incorrect. Ça devrait l'être char **, mais c'est char *(comportement indéfini).
6. Mélanger les styles de déclaration C et C ++, dont la *position diffère (la plupart des directives de codeline veulent un code cohérent).
7. Style de codage étrange où le code plus profond est défini (la plupart des directives de codestyle).
8. Utiliser une fonction ( printf) sans importer l'en-tête correct (comportement indéfini, car c'est une fonction variadique).
9. Utilisation du verrouillage des majuscules pour écrire des messages (la plupart des directives linguistiques).
10. Pas d'espace après une virgule (la plupart des directives linguistiques).
11. Plusieurs déclarations sur une seule ligne (la plupart des directives de codestyle).
12. Aucune nouvelle ligne imprimée à la fin, provoquant le tracé de l'invite à la fin du programme (comportement défini par l'implémentation).
14. La valeur de retour n'est pas définie (comportement défini par l'implémentation).

Aller

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

L'explication est ici . Les règles "tandis que" et "desobjections despiteal" n'apparaissent pas dans la spécification, mais le lexer les saute juste, comme une sorte d'oeuf de Pâques. Je suppose que le linter est plus conforme aux normes car si vous cliquez sur "Format" sur ce lien Go Playground, vous obtenez une erreur d'analyse.

Javascript

standards:
while(1)
   break standards

Explication:

Une boucle while intitulée "standards" est quittée.

Normes brisées:

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

Javascript

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

Il casse un standard car il n'utilise pas assez de jQuery
La bonne façon d'écrire ce code peut être vue ici

GML brise une tonne de normes. L'une étant la beauté de ne pas permettre l'utilisation d'opérateurs ternaires. Au lieu d'utiliser des opérateurs ternaires, en GML, je ferais ceci:

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

Lorsque l'équivalent ternaire est:

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

Le premier est assez méchant, surtout lorsque vous commencez à ajouter d'autres opérations.

Haskell

Mon programme ne déroge pas vraiment aux normes, mais en sélectionne juste une au hasard à utiliser. Il essaie d'être équitable entre les différentes normes. Voici mon code.

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

fairUnlinesprendra une liste de chaînes et les rejoindra en utilisant des normes de caractères de nouvelle ligne aléatoires. De plus, c'est la première fois que j'utilise le style applicatif, sur IO néanmoins.

Frapper

Prenant de votre exemple:

ping 192.168.0.1 -c 1 -s 10000

En supposant que votre routeur est à 192.168.0.1

Remarque: la taille maximale du ping est de 65 Ko, donc j'ai fait 10 Ko au lieu de 10 Mo

Java

Oh mon cher, quelqu'un a encore oublié le 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");
    }
}

Le Usefulchamp doit être en minuscules :useful

Je ne suis pas sûr que ce soit une norme: importation inutile de caractères génériques (devrait être juste java.lang.reflect.Fieldcar c'est tout ce qui est utilisé).