קטגוריה: Object Pascal

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)

להמשיך לקרוא

FPC 2.6.2 שוחרר

השבוע שוחרר FPC 2.6.2 המכיל בעיקר תיקוני באגים, אשר חלקם הם שינויים ב API או בהתנהגות של פונקציות/מחלקות בשביל לתקן את הבעיות.

  • מתודות שונות בTDataset שונו במבנה שלהן, והוחלפו מPChar ל TRecordBuffer‏
  • DLLParam שונה מ longint ל PtrInt‏
  • פונקציות וסמלים ביחידות unix וunixutils סומנו כ deprecated‏
  • התנהגות TStrings.DelimitedText שונתה
  • בfcl-image‏, TTiffIDF שונה ל TTiffIFD‏
  • היחידה libc מחזירה אזהרת deprecated‏
  • הוסרה התמיכה עבור UPX בקבצי ה Makefile‏

הסבר מלא בנושא השינויים

My Database-free Application lecture

Today I gave a lecture about database-free applications.

Most people who first read the title, thought that "oh you probably write to memory or disk or something", yet the lecture is not about storing data, but on one approach of designing systems to work.

It is a completely different thing, yet I find that many people can't see it, they are looking for the "catch".

This post was written prior to the actual lecture itself (a day before in fact 🙂 ), so I can't tell if my lecture was good enough or not, but you have my slide notes, and the whole lecture (using html5 and reveal.js -> firefox or chrome recommended), so take a look and tell me yourself 🙂

Planet Object Pascal

I'm glad to announce the creation of Planet Object Pascal.

I have created it in order to provide one place to have all known blog and knowledge of the Object Pascal developers (Virtual Pascal, Free Pascal, Delphi etc…)

If you have a blog that writes about Object Pascal, feel free to contact me, and I'll add you to the planet.

Having said that, I'm looking for a way to better design this, and at the long run, write something a newer system, then continue and using the unmaintained planetplanet system.

הדגמה מתקדמת לשימוש ב TFPSMap

בFPC 2.2.0 נוספה ספריה בשם fgl בייחד עם התוספת לשימוש ב Generics.

הספרייה מאפשרת לקבל שני מימושים של מחלקות, האחת עובדת בגישה הרגילה של שימוש במצביעים ו/או TObject לבצע פעולות, והשניה לעבוד עם generics.

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

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

לזרוס, חדשות תקופתיות

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

הנה חלק קטן מהדברים אשר הוכרזו בשלושה חודשים האחרונים בנושא:

ביום שני האחרון (4/02/2013) שוחררה גרסה 1.0.6 של לזרוס אשר מכילה תיקוני באגים בלבד.

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

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

מנוע המשחק Castle שיחרר גרסה 4 שלו. המנוע מאפשר לספק API גבוהה לפיתוח משחקים, התחברות למודלים (כדוגמת אלו הנבנים עם blender), ועוד.

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

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

אחרון חביב לפוסט זה, הוא Community של FPC/Lazarus ב Google+‎ שאתם מוזמנים גם להצטרף לשם כמובן.

My First Lazarus plugins – split lazarus

I have released today v0.0.1 b2 of my first ever Lazarus plugins – Split Lazarus.
This plugins allow users to split view source code using the Lazarus IDE.

split_lazarus_v001 b2

The following release is just to provide a look and feel, and request for help with testers etc… and by no mean should be used otherwise.
I must say that it was not so simple to arrive to this version due to few factors:

  • First time of writing such thing
  • For debugging my own code, I need to debug the IDE, because I'm executed from within
  • Found a bug with FPC class
  • There are things that I thought that works in one way, but actually in much different way
  • So I needed to rewrite code in that level as well …
The following release contains only few features, such as syntax color, and fonts that are copied from the original editor.
It also provide a splitter between the original editor and the new one, and should not support anything else. So if you find that it does something else, it was by mistake 🙂

