קטגוריה: FPC

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‏

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

הדגמה מתקדמת לשימוש ב 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.

Installation:

  • 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.
לאחר אתחול מחדש של לזרוס, התוסף כבר מותקן אצלכם.

כמה זה 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 שעושה בדיוק הפוך.

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

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

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

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

createdb

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

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

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

procedure TfrmDBCreate.btnCreateClick(Sender: TObject);
var Transaction : TSQLTransaction;
begin
  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;
  try
   FBConnection.CreateDB;
   FBConnection.ExecuteDirect('CREATE table test1 (name varchar(24) not null)');
   Transaction.Commit;
   MessageDlg('Info', 'The database was created.', mtInformation,
             [mbClose], -1);
  except
    on e : EIBDatabaseError do
     begin
       MessageDlg('Error', 'Could not create database : ' + LineEnding +
                  e.Message, mtError, [mbClose], -1);
     end;

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

קודם כל אנחנו מזינים ל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

lazDebian

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;
begin
  Chart.ClearSeries;
  pie          := TPieSeries.Create(Chart1);
  pie.Title    := 'Pie Chart';
  pie.Exploded := False;
  with pie.Legend do
   begin
     Multiplicity := lmPoint;
     Format       := '%2:s (%1:.2f%%)';
     GroupIndex   := 0;
   end;

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

  with Chart.Legend do
   begin
     GroupTitles.Clear;
     GroupTitles.Add('Pie');
     Chart.AddSeries(pie);
   end;
end;

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

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

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

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

procedure TForm1.btnApplyClick(Sender: TObject);
var i    : integer;
    acol : TColor;
begin
  if not Assigned(pie) then initpie; // first time applying ... it can have memory leak if we apply it every time
  pie.Clear;
  for i := 1 to sgGraphDetails.RowCount -1 do
   begin
     with sgGraphDetails do
      begin
        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);
      end;
   end;
end;

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

אז הגיע הזמן לייצא את התוצר החוצה.
למרות שיש הרבה מאוד סוגי תמונות אליהם ניתן לייצא, החלטתי לתמוך בהדגמה שלי רק ב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;
begin
  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);
          try
            id                       := TSVGDrawer.Create(fs,true);
            id.DoChartColorToFPColor := @ChartColorSysToFPColor;
            Chart.Draw(id, Rect(0,0, Chart.Width, Chart.Height));
          finally
            fs.Free;
          end;
        end;
  end;
end;

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

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

TAChart – חלק שלישי

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

כתיבת קוד

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

TAChart – חלק שני

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

tachart_example

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

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

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

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

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

TAChart – חלק ראשון

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

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

tachart browser statistics

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

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

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

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

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

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

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

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

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

פסקל ברברס

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

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

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

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

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

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

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

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

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

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

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

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

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

Redis סיבוב שלישי

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

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

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

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

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

Redis or not

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

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

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

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

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

nvidia widgets

NvWidget_MacOS_386nvidia שחררה לפני מספר שנים sdk להשתמש בAPI שהיא משחררת עבור שימוש ב OpenGL. בעקבות ה sdk, קם פרוייקט אשר יצר רכיבים גרפיים המשתמש ב API של nvidia.

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

exitproc

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

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

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

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

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

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

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

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

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

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

FPC 2.6.0 שוחררה

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

תוספות

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

לעבוד עם JSON ו FPC

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

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

בנוסף, הספרייה מגיעה עם fpJSONRTTI אשר ממיר אובייקטים באמצעות RTTI ל JSON וממיר חזרה מ JSON לאובייקטים. בנוסף מגיעה בספרייה גם יחידה בשם jsonconf בשביל לעבוד עם קבצי הגדרות מבוססי json. להמשיך לקרוא

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

Quote Window

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

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

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

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

הנה מספר קטן של ניסויים שעשיתי בממשק: להמשיך לקרוא

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

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

גרסה חדשה ל FPC JVM

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

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

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

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

ppcjvm -Tandroid ....

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

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

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

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

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

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

fpGUI 0.8 שוחררה

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

הפרוייקט fpGUI שחרר גרסה חדשה : 0.8. רשימת השינויים והתוספות: להמשיך לקרוא

הקשיים ביצירת תכנות טבעיות לאנדוראיד

"The greatest challenge to any thinker is stating the problem in a way that will allow a solution" — Bertrand Russell

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

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

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

שליחת הודעות עם d-bus

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

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

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

ד"א, לקח לי פחות זמן לממש את הbinding מאשר להבין למה המימוש שלי פשוט לא עובד.

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

display quotes

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

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

עוד שינויים גרפיים משמעותיים:הוספתי יכולת להעתיק את הציטוט ישירות ללוח הגזירים (Clipboard).  כמו כן, החלפתי את פקדי הכפתורים לBitBtn ומציג עכשיו איקונים (רק אם הסביבה מאפשרת להציג. כלומר אם בחרתם שלא יוצגו תמונות של כפתורים בסביבה הגרפית – KDE, Gnome וכו', אז הם לא יוצגו). האיקונים נלקחו באכזריות מאוסף Oxygen.

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

תכנונים לגרסה הבאה:

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

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

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

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

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

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

מאז שנות ה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;
...

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

הצגת QR Barcode בתכנה שלך

http://lazarus-ccr.svn.sourceforge.net/viewvc/lazarus-ccr/components/lazbarcodes/לבקשת הקהל (בשיחות פרטיות), החלטתי להדגים כיצד ניתן ליצור חלון גרפי המציג QR Barcode.

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

רכיבים

הצגתי רכיב שמספק 2D Barcode, עם ברכה ומסר נוסף.

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

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

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