2008-08-30 10 views
53

Me gustaría pensar que parte del software que estoy escribiendo hoy se usará en 30 años. Pero también soy consciente de que muchos de ellos se basa en la tradición UNIX de exponer tiempo que el número de segundos desde los resultados de 1970.¿Qué deberíamos hacer para prepararnos para 2038?

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

void print(time_t rt) { 
    struct tm * t = gmtime(&rt); 
    puts(asctime(t)); 
} 

int main() { 
    print(0); 
    print(time(0)); 
    print(LONG_MAX); 
    print(LONG_MAX+1); 
} 

ejecución en:

  • Jue Ene 1 00:00 : 00 1970
  • Sab Ago 30 18:37:08 2008
  • Mar Ene 19 03:14:07
  • Vie Dic 13 20:45:52

La funciones ctime(), gmtime() y localtime() todos toman como argumento un valor de tiempo que representa el tiempo en segundos desde la Época (00:00:00 UTC, Enero 1, 1970; ver el tiempo (3)).

Me pregunto si hay algo proactivo que hacer en esta zona como un programador, o tenemos que confiar en que todos los sistemas operativos de software (aka Systems) serán de alguna forma ser mágicamente mejorados en el futuro?

actualización Parecería que los sistemas de 64 bits de hecho están a salvo de esto:

import java.util.*; 

class TimeTest { 
    public static void main(String[] args) { 
     print(0); 
     print(System.currentTimeMillis()); 
     print(Long.MAX_VALUE); 
     print(Long.MAX_VALUE + 1); 
    } 

    static void print(long l) { 
     System.out.println(new Date(l)); 
    } 
} 
  • Wed Dec 31 16:00:00 PST 1969
  • Sab Ago 30 de 12:02: 40 PDT 2008
  • Sab Ago 16 de 23:12:55 PST
  • Dom Dic 02 08:47:04 PST

¿Pero y el año 292278994?

+1

Estaría contento si estuviera presente para ser considerado responsable de algún accidente en ese año, ¿verdad? –

+24

No se preocupe por el año 292278994. La mayoría de los sistemas fallan en el año 2147483647. – Schwern

+3

Creo que nos ha convencido, ¡tenemos que movernos a 128 bits inmediatamente! – new123456

Respuesta

40

He escrito reemplazo portátil para time.h (actualmente solo localtime(), gmtime(), mktime() y timegm()) que utiliza 64 bits de tiempo incluso en máquinas de 32 bits. Se pretende incluir en los proyectos C como un reemplazo de time.h. Se está utilizando en Perl y también tengo la intención de solucionar los problemas 2038 de Ruby y Python. Esto le proporciona un rango seguro de +/- 292 millones de años.

Puede encontrar el código at the y2038 project. Por favor, siéntase libre de publicar cualquier pregunta al issue tracker.

En cuanto a "esto no va a ser un problema por otros 29 años", lea este list of standard answers para eso. En resumen, las cosas suceden en el futuro y a veces es necesario saber cuándo. También tengo a presentation on the problem, what is not a solution, and what is.

Ah, y no olvide que muchos sistemas de tiempo no manejan las fechas anteriores a 1970. Las cosas sucedieron antes de 1970, a veces es necesario saber cuándo.

+4

@Schwern: Además, septiembre de 1752 es un mes con menos de 28 días. Conocimiento de nicho gracias al programador pragmático. http://www.genealogytoday.com/columns/everyday/030902.html –

+1

@Dave Oh ho, ¡depende de su localidad! Sólo los británicos y las posesiones cambiaron a Gregorian en 1752. Otros lo hicieron en 1582 hasta el siglo XX (Europa del Este, China, Turquía, Rusia). 'ncal -p' para una lista y http://en.wikipedia.org/wiki/Gregorian_calendar#Adoption para la historia completa. Además, no hay año 0 ... a menos que estés hablando con un astrónomo. Con suerte, nunca tendrás que lidiar con la conversión de Julian/Gregorian. – Schwern

+0

miré ese sitio web (y2038) y no veo descargas de código – pm100

-1

Para el año 2038, las bibliotecas de tiempo deberían estar usando enteros de 64 bits, por lo que no será tan difícil (en un software que no está completamente sin mantenimiento).

Los programas de COBOL pueden ser divertidos.

+5

Considere cuándo termina una nueva hipoteca de 30 años en una casa. – Schwern

+1

El primer encuentro que tuve fue trabajar con pagos de manutención de niños en 1981. El sistema tomó la fecha de nacimiento anticipada del niño, en 1982, agregó 18, obtuvo 0, notó que 81> 0 y calculó que la obligación había terminado. Como dices, los bancos se metieron en este lío antes. –

+0

@Schwern: ¿y cree que la documentación de la hipoteca a 30 años utiliza valores time_t que almacenan # segundos desde 1970? –

-8

La palabra operativa es "debería".

Si es necesario asegurarse de futureproofing entonces usted puede construir su propia clase de fecha/hora y usar eso, pero yo sólo había que hacer si usted piensa que lo que escriba será utilizado en el legado OS'

+1

Las zonas horarias son muy, muy, muy difíciles de manejar por su cuenta. Además, casi todos los sistemas operativos y muchos idiomas tienen este problema, incluso los que se ejecutan en hardware de 64 bits. Al igual que la CPU de 64 bits en su nueva Mac brillante que todavía usa 32 bit time. – Schwern

+1

me gusta cómo la respuesta aceptada es una votación negativa :) –

+0

Parece que siempre estoy a favor de las soluciones "role to your", incluso si nadie más lo hace. :-) –

4

Visual Studio se movió a una representación de 64 bit de time_t en Visual Studio 2005 (mientras todavía deja _time32_t para compatibilidad con versiones anteriores).

