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

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