The plugins install itself into the Editor tab menu, and also allow you to register a shortcut for it's actions that by default are empty.


  • Open the package menu
  • Choose the option of open package file (.lpk)
  • Open the file under the package directory named lazsplitview.lpk
  • At the new opened window, press on compile to make sure that the source can be build. Then choose "Install".
  • You'll be prompt for a question if you wish to build it now, answer "yes"
  • Lazarus will be booted up and enjoy 🙂

Split Lazarus v0.0.1 build 2

לפני חודש בערך, הזכרתי כי אני כותב תוסף ללזרוס.

split_lazarus_v001  b2

התוסף מאפשר לעשות split view עבור העורך של לזרוס, ובכך לאפשר לבצע עריכה ו/או צפיה בקוד תחת 2 view ports על אותו טאב בעצם.

להגיע לנקודה הזו היה מאוד לא פשוט בגלל מספר סיבות:

  • פעם ראשונה שאני עושה דבר כזה
  • לדבג קוד למערכת הזו אינו פשוט – צריך לדבג את ה IDE בעצם מתוך ה IDE‏
  • מצאתי באג בספריות של FPC אשר דורש התייחסות
  • יש המון דברים שחשבתי עליהם בגישה איקס ומסתבר שהם ממומשים אחרת בפועל
  • מה שאומר ששכתבתי קוד יותר מפעם או פעמים להגיע לגישה הנכונה

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

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

הוראות התקנה

פתחו בלזרוס את התפריט package ושם בחרו באפשרות open package file (.lpk)‎.
בספריית התוסף, בחרו את תת הספרייה בשם package ושם את הקובץ lazsplitview.lpk .
לאחר שנפתח לכם חלון של החבילה, לחצו קודם על כפתור compile לבדוק כי אין בעיות בבניית התוסף, וכשזה מסתיים, בחרו ב install.
לאחר אתחול מחדש של לזרוס, התוסף כבר מותקן אצלכם.

התוסף הראשון שלי חלק ראשון

שנה חדשה, התחלות חדשות, כדוגמת פרסום ה gem שדיברתי עליו, וגם החלטתי לעשות משהו שכבר מספר שנים אני חושב עליו: לכתוב תוסף ללזרוס שיאפשר לעשות split view על עורך טקסט.split_view

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

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

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

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

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

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

Brook Framework

Brook Framework הוא שם לא הכי ברור עבור framework לפיתוח אתרי ווב דינאמיים באמצעות פסקל מונחת עצמים, המשוחררת תחת LGPL 2.brook-framework_hello-world

הסביבה מזכירה מאוד את הרעיון של framework כדוגמת dancer של פרל, וPadrino ברובי.

ההצהרה הרשמית של הפרוייקט היא בתמיכה קלה ב:

  • נהול ניתובים – כל הפעולות מתבצעות לפי ניתובים
  • יכולת עבודה עם פריימוורקים נוספים, המספקים תוספות לעבודה עם ווב
  • תמיכה מובנת בJSON ופעולות שונות עליו
  • תמיכה בפעולות REST והפרדת העבודה לפי סוג הבקשה
  • אינטגרציה עבור Lazarus
  • תמיכה בכתיבת תוספים עבור הframework

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

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

יחסית קל ופשוט מאוד ליצור ניתובים דינאמיים, וסביבת CGI טבעית לשרתי ווב כדוגמת אפצ'י, אך לא רק.
במידה ומשתמשים בלזרוס, אז בחירה ב Simple CGI application, זה כל מה שנדרש עבור Hello World, אך במידה ולא, יש צורך ליצור שלושה קבצים.
קובץ אחד הוא בעצם ה"תוכנה" שלנו, שהיא הcgi. קובץ נוסף הוא ברוקר שלנו שיודע לדבר עם שרת HTTP, והקובץ השלישי זו בעצם התוכנית שלנו. כמובן שניתן להוסיף עוד קבצים/מחלקות לפי הצורך.

אפשר להשוות זאת למשל לסינטרה, בה קובץ הראשון הוא כדוגמת config.ru, הקובץ השני הוא Rack והשלישי זה המודול של סינטרה.