Siempre que tenga cuidado de escribir siempre el código en términos de time_t y no asuma nada sobre el tamaño, entonces como señala sysrqb el problema será resuelto por su compilador.

+1

Sus implementaciones de localtime() y gmtime() no funcionan antes de 1970 y fallar en el año 3001. Ver http://code.google.com/p/y2038/wiki/AmazingDiscoveries – Schwern

0

Guarde la documentación adecuada e incluya una descripción de las dependencias de su tiempo. No creo que mucha gente haya pensado en lo difícil que podría ser esta transición, por ejemplo, las cookies HTTP se romperán en esa fecha.

15

Siempre se puede implementar RFC 2550 y estar seguro ;-) siempre

El universo conocido tiene un pasado finito y futuro. La edad actual de el universo se estima en [cebú] entre 10 y 10 ** 2 * 10 ** 10 años. La muerte del universo se estima en [Nigel] para ocurrir en 10 ** 11 años y en [Drake] como que ocurre ya sea en 10 ** 12 años para un universo cerrado (la gran crisis) o 10 ** 14 años para un universo abierto (la muerte por calor del universo). programas compatibles

 

Y10K puede optar por limitar el rango de fechas que apoyo a aquellos compatibles con la vida esperada del universo. sistemas compatibles Y10K DEBEN aceptar fechas Y10K de 10 ** 12 años en el pasado para 10 ** 20 años en el futuro. sistemas compatibles Y10K debe aceptar las fechas durante al menos 10 ** 29 años en el pasado y el futuro .

+2

Esa es la única solución de LARGA DURACIÓN que he visto hasta ahora. –

+4

Ah, pero esa es solo la * edad estimada * del universo. Si ese cálculo está un poco apagado, ¡estamos en un gran problema! – mickeyf

+1

@mickeyf, solo si es más largo que lo estimado ... – CaffGeek

2

Creo que deberíamos dejar el error. Entonces alrededor de 2036 podemos comenzar a vender asesoría por grandes sumas de dinero para probar todo. Después de todo, no es así cómo logramos con éxito la renovación de 1999-2000.

sólo estoy bromeando!

Estaba sentado en un banco en Londres en 1999 y quedé bastante sorprendido cuando vi a un consultor comenzar el Y2K probando la máquina de café. Creo que si hemos aprendido algo de ese fiasco, era que la gran mayoría del software se acaba de trabajar y la mayoría del resto no causará un fundido hacia abajo si se produce un error y se puede fijar después del evento si es necesario. Como tal, no tomaría ninguna precaución especial hasta mucho más cerca del momento.

+7

Y2K no era un problema porque la gente se preparó para eso. La carrera requirió mucho trabajo. La gran mayoría del software no solo funcionó, sino que se examinó y tal vez se solucionó. Las otras cosas no causaron un colapso porque no había mucho de eso. –

+1

David es correcto. Las empresas que se tomaron en serio el problema del y2k tuvieron una revisión exhaustiva de prácticamente todos sus sistemas. Se encontraron problemas y se corrigieron. Como parte de un sistema no crítico más pequeño, solucionamos 3 problemas, todos los cuales habrían llevado a la pérdida de datos si no se hubieran solucionado. – nos

+0

Déjeme ser claro, no estoy diciendo que no deberíamos hacer nada.Simplemente creo que podemos probar muchos menos sistemas de los que los consultores sugerirán y que las políticas de "debemos probarlo todo" están por encima de todo. Vamos a pegarnos a las cosas de misión crítica esta vez. –

0

¿Qué debemos hacer para prepararnos para 2038?

Ocultar, porque viene el apocalipsis.

Pero en serio, espero que los compiladores (o las personas que los escriben, para ser precisos) puedan manejar esto. Tienen casi 30 años. Espero que sea suficiente tiempo.

¿En qué punto comenzamos a prepararnos para Y10K? ¿Han visto los fabricantes de hardware/laboratorios de investigación la forma más fácil de pasar a la nueva tecnología que tendremos que tener debido a eso?

2

Dado mi edad, creo que debería pagar mucho en mi pensión y pagar de todos mis depts, para que alguien más tenga que adaptarse al software.

Lo siento, si piensas en el "valor presente neto" de cualquier software que escribas hoy, no tiene efecto lo que hace el software en 2038. Un "retorno de inversión" de más de unos pocos años es poco común para cualquier proyecto de software, por lo que ganar mucho más dinero para su empleador al enviar el software más rápido, en lugar de pensar en el futuro.

La única excepción común es el software que tiene que predecir el futuro, 2038 ya es un problema para los sistemas de cotización de hipotecas.

+1

+1 para tu edad :)) –

0

Trabajo en embedded y pensé que publicaría nuestra solución aquí. Nuestros sistemas están en 32 bits, y lo que vendemos en este momento tiene una garantía de 30 años, lo que significa que se encontrarán con el error del año 2038. La actualización en el futuro no fue una solución.

Para solucionar esto, establecemos la fecha del kernel 28 años antes que la fecha actual. No es una compensación aleatoria, 28 años es, excatly, el tiempo que tomará para que los días de la semana vuelvan a coincidir. Por ejemplo, estoy escribiendo esto el jueves y la próxima vez el 7 de marzo será un jueves en 28 años.

Además, todas las aplicaciones que interactúan con las fechas de nuestros sistemas tomarán la fecha del sistema (time_t) la convertirán a un time64_t personalizado y aplicarán la compensación de 28 años a la fecha correcta.

Hicimos una biblioteca personalizada para manejar esto. El código que estamos usando está basado en esto: https://github.com/android/platform_bionic

Por lo tanto, con esta solución puede comprarse 28 años más fácilmente.

Cuestiones relacionadas