...וגם עכשיו זה קורה אחרי 136 שנים, כמו שאמרת בעצמך בהודעה הפותחת. אז מה ההבדל?

עריכה: אוקיי, נראה לי שהבנתי עכשיו יותר טוב מה שאלת. הרעיון הוא שאתה רוצה להיות יכול לייצג גם תאריכים בעבר (נניח תאריך לידה של מישהו), אז גם אם תאריך ההתחלה (epoch) של זמן יוניקס הוא ב1970, יש היגיון בנתינת האפשרות לייצג תאריכים מוקדמים יותר.

כן הבנתי בגדול את זה שאפשר לייצג זמן אחורה אבל מבחינה פונקציונלית אתה יכול לחשוב על מקרה שצטרך תאריך אחורה?

ולא בקטע של לרשום טקסט אלא תאריך מערכת...

אתה עשוי להיות צריך לחשב תכנותית תאריכי עבר יחסית לתאריך המערכת, כלומר לבדוק בתוכנה "כמה זמן עבר מאז X". לכן זמן המערכת אמור להשתמש באותו ערך מסוג "זמן" כמו זמנים אחרים שכן הגיוני שיהיו בעבר.

אבל כאמור, סביר להניח שאף אחד לא הוטרד יותר מדי ממה שיקרה עוד 68 שנה. אם היו חושבים על זה והיה אכפת להם, מן הסתם היו משתמשים במספר ביטים גדול יותר לפני שהיו עוברים לסוג ערך חיובי בלבד (unsigned). אבל מתכנתים הם עצלנים, רובם לא יחשבו יותר מדי גם על איך התוכנה תעבוד עוד שנה אלא אם כן הובהר להם מראש שזו הדרישה (כפי שציינתי, שתוכנות מסויימות שנכתבו שנים ספורות לפני באג 2000 לא לקחו אותו בחשבון). אז עוד 68 שנה? למי אכפת. הרי עד אז סביר להניח שרובם כבר לא יהיו בחיים...

למי אכפת. הרי עד אז סביר להניח שרובם כבר לא יהיו בחיים...

חחחח זה נכון....

עכשיו עוד שאלה קטנה בגלל שאני לא ממש מבין בתכנות.

אם אני כתוב תוכנה ועומדה לפני האופציה אם להשתמש ב32 ביט או 64 ביט לדבר מסוים.

כמה "אקסטרה" זה ידרוש ממני (מבחינת כתיבת קוד ומבחינת משאבי מערכת כשהתוכנה רצה)?

אני פשוט מנסה להבין אם ה"אי-מעבר" לפרוטוקול או מספר ביטים יותר מתקדם נובע גם מקטע של חסכון...

היום - הנטיה בתכנות היא להיות בזבזן בלי חשבון. בהתחשב בכמות הזמן שלוקח המאמץ לחסוך במשאבים והצרות שזה יכול לגרום, יחסית לכמות המשאבים הזמינה (זיכרון/מעבד), ההנחה היא שברוב הגדול של המקרים אופטימיזציה כזו תהיה השקעה מיותרת. לכן כמעט תמיד תראה אנשים משתמשים במשתנים של 32 ביט (זה ברירת המחדל) באופן טבעי כדי ליצור לולאות של 10 סיבובים, כלומר גם כשאתה יודע בוודאות שהמשתנה לא יעבור לעולם את המספר 10, עדיין תשתמש בסוג משתנה שיכול להגיע ל2,147,483,647. כי למה לא בעצם?

לעומת זאת, בעבר הרחוק שעליו אנחנו מדברים (1970), הכל היה בצמצום. כל פעולה נוספת של המעבד קריטית לביצועים, כל ביט זיכרון מבוזבז עלול להיות חסר לך אחר כך. אז בהחלט, בתקופה ההיא תיכנתו במידה רבה עם מחשבה של חיסכון.

