האם אורקל מנסה להרוג כל טכנולוגיה מבוססת מחשב ?

הבהרה: אלע"ד (אני לא עוכר דין).

"אין לי בעיה עם בני אדם שהם גם עורכי דין, יש לי בעיה עם עורכי דין השייכים לקבוצת בני האדם." – איי קיי

אורקל תובעת את גוגל על כך כי אנדרואיד מבוססת Java (מעכשיו אכתוב את המילה בעברית), אבל זו לא שילמה להם כסף (והרבה) על כך שהם משתמשים בשפה. או במילות אורקל – גוגל לא שילמה להם על רישיון מתאים.

גוגל מצידה אומרת כי חברת סאן (אשר לצערי אורקל קנו אותה), שיחררה את מימוש ג'אווה "לחופשי" ברישיון אשר מאפשר לכל דורש לעבוד איתה. לפני כן, היו מספר מימושים שונים של JDK כדוגמת המימוש של חברת IBM, אשר נוצר כ clean room. אבל אז למעשה Sun שחררה ב2006 את OpenJDK, ואף התעוד נפתח לגמרי, וקיבלנו API לגמרי פתוח של ג'אווה. ואז חברת RedHat יצרה פרוייקט בשם IcedTea אשר מאגד בתוכו את תכונות ג'אווה ללא צורך בתמיכה של עוד כלים לשם כך, תוך שימוש בגרסת קוד הפתוח שSun פתחה.

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

החשיבה של אורקל היא שיש לשלם על כך שגוגל משתמשת ב API של ג'אווה באנדרואיד, גם אם המימוש של גוגל הוא שלהם בלבד. אבל זה לא הכל, הם מדברים שאפילו על המצאות גנריות וחשובות כמו ה"גלגל" (הקבלה שלי), יש צורך לשלם במידה ומישהו מתגלה כמחזיק בזכויות על יצירה, גם אם הדבר אומר כי אף אחד לא יוכל להשתמש עוד בגלגל (אם לסיים את ההקבלה שאני עושה).

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

או במילים אחרות: זה יעצור לגמרי את כל העולם הטכנולוגי כיום, ולמעשה יהרוג את הגישה של שפות התכנות כפי שאנחנו מכירים אותם. ואז התביעה תהפוך לטביעה של עולם הטכנולוגיה.

לבנות את FPC jvmbackend

רכשתי לפני שבוע Samsung Galaxy S2, והגיע הזמן באמת לבנות משהו לאנדרואיד.

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

אז ניגשתי לרענן את העץ של jvmbackend מהsvn, והחלטתי לבנות בעצמי את הגרסה החדשה.
לפני כן, יש לעשות patch קטן בעץ הקוד של jvmbackend לקובץ fpc.pp:

אפליקציית Android לניהול נסיעות ברכבת

Sven Barth כתב לעצמו תכנה לניהול הנסיעות שלו ברכבת, ולשם כך השתמש בלזרוס ו FPC for JVM.

הגרסה משתמשת ב SQLite בנוסף בשביל לשמור ולשלוף מידע, ורצה בצורה טבעית על ה VM של אנדרואיד.

לדבריו, הוא תכנת הכל בלזרוס, ולא היה צריך להעזר בכלל ב Eclipse לשם הפיתוח. וההמרה לאנדרואיד נעשתה על ידי הכלים אשר מגיעים עם ה SDK עצמו.

הגרסה הקודמת של התכנה נכתבה עבור מערכת מבוססת Windows CE. הגרסה שהוא יצר ל WinCE, השתמשה בקבצי ini, אותם הוא כאמור המיר לSQLite.

Sven פרסם גם את קוד המקור של האפליקציה שלו, במידה ואתם מעוניינים להשתמש בה כמובן 🙂

גרסה חדשה ל FPC JVM

ג'ונס שחרר הודעה לרשימת הדיוור של fpc-devel על כך שהוא שיחרר גרסה חדשה של FPC-JVM.

כזכור, הגישה הזו אומרת שFPC מאפשר לי ליצור קוד שJVM יכול להריץ בצורה טבעית.

בגרסה החדשה נוספה יכולת להדר קוד שיהיה ניתן להמרה נוחה לdalvik של אנדרואיד, ובעצם בנוסף ליכולת ליצור קוד טבעי (arm) לאנדרואיד, עכשיו יש גם יכולת בעצם לכתוב קוד שירוץ כאילו נכתב במקור בג'אווה.

בשביל לגרום לppcjvm להדר את הקוד לקבצי class ש dalvik אוהב יש להעביר את הפרמטר הבא:

ppcjvm -Tandroid ....

כמובן ש3 הנקודות הם המשך הפקודה שרוצים לספק.

