קטגוריה: Delphi

Goodbye Pascal

At 1993, I've started to learn Pascal. It was the first programming language that I actually enjoyed using, and programming was really fun.

I started with TP 5.5, later on with TP 7.0 that I bought myself, and a book. Later it was Delphi (2, 5 and 7).

Since my appearance at the internet, I found myself constantly in a need to "defend" my language of choice, because people didn't understand the language, but had a lot of wrong ideas what it is, and mostly what it can't do.

So I became by my own choice an evangelist for the language itself, and even helped people get started with it.

The problem is that I'm no longer believe in the path of the language, you can call it Delphi, you can call it Object Pascal, it does not matter. I think it goes the wrong way, and instead of able to talk about it with fellow developers, there is constantly arguments, and bickering about it.

I was told that if I raised an issue, it is actually attacking the people, not the features, and it seems no one car to listen inside the "community".

It's not about specific person, but the picture in whole, that I'm deciding (at least for now), for the first time since I first started to use the language, to stop using it.

All my Pascal related work on github remains "as-is", and people can use them if they wish, continue the work etc… But at least for now I will not longer do anything related to it.

So goodbye Pascal, and thanks for the fishes.

What is the feature of Pascal ?

Borland created the name Object Pascal as a marketing way to sell Delphi, and set a boundary between Borland Pascal and Delphi.

Even though that Pascal constantly changing, and started so, not so long after it first released at 1968, only real developers learned the difference, and know what is going on.

Since then we see huge leap foreword with technology and with the language itself. For example the language itself support thread based programming, the object oriented syntax that was added by Apple in 1982 constantly expanding, and even creating support for thing that languages such as Java or C# lack of.

Pascal today is the only programming language that on one hand offer a very low level support for development – Yes! even lower level then with C, but support also very high level development that is closer to dynamic languages – such as mixin, string management, iteration syntax, and much much more…

Pascal today is also the only true multi-platform language, that can provide rich applications to desktop, web and smartphones/tablet platform with the same code base, and run native there. Yes, that includes iOS, Android with JVM/Dalvik.

Things looks good from far away, but closely there are more then few issues with the modern Pascal (and with some of the, I blame Embarcadero):

  • There are way too many dialects (FPC, Delphi, Delphi.NET, Oxygen, GNU Pascal [ISO Pascal] etc …)
  • There is some sort of vendor lock due to the dialect variation (Usually either Delphi or FPC to choose from)
  • Some of the syntax that is added to the language, well it's not longer Pascal, but closer to Java/C#/Ruby/D …
  • There are additions to closures – such as lambda, anonymous functions, generics and more, that not always implemented properly
  • There are support for dependency injection, extended namespace and much more
  • Not a single real standard, and lack of cooperation between Delphi developers and the true FOSS FPC project (due to Embarcadero side)

להמשיך לקרוא

כמה זה 2 מגה מתוך 4 גיגה ?

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

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

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

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

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

בנוסף, כמו שכתבתי בעבר, יש מספר סוגי מחרוזות בפסקל (ובדלפי יש עוד מספר מחרוזות שיכנסו לFPC 2.8.0), והתעמקתי בעבודה על AnsiString. המחרוזת בעצם מסוגלת לשמור כל אורך תו אפשרי, כל עוד מערכת ההפעלה מסוגלת לספק לך את הזיכרון. אבל החל מגרסה 2.8.0, אם לא תשנה בתוכנה שלך את ה Code Page למחרוזת ספציפית, היא תמיד תהיה בקידוד שהריצו את התוכנה שלך, וכל המרה שתבצע בין מחרוזות, יעשה מאחורי הקלעים המרה מהקידוד המקורי, לקידוד הנוכחי.

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

לאחר חצי שעה שבה ראיתי כי המחשב פשוט ממשיך להציג לי את נורת הדיסק פועלת, ניסיתי להגיע לטרמינל (CTRL+ALT+F1), ובכן זה עבד, אבל כל פעולה לקחה מספר דקות, ומהרגע שכתבתי את המשתמש root בשביל לבצע login ועד הרגע בו login ביקש סיסמה, עברו כחמש דקות. ואז עוד כחמש דקות עד שהוא נכנס לטרמינל, והבנתי כי זו לא הדרך להמשיך.
אז השתמשתי בקסם של SysRq, וגם זה לקח מספר דקות להשפיע.