הרעיון הוא שכל מחלקה אחראית על נתיב מסויים (path info), ממש כמו ב Rails למשל, ואנו רושמים את הנתיב בחלק הinitialization של היחידה:


המחלקה בעצם רשמה את עצמה לנתיב של info – כלומר http://example.com/info/ik

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

אתם מוזמנים לבדוק ואף לתרום חזרה לפרוייקט.

כמה זה 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 זה לא היה קורה (ללא פואטנה את האמת 🙂 )

יצירת מסד נתונים בזמן ריצה

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

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


אם אתם עוקבים אחרי הבלוג שלי, אתם יודעים כבר כי המסך הזה נוצר באמצעות לזרוס, ומדובר בסה"כ בLabel ו Edit , עם קינוח של Button.
בנוסף זרקתי רכיב לא וויזואלי של TIBConnection, שמטפל לנו בחיבור למסד נתונים מבוסס Firebird.

אשאיר לכם להשקיע 2 דקות מזמנכם לטפל במראה המתאים לכם.

לאחר מכן, באירוע של הכפתור, אצור את הקוד הבא:

procedure TfrmDBCreate.btnCreateClick(Sender: TObject);
var Transaction : TSQLTransaction;
  FBConnection.DatabaseName := edtDatabaseName.Text;
  FBConnection.CharSet      := 'UTF8';
  FBConnection.HostName     := edtHost.Text;
  FBConnection.UserName     := edtUserName.Text;
  FBConnection.Password     := edtPassword.Text;
  Transaction               := TSQLTransaction.Create(nil);
  FBConnection.Transaction  := Transaction;
   FBConnection.ExecuteDirect('CREATE table test1 (name varchar(24) not null)');
   MessageDlg('Info', 'The database was created.', mtInformation,
             [mbClose], -1);
    on e : EIBDatabaseError do
       MessageDlg('Error', 'Could not create database : ' + LineEnding +
                  e.Message, mtError, [mbClose], -1);

     on e : Exception do
        MessageDlg('Error', 'Unknown error : ' + LineEnding + e.Message,
                 mtError, [mbClose], -1);

קודם כל אנחנו מזינים לTIBConnection את הפרמטרים שהוזנו, כדוגמת קובץ מסד הנתונים, הכתובת של השרת, בנוסף החלטתי להשתמש ב UTF8 כקידוד למחרוזות.
בנוסף יצרתי רכיב עבור טרנזאקציות, הוא צריך להיות בשימוש לשאילתא שאריץ לאחר יצירת מסד הנתונים (כל השימוש בו).
בתוך try אני אומר למנהל החיבור למסד נתונים ליצור את מסד הנתונים. חשוב לדעת כי זה קיים בכל החיבורים שלנו למסדי נתונים המבוססים DataSet, ולא ייחודי ל Firebird.
לאחר מכן, החלטתי גם להציג כיצד ניתן ליצור בתוך אותו קוד טבלה, אז יצרתי טבלה בשם test1 עם שדה בשם name שהוא מסוג varchar ומסוגל לקבל עד 24 תווים.
נעשה על השאילת commit, ואנחנו מוכנים !

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

מי אמר שעבודה עם מסדי נתונים צריכה להיות כואבת ?

את קוד המקור תוכלו למצוא כאן

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



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

החבילה מאפשרת גם לחתום את החבילה ולהעלות אותן אל מאגר ה PPA של אובונטו.

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

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

קוד המקור של החבילה.

* החבילה שונתה בשמה מ LazDebian לLazPackager

עתיד עולם התכנות לאן ?

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

למשל כאשר אדם שאל שאלה בwhatsup על ללמוד לפתח אפליקציות לאנדרואיד. אנשים התחילו להציע לו ללמוד את שפת C ואת שפת ++C, וכו' … ובסוף אחרי שהבין איך לתכנת בשפות האלו, לעבור לJava אשר איתה הוא סוף כל סוף יגיע "למנוחה ולנחלה".

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