עוד תוספות ושינויים שנכנסו לגרסה הזו הם:

• המהדר עכשיו מנקה כמו שצריך את קבצי ה j אלא אם הועבר פרמטר של a-.
• עכשיו קובץ ה Makefile יוצר את ה rtl כמו שצריך עבור גרסת הג'אווה וגרסת האנדרואיד
• תוקן קוד המתייחס לפרמטרים עם var או out בתוך פונקציות/פרוצדורות מקוננות
• תוקן באג של try/except מקונן
• נוספת פקודה למהדר Ctcompactintarrayinit-

הסיבה להוספה האחרונה היא בכך שJVM אינו תומך במערכים קבועים, כך שצריך ליצור קוד אשר יעשה את העבודה בתוך קובץ ה class, אך בגלל שגודל ה class יכול להיות עד בגודל של 64K של ByteCode, ובמידה ויש הרבה מערכים, הוא גם יכול לגלוש מכך, אז נוספה אפשרות שיוצרת קוד חדש, אשר פוטנציאלית איטי יותר, אבל יוצר קוד קטן יותר.

• תוקן קוד של copy כאשר x שונה מ0.
• הקוד של ה rtl נכנס לספרייה rtl/android/jvm כך שלא תהיה התנגשות במימוש קוד טבעי של android arm.

FPC JVM

יש מספר התפתחויות מאוד מעניינות עם FPC לאחרונה. דבר ראשון עובדים על תמיכה לעוד ארכיטקטורות מעבדים (חלקם הגדול שייכות ל ARM). דבר שני, הקפיאו את עץ הפיתוח של 2.5.1, מה שאומר שגרסה 2.6.0 צריכה לצאת בקרוב (שזה דבר יחסי כמובן). וכרגע עץ הפיתוח עומד על 2.7.1 .
יש דיבורים על כך, כי אולי יגרמו לפסקל (FPC וכנראה גם דלפי) להיות חלק מ Firebird SQL. כלומר שפה שאפשר לתכנת בה stored procedures, trigger וכו' … ממש כמו ב Pg, רק המטרה היא להימנע משפת C. אבל זה כמובן בשלב התאוריה בלבד. אם זה יתממש, אז זה יכנס ל Firebird 3.0.
אם זה לא מספיק, אז הסתבר כי Embarcadero – המפתחת של דלפי כיום, משתמשת ב FPC ולזרוס בשביל לפתח תוכנות גרפיות עבור iPad, בדגש על תכנת הסיוע שלהם לדיווח באגים.

אבל החדשה שלדעתי הכי מעניינת, ומעט שונה הגיעה ביום שישי האחרון: יצרו עץ פיתוח מיוחד ל FPC עבור יצירת אפשרות להדר קוד פסקל לJVM. זה למעשה מתורגם ל Java Assembler אבל התוצר הוא שאפשר להשתמש בקוד פסקל בתוך Java בצורה טבעית והפוך.

כרגע, נכון לכתיבת הפוסט, חסר תמיכה בחלקים של בסיס השפה. היחידה שנקראת system – שהיא היחידה הבסיסית ביותר בפסקל, לא ממומשת עד סופה. גם ה RTL עדיין לא קיבל מימוש מלא. יש תחבירים בשפה שגם עוד לא קיבלו מימוש, וחלק גם לא יקבלו בשל מגבלות שפת Java. יש גם מספר מגבלות של פסקל מול ג'אווה, כדוגמת קוד מעגלי, אשר פסקל אינה תומכת בו (בצורה מכוונת), וכן עבודה עם namespace של ג'אווה, אשר כנראה כן ישתנה אבל בקרוב.

כמו כן, הוצג תחביר חדש בנוסף, על מנת להשתמש בספריות java מתוך קוד פסקל:

{$namespace x.y.z}
type
JavaClassName = class [external ['package.name'] [name 'ExternalClassName']] [(JavaSuperClassName|ProtocolName [, ProtocolName, ProtocolName])]
[strict][private, protected, public]
 [variables declarations]
 [method declarations]
end;

הקוד בעצם מגדיר שאנחנו משתמשים ב namespace מסויים, במקרה הזה x.y.z, ויורשים ממחלקה מסויימת השייכת לג'אווה. חשוב להבין כי זה המבנה ולא הקוד עצמו שצריך לכתוב.

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

טיפ לעצמי: Firebird Events, Java, JayBird

אני עושה ניסויים עם JRuby. הבעיה שלי היא שאין לי ברובי תמיכה באירועים של Firebird ואין לי זמן ללמוד להוסיף את התמיכה הזו לרובי, ולכן אני מנסה ללמוד לעבוד עם האירועים של JayBird לג'אווה. השימוש שלי ב JRuby אם מישהו סתם רצה לדעת הוא דווקא בגלל הצורך שלי להשתמש בThreads, ולצערי ברובי 1.8 הם עדיין ירוקים, ולכן אני נאלץ לעבוד עם JRuby.

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