מה שמצחיק הוא, שדווקא ב C זה היה יכול להיות ברור הרבה יותר כי אגיע למצב הזה, אבל פסקל לא מתעסקת בתפל, אז היה קל מידי להגיע למצב הזהשעשיתי לעצמי DoS רציני 🙂

ב Brainfuck זה לא היה קורה (ללא פואטנה את האמת 🙂 )

מלח הארץ

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

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

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

השימוש בSalt אומר כי החתימה היא בעצם הSalt פלוס הסיסמה (או הסיסמה פלוס ה Salt). יש עוד הרבה דרכים לעשות את זה, כדוגמת הוספת ביטים/בתים לסוג הhash וכו' כאשר משתמשים בSalt, אבל העיקרון בסופו של דבר אומר, כי החתימה של הסיסמה זה Salt וסיסמה בייחד, ולא רק הסיסמה לבד.

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

יחידות בדיקה עם fpcUnit

הקדמה

ישנם מספר ספריות לבדיקה עבור שפת פסקל. הספרייה הכי וותיקה שאני מכיר נקראת DUnit, והיא שוחררה לראשונה ב1999, כמימוש jUnit עבור דלפי. ד"א jUnit למיטב ידיעתי היא מימוש ג'אווה של SUnit עבור שפת Smalltalk.
fpcUnit הוא סוג של מימוש מחודש עבור FPC ולזרוס. fpcUnit מגיע בשני טעמים:

  1. הצגה גרפית של בדיקות
  2. הצגה טקסטואלית (כולל ייצוא למספר פורמטרים) של בדיקות

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

צורת עבודה

הרעיון:

הרעיון הכללי הוא ליצור "תוכנה" אחת שמריצה הרבה unit tests, שבפסקל, זה באמת יחידות :). היחידות נרשמות בחלק ה initialization של היחידה, באמצעות RegisterTest. אשר לוקח את המחלקה של הבדיקות ורץ על הפרוצדורות השונות לבדיקה.
המחלקה יורשת מ TTestCase, וכל פרוצדורות הבדיקה (הרי אנחנו רוצים לפרק את הבדיקות לחלקים הגיוניים), חייבת להיות בחלק ה published, בשביל שתוכל לרוץ.
ישנה מתודה אחת שבמידה וצריך לאתחל מידע, צריך להגדיר אותה (בחלק ה protected) בשם SetUp. במידה והגדרנו את SetUp מומלץ גם להגדיר מתודה בשם TearDown שעושה בדיוק הפוך.

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

Bero's Ecma Script Engine

Bero's Ecma Script Engine או BESEN בקיצור הוא מנוע שממש EmcaScript גרסה 5 בשפת פסקל מונחת עצמים.
המנוע משוחרר ברישיון AGPLv3 (בעבר היה LGPL) עם חריגה המאפשרת לקשר אל תוך קובץ הריצה את המנוע.

EmcaScript הוא למעשה השם של Javascript רק ללא "זכויות יוצרים" על השם.

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

המימוש מכיל:

  • תמיכה מלאה בתקן EmcaScript גרסה 5
  • מימוש ByteCode מבוסס על ECMA262 עבור מנוע Regex
  • מימוש garbage collector וכן סימון של מקומות לביצוע ניקוי
  • תמיכה בUnicode בפורמטים  UTF8/UCS2/UTF16/UCS4/UTF32
  • תמיכה במצב תאימויות שונות לשפה
  • מהדר ByteCode מובנה
  • קריאה לשגרות (subrotine) מבוססות חוטים
  • תמיכה בהרצת הוראות חוטים לפי מעבדים (אינטל 32 ו64 ביט, amd64 עם  just in time compiler. בתכנון גם תמיכה בהוראות של ARMv7).
  • קיפול קבועים
  • אופטימיזציות בסיסיות על בסיס עצים
  • התעלמות מקוד אשר לא בשימוש (dead code elimination)
  • Type inference (גם exact וגם speculative)
  • תמיכה במטמון פולימורפי במקום, מבוסס על מבנה אובייקט ותכונות של מזה מפתוח
  • אופטימיזציות עבור פעולות מיפוי עם hash
  • עצים מאוזנים (למשל עבור מיון מידע on the fly המקושר למידע בhash maps )
  • הוספה טבעית של מחלקות פסקל (תכונות לפי RTTI)

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

