| dbo:abstract
|
- معضلة عام 2038 (المعروفة أيضًا باسم Y2038 ، Y2K38 ، أو ايبوكلابيس ) هي خطأ برمجي في تنسيق الوقت في أنظمة الكمبيوتر ذات معمارية 32 بت عند محاولتها تمثيل الأوقات بعد الساعة 03:14:07 بالتوقيت العالمي المنسق في الـ19 يناير 2038. تتواجد المشكلة في الأنظمة التي تقيس الوقت بنظام توقيت يونكس - حيث تُقاس عدد الثواني المنقضية منذ «عصر يونكس» والذي يبدأ من منتصف الليل من 1 كانون الثاني 1970 حسب التوقيت العالمي المنسق (00:00:00 UTC في 1 يناير 1970) - ويكون تخزين عدد الثواني في نوع البيانات الذي يدعى «عدد صحيح بإشارة ذو حجم 32 بت». نوع البيانات هذا قادر فقط على تمثيل الأعداد الصحيحة بين سالب 231 (2 إلى قوة 31) وموجب 1 -231، مما يعني أن آخر وقت يمكن ترميزه هو 1 -231 ثانية بعد عصر يونكس والذي يكون (03:14:07 بالتوقيت العالمي المنسق في 19 يناير 2038). ستؤدي محاولة تمثيل الثانية التالية (03:14:08) إلى تجاوز العدد الصحيح أي تجاوز القدرة التخزينية لنوع البيانات «عدد صحيح بإشارة ذو حجم 32 بت»، ما سيؤدي إلى حدوث خطأ يؤدي إلى تعيين قيمته لسالب 231 والتي ستفسرها الأنظمة على أنها 231 ثانية قبل عصر يونكس والذي سيكون الساعة 20:45:52 بالتوقيت العالمي المنسق في 13 ديسمبر 1901. إن المعضلة مشابهة في طبيعتها لمشكلة عام 2000 . قد تواجه أنظمة الكمبيوتر التي تستخدم نظام توقيت يونكس في العمليات الهامة أخطاء فادحة إذا لم يتم حل معضلة Y2038 مبكرًا. وقد حدث أن واجهت بعض الأنظمة التي تستخدم التواريخ اللاحقة الأخطاء بالفعل. أكثر الأنظمة عرضة للأخطاء هي تلك التي نادرًا ما يتم تحديثها أو لا يتم تحديثها أبدًا، مثل الأنظمة القديمة أو المدمجة. لا يوجد حل شامل لهذه المشكلة، لكنه تم بالفعل تحديث العديد من الأنظمة الحديثة لقياس وقت يونكس بأعداد صحيحة حسب معمارية 64 بت والتي لن يحدث بها تجاوز للسعة ل حتى 292 مليار. (ar)
- En informàtica, el problema de l'any 2038 (conegut també pel Numerònim Y2K38) podria causar que una part del programari falli en aquest any. El problema afecta els programes que utilitzen la representació del temps basada en el sistema POSIX, que es basa a comptar el nombre de segons transcorreguts des de l'1 de gener de 1970 a les 00:00:00 (ignorant els segons intercalars). Aquesta representació és un estàndard de facto en els sistemes tipus Unix i també en els programes escrits per a molts altres sistemes operatius a causa del gran abast del llenguatge de programació C. En la majoria de sistemes de 32 bits, el tipus de dada time_t utilitzat per guardar el comptador de segons és un sencer de 32 bits amb signe, és a dir, que pot representar un rang de nombres entre 2147483648 i 2147483647 (-231 i 231-1; 1 bit per al signe, i 31 per al valor absolut), per la qual cosa l'últim segon representable amb aquest format serà a les 03:14:07 UTC del 19 de gener de 2038, quan el comptador arribi a 2147483647. Un segon després, el comptador es desbordarà, i saltarà al valor 2147483648, que causarà la fallada de programes que interpretaran el temps com que estan en 1901 (depenent de la implementació), en comptes de 2038. Al seu torn, això causaria càlcul i processament incorrecte i causaria un problema mundial. No hi ha una forma senzilla de resoldre aquest problema degut a les combinacions existents de CPU/SO. Canviar la definició de time_t per utilitzar un tipus de 64 bits trencaria la compatibilitat binària per al programari, emmagatzematge de dades, i, en general, qualsevol cosa que tingui alguna cosa a veure amb la representació binària del temps. Canviar time_t a un enter de 32 bits sense signe afectaria als programes que fan càlculs amb diferències de temps. La majoria de sistemes operatius per arquitectures de 64 bits utilitzen sencers de 64 bits per time_t . La migració a aquests sistemes està encara en procés i s'espera que es completi molt abans de 2038. Utilitzar un enter de 64 bits retardaria la data del problema uns 2,90 bilions d'anys (2,9 x 1012). És a dir, 220 vegades l'edat aproximada de l'Univers. (ca)
- Problém roku 2038 (jinak známý jako „Unix millenium bug“, „Y2K38“, „Y2K+38“, nebo „Y2.038K“ podle přirovnání k problému Y2K) může hypoteticky způsobit pád počítačových programů v roce 2038. Problém může nastat v unixových nebo podobných datovacích systémech, které reprezentují systémový čas jako počet sekund (ignorujíce přestupné sekundy) od 00:00:00 1. ledna 1970. Tato reprezentace času se díky masové rozšířenosti programovacího jazyka C vyskytuje v programech pro většinu operačních systémů. Datový typ <a href="/w/index.php?title=Time_t&action=edit&redlink=1" class="new" title="Time t (stránka neexistuje)">time_t</a> je na většině 32bitových systémů používán k ukládání počítadla sekund jako 32bitové celé číslo se znaménkem (32-bit signed integer). Poslední čas, který takto může být zapsán, je úterý 19. ledna 2038 v 03:14:07. Čas v další sekundě „přeteče“ a bude vnitřně reprezentován jako záporné číslo, což může způsobit pád programů, jelikož neuvidí takovéto datum jako 2038, ale spíše jako 1901. (cs)
- Το πρόβλημα του έτους 2038 είναι ένα πρόβλημα παρόμοιο με το Πρόβλημα του έτους 2000. Το πρόβλημα υπάρχει στις περιπτώσεις στις οποίες για την χρονική σήμανση και τους υπολογισμούς ημερομηνιών χρησιμοποιείται η διαφορά σε δευτερόλεπτα από την 1η Ιανουαρίου 1970 και αυτή η διαφορά αποθηκεύεται σε προσημασμένους ακεραίους 32 μπιτ. (el)
- La problemo de jaro 2038 estas komputila problemo, kiu povos kaŭzi malfunkciadon de komputiloj en la jaro 2038. Ĝi havos efikojn al komputiloj, kiuj konservas la daton kaj horon kiel la nombron da sekundoj pasintaj de la 1-a de januaro 1970 (nomata Unix-tempo laŭ la uzado en Unix-ecaj operaciumoj), kaj konservas ĝin kiel signan 32-bitan nombron. En signa nombro, la unua bito estas interpretata kiel signo: ĝi estas "1" por negativa, kaj "0" por pozitiva nombro. 231 sekundojn post 1970, la 19an de januaro 2038 je 03:14:07 UTC, la 31 malplej signifaj bitoj, reprezentantaj la absolutan valoron, havos valoron de 1, kaj unu sekundon pli poste, la bito por la signo havos valoron de 1, kaj tial la nombro estos interpretata kiel negativa, do reen de la 1-a de januaro 1970. Tio egalas al la 13a de decembro 1901, 20:45:52 UTC. (eo)
- Das Jahr-2038-Problem von EDV-Systemen (Numeronym: Y2K38) könnte zu Ausfällen von Software im Jahr 2038 führen. Dieses Problem ist auf EDV-Systeme beschränkt, die die Unixzeit benutzen und time_t als vorzeichenbehaftete 32-Bit-Ganzzahl definieren. (de)
- En informática, el problema del año 2038 (conocido también por el numerónimo Y2K38) podría causar que una parte del software falle en ese año. El problema afecta a los programas que usen la representación del tiempo basada en el sistema POSIX (Tiempo Unix), que se basa en contar el número de segundos transcurridos desde la noche del 1 de enero de 1970 a las 00:00:00 (ignorando los segundos intercalares). 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 (-231 y 231-1; 1 bit para el signo, y 31 para representar su valor en complemento a dos), 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 2 147 483 647. 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 (dependiendo de la implementación), en vez de en 2038. A su vez, esto causaría cálculo y procesamiento incorrecto y causaría un problema mundial. 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 y, 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 mucho antes de 2038. Usar un entero de 64 bits retrasaría la fecha del problema unos 290 mil millones de años (2,9 × 1011). Es decir, 22 veces la edad aproximada del universo. (es)
- 2038 efektua edo 2038. urteko efektua, urte horretan mundu osoko software batzuk zuzen funtzionatzeari utziko diotenaren arazoa da. Fenomeno honek, datak 1970. urte hasieratik segundotan zenbatu eta 32 biteko zenbaki oso bezala gordetzen dituzten sistemetan du eragina. Datak adierazteko modu honek 2038. urteko urtarrilaren 19ko 03:14:07 UTC ordua da adierazi dezakeen azkena, beraz, hortik segundo baten ostean, 32 biteko zenbaki osoa negatibo bihurtuko da eta 1901. urtea adieraziko du. Denbora adierazteko modu hau Unix motako 32 biteko sistemetan erabiltzen da batik bat, baina arazoak datak modu honetan manipulatzen dituzten sistema orotan du eragina. Gaur egungo 64 biteko sistema gehienetan 64 biteko zenbaki osoak erabiltzen dira eginkizun honetarako, arazoa milaka milioi urtetan atzeratuz. (eu)
- Masalah Tahun 2038 berhubungan dengan penunjukan waktu dalam banyak sistem digital sebagai banyaknya detik yang terlewati sejak 1 Januari 1970 dan disimpan sebagai integer 32-bit bertanda. Implementasi semacam itu tidak dapat menyandikan waktu setelah 03:14:07 UTC pada 19 Januari 2038. Seperti Masalah Tahun 2000, masalah tahun 2038 disebabkan oleh ketidakcukupan kapasitas dari unit penyimpanan yang dipilih. (in)
- Le bug de l'an 2038, ou bogue de l'an 2038 (au Canada), aussi appelé Y2038, est un bug informatique similaire au bug de l'an 2000 qui pourrait perturber le fonctionnement d'un grand nombre de systèmes informatiques le 19 janvier 2038 à 3 h 14 min 8 s, temps universel. Ils afficheront alors 13 décembre 1901 et 20 h 45 min 52 s. Ce bug concerne potentiellement tous les systèmes d'exploitation et les programmes qui utilisent une représentation des dates codée sur 32 bits. Il concerne les formats de fichier (tels que ZIP), les systèmes de fichiers (comme le système de fichier FAT utilisé sur la plupart des clés USB et cartes flash) et les systèmes d'exploitation à tous les niveaux (du noyau de système d'exploitation aux langages de programmation), voire l'horloge temps réel elle-même. (fr)
- The Year 2038 problem (also known as Y2038, Y2K38, Y2K38 superbug, or the Epochalypse) is a time formatting bug in computer systems with representing times after 03:14:07 UTC on 19 January 2038. The problem exists in systems which measure Unix time – the number of seconds elapsed since the Unix epoch (00:00:00 UTC on 1 January 1970) – and store it in a signed 32-bit integer. The data type is only capable of representing integers between −(231) and 231 − 1, meaning the latest time that can be properly encoded is 231 − 1 seconds after epoch (03:14:07 UTC on 19 January 2038). Attempting to increment to the following second (03:14:08) will cause the integer to overflow, setting its value to −(231) which systems will interpret as 231 seconds before epoch (20:45:52 UTC on 13 December 1901). The problem is similar in nature to the Year 2000 problem. Computer systems that use time for critical computations may encounter fatal errors if the Y2038 problem is not addressed. Some applications that use future dates have already encountered the bug. The most vulnerable systems are those which are infrequently or never updated, such as legacy and embedded systems. There is no universal solution to the problem, though many modern systems have been upgraded to measure Unix time with signed 64-bit integers which will not overflow for 292 billion years. (en)
- 2038年問題（にせんさんじゅうはちねんもんだい）は、2038年1月19日3時14分7秒（UTC、以下同様）を過ぎると、コンピュータが誤動作する可能性があるとされる年問題。 (ja)
- 2038년 문제(2038年 問題, 영어: year 2038 problem, Unix Millennium bug, Y2K38)란 컴퓨터 분야에서 2038년 또는 전후에 특정한 컴퓨터 소프트웨어에 이상이 발생하는 문제를 말한다. 이 문제는 표기법을 이용하는 프로그램에서 발생하는데, 이 표기법은 시간을 1970년 1월 1일 자정 UTC 이후 경과된 초 시간을 이용하여 표현한다. 이 표기법은 유닉스 계열의 운영 체제에서 표준이며, C가 널리 이용되기 때문에 다른 대부분의 운영 체제에서 작동하는 프로그램에도 영향을 준다. 대부분의 32비트 시스템에서 초 시간을 저장하는 데 이용되는 time_t 자료 형식은 부호 있는 32비트 정수형이다. POSIX 표준에 따르면, 이 형식을 이용하여 나타낼 수 있는 최후의 시각은 1970년 1월 1일 자정에서 2147483647초가 지난 2038년 1월 19일 화요일 03:14:07 UTC이다. 이 시각 이후의 시각은 범위를 초과하여 내부적으로 음수로 표현되며, 프로그램의 이상 작동을 유발하는데, 왜냐하면 이러한 값은 2038년 대신 프로그램의 구현 방법에 따라 1970년 또는 1901년을 가리키기 때문이다. 따라서 계산 오류와 결정 오류가 발생할 수 있다. (ko)
- Het softwareprobleem van het jaar 2038 is een probleem dat machines en computers kunnen hebben op 19 januari 2038. Unix-achtige besturingssystemen houden de tijd bij als het aantal seconden dat is verstreken sinds 1 januari 1970 00:00:00 (UTC). Dit getal werd oorspronkelijk bijgehouden in een (signed) integer van 32 bits. Deze integer kan waardes bevatten tussen −2147483648 en 2147483647. Op 19 januari 2038 om 03:14:07 UTC zal de integer de maximale waarde bereiken. Hierna zal de integer overgaan naar de minimale waarde. Doordat dit een negatieve waarde is zal de datum worden aangegeven als 13 december 1901. Om het probleem te voorkomen hebben de meeste makers van besturingssystemen software-updates uitgevaardigd. (nl)
- Il bug dell'anno 2038 (abbreviato in Y2038) è un bug informatico che potrebbe avere ripercussioni su alcuni software, riguardante la gestione di date relative all'anno 2038 e successivi. (it)
- Problem roku 2038 (Y2K38, analogicznie do Y2K) – wada oprogramowania, która może ujawnić się 19 stycznia 2038. Źródło problemu leży w sposobie zliczania czasu przez niektóre wersje systemu operacyjnego Unix oraz przez oprogramowanie korzystające z tzw. uniksowego timestampu (który bywa także wykorzystywany w systemach operacyjnych i oprogramowaniu niemającym korzeni w systemie Unix). W podatnym na problem oprogramowaniu do przechowywania informacji o punktach w czasie służy 32-bitowa zmienna typu całkowitego ze znakiem (ang. signed integer) zawierająca liczbę sekund, które upłynęły od rozpoczęcia tzw. ery Uniksa, czyli od 1 stycznia 1970, godz. 0:00 UTC. Maksymalna wartość wspomnianej zmiennej wynosi 2 147 483 647 sekund, co odpowiada godzinie 03:14:07 UTC, 19 stycznia 2038. W następnej sekundzie stan licznika stanie się ujemny – nastąpi przeskok do najmniejszej wartości ujemnej (-2 147 483 648) lub licznik zostanie wyzerowany. Wyświetli się wtedy data 13 grudnia 1901 godz. 20:45:52 (przeskok do najmniejszej wartości ujemnej) lub 1 stycznia 1970 godz. 00:00:00 (wyzerowanie licznika Timestamp). Może to spowodować poważne błędy w obliczaniu upływu czasu. (pl)
- År 2038-problemet eller Y2K38 är beteckningen på ett stundande problem som väntar många datasystem år 2038. I likhet med millenniebuggen rör det sig om att det utrymme som tillägnats tidmätningen i exempelvis operativsystemet inte längre räcker till. Framförallt i unixliknande operativsystem anges tiden i många funktioner som antalet sekunder som passerat sedan den 1 januari 1970 kl 00:00:00 (UTC). I datorer där centralprocessorn arbetar med 32 bitars ordbredd sparas värdet vanligen i ett 32 bitars heltal med teckenbit, vilket då kan hantera tidpunkter högst 2 147 483 647 (231 − 1) sekunder från nollpunkten. Den 19 januari 2038 kl 03:14:08 (UTC) kommer detta heltal bli fullt och börja om på −2 147 483 648 vilket motsvarar den 13 december 1901 kl 20:45:52 (UTC). En enkel åtgärd vore att ändra programmen så att tiden istället lagras som 64-bitarstal. Problemet är att programmen måste kompileras om för att ändra variabeltypen och eventuellt anpassas på andra sätt. Detta måste göras samtidigt för alla program i ett system, inklusive program från tredje part, då många systemanrop använder tidsvariabeln. Alternativt måste man skapa parallella system. Aritmetik med 64 bitars tal är dessutom resurskrävande om processorn internt arbetar med 32 bitars aritmetik. Tidsfältet förekommer i binär form också i datastrukturer i till exempel filsystem, som inte ändras genom en uppdatering av operativsystem och programvara.[källa behövs] I server- och persondatorer har man för det mesta övergått till 64 bitars system, där tiden enkelt kan anges med 64 bitar, och programvaran hur som helst anpassats för den nya ordbredden. Däremot kommer många inbyggda system ännu länge att använda 32 bitars ordbredd. I dessa system är resurserna också annars knappa, så intresset att övergå till en mindre effektiv lösning är svalt, i synnerhet som problemet inte uppstår inom de flesta apparaters beräknade livslängd. (sv)
- Проблема 2038 года в вычислительной технике — ожидаемые сбои в программном обеспечении накануне 19 января 2038 года. Данная проблема затронет программы и системы, в которых используется представление времени по стандарту POSIX (UNIX-время), которое представляет собой количество секунд, прошедшее с полуночи 1 января 1970 года. Такое представление времени — это стандарт для Unix-подобных операционных систем (из-за повсеместного использования языка Си). (ru)
- O problema do ano 2038, efeito 2038, bug 2038, problema Y2K38 ou falha de Gangnam Style (em referência ao problema Y2K) refere-se ao problema previsto para ocorrer no ano de 2038 nos sistemas informatizados (programas de computador) que utilizam a representação de tempo no padrão POSIX/IEEE 1003, em que a data é calculada através do número de segundos ignorando os segundos bissextos desde 1 de janeiro de 1970. A representação POSIX é de uso padrão nos sistemas operacionais do tipo Unix, afetando a maioria dos sistemas, pois grande parte deste software foi desenvolvido na linguagem C. Na maioria dos sistemas com processadores do tipo 32 bits, o tipo de dados <a href="/wiki/Time_t" title="Time t">time t</a>, utilizado para armazenar esta contagem de segundos, é um inteiro de 32 bits do tipo signed (considera o sinal). O último registro de tempo que pode ser representado por este formato no padrão POSIX, é 03:14:07 na terça-feira 19 de janeiro de 2038 (UTC). 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 (prever-se a data 13 de dezembro de 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 presentes principalmente em instituições financeiras e governamentais. (pt)
- 在计算机应用上，2038年问题可能会导致某些软件在2038年1月19日3时14分07秒之后无法正常工作。所有使用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年。因此可能产生错误的计算及动作。 有少數的情況下，在制定規格時，特別規定以無正負號的32位元整數（unsigned int32）儲存 POSIX 时间，因此錯誤會被延後到 2106 年。例如比特幣區塊鏈中的區塊時間戳記，就是以這種方法儲存。 目前并没有针对现有的CPU／操作系统搭配的简单解决方案。直接将POSIX时间更改为64位模式将会破坏对于软件、数据存储以及所有与二进制表示时间相关的部份的二进位兼容性。更改成无符号的32位整数则会影响许多与两时间之差相关的程序。不过，那时使用32位系统的计算机可能会很少。 大部份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)
- Пробле́ма 2038 ро́ку у комп'ютерних системах — очікувані збої в роботі програмного забезпечення 19 січня 2038 року. Ця проблема стосується програм і систем, в яких використовується представлення часу за стандартом POSIX (час Unix). Цей стандарт використовує кількість секунд, які пройшли від початку «епохи», тобто з півночі 1 січня 1970 року. Таке представлення часу — стандарт для Unix-подібних операційних систем (через розповсюджене використання мови Сі). На більшості систем з розрядністю процесора не вище 32-біт для зберігання секунд використовується тип даних <a href="/wiki/Time.h#Типи_даних" title="Time.h">time_t</a>, визначений як signed int, тобто у форматі 32-бітного цілого числа зі знаком. Найпізніша дата, яка може бути представлена таким форматом в стандарті POSIX — це 03:14:07, вівторок, 19 січня 2038 року за всесвітнім часом (UTC). Наступний момент часу час змусить таке поле даних прийняти від'ємне значення, що подібно до зациклювання часу (оскільки від'ємне число може бути сприйнято програмами як час у 1970 або 1901 році, залежно від реалізації). Унаслідок можуть бути здійснені помилкові обчислення або отримані некоректні результати. Для багатьох комбінацій процесорів і операційних систем не існує простого розв'язання проблеми 2038 року. Розширення типу time_t до 64 біт порушить бінарну сумісність програм, збережених даних і всього іншого, що використовує представлення часу в бінарному вигляді. А приведення time_t в ціле без знаку може порушити роботу програм, які обчислюють різницю в часі. Більшістю операційних систем для 64-бітних архітектур вже використовується 64-бітне представлення цілого в time_t. Перехід на такі архітектури вже відбувається, і за прогнозами, він буде завершений до 2038 року. Проте, сотні тисяч 32-бітних систем все ще вводяться експлуатацію, у тому числі — у вбудовуваних системах (наприклад, на 32-бітних процесорах архітектури ARM та на процесорах меншої розрядності). Викликає сумнів, що вони всі будуть замінені до 2038 року. Вбудовані комп'ютери можуть діяти без модернізації весь термін, який працюють керовані ними системи. Наприклад, комп'ютери управління процесами моделі IBM 1800, випуск яких розпочато 1965 року, усе ще використовувалися на одній з атомних станцій у Канаді у 2006 році. На додаток до цього, 32-бітний формат time_t також включено до специфікацій форматів файлів, таких як повсюдно поширений архівний формат ZIP. Формат файлу може існувати протягом часу, за який зміняться багато поколінь комп'ютерів, а це означає, що Проблема 2038 залишиться актуальною. Введення 64-бітного формату вносить нову дату «закільцьовування» через приблизно 290 мільярдів років, в 15:30:08 UTC в неділю, 4 грудня 292 277 026 596 року. Але ця проблема в наш час не вважається терміновою. Представлення дати у Java і .NET не мають цієї проблеми. (uk)
|
| rdfs:comment
|
- Το πρόβλημα του έτους 2038 είναι ένα πρόβλημα παρόμοιο με το Πρόβλημα του έτους 2000. Το πρόβλημα υπάρχει στις περιπτώσεις στις οποίες για την χρονική σήμανση και τους υπολογισμούς ημερομηνιών χρησιμοποιείται η διαφορά σε δευτερόλεπτα από την 1η Ιανουαρίου 1970 και αυτή η διαφορά αποθηκεύεται σε προσημασμένους ακεραίους 32 μπιτ. (el)
- Das Jahr-2038-Problem von EDV-Systemen (Numeronym: Y2K38) könnte zu Ausfällen von Software im Jahr 2038 führen. Dieses Problem ist auf EDV-Systeme beschränkt, die die Unixzeit benutzen und time_t als vorzeichenbehaftete 32-Bit-Ganzzahl definieren. (de)
- Masalah Tahun 2038 berhubungan dengan penunjukan waktu dalam banyak sistem digital sebagai banyaknya detik yang terlewati sejak 1 Januari 1970 dan disimpan sebagai integer 32-bit bertanda. Implementasi semacam itu tidak dapat menyandikan waktu setelah 03:14:07 UTC pada 19 Januari 2038. Seperti Masalah Tahun 2000, masalah tahun 2038 disebabkan oleh ketidakcukupan kapasitas dari unit penyimpanan yang dipilih. (in)
- 2038年問題（にせんさんじゅうはちねんもんだい）は、2038年1月19日3時14分7秒（UTC、以下同様）を過ぎると、コンピュータが誤動作する可能性があるとされる年問題。 (ja)
- 2038년 문제(2038年 問題, 영어: year 2038 problem, Unix Millennium bug, Y2K38)란 컴퓨터 분야에서 2038년 또는 전후에 특정한 컴퓨터 소프트웨어에 이상이 발생하는 문제를 말한다. 이 문제는 표기법을 이용하는 프로그램에서 발생하는데, 이 표기법은 시간을 1970년 1월 1일 자정 UTC 이후 경과된 초 시간을 이용하여 표현한다. 이 표기법은 유닉스 계열의 운영 체제에서 표준이며, C가 널리 이용되기 때문에 다른 대부분의 운영 체제에서 작동하는 프로그램에도 영향을 준다. 대부분의 32비트 시스템에서 초 시간을 저장하는 데 이용되는 time_t 자료 형식은 부호 있는 32비트 정수형이다. POSIX 표준에 따르면, 이 형식을 이용하여 나타낼 수 있는 최후의 시각은 1970년 1월 1일 자정에서 2147483647초가 지난 2038년 1월 19일 화요일 03:14:07 UTC이다. 이 시각 이후의 시각은 범위를 초과하여 내부적으로 음수로 표현되며, 프로그램의 이상 작동을 유발하는데, 왜냐하면 이러한 값은 2038년 대신 프로그램의 구현 방법에 따라 1970년 또는 1901년을 가리키기 때문이다. 따라서 계산 오류와 결정 오류가 발생할 수 있다. (ko)
- Il bug dell'anno 2038 (abbreviato in Y2038) è un bug informatico che potrebbe avere ripercussioni su alcuni software, riguardante la gestione di date relative all'anno 2038 e successivi. (it)
- Проблема 2038 года в вычислительной технике — ожидаемые сбои в программном обеспечении накануне 19 января 2038 года. Данная проблема затронет программы и системы, в которых используется представление времени по стандарту POSIX (UNIX-время), которое представляет собой количество секунд, прошедшее с полуночи 1 января 1970 года. Такое представление времени — это стандарт для Unix-подобных операционных систем (из-за повсеместного использования языка Си). (ru)
- معضلة عام 2038 (المعروفة أيضًا باسم Y2038 ، Y2K38 ، أو ايبوكلابيس ) هي خطأ برمجي في تنسيق الوقت في أنظمة الكمبيوتر ذات معمارية 32 بت عند محاولتها تمثيل الأوقات بعد الساعة 03:14:07 بالتوقيت العالمي المنسق في الـ19 يناير 2038. (ar)
- En informàtica, el problema de l'any 2038 (conegut també pel Numerònim Y2K38) podria causar que una part del programari falli en aquest any. El problema afecta els programes que utilitzen la representació del temps basada en el sistema POSIX, que es basa a comptar el nombre de segons transcorreguts des de l'1 de gener de 1970 a les 00:00:00 (ignorant els segons intercalars). (ca)
- Problém roku 2038 (jinak známý jako „Unix millenium bug“, „Y2K38“, „Y2K+38“, nebo „Y2.038K“ podle přirovnání k problému Y2K) může hypoteticky způsobit pád počítačových programů v roce 2038. Problém může nastat v unixových nebo podobných datovacích systémech, které reprezentují systémový čas jako počet sekund (ignorujíce přestupné sekundy) od 00:00:00 1. ledna 1970. Tato reprezentace času se díky masové rozšířenosti programovacího jazyka C vyskytuje v programech pro většinu operačních systémů. Datový typ <a href="/w/index.php?title=Time_t&action=edit&redlink=1" class="new" title="Time t (stránka neexistuje)">time_t</a> je na většině 32bitových systémů používán k ukládání počítadla sekund jako 32bitové celé číslo se znaménkem (32-bit signed integer). Poslední čas, který takto může být zapsán (cs)
- La problemo de jaro 2038 estas komputila problemo, kiu povos kaŭzi malfunkciadon de komputiloj en la jaro 2038. Ĝi havos efikojn al komputiloj, kiuj konservas la daton kaj horon kiel la nombron da sekundoj pasintaj de la 1-a de januaro 1970 (nomata Unix-tempo laŭ la uzado en Unix-ecaj operaciumoj), kaj konservas ĝin kiel signan 32-bitan nombron. (eo)
- En informática, el problema del año 2038 (conocido también por el numerónimo Y2K38) podría causar que una parte del software falle en ese año. El problema afecta a los programas que usen la representación del tiempo basada en el sistema POSIX (Tiempo Unix), que se basa en contar el número de segundos transcurridos desde la noche del 1 de enero de 1970 a las 00:00:00 (ignorando los segundos intercalares). (es)
- 2038 efektua edo 2038. urteko efektua, urte horretan mundu osoko software batzuk zuzen funtzionatzeari utziko diotenaren arazoa da. Fenomeno honek, datak 1970. urte hasieratik segundotan zenbatu eta 32 biteko zenbaki oso bezala gordetzen dituzten sistemetan du eragina. Datak adierazteko modu honek 2038. urteko urtarrilaren 19ko 03:14:07 UTC ordua da adierazi dezakeen azkena, beraz, hortik segundo baten ostean, 32 biteko zenbaki osoa negatibo bihurtuko da eta 1901. urtea adieraziko du. (eu)
- The Year 2038 problem (also known as Y2038, Y2K38, Y2K38 superbug, or the Epochalypse) is a time formatting bug in computer systems with representing times after 03:14:07 UTC on 19 January 2038. The problem exists in systems which measure Unix time – the number of seconds elapsed since the Unix epoch (00:00:00 UTC on 1 January 1970) – and store it in a signed 32-bit integer. The data type is only capable of representing integers between −(231) and 231 − 1, meaning the latest time that can be properly encoded is 231 − 1 seconds after epoch (03:14:07 UTC on 19 January 2038). Attempting to increment to the following second (03:14:08) will cause the integer to overflow, setting its value to −(231) which systems will interpret as 231 seconds before epoch (20:45:52 UTC on 13 December 1901). The (en)
- Le bug de l'an 2038, ou bogue de l'an 2038 (au Canada), aussi appelé Y2038, est un bug informatique similaire au bug de l'an 2000 qui pourrait perturber le fonctionnement d'un grand nombre de systèmes informatiques le 19 janvier 2038 à 3 h 14 min 8 s, temps universel. Ils afficheront alors 13 décembre 1901 et 20 h 45 min 52 s. (fr)
- Het softwareprobleem van het jaar 2038 is een probleem dat machines en computers kunnen hebben op 19 januari 2038. Unix-achtige besturingssystemen houden de tijd bij als het aantal seconden dat is verstreken sinds 1 januari 1970 00:00:00 (UTC). Dit getal werd oorspronkelijk bijgehouden in een (signed) integer van 32 bits. Deze integer kan waardes bevatten tussen −2147483648 en 2147483647. Op 19 januari 2038 om 03:14:07 UTC zal de integer de maximale waarde bereiken. Hierna zal de integer overgaan naar de minimale waarde. Doordat dit een negatieve waarde is zal de datum worden aangegeven als 13 december 1901. (nl)
- Problem roku 2038 (Y2K38, analogicznie do Y2K) – wada oprogramowania, która może ujawnić się 19 stycznia 2038. Źródło problemu leży w sposobie zliczania czasu przez niektóre wersje systemu operacyjnego Unix oraz przez oprogramowanie korzystające z tzw. uniksowego timestampu (który bywa także wykorzystywany w systemach operacyjnych i oprogramowaniu niemającym korzeni w systemie Unix). W podatnym na problem oprogramowaniu do przechowywania informacji o punktach w czasie służy 32-bitowa zmienna typu całkowitego ze znakiem (ang. signed integer) zawierająca liczbę sekund, które upłynęły od rozpoczęcia tzw. ery Uniksa, czyli od 1 stycznia 1970, godz. 0:00 UTC. Maksymalna wartość wspomnianej zmiennej wynosi 2 147 483 647 sekund, co odpowiada godzinie 03:14:07 UTC, 19 stycznia 2038. W następnej se (pl)
- O problema do ano 2038, efeito 2038, bug 2038, problema Y2K38 ou falha de Gangnam Style (em referência ao problema Y2K) refere-se ao problema previsto para ocorrer no ano de 2038 nos sistemas informatizados (programas de computador) que utilizam a representação de tempo no padrão POSIX/IEEE 1003, em que a data é calculada através do número de segundos ignorando os segundos bissextos desde 1 de janeiro de 1970. (pt)
- År 2038-problemet eller Y2K38 är beteckningen på ett stundande problem som väntar många datasystem år 2038. I likhet med millenniebuggen rör det sig om att det utrymme som tillägnats tidmätningen i exempelvis operativsystemet inte längre räcker till. (sv)
- 在计算机应用上，2038年问题可能会导致某些软件在2038年1月19日3时14分07秒之后无法正常工作。所有使用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年。因此可能产生错误的计算及动作。 有少數的情況下，在制定規格時，特別規定以無正負號的32位元整數（unsigned int32）儲存 POSIX 时间，因此錯誤會被延後到 2106 年。例如比特幣區塊鏈中的區塊時間戳記，就是以這種方法儲存。 新的64位运算器可以记录至约2900亿年后的292,277,026,596年12月4日15:30:08，星期日（UTC）。 (zh)
- Пробле́ма 2038 ро́ку у комп'ютерних системах — очікувані збої в роботі програмного забезпечення 19 січня 2038 року. Ця проблема стосується програм і систем, в яких використовується представлення часу за стандартом POSIX (час Unix). Цей стандарт використовує кількість секунд, які пройшли від початку «епохи», тобто з півночі 1 січня 1970 року. Таке представлення часу — стандарт для Unix-подібних операційних систем (через розповсюджене використання мови Сі). Для багатьох комбінацій процесорів і операційних систем не існує простого розв'язання проблеми 2038 року. (uk)
|