הקוד של מסד הנתונים לבדיקה:

מרוב תקלות ואבסורד לא רואים את היער

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

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

אחרי שהצלחתי להבין כי לשם שינוי הוט היו בסדר (זה לא דבר שקורה הרבה אני חייב לציין), ישבתי והתחלתי לחקור את הנושא ב4 רמות שונות. כאשר הכל נכשל, החלטתי לעשות test case ואז גיליתי את הגורם לבעיה. לאחר מכן דיווחתי על זה באג, והאדם האמון על הנושא שקשור לבאג הזה, היה עם אצבע מהירה על ה"סגור" וסיפק תחושה בסגנון של "עזוב אותי באימשך, מה אתה מדווח באגים, זה בכלל פיטצ'ר". בזכות צפריר הבאג נפתח שוב, אבל היות וכל המידע בפנים, ורק צריך לעשות copy paste למה שכתבתי ולקבל את הבאג, אין לי הרבה מה להוסיף, אבל האדם שאחראי על הבאג יותר מעניין אותו הכותרת ששמתי לבאג מאשר כל המידע ששפכתי על הבאג לאחר הכותרת.

בזמן העבודה על הבאג, גיליתי כמה דברים (מחדש) על ג'אווה, אחרי שלמעלה משנתיים וחצי לא נגעתי בשפה (כאילו שזה היה משהו רע). הנה כמה דוגמאות:

איך משווים בין מחורזות בג'אווה (הנה כמה אפשרויות) ?

"a" == "a"

"a".equals("a")

"a".compare("a")

ובכן, 2 השורות הראשונות זהות, והן מבצעות השווה של האם instance זהה. התשובה השלישית היא התשובה שאנחנו מחפשים לביצוע השוואה של מחרוזות.

אבל זה לא נגמר כאן. נגיד ואתה מעוניין לעשות wait בתוך טרד רץ. ובכן תאורטית אתה צריך לטפל בחריגה אחת. הבעיה היא שבפועל יש לך עוד חריגה שצריך לטפל בה. ואם היא מתרחשת, אי אפשר לעשות wait אלא Thread.sleep אשר שונה לגמרי בגישה שלו מ wait.

יש לי עוד המון מה להגיד על הזוועה הזו שנקראת ג'אווה אבל הזמן קצר והזעם רב.

יש לי לקוח אשר מחזיק router + ips בכלי אחד של Fortigate. יש לי כמה שרתי לינוקס אצלו ברשת (למעשה שרתים שלו שאני היחיד שנוגע בהם) והשאר זה הכל Windows. נטוויז'ן שמנהלים לו את הכלי הזה, החליטו ש ssh זה פרוטוקול לא מאובטח ולכן אני מחוייב להתחבר ב ssl vpn ואז משם אני יכול להתחבר לאן שאני רוצה ברשת, אם זה rdp או ssh.

כמה בעיות בגישה הזו:

1. שניהם עובדים על אותו סוג מנהרה
2. אני עדיין יכול לעשות מה שאני רוצה בתוך הרשת שלו
3. יש לי עוד שכבה שיכולה/עושה בעיות ומאיטה את הרשת
4. בשניהם אפשר להחליט איזו סוג הצפנה (עד כמה שאני יודע) אפשר להשתמש
5. ב ssh אפשר לשים עוד כמה הגנות שאני לא יודע אם אפשר להכניס אותם ל ssl vpn

ככה שאני מאמין בלב שלם שנטוויז'ן טועים בקטע הזה.

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

כאשר שפת התכנות מהירה מידי למערכת

לפני כמה חודשים ניסיתי לכתוב מערכת של Progressive Dialer למערכת Asterisk. המערכת התממשקה עם מערכת click2call שבניתי, ובעצם היתה אמורה להוציא שיחה לנציג וללקוח כאשר הנציג מתפנה.

המערכות עצמן היו כתובות בין היתר גם בג'אווה. הבעיה היתה, שגם השרת click2call וגם השרת של הprogressive dialer שניהם היו מהירים מידי מול התגובות (Signals) של Asterisk. בעיה זו גרמה בין היתר לכמה התנהגויות ממש לא צפויות לרעה.

RAD זו לא רק סביבה