לפרטים נוספים ולקוד מקור

צפייה בעץ חלק שני

עבר הרבה זמן מאז שיצרתי את החלק הראשון, והגיע הזמן להשלים חוסרים.

Program using VirtualTreeView

תוכנה בשם precisionhelper המשתמשת ברכיב

יש רכיב צד שלישי הנקרא VirtualTreeView אשר נכתב במקור לדלפי ומגיע כקוד פתוח (LGPL).
הרכיב לא ניתן לעבודה בברירת מחדל עם לזרוס), והוא עובר מספר שינויים על מנת לקבל תמיכה בלזרוס, כאשר השינויים נמצאים ב Lazarus-CCR.

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

הרצת מתודות בצורה דינאמית חלק ראשון

לאחרונה יצא לי לשנות גישה במספר מערכות שאני בונה, ובהם בrpc לאפשר להריץ מתודות פיזיות שיש ברשותי (לאחר שזה עבר כמובן אישור של white list כלשהו).

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

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

פסקל ברברס

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

תודה לאורי ורן על האירוח.

אתם מוזמנים להקשיב , ובעיקר להעריך את העובדה שאני יותר כותב ופחות מדבר 🙂

מערך כתכונה

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

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

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

עוד יכולת מעניינת שיש ברובי, אבל לא בשאר השפות שאני מכיר, היא העבודה עם תכונות (properties). רובי מאפשרת לנו ליצור תכונות, אשר לא דורשות מאיתנו Getter ו Setter כל הזמן. וגם פסקל מציעה תמיכה דומה בפיטצ'ר הזה.

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

...
  TPerson = class(TPrimates)
...
  public
...
    property MatchingColor[name : string] : TColor read GetColor write SetColor;
...
  published
...
    property ShirtColor : TColor read FShirtColor write FShirtColor;
...
  end;
...

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

לתכונה הגדרנו שם כלשהו שהוא מחרוזת. וGetter ו Setter. כלומר התכונה היא גם לקריאה וגם לכתיבה.

הגדרת ה Getter תראה בצורה הבאה:

private
...
   function GetColor(AName : String) : TColor;
...

ה Setter יראה בצורה הבאה:

private
...
   procedure SetColor(AName : String; AValue : TColor);
...

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

התכונה של צבע החולצה (ShirtColor), כותבת ישירות לשדה מסויים, ולא דורשת מאיתנו בעצם ליצור Getter ו Setter בכלל. היות ואין פעולה חשובה שצריך לבצע במיוחד לשם כך. הגדרות של Geter ו/או Setter מתבצעות רק כאשר אנחנו צריכים להתערב במשהו, ולא בכל פעם שאנחנו כותבים תכונה.

להמשך קריאה בנושא, אתם מוזמנים לגשת לכאן.

Redis or not

טוב זה קצת pun על הצליל, אבל הפוסט הזה עוסק בRedis – עוד מסד נתונים בקוד פתוח שאומר לא לSQL. ואת האמת, הוא לא זקוק לשפה הזו בכלל …

למי שלא מכיר, אז Redis הוא מסד נתונים אשר מספק מערכת Key value עם הרבה יכולות. הוא מאפשר לי ליצור הרבה מעבר ל key value, ולמעשה הוא סוג של data struct manager.

פירוש השם הוא קיצור של מספר מילים ולא כתיבה שגויה של צנון: REmote Dictionary Server. רק אם תהיתם במקרה.

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

זה על רגל אחת על מסד הנתונים הזה. להמשיך לקרוא

להבין מחרוזות

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

Abbrevia