כמובן שגם היום ישנם יישומים שדורשים אופטימיזציה מקסימלית לצורך ביצועים, וככה אתה רואה לפעמים שמנסים שמידע מסויים יוכל להיכנס כולו לתוך L1 Cache של המעבד, כדי שלא תצטרך לגשת לזיכרון המערכת (או אפילו לL2) ולהפסיד מהירות כתוצאה מזה. אבל יישומים כאלה הם יחסית מעטים, ובדרך כלל רק חלקים קטנים מהם דורשים אופטימיזציה ברמה כזו.

ולשאלה שלך - כמה השקעה תידרש כדי להשתמש במשתנה 64 ביט במקום 32? כלום, בסך הכל צריך להגדיר את הערך כראוי, לצורך העניין להכריז על משתנים כ int64 במקום int (שהוא כברירת מחדל כינוי של int32).

הבעיה בנושא של NTP היא אפילו יותר זניחה מכיוון שהפרוטוקול בעיקר נועד לסנכרון זמנים, הוא משתמש בערכים היחסים בין הזמן שהוא מדווח לזמן שהשעון השני מדווח. לכן בהנחה ששני השעונים די מסונכרנים, גם בעת החריגה / מעבר חזרה לערכים ישנים, זה עדיין יהיה בסדר (גם אם למשל לא היה את ה ERA).

היום - הנטיה בתכנות היא להיות בזבזן בלי חשבון. בהתחשב בכמות הזמן שלוקח המאמץ לחסוך במשאבים והצרות שזה יכול לגרום, יחסית לכמות המשאבים הזמינה (זיכרון/מעבד), ההנחה היא שברוב הגדול של המקרים אופטימיזציה כזו תהיה השקעה מיותרת. לכן כמעט תמיד תראה אנשים משתמשים במשתנים של 32 ביט (זה ברירת המחדל) באופן טבעי כדי ליצור לולאות של 10 סיבובים, כלומר גם כשאתה יודע בוודאות שהמשתנה לא יעבור לעולם את המספר 10, עדיין תשתמש בסוג משתנה שיכול להגיע ל2,147,483,647. כי למה לא בעצם?

לעומת זאת, בעבר הרחוק שעליו אנחנו מדברים (1970), הכל היה בצמצום. כל פעולה נוספת של המעבד קריטית לביצועים, כל ביט זיכרון מבוזבז עלול להיות חסר לך אחר כך. אז בהחלט, בתקופה ההיא תיכנתו במידה רבה עם מחשבה של חיסכון.

כמובן שגם היום ישנם יישומים שדורשים אופטימיזציה מקסימלית לצורך ביצועים, וככה אתה רואה לפעמים שמנסים שמידע מסויים יוכל להיכנס כולו לתוך L1 Cache של המעבד, כדי שלא תצטרך לגשת לזיכרון המערכת (או אפילו לL2) ולהפסיד מהירות כתוצאה מזה. אבל יישומים כאלה הם יחסית מעטים, ובדרך כלל רק חלקים קטנים מהם דורשים אופטימיזציה ברמה כזו.

ולשאלה שלך - כמה השקעה תידרש כדי להשתמש במשתנה 64 ביט במקום 32? כלום, בסך הכל צריך להגדיר את הערך כראוי, לצורך העניין להכריז על משתנים כ int64 במקום int (שהוא כברירת מחדל כינוי של int32).

אוקי אבל אם בעצם אני משאיר משתנה מסויים כברירת מחדל של 32 ביט והוא בסך הכל צריך 10 ביטים אז זה גם "ביזבוז" לא? (אני באמת שואל, אני לא יודע)

הרי אם אני רק מגדיר בתור 64 ואין בו שימוש באמת של יותר מ32 אז זה עדיין יחשב כאותו "ביזבוז" כמו בדוגמה מקודם לא? אבל עכשיו יש לי את היתרון שאם הוא כן צריך יותר אז יש לו את האפשרות...

לא יודע, אולי אני סתם מדבר שטויות מתוך מקום של אי הבנה בנושא.

לכל מעבד יש את המאפיין שלו. הכוונה ב 32 ביט (פה) היא שהמעבד יכול לבצע פעולות במחזור שעון אחד על מידע עד גודל 32 ביט. בכל מקרה המשתנים הטיפוסיים הם בכפולות של 8 ביט.