May your sockets never timeout
לאחר חודשים של עבודה מפרכת שחררתי היום את ספרית המפות מבוססת ה-Google Web Toolkit שלי. הספריה מאפשרת פיתוח אפליקציות web עם מפות בשפת Java (החביבה עלי וכן על עמרי עד מאוד), כשם ש-Google Maps API מאפשר זאת למפתחי JavaScript.
לאחר נסיוני המר עם ה-GPL פרסמתי את ספרית המפות תחת ה-CC BY-NC-SA.
יום הולדת שמח, עמרי, ותהנה מהאוגרים!
מפתחי ג'אווה שמפתחים למכשירים סלולאריים הם עם די מסכן, יש בעיות שונות ומשונות במכשירים מסויימים, ואם אתם רוצים שהישום שלכם יעבוד בכל המכשירים צפויה לכם דרך קשה ומייגעת.
ללא ספק, החברה שמייצרת את המכשירים השנואים ביותר עלי אישית היא מוטורולה.
למרות שהמכשירים החדשים של מוטורולה (RAZR2-V9 שמריץ לינוקס, V6 ואפילו V3) הם מכשירים חזקים, עתירי זכרון ועם תקשורת נתונים מהירה מאוד, הם עדיין שנואים במיוחד.
איך זה?
הבעיה עם מוטורולה, היא שלמרות שהם מייצרים מכשירים עם חומרה מצויינת, התוכנה שלהם היא לא פחות מפיגוע רב נפגעים.
הבעיות מתחילות בממשק מעצבן ולא אינטואיטיבי (נסו לקבוע דף בית לדפדפן, או להעלות אפליקציית ג'אווה דרך הכבל USB), וממשיכות במגוון באגים במכשירים.
HTTP 100
HTTP 1.1 תומך בקוד תגובה 100, שאומר לקליינט להמשיך לקרוא הלאה. השרת יכול לשלוח את זה אם הוא רוצה אחרי שהוא קרא את הכותרות של הבקשה, והלקוח אמור להמשיך את הבקשה אוטומטית בצורה שקופה למתכנת.
הבעיה היא שמוטורולה לא עובדים לפי הפרוטוקול, ומחזירים לאפליקציה את הקוד 100, ומשם התגובה האמיתית של השרת כבר אבודה.
יש פתרון שמצליח לעקוף את הבעיה הזו, והוא האק בקנה מידה בין לאומי. לא משהו שהייתם מכניסים לאפליקציה (ולשרת) אם לא היו מאיימים עליכם שיחליפו את המכשיר האישי שלכם למוטורולה.
כתיבה של קבצים בRAZR2
RAZR2 הוא המכשיר החדש ביותר של מוטורולה, והוא מריץ לינוקס. לכאורה, הזדמנות פז למוטורולה להוציא תוכנה פחות מסריחה.
איכשהו, מוטורולה הצליחו ליצור באג בכתיבה של קבצים בשימוש בFileConnection.
הבאג ממש ביזארי, וגרם לכך שלפעמים קבצים שתכתבו לא יכתבו כמו שצריך למערכת הקבצים.
הבאג מופיע בעיקר כשוכתבים "הרבה" נתונים במכה, למשל:
[code lang="java"]
byte buf[] = new byte[20000]; // create buffer
for (int i = 0; i < buf.length; i++) buf[i] = (byte) i; // populate with some crap
FileConnection conn = (FileConnection) Connector.open("file:///..."); // open file connection
OutputStream out = conn.openOutputStream(); // open output stream
out.write(buf); // write buffer to file
// cleanup
out.close();
conn.close();
conn = (FileConnection) Connector.open("file:///..."); // open file connection again
InputStream in = conn.openInputStream();
// read, you are in for a surprise
[/code]
פתרון שעובד לבעיה המוזרה הזו הוא לכתוב את הקובץ בכמה חתיכות יותר קטנות, למשל:
[code lang="java"]
private void writeChunked(byte[] buffer, OutputStream out) throws IOException
{
final int MAX = 4096;
int offset = 0;
while (offset < buffer.length)
{
int chunkSize = (buffer.length - offset > MAX ? MAX : buffer.length – offset);
out.write(buffer, offset, chunkSize);
offset += chunkSize;
out.flush();
}
}
[/code]
ממשק לעיון בקבצים
מוטורולה לא מספקים ממשק לעיון במערכת הקבצים על הפלאפון, רק משהו מוגבל שמאפשר גישה לתמונות ומדיה בלבד.
זה מראה שהם מפחדים מהמשתמשים שלהם, ולא סומכים על מערכת ההפעלה שלהם שתעמוד בפני משתמש חקרן.
אם במכשירים מהדור הקודם אפשר איכשהו לעיין בקבצים באמצעות MIDWay הזוועתית (תוכנה לניהול של מכשירי מוטורולה), בגרסאות החדשות (לינוקס) זה לא עובד עדיין.
הגבלות משאבים מגוחכות
במוטורולות למיניהן, אין אפשרות לפתוח יותר מארבעה חיבורי רשת בו זמנית. זה אולי נשמע הרבה, אבל זה לא.
הרבה ישומים נאלצים להתעקם בגלל המגבלה הזו.
בעיה נוספת היא שאי אפשרת לפתוח יותר מ14 קבצי קול בו זמנית (ליתר דיוק, 14 Players).
אפליקציות שמנגנות אפקטים קוליים טוענות בדרך כלל את הצלילים מראש כדי לנגן אותם מהר בעת הצורך. במוטורולה החליטו ש14 זה מספיק, מה שמכריח אפליקציות עתירות סאונד לקפוץ דרך חישוקי אש נוספים.
חוסר יציבות
זה אולי ישמע כמו התבכיינות, במיוחד למפתחי סלולארי שרגילים לקריסות (BREW, Symbian), אבל קל מאוד לגרום למכשירי מוטורולה לקרוס.
מספיק לפתוח ולא לסגור יותר מדי קבצים. במקום לקבל איזו שגיאה סבירה, המכשיר זורק במקרה הטוב "IOException : native error" ובמקרה הפחות טוב פשוט נתקע לחלוטין.
תמיכה במקשים
שינאה מיוחדת גורמת התמיכה במקשים במכשירי מוטורולה.
הקודים של המקשים שונים מהקודים של יצרני סלולאר אחרים, ואם על זה אני מוכן לסלוח, אני הרבה פחות סלחן כשמדובר בהבדלים בקודי הלחיצה בין מכשירי מוטורולה שונים, כשלפעמים ההבדל היחיד בינהם הוא מאיזה ספק נרכש המכשיר.
זה בהחלט גורם לצער ויגון לא מבוטל למפתחי משחקים.
בעית מקשים נוספת היא התמיכה הצולעת במצב שהמשתמש לוחץ על שני כפתורים בו זמנית.
במכשירים מסויימים, למשל V9m, האפליקציה מקבלת שני ארועי "מקש נלחץ" וארוע יחיד של "מקש שוחרר", במכשירים אחרים בכלל לא מקבלים ארועים על הכפתור השני שנלחץ.
התממשקות למחשב
מוטורולה עדיין לא הבינו שחיבור בממשק של מודם (פקודות AT) פס מהעולם, וישום הניהול שלהם – MIDWay (המשוקץ) מתחבר למכשיר ממש כאילו הוא מודם. מי שזוכר את המחלות של מודמים (מה הערוץ הCOM? מה הBaud rate? שיט, העכבר לא זז, שיט הCOM נתקע וצריך לאתחל את המחשב) ירגיש כמו בבית.
ההתקנה של ישומי ג'אווה היא ממש מציקה:
כדי להתקין, צריך לחפור בתפריטי המכשיר למצוא אפשרות נסתרת שמעבירה את המכשיר למצב טעינת ג'אווה, להפעיל אותה, ורק אז לחבר את הכבר נתונים (אם הוא היה מחובר כבר, צריך לנתק אותו! Serenity now!).
דבר מעצבן נוסף הוא שברגע שמחברים את המכשיר למחשב עם הכבל, ישום הג'אווה הפעיל – אם יש כזה, מושהה מיד ואי אפשר להריץ אותו.
למה? כי מוטורולה עושים כל מה שהם יכולים כדי לעלות למפתח הנואש על העצבים.
בלוטות'
התמיכה בבלוטות' במכשירי מוטורולה חלקית ביותר, ולא מאפשרת פעולות טרויאליות כמו התקנה של תוכנת ג'אווה דרך בלוטות', או עיון בקבצים שעל המכשיר.
כמיטב המסורת, לקראת שנת 2008, מוטורולה עדיין חוסמים את המשתמשים ואת המפתחים מכל דבר שמזכיר נוחות עבודה מול מכשירים אחרים.
יש לציין שיצא לי לעבוד עם מכשירי מוטורולה לראשונה לפני ארבע או חמש שנים, וכבר אז שנאתי אותם פחות או יותר מאותן סיבות.
מוטורולה הוציאו כמות מפחידה של מכשירים מאז, אבל לא תיקנו תקלות שמישות בסיסיות בשיטת העבודה עם המכשירים.
סיכום
אין ספק בליבי שמוטורולה מנסים, אבל משום מה הם לא מצליחים.
אולי המפתחים שלהם לא יוצלחים, ואולי יש בעיה בתרבות הארגונית שלהם שמונעת מאנשים לזהות או להגיב לחרא שהם מייצרים.
בכל מקרה, התוצאה זהה.
אני שונא את מוטורולה.
JavaMonkey הוא מנוע משחקים מרשים ופתוח קוד שכתוב בג'אווה.
המנוע מאפשר כתיבת משחקים תלת מימדיים בקלות, כולל תמיכה בOpenGL (בעזרת ספרייתLWJGL ) שמאפשרת גישה ליכולות של כרטיס המסך מג'אווה.
פרוייקט צדדי בשם jME Physics מאפשר התממשקות קלה למנוע הפיזיקה Open Dynamics Engine.
הגרסא האחרונה כוללת תמיכה באפלטים, מה שאומר שלא רחוק היום שנראה משחקי ג'אווה תלת מימדים בדפדפן.
IP2C היא ספריה קטנה למציאת קוד המדינה אליה שייכת כתובת IP.
הספרייה מכילה נכון לכרגע מימוש בPHP ובג'אווה, וכוללת ומבוססת על המרת הנתונים לקובץ בינארי קומפקטי שמתוכנן לחיפוש מהיר.
בסיס נתונים של נתוני IP למדינה זה דבר די גדול, בסיס הנתונים החינמי של WHI שמגיע כקובץ CSV מכיל כ77000 טוחי כתובות (הטווח מכתובת X לכתובת Y שייך למדינה C) ובסיסי נתונים אחרים הם הרבה יותר גדולים.
כשרוצים לחפש בדבר כזה יש כמה אפשרויות:
1. העלאת הנתונים לטבלא לבסיס הנתונים ושימוש בבסיס הנתונים לחיפוש.
2. המרה של קובץ הCSV לקובץ בינארי חסכוני ואז חיפוש בקובץ. על הדרך הזו המשך הפוסט מדבר.
הגישה הראשונה בעייתית כי היא דורשת גישת מנהל לבסיס הנתונים כדי לבצע יבוא מהיר, או דורשת עדכון בלולאה – מה שלוקח דקות ארוכות.
הגישה השניה עדיפה כי הנתונים תופסים פחות מקום וקל יותר לעדכן אותם, בנוסף אין תלות בבסיס נתונים.
שורה בקובץ הCSV המקורי מכילה תחילת טווח, סוף טווח, ומידע לגבי הטווח – כמו קוד ISO של המדינה והשם שלה. שורה לדוגמא:
"201620312","201674095","US","USA","UNITED STATES"
נניח שאנחנו שומרים את הנתונים האלו לקובץ בצורה הזו:
לכל מדינה:
4 בתים: תחילת טווח.
4 בתים: סוף טווח.
2 בתים קודISO
X בתים שם מדינה.
יש פה בעיה, כי שם המדינה הוא לא באורך ידוע, מה שלא מאפשר גישה ישירה לנתונים (כדי להגיע לשורה X צריך לסרוק את כל השורות שלפניה).
פתרון חלופי הוא לחלק את הקובץ לשני תחומים כדלקמן:
חלק ראשון בקובץ, לכל מדינה:
4 בתים: תחילת טווח.
4 בתים: סוף טווח.
2 בתים קודISO
4 בתים ההיסט של שם המדינה בתוך הקובץ
חלק שני בקובץ, לכל מדינה:
X בתים: שם המדינה.
זה כבר יותר טוב, עכשיו אפשר לחפש חיפוש בינארי בחלק הראשון, ולמצוא את שם המדינה לפי ההיסט שמצאנו ברשומה בחלק הראשון.
נניח שאלו הנתונים שלנו:
1. 1 עד 10 : ישראל
2. 10 עד 20: הודו
3. 20 עד 22: סין
4. 25 עד 30: ארצות הברית
אפשר לשים לב שלמעט המעבר מסין לארצות הברית טווח n תמיד מתחיל איפה שטווח n-1 נגמר.
ככה זה גם במציאות, כמעט תמיד אין חורים בין הטווחים.
זה מאפשר לנו ליעל את צורת השמירה: פשוט נשמור רק את תחילת הטווח של כל שורה, ונשתמש בתחילת הטווח של השורה הבאה בתור סמן לסוף הטווח.
אבל אני שומע את הצעקות: אבל מה עם סין? היא תקבל עוד שלוש כתובות!
הפתרון הפשוט למדי הוא להוסיף שורת סרק אחרי סין, שסוגרת את הטווח שלה:
1. 1 : ישראל
2. 10: הודו
3. 20 : סין
4. 22: אף אחד
4. 25 : ארצות הברית
…
חסכנו בממוצע 4 בתים מתוך 14, שזה כשלושים אחוז מנפח הנתונים, בלי לאבד שום דבר.
כמובן שהאלגוריתם של החיפוש יצטרך להתחשב בשורות ששייכות ל"אף אחד", מה שיסבך אותו, אבל זה שווה את המחיר.
אופטימיציה נוספת שמתבקשת היא לשמור את שם המדינה ואת הנתונים הנילוים (קוד מדינה וכו') פעם אחת בלבד לכל מדינה.
מה שיוביל לחסכון רציני נוסף בנפח הנתונים.
למעשה הקובץ שIP2C מייצרת אפילו יותר חסכוני מזה, החלק הראשון של הקובץ מכיל שורות בצורת:
IP התחלה: 4 בתים.
קוד מדינה: 2 בתים.
החלק השני של הקובץ מכיל עוד טבלה מאפשרת לגשת לשאר הנתונים (שם מדינה וכו'), אבל מחיב הפעלת חיפוש בינארי שני (במילים אחרות, המרתי את הנפח הדרוש להיסט בזמן מעט גבוה יותר לחיפוש).
בממוצע, כל טווח מהקובץ המקורי תופס כ7 בתים בקובץ, מאד חסכוני לכל הדעות.
עכשיו שסגרנו את מבנה הקובץ (פחות או יותר), הגיע הזמן לדבר על דרך הגישה אל הנתונים.
יש כמה דרכים, שלא כולן ישימות בכל שפה:
טעינת הקובץ לזכרון
הגישה הטבעית שכמעט כולם יבחרו תהיה להעלות את כל הקובץ לזכרון (סך הכל חצי מגה במקרה שלי) ולחפש בתוכו.
יש שתי חסרונות לגישה הזו: הראשונה היא צריכת הזכרון שפרופורציונית לגודל הקובץ, והשניה היא שהזמן לחיפוש הראשון הוא גדול כי משלמים גם על טעינת הקובץ.
מצד שני החיפוש עצמו מהיר מאוד, הכי מהיר למעשה מכל הגישות האחרות.
הגישה הזו לא אופטימלית לPHP בדרך כלל, כי בכל בקשה נצטרך לטעון את הקובץ מחדש.
הגישה הזו ממומשת כרגע במימוש בJava בלבד.
חיפוש ישירות על הקובץ
הטכניקה הזו היתה הרבה יותר נפוצה בעבר, כש640K היו צריכים להספיק לכולם.
במקום לטעון את הקובץ כולו לזכרון, מבצעים את החיפוש הבינארי ישירות על הקובץ.
החסרון הוא שזה איטי משמעותית יותר מחיפוש בזכרון, והיתרונות הם שצריכת הזכרון מינימלית ושהמחיר של החיפוש הראשון זול בדיוק כמו של אלו שאחריו.
הגישה הזו מתאימה מאוד לPHP, במיוחד אם צריך לבצע מספר קטן של חיפושים בכל בקשה.
מימוש: Java וPHP.
קובץ ממופה זכרון
קובץ ממופה זכרון (Memory mapped file) לוקח את הטוב משני העולמות. מצד אחד לא טוענים את כל הקובץ לזכרון, מצד שני המהירות קרובה למהירות חיפוש בזכרון.
PHP לא תומך בזה, אבל ג'אווה כן – וקיבלתי תוצאות יפות למדי עם זה.
היתרונות הם שכמו בחיפוש ישירות על הקובץ, לא טוענים את כל הקובץ לזכרון בהתחלה ולכן החיפוש הראשון יהיה מהיר בערך כמו החיפוש הראשון בחיפוש ישיר על הקובץ, אבל החיפושים הבאים יתקרבו למהירות חיפוש בזכרון. החיסרון העיקרי הוא שלא כל הפלטפורמות תומכות בזה.
מימוש: Java בלבד.
זכרון משותף
זכרון משותף (Shared memory) היא עוד גישה. הפעם הקובץ נטען פעם אחת ויחידה לזכרון, ונשאר שם. הגישה הזו מנטרלת את הבעיה המרכזית של PHP עם הגישה של טעינת הקובץ לזכרון (שצריך לטעון אותו כל פעם מחדש), אבל עדיין סובלת מהבעיה של צריכת זכרון גבוהה (למעשה הבעיה מחריפה גם הזכרון יהיה בשימוש גם אם אף אחד לא רוצה לבצע חיפוש במשך שבוע).
גם PHP וגם Java תומכים בזכרון משותף, אבל לא בדקתי את הביצועים של מימוש כזה.
מימוש: לא ממומש.
IP2C משוחררת ברשיון GPL2, והיא קלה מאוד לשימוש.
לפני יותר משלוש שנים פתחתי פרוייקט בשם JWebcam בסורס-פורג'.
הפרוייקט היה הנסיון הראשון שלי לכתוב פרוייקט קוד פתוח, והיה מערכת שרת/לקוח להזרמת וידאו ממצלמת רשת.
התחלתי לפתח אותו אחרי שלא הייתי מרוצה מהאלטרנטיבות שהיו בזמנו.
הפרייקט היה נחמד, וכלל פונקציות נחמדות כמו זיהוי תנועה, הזרמת וידאו על גבי HTTP ויכולת לתמוך בכמה מצלמות שמשדרות לאותו שרת.
וברגע שעברתי לעבודה על לינוקס הפסקתי סופית את הפיתוח שלו, כי לא היה לי מספיק זמן לברר מה השינויים שאני צריך לעשות כדי לשאוב נתונים מהמצלמה תחת לינוקס.
לפני כשבוע פנה אלי schwarzer_peter שרצה להחיות את הפרוייקט; הוא התחיל לפתח משהו דומה וכשהוא ניסה לרשום אותו בסורס-פורג' – כנראה תחת אותו שם, הוא גילה שתפסתי את השם.
אחרי קצת אימייל-פונג החלטנו שהוא יקבל הרשאות מנהל ומנדט לעשות ככל העולה על רוחו, ושאני אייעץ ואעזור לו להתממשק אל הקוד שכבר כתבתי.
הוא פתח בלוג וורדפרס חביב לפרוייקט, ונראה שהוא עובד די במרץ.
כיף לראות שאחרי שלוש שנים מישהו מוצא שימוש לקוד שכתבתי ושהפרוייקט מתעורר.
Antenna הוא פרוייקט ותיק לבניה של ישומי J2ME (ג'אווה לטלפונים סלולאריים), הפרוייקט היה בתרדמת די ארוכה.
לפני כמה שנים התחלתי לתרום קוד לפרוייקט, אבל התרדמת היתה כל כך עמוקה שהשיפורים לא שוחררו.
עד עכשיו.
קיבלתי הרשאות Commit לפרוייקט לפני כחצי שנה, הכנסתי את השיפורים שלי, כשגולת הכותרת היא Preprocessor חדש ורב עוצמה, שמגיע גם כפלאג-אין לEclipse (אבל כמובן מאפשר גם הרצה מסקריפט ANT) וכן Task שמאפשר חתימה על מידלטים.
את הTask שחותם פיתחתי מזמן, ואת הPreprocessor ממש לפני כמה חודשים, במסגרת העבודה שלי בחברת Vollee.
ביום שישי שחררתי גרסא חדשה (0.9.5-beta) שכוללת את הכל.
הפוסט הזה הוא על מיילר, והוא מכוון בעיקר למפתחים, אם כי כולם מוזמנים לקרוא ולהתפעל :).
כששוטטתי בבאגים של Eclipse בזמן שחיפשתי מידע על משהו, נתקלתי בAttachment של קובץ מוזר שסיקרן אותי:
mylar/context/zip.
לא נתקלתי בזה בעבר, ולא ראיתי שום קשר בינו לבין הבאג.
חיפוש קצר בגוגל הביא אותי לדף הזה, שמכיל מאמר על "תכנות מונחה משימות עם מיילר".
חפרתי עוד קצת, ומצאתי גם את המצגת ווידאו הזו, שמתארת איך משתמשים במיילר ומה הוא עושה (40 דקות).
מסתבר שמיילר הוא פרוייקט Eclipse חדש, אחד מני רבים (Eclipse הפכה לחממה של עשרות טכנולוגיות חדשניות), שמתיימר לפתור את הבעיה של עומס מידע בזמן שעובדים עם Eclipse.
באופן הבסיסי ביותר, Mylar הוא רשימת משימות, למשימות מקומיות וכן למשימות/באגים ממערכות באגים כמו bugzilla, trac וJira
מה שיפה זה שמיילר מנהל הקשר (Context) לכל משימה בצורה אוטומטית, שמכיל את כל מה שקשור אל המשימה – איזה קבצים פתחת, איזה אלמנטים בתוך הקבצים מעניינים (במקרה של קוד ג'אווה – איזה פונקציות למשל) וכו'.
ברגע שעוברים לעבוד על משימה, מתחילים מיד מההקשר הקודם של המשימה (ריק בהתחלה), ואחרי שעוברים למשימה אחרת, ההקשר נשמר – מוכן להשלף אוטומטית ברגע שחוזרים לעבוד על אותה משימה.
דמיינו את הסיטואציה הבאה:
אתם עובדים על איזה באג/פיצ'ר לתומכם, ופתאום יש מקרה חירום וצריך לתקן באג חדש ולייצר גרסא חדשה של הdemo מאתמול.
לפני מיילר, מה שזה אומר זה שצריך להתחיל להזכר מה צריך כדי ליצר גרסא חדשה, לפתוח קבצים חדשים, כנראה גם לסגור את כל מה שקשור לבאג שעבדתם עליו.
עכשיו, נניח שהבאג הזה בכלל שייך למישהו אחר בצוות, אז צריך להעביר את העסק עליו ואז להזכר מחדש איפה הייתם ומה עשיתם, לסגור את הקבצים שקשורים לבאג בdemo, לפתוח את הקבצים של הבאג שעבדתם עליו ולהמשיך לעבוד.
כל הסחות הדעת האלו יגרמו לכך שגם תבלו איזה עשר דקות בynet בין המשימות, סתם כדי לנקות את הראש.
עם מיילר, אפשר לעבור בקלות בין ההקשרים, בלי לבזבז זמן ותאי זכרון יקרים.
מיילר מייעל גם עבודה בצוותים: את ההקשרים האלו, שכוללים בעצם ריכוז של ידע על אותו באג, אפשר לצרף לבאג עצמו, ככה שהמפתח הבא יוכל פשוט למשוך את ההקשר מהבאג ולהמשיך מאותו מקום שאתם עצרתם. (כל הקבצים פתוחים, כל הפונציות שרלוונטיות לדעתכם כבר יהיו בהקשר, וכו').
Eclipse הוא כבר מזמן לא כלי לפיתוח Java בלבד, כבר היום הוא תומך בC/C++, PHP, Prolog ועוד, מיילר אמור לתת ערך מוסף לתכנות בלי קשר לשפה, כל עוד אתם עובדים בתוך Eclipse – אם כי אני לא בטוח שהוא באמת מוכן לשפות אחרות עדיין.
יתרון נוסף הוא התמיכה האוטומטית בקבוצות שינויים (Changeset) כשעובדים מול מערכת ניהול גרסאות הקוד (CVS/SVN וכו').
מה שזה אומר זה שמיילר ינהל בצורה אוטומטית את הChangeset שקשור לבאג שאתם עובדים עליו, ואפילו יכלול הודעת Commit אוטומטית כשתעשו Commit!
עם הזמן, רשימת המשימות שלכם תתנפח ותתנפח, ותהפוך לבעיה של עומס מידע בפני עצמה.
הדרך לפתור את זה היא תזמון של המשימה (Schedule) לתאריך מסויים, ואז התמקדות בשבוע העבודה הנוכחי. משימות שזמנן עבר יהיו מסומנות באדום, משימות להיום בכחול ומשימות שנסגרו בירוק. מיילר גם מציג סרגל התקדמות שבועי, שעושה הרגשה חמימה בבטן כשהוא מתקרב ל100% ביום רביעי (אפשר לשחק Unreal ביום חמישי!).
יש עוד, ועדיין לא התחלתי להשתמש במיילר באמת, אבל הוא נראה מבטיח.
יש לינקים עם עוד מידע פה.
שוחררה ג'אווה 6.
משהו מעניין, בדף הJSR של הפרוייקט, רשימת קבוצת המומחים ההתחלתית היא:
Initial Expert Group Membership:
* HP
* IBM
* Intel
* Doug Lea
דאג לי הוא פרופסור שכתב את ספריות הסנכרון שנכנסה
בג'אווה 5 (java.util.concurrent), די מצחיק לראות את השם שלו שם בין כל חברות הענק.
אחת השאלות בממ"נ האחרון בקורס ג'אווה היתה לכתוב ישומון של סודוקו.
אז הנה, מי שרוצה לחקור או לשחק עם הקוד מוזמן לקחת מפה. (הJAR כולל את הקוד).
הקוד משוחרר תחת רשיון GPL.
שחררתי ספריה חדשה למציאת המדינה שאליה שייכת כתובת IP.
הספריה, IP2C – משוחררת תחת רשיון GPL2, ותומכת בJava, PHP ושורת פקודה.
הביצועים מצויינים:
250 חיפושים בשניה בPHP, ו330,000 חיפושים בשניה בג'אווה (זה ממש טוב מדי מכדי להיות אמיתי, אבל אלו התוצאות שלי) זה באמת טוב מכדי להיות אמיתי, כתבתי תוכנית בדיקת ביצועים והתוצאה היא ש100,000 כתובות אי פי אקראיות לחיפוש לוקחות 14.7 שניות, מה שנותן כ7140 חיפושים לשניה בג'אווה.
הספריה עובדת על קובץ בינארי, ככה שלא צריך להתעסק עם בסיס נתונים כדי להשתמש בה.
עדכון:
בשימוש במטמון אופציונלי (העלאת הקובץ לזכרון, מה שצורך כ460K), הגעתי לכ170,000 חיפושים בשניה.