Abbrevia הוא סוג של toolkit עבור C++ Builder, Delphi, Kylix ו FPC/Lazarus אשר מספק רכיבים וספריות רבות לטיפול בפורמטי קיבוץ שונים כדוגמת ZIP, CAB, LZMA ואחרים.

הtoolkit הוא בעצם סדרת רכיבים בקוד פתוח, אשר חזרה להיות מפותחת אחרי קרוב לעשור, בה היא סתם שכבה בSourceForge. כמו כן, היא כיום עובדת במספר מערכות הפעלה כדוגמת Windows, Linux ו Mac OS-X.

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

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

חברת TurboPower היתה חברה כזו. החברה היתה מאוד מוכרת בעולם בשנות ה80 וה90 בעיקר. היא היתה חברה מאוד קטנה, אבל עם המון פיתוחים אשר שינו את עולם התכנות המקצועי לכל אלו אשר בחרו בדלפי או C++ Builder של בורלנד, ולפני כן גם ב Turbo Pascal ו Turbo C, וכן Borland Pascal ו Borland C.

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

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

החברה שיחררה את גרסה 5.0 עבור הספרייה והחלטתי לפרסם על זה כאן. תכנות מהנה.

פונקציות אנונימיות בתכנות פרוצדורלי

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

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

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

...
type
  TMyProc = reference to procedure(x: Integer);
...
 procedure call(const proc: TProc);
  begin
    proc(42);
  end;

  var
    proc: TProc;
  begin
    proc := procedure(a: Integer)
    begin
      Button1.Caption := IntToStr(a)
    end;
    call(proc)
  end;
...

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

עם או בלי ?

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

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

Object1.Property1 := 'Hello';
Object1.Property2 := 12;
...
Object1.method11(1, 2, Object1.Width, Object1,Height -2);

אם נכתב את אותו הדבר רק עם with הוא יראה ככה:

with Object1 do
  begin
    Property1 := 'Hello';
    Property2 := 12;
    ...
    method1(1,2,width, height -2);
  end;

ובכן with חוסך לנו לכתוב את Object כל פעם מחדש. נשמע נחמד נכון ? ובכן יש עם זה הרבה בעיות. בפסקל צריך לזכור כי מה שמגיע מצד שמאל חזק יותר מצד ימין, ומה שקרוב יותר אלייך חזק יותר ממה שרחוק יותר ממך. כלומר אם יש לי נגיד 2 סמלים שנקראים Width, אחד שייך למתודה שאני כותב בה את הקוד והשנייה ל 1‏Object, אני לא בהכרח ידע עם מי הוא משתמש, אבל הבעיה יותר חמורה. with מאפשר לי להשתמש עם יותר ממשתנה אחד שיש לו עוד אלמנטים בתוכו, ובנוסף אפשר גם להשתמש ב with מקונן:

  with Object1, Object2 do
    begin
      Height := 24;

      with Rec1 do
        Width := 18;
...
    end;

תיאורטית Height יהיה שייך ל Object1 נכון ? אבל אתם באמת יכולים להיות בטוחים שזה המצב ? אולי הוא משתמש בזה של Object2 בכלל ?

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

אז בבקשה תפסיקו להשתמש ב with. תודה !

מחלקה מופשטת

אחת התכונות שFPC 2.4.2 מביאה איתה הוא תמיכה ביצירת מחלקה שהיא abstract. כלומר אני יכול להגיד שמחלקה מסויימת היא בעצם סוג של API שכל מי שיורש ממנה צריך לממש בעצמו, אלא אם הוא גם class abstract משל עצמו.

הבעיה היא שהצוות של FPC לא המציא את הגישה אלא Embarcadero אחראים למחדל הזה – לפחות במימוש שלו.

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

כאשר אין לי צורך לרשת כלום, התחביר הוא עוד הגיוני:

TMyAbstractClass = class abstract

אבל כאשר אני צריך לרשת והלגדיר מחלקה, זה כבר שובר את הלוגיקה וכבר לא קריא:

TMyInheritingAbstractClass = class abstract(TMyAbstractClass)

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

תבינו, ירושה רגילה נראת בצורה הזו:

TNormalInheritence = class(TMyInheritingAbstractClass)

