| p:abstract
| - The year 2038 problem (also known as "Unix Millennium bug", or "Y2K38" by analogy to the Y2K problem) may cause some computer software to fail before or in the year 2038. The problem affects all software and systems that store system time as a signed 32-bit integer, and interpret this number as the number of seconds since 00:00:00 January 1, 1970. The latest time that can be represented this way is 03:14:07 UTC on Tuesday, January 19, 2038. Times beyond this moment will "wrap around" and be stored internally as a negative number, which these systems will interpret as a date in 1901 rather than 2038. This will likely cause problems for users of these systems due to erroneous calculations. Most 32-bit Unix-like systems store and manipulate time in this format, so this problem is often referred to as the "Unix Millennium Bug". However, there are many other non-Unix operating systems and software that store and manipulate time this way, and these will be just as affected by this problem. (en)
- Пробле́ма 2038 го́да в вычислительной технике — ожидаемые сбои в программном обеспечении 19 января 2038 года. Данная проблема затрагивает программы и системы, в которых используется представление времени по стандарту POSIX (Unix time), которое представляет собой количество секунд, прошедшее с 1 января 1970 года. Такое представление времени — это стандарт для Unix-подобных операционных систем . На большинстве 32-битных систем используется тип данных time_t<code> для хранения секунд в виде <code>signed int<code> . Самая поздняя дата, которая может быть представлена таким форматом в стандарте POSIX — это 03:14:07, вторник, 19 января 2038 года по Всемирному времени . Более позднее время заставит такое поле данных стать отрицательным как бы закольцевав таким образом время . В результате могут быть произведены ошибочные вычисления или результаты. Для проблемы 2038 года не существует простого решения для существующих комбинаций процессоров и операционных систем. Изменение определения типа <code>time_t<code> на 64 бита нарушит бинарную совместимость программ, существующих хранимых данных и всего другого использующего представление времени в бинарном виде. А приведение <code>time_t<code> в целое без знака может нарушить работу программ, которые вычисляют разницу во времени. На большинстве операционных систем для 64-битных архитектур уже используется 64-битное представление целого в <code>time_t<code>. Переход на такие архитектуры уже происходит, и некоторые ожидают, что он будет завершён к 2038 году. Тем не менее сотни тысяч 32-битных систем всё ещё вводятся в строй в 2008 году, в том числе и во встраиваемых системах. Вызывает сомнение, что они все будут заменены к 2038 году. Несмотря на то, что современные компьютерные системы могут модернизироваться раз в 18-24 месяцев, встроенные компьютеры могут действовать без модернизации весь срок, который работают системы, ими управляемые. Например, компьютеры управления процессами модели IBM 1800, выпуск которых был начат в 1965 году, всё ещё использовались на одной из атомных станций в Канаде в 2006 году. В дополнение к этому, 32-битный формат <code>time_t<code> также включён в спецификации форматов файлов, таких как повсеместно распространённый архивный формат ZIP. Формат файла может существовать в течение времени, за которое сменятся многие поколения компьютеров, а это означает, что Проблема 2038 останется актуальной. Введение 64-битного формата вносит новую дату «закольцевания» через примерно 290 миллиардов лет, в 15:30:08 UTC в воскресенье, 4 декабря 292 277 026 596 года. Но эта проблема на данный момент не считается срочной. (ru)
- Y2K38 är beteckningen på ett stundande problem som väntar många Unixliknande datasystem år 2038. I likhet med Y2K-problemet rör det sig om att det utrymme som tillägnats tidmätningen i operativsystemet inte längre räcker till. Ett vanligt sätt att hantera tid i Unixliknande operativsystem är att räkna antalet sekunder som passerat sedan den 1 januari 1970. Det är också tämligen vanligt att spara värdet i ett 32-bitars heltal med teckenbit, vilket då kan hantera högst 2147483647 sekunder. Klockan 3:14 den 19 januari år 2038 kommer detta heltal "bli fullt" och börja om på -2147483648 vilket motsvarar klockan 20:45 den 13 december 1901. En enkel åtgärd är att ändra programmet så att tiden istället lagras som ett 64-bitarstal. Problemet är att tidsfältet ofta förekommer i datastrukturer i till exempel filsystem, som inte är så enkla att ändra. (sv)
- En informática, el problema del año 2038 podría causar que una parte del software fallara en ese año. El problema afecta a los programas que usen la representación del tiempo basada en el sistema POSIX, que se basa en contar el número de segundos transcurridos desde el 1 de enero de 1970 a las 00:00:00 . Esta representación es un estándar de facto en los sistemas tipo Unix y también en los programas escritos para muchos otros sistemas operativos debido al gran alcance del lenguaje de programación C. En la mayoría de sistemas de 32 bits, el tipo de dato time_t usado para guardar el contador de segundos es un entero de 32 bits con signo, es decir, que puede representar un rango de números entre -2. 147. 483. 648 y 2. 147. 483. 647, por lo que el último segundo representable con este formato será a las 03:14:07 UTC del 19 de enero de 2038, cuando el contador llegue a 2147483647. Un segundo después, el contador se desbordará, y saltará al valor -2. 147. 483. 648, que causará el fallo de programas que interpretarán el tiempo como que están en 1901 ó 1970, en vez de 2038. A su vez, esto causaría cálculo y procesamiento incorrecto. No hay una forma sencilla de arreglar este problema para las combinaciones existentes de CPU/SO. Cambiar la definición de time_t para usar un tipo de 64 bits rompería la compatibilidad binaria para el software, almacenamiento de datos, por lo general, cualquier cosa que tenga algo que ver con la representación binaria del tiempo. Cambiar time_t a un entero de 32 bits sin signo afectaría a los programas que hacen cálculos con diferencias de tiempo. La mayoría de sistemas operativos para arquitecturas de 64 bits utilizan enteros de 64 bits para time_t. La migración a estos sistemas está todavía en proceso y se espera que se complete antes del 2038. Sin embargo, cientos de millones de sistemas de 32 bits son utilizados todavía en el 2008, muchos en sistemas integrados, y no es posible asegurar que todos ellos habrán sido reemplazados antes del 2038. Usar un entero de 64 bits retrasaría la fecha del problema unos 290 mil millones de años, mucho tiempo después de que el sol se haya extinguido. (es)
- Lyhenteellä Y2K38 tarkoitetaan Y2K-ongelmien kaltaista, 18. tammikuuta 2038 tapahtuvaa 32-bittisen kellon ympäripyörähtämistä. Unix-käyttöjärjestelmässä aikaa mitataan sekunteina nollahetkestä 1. tammikuuta 1970 kello 0.00.00 UTC. Tietokoneissa ja käyttöjärjestelmissä joissa käytetään ajan esittämiseen etumerkillistä 32-bittistä time_t-sekuntilaskuria tämä ajan esitystapa ei riitä ilmaisemaan 18. tammikuuta 2038 jälkeisiä aikoja. Monissa 64-bittisissä arkkitehtuureissa (esim. Linux/amd64) on siirrytty käyttämään 64-bittistä time_t:tä. Tilapäisratkaisuna on myös esitetty time_t:n muuttamista etumerkittömäksi, joka antaa siirrokseen lisäaikaa, mutta tällöin ei voida esittää ennen 1.1. 1970 olevia ajankohtia. Ongelmana on myös, että jos time_t:n tyyppiä muutetaan, sitä käyttävät ohjelmat - käytännössä lähes kaikki ohjelmat - on pakko kääntää uudelleen. On kuitenkin erittäin todennäköistä, että 64-bittiset järjestelmät syrjäyttävät 32-bittiset järjestelmät kokonaan ennen kriittistä ajankohtaa, koska niihin siirtyminen alkoi laajasti serverijärjestelmissä 1990-luvulla ja jopa pöytäkoneissa 2000-luvun alussa. Ongelmaan on alettu törmätä jo varhemmin. Esimerkiksi kolmenkymmenen vuoden asuntolainan ottaminen vuonna 2008 voi paljastaa kyseisen ongelman. (fi)
- Il Bug dell'anno 2038 è un noto bug informatico che potrebbe avere ripercussioni su alcuni software nell'anno 2038.Il problema riguarda programmi che usano la rappresentazione POSIX per calcolare il tempo: questa calcola la data del sistema a partire dal numero di secondi a partire dal 1 gennaio 1970 . Questo tipo di sistema è lo standard per i sistemi Unix, e colpisce anche software per altri sistemi operativi che siano stati sviluppati in C. Sulla maggior parte dei sistemi a 32 bit il valore del dato time_t usato per questo calcolo è un numero intero a 32 bit di tipo signed. Usando questo sistema, la data più avanzata rappresentabile a partire dal 1/1/1970 sono le 03:14:07 di martedì 19 gennaio 2038. Dopo questo momento, il contatore supererebbe il valore massimo, e verrebbe considerato come un numero negativo. I computer leggeranno la data non come 2038 ma come 1901, causando errori di calcolo. "Year 2038" è chiamato anche "Y2038", "Y2K38", o "Y2. 038K" nel linguaggio specialistico. Era stato previsto nel 2000 da John Titor, un presunto viaggiatore del tempo. (it)
- O problema do ano 2038 é uma falha na representação de datas em computadores, que pode causar erros em alguns programas de computador no ano de 2038. O problema afeta os programas que utilizam a representação de tempo POSIX, em que a data é calculada através do número de segundos (ignorando os segundos bissextos) desde 1 de janeiro de 1970. Esta representação é padrão nos sistemas operacionais do tipo Unix e afeta a maioria dos sistemas, pois grande parte deste software foi desenvolvido na linguagem C. Na maioria dos sistemas de 32 bits, o tipo de dados time t, utilizado para armazenar esta contagem de segundos, é um inteiro de 32 bits do tipo signed . O último registro de tempo que pode ser representado por este formato, seguindo o padrão POSIX, é 03:14:07 na terça-feira 19 de janeiro de 2038 . Após este momento a data será representada por um número decimal negativo que, dependendo da implementação, corresponderá ao ano 1970 ou 1901. Este valor para a data corrente certamente resultará em erros de cálculo e de funcionamento na maior parte dos programas em execução pelo sistema. (pt)
- 在计算机应用上，2038年问题可能会导致某些软件在2038年无法正常工作。所有使用POSIX时间表示时间的程序都将受其影响，因为它们以自1970年1月1日经过的秒数（忽略闰秒）来表示时间。这种时间表示法在类Unix（-{Unix-like}-）操作系统上是一个标准，并会影响以其C编程语言开发给其他大部份操作系统使用的软件。在大部份的32位操作系统上，此「time_t」数据模式使用一个有正負號的32位元整數(signed int32)存储计算的秒数。依照此「time_t」标准，在此格式能被表示的最后时间是2038年1月19日03:14:07，星期二（UTC）。超过此一瞬间，时间将会被掩盖（-{wrap around}-）且在内部被表示为一个负数，并造成程序无法工作，因为它们无法将此时间识别为2038年，而可能会依個別實作而跳回1970年或1901年。错误的计算及动作可能因此产生。目前并没有针对现有的CPU/操作系统搭配的简单解决方案。直接将POSIX时间更改为64位模式将会破坏对于软件、数据存储以及所有与二进制表示时间相关的部份的二进位兼容性。更改成无符号的32位运算器（integer）则会影响许多与时间改变相关的程序。大部份64位操作系统已经把time_t這個系統變數改為64位寬。不過，其他現有架構的改動仍在進行中，不過預期「應該可以在2038年前完成」。然而，直到2006年，仍然有数以亿計的32位系统在運行中，特別是许多嵌入式系统。相对于一般电脑科技18至24个月的革命性更新，嵌入式系统可能直至使用寿命终结都不会改变。32位time_t的使用亦被编码于文件格式，例如众所周知的ZIP压缩格式。其能存在的时间远比受影响的机器长。新的64位运算器可以记录至约2900亿年后的292,277,026,596年12月4日15:30:08，星期日（UTC）。 (zh)
- Das Jahr-2038-Problem könnte zu Softwareausfällen im Jahr 2038 führen. Dieses Problem ist auf EDV-Systeme beschränkt, die den POSIX-Zeitstandard benutzen und time_t als 32-Bit-Binärzahl definieren. POSIX zählt die seit dem 1. Januar 1970 abgelaufene Zeit in Sekunden. Am 19. Januar 2038 um 03:14:08 Uhr UTC wird die Anzahl der vergangenen Sekunden die Kapazität einer 31-Bit-Zahl überschreiten. Das 32. Bit wird laut Konvention dazu verwendet, positive und negative Zahlen zu unterscheiden (siehe Zweierkomplement), so dass die Zählung in den negativen Bereich springt und die Konvertierung zu Datum und Uhrzeit Freitag, den 13. Dezember 1901, 20:45:52 Uhr UTC ergibt. Im Vergleich zum Jahr-2000-Problem, welches im Wesentlichen beim Datumsstempel von Dateien auftrat, führt das Jahr-2038-Problem zu Fehlern bei elektronischen Transaktionen, die die Unixzeit als Zeitstempel verwenden. Ohne Gegenmaßnahmen könnten die wirtschaftlichen Auswirkungen verheerend sein, zumal im Banken- und Versicherungsumfeld Unix-Systeme neben Mainframes zur Standardausstattung gehören. Ein Beispiel für typische Jahr-2038-Fehler sind Transaktionen, deren Gültigkeit vom Zeitstempel des Ergebnisfeldes abgeleitet wird. Ist das Ergebnis nicht jünger als die Ausgangsdaten, so wird weiterhin auf ein gültiges Ergebnis gewartet oder die Transaktion irgendwann automatisch neu angestoßen. Am Stichtag des Jahr-2038-Problems werden allerdings sämtliche Ergebnisse den vermeintlichen Zeitstempel Dezember 1901 tragen, sind also immer älter als die Eingabedaten. Wartende Programme geraten so leicht in Endlosschleifen, was sich für den Endbenutzer in „abgestürzten“ Anwendungen äußert – z. B. ein Geldautomat, der ewig auf die elektronische Bestätigung der Kontenabbuchung wartet, bevor er Geld ausgibt. (de)
- År 2038-problemet (også kjent som «Unix Millennium bug», «Y2K38», «Y2K+38» eller «Y2. 038K» som en analogi til År 2000-problemet) kan forårsake at noen dataprogram feiler før eller i 2038. Problemet omfatter Unix-lignende operativsystem, som representerer systemtiden som sekunder siden 1. januar 1970 klokken 00.00.00 (1970-01-01T00:00:00). Cite error: Invalid <ref> tag; refs with no name must have content (no)
|
![[RDF Data]](http://dbpedia.org/statics/sw-cube.png)
