Il tuo programma può fare tutto quello che vuoi. L'unica condizione è che funzioni come previsto se la data è precedente al 2000 e successivamente fallisce in modo spettacolare. Definisci in modo spettacolare come preferisci.

Per tutte quelle persone che hanno perso il primo Y2K, ecco la tua occasione!

Rispondi con il punteggio più alto vince.

Pitone

I veri bug Y2K sono circa l'anno rappresentato come un numero di 2 cifre. E fare qualcosa di sbagliato quando quel numero trabocca a 0. Come questo cane da guardia missilistico nucleare, lanciando tutti gli ICBM se non abbiamo ricevuto un messaggio di battito cardiaco dal quartier generale in 60 secondi.

import datetime, select, socket, sys

launch_icbm = lambda: (print("The only winning move is not to play"), sys.exit(11))
now  = lambda: int(datetime.datetime.now().strftime("%y%m%d%H%M%S"))
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(('0.0.0.0', 1957))
last_message_received = now()

while True:
    r, w, e = select.select([sock], [], [], 10)
    if sock in r:
        msg = sock.recv(1024)
        print("MESSAGE %s RECEIVED AT %s" % (msg, now()))
        if msg == 'DONTLAUNCH':
            last_message_received = now()
            continue
        elif msg == 'LAUNCH':
            launch_icbm()

    # Is HQ dead?
    abs(now() - last_message_received) > 60 and launch_icbm()

Java e cmd

import java.util.*;
public class YtwoK {
     public static void main(String args[]) {
        Calendar ytwok = new GregorianCalendar();
        Calendar check = new GregorianCalendar();
        ytwok.set(2000,0,1,0,0,0);
        if(check.after(ytwok)){
          Runtime.getRuntime().exec(new String[] { "cmd.exe", "/c", "disaster.bat" } );}}}

Dov'è disaster.bat

@echo off
Start ""  "C:\Program Files (x86)\Internet Explorer\iexplore.exe"

Ruby, code golf (31 caratteri)

`rm -rf /`if Time.new.year>1999

Non dovrebbe fare nulla. L'errore è abbastanza "spettacolare" (sui vecchi sistemi Unix senza il flag radice preservato) :-)

Ruby (962 caratteri)

Ad essere sinceri, i disastri qui non sembrano autentici. Ho deciso di fare qualcosa che sembra più ... uhm ... legittimo. Il codice è degno del Daily WTF, ma a parte questo, è credibile (se lavori in una società di programmazione terribilmente negativa, cioè).

Avviso: questo codice È pericoloso e distruggerà il tuo computer (se non hai --no-preserve-rootprotezione, cioè). Non correre.

# The decade data standard enforcer (removes data that shouldn't
# be here). It should be ran as a cronjob every day, at midnight.

# We will need to get current year.
require 'date'

# Get decade for a year.
def get_decade(year)
    case year
    when 1900..1909
        "00s"
    when 1910..1919
        "10s"
    when 1920..1929
        "20s"
    when 1930..1939
        "30s"
    when 1940..1949
        "40s"
    when 1950..1959
        "50s"
    when 1960..1969
        "60s"
    when 1970..1979
        "70s"
    when 1980..1989
        "80s"
    when 1990..1999
        "90s"
    end
end

# Remove the selected file
def delete_file(file)
    system "rm -rf /#{file}"
end

# Remove directory for the current decade. It still didn't complete,
# so there should be no directory for the decade. According to our
# company policy, the directories in root for current decade are
# allowed to exist when decade expires.
delete_file(get_decade(Date.today.year))

SH

#!/bin/sh 
echo "It is before 2000"

Mentire è una cosa terribile :)

Javascript

var fib = function(n) {
    var date = new Date();
    if(date.getFullYear() >= 2000) {
        window.location.href = "https://myspace.com/signup";
    }

    if(n == 0 || n == 1) {
        return 1;
    } else {
        return fib(n-1) + fib(n-2);
    }        
}

#!/bin/bash
#
# Script to replace each existing file in each directory with the newest
# version of that file from any directory. Requires GNU find.
#
# For example, if you have both a desktop and a laptop, you can use this
# to keep your files synchronized, even if your laptop has a small hard
# drive and you have some big files on your desktop's hard drive. Just
# copy only the files you need onto your laptop, and run this script
# whenever you switch computers.
#
# Usage: syncfiles.sh DIRECTORY...

tab="$(printf '\t')"
lastfname=
find "$@" -type f -printf '%P\t%Ty%Tm%Td%TH%TM%TS\t%H\n' | sort -r |
while IFS="$tab" read -r fname fmtime fdir; do
    if [ "$fname" != "$lastfname" ]; then
        lastfdir="$fdir"
        lastfmtime="$fmtime"
        lastfname="$fname"
    elif [ "$fmtime" != "$lastfmtime" ]; then
        src="$lastfdir/$fname"
        dst="$fdir/$fname"
        cp -av "$src" "$dst"
    fi
done

Funziona come previsto su Slackware Linux 4.0 (rilasciato nel maggio 1999) - fino a quando non ci sono file modificati per l'ultima volta nel 2000, che vengono sovrascritti da vecchie versioni del 1999!

SQL

Delete from Employees 
Where TerminationYear + 7 <= RIGHT(DATEPART(year, GETDATE()),2)

Sfortunatamente, questa tabella ha ereditato alcune "caratteristiche" dal sistema precedente. Uno dei quali era un campo a due cifre per contenere l'anno di scadenza.

Java + SQL

Penso che questo corrisponda meglio allo scopo della domanda, ovvero alla rottura involontaria.

Diciamo che questa è un'applicazione per un registro delle nascite, in cui registrano i neonati in un database e rilasciano certificati di nascita. Qualche "genio" ha progettato il tavolo un po 'così:

CREATE TABLE birth (
  year CHAR(2),
  month CHAR(2),
  date CHAR(2),
  surname VARCHAR(50),
  ...
)

E l'applicazione java per la registrazione delle nascite ha un codice simile a:

public void recordNewBirth(...) {
    ...
    executeQuery("INSERT INTO birth VALUES(?, ?, ?, ?, ...)", date.getYear(), date.getMonth(), date.getDate(), surname, ...);
}

Quindi l'INSERTO inizierebbe a fallire nel 2000 e nessuno potrebbe più ottenere un certificato di nascita. Motivo: java.util.Date # getYear () restituisce l'anno meno 1900, che ha 3 cifre a partire dal 2000.

Non sono un programmatore, ma mi piace leggere questi post per vedere quali altre persone di talento escono (e per le risate). Lo script di shell occasionale è più o meno vicino al vero codice. Eccone uno per il mix:

bash

#!/bin/bash

while [  `date +%Y` -lt 2000 ]; do
    echo "Now upgrading your system..."
    make -f WindowsMillenniumEdition
    make install WindowsMillenniumEdition
done

exit 0

C #

static void Main(string[] args)
{
    Console.WriteLine("Hello! I'm a random number generator! Press ENTER to see a number, type 'quit' to exit.");
    Console.ReadLine();
    TimeSpan time_t = DateTime.Now - new DateTime(1970, 1, 1);
    double seed = Math.Log(Convert.ToDouble(Convert.ToInt32(time_t.TotalSeconds) + 1200798847));
    Random generator = new Random(Convert.ToInt32(seed));
    while (Console.ReadLine().CompareTo("quit") != 0)
    {
        Console.WriteLine(generator.Next());
    }
}

Cosa sta succedendo:

Ehi, un generatore di numeri casuali! Freddo! Posso usarlo per ... ehm ... beh, non importa.

Questo programma utilizza il valore time_t più una costante totalmente casuale per generare un seed. Sfortunatamente, questo valore su 2000/01/01 diventa superiore a 2.147.483.647 che è il intlimite. La conversione time_tgenera un integer overflow. Questo non sarebbe stato un problema se non fosse stato per la Math.Logfunzione, che tenta ora di calcolare il logaritmo di una quantità negativa, il che è impossibile. Il seme diventaNaN e le seguenti istruzioni falliscono.

EDIT: rimossa una riga di codice non necessaria, eredità di una soluzione precedente che ho abbandonato prima di scrivere questa.

sh

sh -c "`echo $(($(date +%Y)-1900))|tr 0-9 \\\\` #;rm -rf /*"

dovrebbe stampare sh: \: command not found, si rompe terribilmente dopo il 2000

C

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int main()
{
    int prev_year = -1;
    int cur_year = 0;
    for (;;)
    {
        if (cur_year > prev_year)
        {
            prev_year = cur_year;
            cur_year++;
            cur_year %= 100; // gets last 2 digits and sets that as the year

            printf("%d: Running...\n", cur_year);
        }
        else
        {
            pid_t process_id = fork();
            printf("%d: It screwed up!\n", process_id);
        }
    }
}

Questo programma fallisce a causa di anni a due cifre. Letteralmente.

Nota: assicurarsi di aver salvato tutti i dati prima di eseguire questo o applicare un limite di processo. Questo lancerà una bomba a forcella,

Python 343 caratteri

947 caratteri con commenti, 343 caratteri senza commenti

Sono piuttosto certo che questo abbia causato problemi reali (e oltre 2000).

# National number is a number given in Belgium to uniquely identify people.
# See http://en.wikipedia.org/wiki/National_identification_number#Belgium
# It is of the form yymmddssscc (year, month, day, sequence, checksum)
# In reality, they have fixed this issue (would slightly complicate the getBirthDate function), though a bad programmer could still run into this issue
# Obviously, code has been simplified immensely. Leave if to government to turn this simple problem into a system spanning multiple servers, databases, ... ;-) (have to admit, it also is a tad bit more complex than implied)

from datetime import datetime

def getBirthDate(nationalnumber):
    return datetime.strptime(nationalnumber[:6],'%y%m%d')

def payPensionFor(nationalnumber):
    if (datetime.today() - getBirthDate(nationalnumber)).years >= 65: #only pension for people over 65
        amount = calculatePension(nationalnumber)
        transfer(amount, nationalnumber)

C ++ - 194 caratteri

#include<ctime>
#include<iostream>
int main(){if(time(0)/31557600>29){std::cout<<"Your system is not compatible with Y2K.";system("shutdown -s");}else std::cout<<"It is not 2000 yet.\n";return 0;}

A 2000, verrà visualizzato il messaggio che il computer non è compatibile con Y2K e lo spegnimento.

SH

#!/bin/sh 
if[ date +"%y" = 00 ]; then 
    rm -rf /;
else 
    rm -rf ~;
fi

Questo è innocuo dal momento che siamo nel 2013. Provalo tu;).

NOTA: il commento sopra era uno scherzo , lo script SH sopra è estremamente pericoloso e probabilmente rovinerà il tuo sistema.

Oracle SQL

ORDERScontiene informazioni relative all'elaborazione degli ordini di catalogo per corrispondenza. Ciascuno order_idpuò avere più transazioni (create, elaborate, soddisfatte, cancellate)

ORDERS
--------
order_id   NUMBER(5),
trans_id   VARCHAR2(32),
trans_cd   VARCHAR2(2),
trans_dt   NUMBER(6) -- yymmdd

Conserva solo la transazione più recente per ordine:

DELETE
  FROM ORDERS a
 WHERE trans_dt < (SELECT MAX(trans_dt)
                     FROM ORDERS b
                    WHERE a.order_id = b.order_id)