אפשר בפירוש להבין שclass יורש מאב בשם TMyInheritingAbstractClass, אבל התחביר של class abstract גורם לך לעצור ולשאול בעצם מי יורש מה, האם abstract מסוגל לרשת ? ובכן לא הוא לא. אז הירושה הוא של class, אבל אם תנסו לשים ירושה "רגילה" ואז abstract המהדרים לא ידעו להתמודד עם זה.

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

צפייה בעץ חלק ראשון

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

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

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

אז איך מתחילים בעצם ? הולכים ללשונית Common Controls וזורקים במקום המתאים את הפקד של TTreeView. בתכונות שלו אפשר לשחק איתו בשביל שיתאים לצרכים שלנו. בנוסף יש לו תכונה בשם Items. התכונה הזו מאפשרת לנו גם בצורה תכנותית וגם בצורה וויזואלית להוסיף בעצם את האיברים ברשימה. אני אדגים כאן כיצד יוצרים את האיברים בצורה תכנותית, הרי וויזואלית זה מאוד פשוט.

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

בקוד של החלון ב OnCreate יצרתי את הקוד הבא:

procedure TForm1.FormCreate ( Sender : TObject ) ;
var
  i : byte;
  Node : TTreeNode;
begin
  for i := 1 to 20 do
    begin
      Node := TreeView1.Items.Add(nil, 'Test ' + IntToStr(i));
    end;
end;

הקוד עושה פעולה מאוד פשוטה, רץ על כל המספרים מ1 ועד 20 ומוסיף את האיברים אל הרשימה עם מספור של האיבר עצמו. אנחנו שומרים את האיבר שנוצר ב TTreeNode לשימוש עתידי. שמתי בפרמטר הראשון של Add את הערך nil בשביל לציין שהאיבר שנוצר אינו אח של איבר אחר (שגם הוא מסוג המחלקה של TTreeNode).

אבל עכשיו יש לנו רשימה של 20 איברים, אבל הם עריריים ללא ילדים. בשביל לדאוג לכך שיהיו להם ילדים נגיד לItems להוסיף ילד לאיבר שיצרנו באמצעות AddChild אשר דומה מאוד ל Add הרגיל, אבל יוצרת בן. בשביל להשיג את התוצאה כמו בתמונה למעלה, הקוד המלא נכתב בצורה הבאה:

procedure TForm1.FormCreate ( Sender : TObject ) ;
var
  i : byte;
  Node : TTreeNode;
begin
  for i := 1 to 20 do
    begin
      Node := TreeView1.Items.Add(nil, 'Test ' + IntToStr(i));
      if i mod 2 = 0 then
        begin
          TreeView1.Items.AddChild(Node, 'Sub Test');
          if i mod 4 = 2 then
            Node.Expand(False);
        end;
    end;
end;

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

חלון ל HTML

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

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

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

כלומר אם אצור מסך עם רכיבים גרפיים שונים עבור שולחן העבודה אוכל לקבל אותם כ HTML בנוסף ואוכל להשתמש בהם באפליקציה שלי. כך שאפשר להשתמש בעצם בלזרוס ודלפי כסביבת WYSIWYG עבור פיתוח web, וזה אם לא משתמשים בExtJS אשר כבר פגשנו לו תוסף ללזרוס.

הרחבת מחלקות בזמן ריצה

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

אז כמובן שבשפות דינאמיות אפשר להרחיב בזמן ריצה את המחלקה. אבל בפסקל החל מדלפי 8, ומגרסת הפיתוח 2.5.1 של FPC יש תמיכה גם בהרחבת המחלקה בזמן ריצה.

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

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

אחד היתרונות בהרחבה שכזו, היא היכולת להרחיב גם מחלקות ש"נאטמו" (sealed class), כך שבכל זאת הם יוכלו לקבל הרחבה כלשהי.

אז כיצד התחביר של class helpers נראה ? להמשיך לקרוא

Precision Language Suite

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

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

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

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

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

תרגום Essential Pascal לעברית

עידו גנדל תרגם את הספר Essential Pascal לעברית, לפני מספר שנים, ושלח לי לאחרונה דואר אם אסכים לכתוב על הספר בבלוג שלי. אז כמו שאפשר לראות, כמובן שאני מסכים 🙂

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

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

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