הרבה מאוד אנשים בטוחים, שאם יש סביבת עבודה טובה, אפשר לתחזק קוד בצורה נכונה וטובה. ובכן, גם אם לא הרבה יודו בזה (אולי בגלל אפקט העדר, והרגשה ש"אולי אני מפספס משהו שאחרים מצליחים"), אבל שפה כדוגמת Java לא באמת כזו פשוטה לניהול בפרוייקט גדול באמת. גם ++C וC אינן נותנות יכולת שכזו.

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

אני רואה את השאלה של למה צריך את זה… אוקי, נגיד והמדיניות של המוצר שאת/ה מפתח/ת כרגע היא להכניס לקובץ כל חריגה שמתרחשת בתוכנית. עכשיו כל מקום שיש חריגה צריך להוסיף גם קריאה למתודה שתשים את החריגה בקובץ. נגיד למשל שמדובר בג'אווה ואנחנו מתעסקים עם log4j.

The right tool for the right task

ישנו אדם, אשר רוצה לגרום לבורג שלו להיכנס במידה מסויימת להברגה היעודית. אותו אדם מנסה להשתמש בהתחלה במברג ידני, אבל מגלה כי המברג אינו מתאים לצורה של הבורג. הבורג בעל חריץ יחיד, והמברג שברשותו, נמצא בצורת כוכב. אותו אדם, אז מנסה לקחת מקדחה, אבל מגלה כי אין לו ראש מתאים להבריג את הבורג, אז הוא קם, לוקח פטיש 10 גרם ודופק על ראש הבורג. הבורג טיפה התעקם, אבל הוא נכנס ממש במעט לחור המיועד, ולכן אינו יכול להישלף. עכשיו אותו אדם לוקח פטיש 3 קילו ושובר את הבורג בתוך החור, כאשר חלק מהבורג נכנס עוד יותר. עכשיו החור סתום בחלקי בורג, ואי אפשר לעשות יותר שום דבר.

לראות שונה – תכנות

בעולם התכונה ישנם הרבה דברים שמקובלים לעשות ולבחור.

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

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

לפני כמה ימים היה לי חצי וויכוח עם מאיר קרחילי. הנושא כמובן בחירת שפות תכנות.

למען הפרוטקול, אני יודע לתכנת בהרבה שפות תכנות: משפות "נמוכות" כדוגמת assembly 16 ביט של x86, וכן גם הגרסה שמוגנת של 32ביט (או לפחות זוכר איך לעשות כמה דברים עם השפות האלו). אני גם יודע לגעת בC אם כי בצורה די בינונית, Java, Perl, Ruby, Bash כמובן שפסקל, ועוד… אני כמובן גם יודע שפות יעודיות כדוגמת nasl מבית nesus או SQL בהתאם למסד הנתונים והרשימה עוד ממשיכה.

אני מאמין שהדבר הכי חשוב הוא לבחור בשפה ובכלי שהכי מתאים לביצוע משימה. העניין הוא שלפעמים מה שבאמת אמור לעשות את המשימה כמו שצריך ומה שאנחנו בוחרים הם שני דברים שונים.

לדוגמה, אני לא אבחר בג'אווה בחיים כאשר אני צריך לעבוד עם Threads ו nio בשביל לקבל לדוגמא sockets. שני האופציות לא הולכות בייחד, ולכן אני לא אתקרב לג'אווה בשביל לבצע את המשימה. העניין הוא שיש שפה אחרת שכן תיתן לי (לדעתי בעוד יותר קלות) גישה לsockets ולthreads והיא פסקל מונחת עצמים. אז למה בעצם לא לבחור בה ?

כאשר אני רוצה לבנות קוד שיעבוד במהירות על טקסט, אני אעדיף את פרל. חוצמזה שאני מאוד אוהב את השפה, היא פשוט בנוייה לזה. אין כיום שום שפה אחרת שתיתן לי את מה שפרל נותנת (אל תזכירו את awk בבקשה).
אם אני רוצה לבנות אתר Web, אני אבחר או בRuby או בPerl. שוב, הם הכלים הכי טובים לדעתי לביצוע המשימה. לדוגמה PHP רק בגרסה 5 התחיל להתקרב למצב שניתן להשתמש בו בצורה טובה, אבל הוא עדיין רחוק מהמטרה. נראה כי Zend מסתובבים סביב המטרה, אבל לא מגיעים אליה… כרגע הם רק הקטינו את גודל המעגל.

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

לGUI, אני בוחר בLazarus, אשר הרבה יותר טובה מכל הכלים הקיימים כיום בשוק ללינוקס.

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

אז מה אתם אומרים ? האם אתם תבחרו כלי ושפה שתבצע לכם את המשימה הכי טוב שאפשר, או שתבחרו בכלי הכי פפולרי, גם אם הוא לא בהכרח יעשה את העבודה כמו שצריך בלי מאמץ כזה או אחר מצדכם ?