ההבדל בהצעה שלי, הוא בכך שבאמצעות FPC, אני יכול לכתוב אפליקציות טבעיות לאנדרואיד (מהדר אותן לקבצי class של ג'אווה), ויותר מזה, אני יכול גם לבנות מערכות עבור iOS (יש בMarket של אפל, תוכנות שלמות אשר כתובות עם FPC ודלפי החדש עבור iOS), לספק את אותן המערכות לסביבות שולחנות העבודה, web ושרתים. כל זה ללא צורך להחליף שפה או טכנולוגיה, ועדיין לתת מענה רחב יותר מאשר פיתוח רק בשפת ג'אווה או Objective-C. להמשיך לקרוא

TAChart – חלק רביעי

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

יצירת הגרף

את פעולת היצירה חילקתי לשני חלקים:

  1. אתחול המידע
  2. הזנת הנתונים לעוגה

TAGraph עובד עם "סדרות". הסדרות הללו הן למעשה סוגי הגרפים עבור TAGraph. אתם בטח מבינים כי מן הסתם, סדרה בשם TPieSeries מדברת על גרף מסוג Pie.
התחלתי קודם בחלק האתחול. היות והוא צריך לרוץ רק פעם אחת, אבל הכנסתי אותו למתודה משל עצמו וקראתי לה בשם initpie. יצרתי גם שדה בשם pie מסוג TPieSeries שהוא גלובלי במחלקה של החלון.

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

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

לאחר מכן, החלתי לטפל קצת במקרא של Chart עצמו. והוספתי קבוצה מספר 0, בשם Pie. לאחר מכן, הוספתי את הסדרה שיצרתי:

procedure TForm1.initpie;
  pie          := TPieSeries.Create(Chart1);
  pie.Title    := 'Pie Chart';
  pie.Exploded := False;
  with pie.Legend do
     Multiplicity := lmPoint;
     Format       := '%2:s (%1:.2f%%)';
     GroupIndex   := 0;

  with Pie.Marks do
     LabelBrush.Color  := $80FFFF;
     LinkPen.Width     := 2;
     Style             := smsLabelPercent;
     OverlapPolicy     := opHideNeighbour;
     Visible           := true;

  with Chart.Legend do

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

procedure TForm1.FormDestroy(Sender: TObject);
  if Assigned(pie) then

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

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

procedure TForm1.btnApplyClick(Sender: TObject);
var i    : integer;
    acol : TColor;
  if not Assigned(pie) then initpie; // first time applying ... it can have memory leak if we apply it every time
  for i := 1 to sgGraphDetails.RowCount -1 do
     with sgGraphDetails do
        if Cells[2, i] = '' then continue; // empty content
        acol := clTAColor; // set color automatic
        if Cells[3, i] <> '' then // unless we choose one ...
          acol := StringToColor(Cells[3, i]);

        // Add the values
        pie.Add(StrToFloat(Cells[2, i]), Cells[1, i], acol);

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

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

  1. Windows Bitmap (bmp)‎
  2. Jpeg (jpg)‎
  3. Portable Network Graphics (png)‎
  4. Portable Map Graphics (ppm)‎
  5. X Pixmap (xpm)‎
  6. SVG

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

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

procedure TForm1.btnExportClick(Sender: TObject);
var fs : TFileStream;
    id : IChartDrawer;
  if not SaveDialog.Execute then exit;

  case SaveDialog.FilterIndex of // lets see what type of image they want
    1 : Chart.SaveToBitmapFile(SaveDialog.FileName);                          // bitmap
    2 : Chart.SaveToFile(TJPEGImage, SaveDialog.FileName);                    // JPeg
    3 : Chart.SaveToFile(TPortableNetworkGraphic, SaveDialog.FileName);       // PNG - our default
    4 : Chart.SaveToFile(TPortableAnyMapGraphic, SaveDialog.FileName);        // PPM
    5 : Chart.SaveToFile(TPixmap, SaveDialog.FileName);                       // XPM
    6 : begin                                                                   // SVG
          fs := TFileStream.Create(SaveDialog.FileName, fmCreate);
            id                       := TSVGDrawer.Create(fs,true);
            id.DoChartColorToFPColor := @ChartColorSysToFPColor;
            Chart.Draw(id, Rect(0,0, Chart.Width, Chart.Height));

החלטתי להשתמש בסטטיסטיקה של w3school על דפדפנים, והשתמשתי בנתונים שלהם לחודש אוגוסט 2012.
זהו, עכשיו אפשר לקחת את התוצר ולאכול. בתאבון 🙂
tachart browser statistics

את קוד המקור, ניתן להורד מgithub.

TAChart – חלק שלישי

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

כתיבת קוד

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

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

הקוד עבור הcallback מאוד פשוט. אנחנו הולכים להוסיף לו 2 שורות. הראשונה אומרת להוסיף עוד שורה, השניה הולכת לשים מספור מתאים לתא, ובכך נקבל מספורים כדוגמת "1, 2, 3" וכו' … פר שורה:

procedure TForm1.btnAddItemClick(Sender: TObject);
  sgGraphDetails.RowCount := sgGraphDetails.RowCount + 1;
  sgGraphDetails.Cells[0,sgGraphDetails.RowCount -1] := IntToStr(sgGraphDetails.RowCount -1);

השלב הבא יהיה להסיר שורה על ידי הוספת Callback עבור btnRemoveLastItem:

procedure TForm1.btnRemoveLastItemClick(Sender: TObject);
  if sgGraphDetails.RowCount > 1 then
    sgGraphDetails.RowCount := sgGraphDetails.RowCount - 1;

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

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

procedure TForm1.sgGraphDetailsColRowDeleted(Sender: TObject; IsColumn: Boolean;
  sIndex, tIndex: Integer);
  btnRemoveLastItem.Enabled := sgGraphDetails.RowCount > 1;
  btnApply.Enabled          := sgGraphDetails.RowCount > 1;

אני מבצע בדיקה לוגית (במקום שאלת if), האם יש יותר משורה אחת בודדה, ואם כן, רק אז לאפשר את הכפתורים.
אבל זה לא מספיק ! הרי מה קורה כאשר אני מוסיף שורה ?
אז חזרתי לטאב הEvents של sgGraphDetails, ובאירוע OnColRowInserted בחרתי מהרשימה את sgGraphDetailsColRowDeleted, ולמעשה יש לי שני Callbacks אשר מצביעים על אותו הקוד, רק מתרחשים בזמנים שונים.

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

procedure TForm1.FormCreate(Sender: TObject);
  sgGraphDetails.Cells[0,0] := '#';
  btnRemoveLastItem.Enabled := sgGraphDetails.RowCount > 1;
  btnApply.Enabled          := sgGraphDetails.RowCount > 1;

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

procedure TForm1.sgGraphDetailsButtonClick(Sender: TObject; aCol, aRow: Integer);
  if (aRow >= 1) and (aCol = 3) then
      if ColorDialog.Execute then
          sgGraphDetails.Cells[aCol, aRow] := ColorToString(ColorDialog.Color);

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

procedure TForm1.sgGraphDetailsSetEditText(Sender: TObject; ACol, ARow: Integer;
  const Value: string);
var num : double;
  if (ACol = 2) and (Value  '') then
      if not TryStrToFloat(Value, num) then // do we have a real floating point number ?
          sgGraphDetails.Cells[ACol, ARow] := '';

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

בחלק הבא (כאמור), אציג כיצד להגיע תאכלס ליצירת הגרף.

TAChart – חלק שני

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


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

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

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

עיצוב וויזואלי

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

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

לאחר מכן, נלך לטאב של Additional ונזרוק לנו על ה pnlBottom את הרכיב TStringGrid. זה בעצם הרכיב שאיתו נבצע את העריכות שלנו.

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

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

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

  • הכפתור הראשון קיבל כותרת של Add Item. והוא קיבל את השם btnAddItem.
  • הכפתור השני קיבל את השם Remove Last Item .השם אותו קיבל הוא btnRemoveLastItem.
  • הכפתור השלישי קיבל כותרת של Apply. והשם שלו הוא btnApply.
  • הכפתור הרביעי קיבל כותרת של Export. וכמובן שהשם שלו כמו שאתם כבר מזמן, מבינים הוא btnExport.

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

אמרתי לsgGraphDetails, שיש לו רק שורה אחת כרגע  על ידי שינוי התכונה RowCount.
לאחר מכן בתכונה Options, הודעתי כי האפשרות לעריכה מאופשרת.
עם ה StringGrid, הלכתי להגדיר את תכונת ה Columns בצורה וויזואלית.

  • העמודה הראשונה שהגדרתי קיבלה כותרת בשם Name. וזהו השינוי היחיד שהיא קיבלה.
  • העמודה השניה שהגדרתי קיבלה כותרת בשם Percentage וגם כאן זה השינוי היחיד.
  • העמודה השלישית, קיבלה את הכותרת Color, אבל קיבלה עוד שינוי: ButtonStyle מצביע על כפתור בעל שלוש נקודות (Ellipsis), היות ואנחנו נאפשר למשתמש לבחור בצורה וויזואלית איזה צבע הוא מעוניין להשתמש עבור כל עמודה לגרף.

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

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

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

זרקתי גם מטאב Dialogs שני רכיבים. זרקתי את TColorDialog לבחירת צבע, וכן SaveDialog, לייצא יותר מאוחר את הגרף.


TAChart – חלק ראשון

להכיר על TAChart על קצה המזלג

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

tachart browser statistics

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

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

הרכיבים יודעים גם להיכנס למערכות של דו"חות כדוגמת LazReport ובכך גם להתאים את עצמה לדו"ח מודפס, PDF וכו'. למעשה את הרכיבים לא מעניין סוג "בד הציור" עליהם הם נמצאים, כך שאפשר למשל לעבוד איתם באמצעות OpenGL, מערכת BGRA או אפילו מערכת Agg. זו הסיבה שאפשר כאמור ליצור מהם SVG בנוסף לתמונות Bitmap,  PDF וכו' ….
אבל זה לא הכל. ניתן גם להציג את הגרפים כיום בצורת אנימציה ובכך גם להמחיז את השינויים השונים, ולא לקבל אותם רק בצורה "יבשה".

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

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

Display Quote ההמשך

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

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


החלטתי עכשיו לשים לעצמי 2 מטרות לגרסה שאני יוצר:

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

הבעיה עם פייסבוק, היא שאסור לי לפרסם את הסיסמה שהפרוייקט קיבל, ובנוסף אני צריך ליצור או להתחבר למימוש של OAuth2, אשר שונה מ OAuth1 למשל …

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

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

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

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


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

לאחר שאסיים את 2 השלבים האלו, כנראה שהשלבים הבאים יהיו:

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

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

הקוד עצמו, ד"א כרגיל נמצא ב github.

קוד זה ישמיד את עצמו בעוד …

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

מרבית שפות התכנות, ירימו על כך חריגה כלשהי, היות ואין תמיכה לכך בתחביר עצמו. אלו שאינן תומכות בחריגות יציגו הערה כלשהי למשהו בסגנון stderr. אבל בשפת פסקל, יש לכך תמיכה בתחביר עצמו. התמיכה נוספה ל FPC 2.6.0 ודלפי 2009.

התחביר נראה כך:

unit oldunit deprecated 'Please use NewUnit';


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

procedure OldProc; deprecated 'Please use NewProc instead';

נגיד ונרצה לעשות זאת למחלקה:

  TOldClass = class
  end deprecated 'Use NewClass';

וכן הלאה …
עכשיו בואו נראה מה קורה בפועל. נגיד ויש לנו קוד כזה:

{$mode objfpc}
program test;

  TOldClass = class
  end deprecated 'Use NewClass';

  A : TOldClass;
  a := TOldClass.create;

צעקת המהדר תהיה:

test.pas(9,16) Warning: Symbol "TOldClass" is deprecated: "Use NewClass"
test.pas(11,17) Warning: Symbol "TOldClass" is deprecated: "Use NewClass

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

Gtk3, GObject Introspection ו Free Pascal

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

ביצוע הBinding משתמש למעשה בפרויקט שקהילת GTK יצרה בשם GObject Introspection.
אם להסביר על רגל אחת את מהות הפרוייקט, אז הוא לוקח את ה API של פרוייקט GTK וממיר את המידע לקבצי XML אותם ניתן לקרוא בכל שפת תכנות.

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

קובץ כזה יראה כך: להמשיך לקרוא

לזרוס 1.0

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

אודות לזרוס

לזרוס 0.9.29 המשתמש ב Qt תחת לינוקס

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

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

סביבות העבודה אשר כיום לזרוס יודעת לאפשר עבודה מולם הם: MS Windows, Linux, FreeBSD, Solaris, Mac OS X, WinCE, Android, JVM, iOS ועוד מספר מערכות אחרות, בהתאם לתמיכת המהדר.
בנוסף, ישנה תמיכה בסביבות גרפיות כדוגמת Windows GDI, X11, GTK, Qt, Cocoa, Carbon ו fpGUI.

התמיכה הזו מגיעה באמצעות ספריית רכיבים בשם LCL‎ ‏(Lazarus Component Library) אשר תפקידה הוא אספקת כלים להתמודדת עם כתיבת התוכנות הגרפיות (אך לא רק) ללא צורך בלימוד של סביבה מסויימת כדוגמת Windows GDI או Qt.

בנוסף, המערכת מגיעה עם תמיכה מובנת למספר מסדי נתונים בניהם ODBC, SQLite, Firebird SQL, MS SQL, Oracle, MySQL, PostgreSQL, Sybase ואפילו Paradox במידה והותקנו הספריות המתאימות במערכת. בנוסף גם יש תמיכה ל dBase בצורה טבעית.

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

לזרוס אף מגיעה עם תמיכה ברירת מחדל לפיתוח מערכות CGI ברמה נמוכה מאוד בשם fpWeb ועוד מספר כלים אחרים כדוגמת ExtPascal המאפשר לכתוב תוכנת web וויזואלית שמומרת ל ExtJS.

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

עוד יום שלישי ה13

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

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

זהירות, הקוד קצר מידי, בייחוד אם משווים לC

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

שינוי תצורת ממשק ה IDE

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

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

באמצעות חבילה כזו, אפשר ליצור מצב של Dock לסביבת העבודה, אבל לאחרונה גיליתי עוד דרך מדהימה (לדעתי) שמשנה את סביבת העבודה בצורה הזו: KZDesktop.

תכנות גרפיהגישה של KZDesktop היא להשתמש ב Tabbed Based User Interface ולא בDock UI, SDI או MDI.

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

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

נכון לכתיבת פוסט זה, עדיין לא ניסיתי בעצמי את התוסף, אבל אנסה אותו בסופ"ש הזה וכנראה אדווח 🙂

התמונה הבאה, מציגה איך מתקינים חבילות בלזרוס, תכנות נעים 🙂

התקנת חבילות

עוד חוזר הדיון, שנזנח כך לשווא …

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

הוא התחיל בדוגמה בכך שבC אפשר לקבוע את רמת הביט של מספר, למשל:

typedef int7b int:7

ואם אתם אוהבי ממים, אז המשפט שהגיע מפי היה בסגנון "bitch please", או בגרסתו העברית – "כלבתא במטותא":

  int7b = 0..63;

רגע, אבל למה להתחיל מ0, למה שלא נתחיל מ5 במקום ?

  int7b = 5..68;

אתה יכול לעשות את זה ב C ? אה, לא, אוקי. ומה עם זה ?

  TMyRec = bitpacked record
    Value : int7b;

ולהבטיח כי הרשומה בהכרח תקבל דיחסה לפי ביטים ולא לפי גישה אחרת (יש מספר יכולות דיחסה בפסקל לרשומות) ? להמשיך לקרוא

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

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

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

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

וואוו איזה כלי מגניב

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

אחד הדברים שאני כל הזמן מגלה הוא, עד כמה הם אוהבים את סביבת העבודה שלהם, אבל כל הכלים שיש לסביבת העבודה שלהם, ובכן איך להגיד את זה בצורה לא משתחצנת – משעממים מאוד אנשים שהתרגלו לעבוד עם כלי בורלנד (שנמכרו לחברת אמברקדו). אין באמת משהו מעניין או מסעיר בכלי הפיתוח הללו. עבורי זה משהו די סטנדרטי ב12-15 שנה האחרונות. למעשה ב vim יש יותר כלים מעניינים מאשר אלו המגיעים עם MS Visual Studio.

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

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

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

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

Redis – From client to execution

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

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

את ההרצאה לא תוכלו לקבל ברשת, אבל את השקפים המטורפים שלי כן:

פסקל ברברס

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

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

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

לבנות את FPC jvmbackend

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

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

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

כתיבת ממשקי משתמש בסיסיים ללא שימוש ב C או Glade

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

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

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

עבור תוכנה גרפית, נתחיל בכך שנעבוד עם Lazarus. ונתחיל שם פרוייקט חדש:

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


fpIndexer הוא מנוע קוד פתוח הנועד לסרוק טקסט וליצור עבורו אינדקסים אשר יעזרו לחפש טוב יותר את המילים השונות, ואף ליצור מעל התוצר שלו במסדי נתונים, גם מנוע מסוג Full Text Search

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

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

  • מחלקה עבור שמירה ושליפת מידע
  • מחלקה עבור אינדקסים
  • מחלקה לחיפוש
  • מחלקה לעיבוד טקסט

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

בזמן כתיבת הפוסט, ישנה תמיכה בארבעה צורות של "שמירה ושליפה של המידע":

  • מסד נתונים בזיכרון
  • קובץ שטוח
  • Firebird SQL
  • SQLight

המערכת יודעת לסרוק כרגע שלושה סוגים של מבני קבצים:

  • קבצי טקסט רגילים (plaintext)
  • קבצי HTML
  • קבצי Pas

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

מעל מאנדקס הטקסט/stream, קיים גם מימוש של אינדקס השייך למסד הנתונים, דבר המאפשר ליצור מנוע full text search מעל מסד הנתונים.

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

WAT I have learned about …

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

למשל לכתוב קצת קוד פיתון, ולגלות כי Tuple זו הגדרה מוזרה במקצת:

a = (1)  # an Integer
a = (1,) # a Tuple
a = 1    # an integer
a = 1,   # a Tuple

על זה נאמר WAT ?

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

case a
 when 1 : something # 1.9.3 raises syntax error
 when 1
          something # Both 1.8.7 and 1.9.3 accept it

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

המפרש החדש שכתבתי ל Redis

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

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

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

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

Redis סיבוב שלישי

הסיבוב הבא עם Redis הולך להכריע איך יגמר הקרב ביני לבין מסד הנתונים המעצבן הזה.

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

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

השנה 1994, הגרסה 0.2 התכנה FPK

התגלה אוצר באחד משרתי ה FTP של הפרוייקט FPC: גרסה 0.2 של המהדר.
נחמד לראות, ומומלץ להשתמש במילון גרמני אנגלי/עברי בשביל להבין.

מערך כתכונה

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

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

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

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

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

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

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

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

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

   function GetColor(AName : String) : TColor;

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

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

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

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

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

ממשק גרפי לציטוטים חלק רביעי

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

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

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

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

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

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

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

עוד מספר פיטצ'רים שחשבתי להוסיף:

  •  לשלוח ציטוטים לרשת חברתית (או יותר נכון מספר רשתות חברתיות).
  • להוסיף צלמית ל system tray, וגם לשלוט משם.

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


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

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

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

אז כיצד "רושמים" את ה callback ? זה מאוד פשוט: להמשיך לקרוא

לכידת אותות סוררים ביוניקס

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

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

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

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

למשל אם תכתבו בלינוקס : להמשיך לקרוא

FPC 2.6.0 שוחררה

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


רשימת התוספות: להמשיך לקרוא