את התרגום העברי של עידו, ניתן להשיג בכתובת הזו.

class var

FPC מיישם כל מיני תוספות לשפה אשר Embarcadero הוסיפו לדלפי כמה מהתוספות מכניסות את שפת פסקל מונחת העצמים להיות קרובה יותר לשפת ג'אווה ואפילו תוספות שאני מכיר רק ברובי (אולי יש בעוד שפות) מאשר השפה שהתרגלנו אליה.

למשל אפשר בתוך מחלקה (class) ליצור קבועים (const), שימוש בהגדרות טיפוס (type) ובכלל זה גם הגדרות של טיפוס מסוג רשומה ואפילו מחלקות בנים. בנוסף אפשר ליצור גם class var, שזה בעצם משתנה במחלקה אשר הערך שלו נשאר אצל כל ה instance והבנים, ואם אחד מהם משנה אותו, אז הוא משתנה אצל כולם באותה מידה. אני מכיר את זה רק בשפת רובי, אבל לא אתפלא אם עוד שפות תומכות בזה.

בניגוד למשל לשפת ג'אווה ואפילו ++C, בפסקל אני יוצר איזור (section) אשר משפיע על השאר, כלומר כאשר אני מגדיר const או type או אפילו class var, עד שאני לא יוצר איזור חדש של משהו אחר (private, public, published, const, הגדרת מתודות וכו') או סוגר לגמרי את המחלקה (עם end), תמיד הקוד שיהיה בתוך האיזור יהיה שייך לאיזור הזה. בגלל זה גם נוסף הגדרה של var בשביל ליצור שדות שיצאו מחוץ לאיזור קיים. וגם var עצמו יוצר איזור משל עצמו.

כמו כן, כבר הרבה מאוד זמן יש תמיכה במילה השמורה deprecated אשר המטרה שלה הוא להגיד שהגדרת קוד/בלוק מסויים הוא כמובן deprecated מה שיוביל לאזהרה מהמדר.

כלומר מחלקות בפסקל מונחה עצמים יכולים להראות ככה:

type
 generic TAClass<T> = class
   constructor Create(const AParam : T);
 end;

  TTest = class
  private
    type
      TIntegerAClass = specialize TAClass<Integer> deprecated;
    var
     FAClassInt : TIntegerAClass;
  public
    property AClassInt : TIntegerAClass read FAClassInt; // read only property ...
  end;

אל תגידו שלא הזהרתי אותכם מראש 🙂

מדוע FPC וLazarus צריכים לעניין גם אנשי קוד פתוח

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

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

SynEdit חלק ראשון

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

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

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

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

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

מי שלא מבין את דלפי…

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

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

אפשר לקחת את כח השפות השולטות כיום בשוק למשל: C, C++, ִJava, C#, Python, Ruby אנחנו יכולים לראות של C ו ++C כל הזמן מחפשים דרכים עוקפות ובגלל זה יש לנו את שאר הטנולוגיות שהזכרתי. אחד הדברים הכי בולטים בכל השפות האחרות, זה הניסיון לברוח מעודף הסימנים המורכבים והגישה העודף גמישה (אשר יוצרת רק בעיות) של C ו ++C תוך כדי ניסיון לשמור על תחביר קרוב כמה שניתן ל2 הטכנולוגיות הנפוצות כל כך.

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

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

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

דוגמא אחת (מני רבות): http://showmedo.com/videos/video?name=4010010&fromSeriesID=401

אפילו בלזרוס זה יותר פשוט מזה..

דלפי .net ללינוקס ?!

CodeGear זנחו את Delpi.NET המקורי שלהם, ויוצאים עם מוצר חדש בשם Delphi .NET Prism. שמבוסס על טכנולוגיה בשם Oxygen של חברת RemObject המוכרת (למפתחי דלפי).

ככול הנראה Delphi Prism מספק פתרונות גם ללינוקס ומאק ולא רק עבור Windows. הזניחה של Delphi ל .NET המקורי של CodeGear מתבצעת בגלל חוסר הצלחה של חברת CodeGear להרים את התמיכה ב CIL בגישה שלהם.

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

חדשות FPC וLazarus

כמו שדיווחתי בעבר, Lazarus שוחרר (עכשיו בצורה רשמית) בגרסה 0.9.24. היו כמה עיקובים בשחרור בשל 2 סיבות:

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

ובנוסף לכך, יצא Live-CD של אובונטו המכיל בתוכו את Lazarus 0.9.24, כך שניתן לנסות, לבדוק ואף להתקין מערכת אובונטו עם Lazarus.

קובץ הISO ניתן להורדה מכאן : Ubuntu-7.10-NTC-Lazarus.iso .
בשביל לבדוק אם העותק שברשותכם תקין, ניתן להשתמש בקובץ החתימות של md5sum.

פרשת העתקה של FPC וLazarus:

בFPC נמצאו כמה פונקציות אשר קרובות למדי לקוד של דלפי ובימים אלו נעשים שכתובים וכנראה שבסוף השנה תצא גרסה 2.2.2 אשר תכיל את הקוד המשוכתב.

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

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

בדיקת הקוד ד"א נעשת ע"י תוכנה המופצת ברשיון BSD בשם similarity_test.

FUD 2.0

FUD הינו ראשי תיבות של Fear, uncertainty and doubt. בד"כ הר"ת נמצא בשימוש כאשר מנסים להניע אנשים מלהשתמש או לגשת בדברים מסויימים. כך למשל חברת SCO הציגה מצג שווא שבו לינוקס גנב קוד מUnix שהבעלות על הקוד שייך לחברה.

להמשיך לקרוא

על אליעזר וחיות אחרות חלק ראשון

Lazarus או בשמו המקורי אליעזר [אליעזר היה אדם אשר ישו החזיר מהמתים בברית החדשה, ובלטינית קראו לו Lazarus] הוא שם של סביבת עבודה משולבת אשר בנוייה סביב פסקל מונחה עצמים אשר מתממשק עם המהדר FPC. אליעזר יודע לרוץ בסביבות ריצה שונות כדוגמת Windows לגרסאותיו [CE, XP, Vista וכו'], Linux, Mac ועוד כמה מערכות Unix שונות.

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

להמשיך לקרוא

הדרך ל Low Level רצופה בכלי עזר

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

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

כמה פעמים ספרת עד 10 …

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

להמשיך לקרוא

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 לאיזשהו משימה, בגל שאני בטוח כי השפות האלו כבר לא מסוגלות לתת משהו טוב וייחודי שאני לא יכול לקבל בצורה טובה יותר עם שפה וכלים אחרים. הן גם לא שפות שמסוגלות להתפתח יותר, הן פשוט נעצרו די בהתחלה, ואולי מידי פעם מוסיפים להם איזו תוספת קטנה, אבל בסופו של דבר כל פעם שמחפשים משהו חדש, אנחנו מוצאים את עצמנו עם שפה חדשה שמנסה לתת את אותו מענה, רק היא גם נתקעת באיזשהו שלב, דבר שלדעתי מעיד על כך שהגישה של שני השפות פשוט לא נכונה.

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

פיתוח חוצה פלטפורמות באמצעות Free Pascal 2.2.0

תרגום מהגרסה האנגלית לכתבה שפורסמה בOSNews ע"י Joost van der Sluis
תורגם ע"י עידו קנר

לאחרונה Free Pascal (FPC) שחררה את הגרסה 2.2.0. מהדר הקוד הפתוח לשפת פסקל אשר ממשיך מאז התחיל ב-1993 לגדול ולהיות אחד ממהדרי הקוד הפתוח הכי מתוחכמים הקיימים כיום. מדי יום מפתחים רבים מגלים את FPC ומפתחים את התכנות שלהם באמצעות פסקל מונחה עצמים. הפיתוח של Lazarus תרם לכך באופן מיוחד: Lazarus היא סביבת עבודה משולבת גרפית עבור FPC, עם כלי פיתוח רבים לפיתוח ותכנון תכנות גרפיות.
להמשיך לקרוא