יום שבת, 29 בנובמבר 2014

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


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

#1
p nil # nil

#2
puts nil.inspect # nil ; why not NilPointerException !?

#3
puts nil.to_s # empty line
#1
אנו מקלידים את הביטוי "p nil" - ביטוי שנראה קצת מוזר, אולי שגיאה.
בפועל, p x הוא קיצור ברובי לכתיבת puts x.inspect.

2 מתודות בסיסיות של המחלקה Object ברובי הן:
  1. to_s (המקבילה של ()toString) - מתודה המחזירה ייצוג של המחלקה כמחרוזת
  2. inspect - עוד מתודה מאוד דומה שמחזירה ייצוג של המחלקה כמחרוזת
מה ההבדל?
to_s נועדה יותר ל output למשתמש, בעוד inspect נועדה יותר לצרכים פנימיים - למשל debug.
ברוב המקרים inspect פשוט תקרא ל to_s, ורק לפעמים היא תציג ערך שונה.

למשל שימו לב להבדלים:
puts 1.to_s        # 1
puts 1.inspect     # 1
puts '1'.to_s      # 1
puts '1'.inspect   # "1"
בעוד to_s מחזירה את אותו הערך, inspect - מספקת לי "רמז" על הטיפוס של המשתנה. למשל: העובדה ש "1" הוא בעצם מחרוזת  - בעזרת המירכאות שמסביב.


#2
טוב... אז p nil שקול בעצם להדפסה של inspect על nil, אבל בעצם - למה לא נזרקת לי Exception?
התשובה היא ש nil ברובי לא ממומש כ pointer ריק (או מקבילה מודרנית) אלא כ Null Object (אובייקט שמדמה ערך null-י - הקישור מוביל לפוסט בנושא). בעצם nil ברובי הוא אובייקט לכל דבר, כמו כמעט כל דבר אחר (למשל הערכים true ו false המיוצגים ע"י מחלקות גלובליות בשם TrueClass ו FalseClass, בהתאמה).


#3
אז למה ש nil.to_s יחזיר לנו שורה ריקה?
אם זה לא ברור - חזרו שוב על מה שעשינו למעלה....



פוסט זה שייך לסדרה: רובי (Ruby) למפתחי ג'אווה ותיקים



Special Literals

הנה כמה צורות כתיבה מקוצרות שעשויות להיות מבלבלות (אם אתם לא מכירים), או שימושיות (כאשר אתם כבר מכירים):
# large integer literal
puts 100_000 # 100000
puts 1_0_0_0 # 1000

# character literal
puts ?c  # c
puts 'c' # same. c

# hex literals
puts 0x292 # 658

# binary literals
      # rwxrwxrwc
puts  0b100100100 # 292
puts  0b100100100.to_s(8) # 444
large integer literal
בכדי להקל על קריאה של מספרים גדולים - ניתן להכניס קו תחתי "_" בין הספרות - וזה עדיין מספר לכל דבר. צורה זו הופכת את המספר "מאה אלף" לקל לקריאה, ואפשר להשתמש בה להפוך את אלף להראות כמו... נחש?!

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

hex literal
ברור

binary literal
תחילית של 0b עם 0 ו 1 אחריה מצהירה שמדובר במספר בינארי. אם לדוגמה אנו רוצים להגדיר הרשאות בלינוקס - פורמט זה נוח יותר לעבודה.
שימו לב שהמספרים שאנו מכירים כקודים להרשאות (444, 777, וכו') הם מספרים בבסיס 8, אותו ניתן להציג ברובי ע"י to_s עם הבסיס הרצוי


השוואת ערכים

x = Object.new
if x
  puts 'yeah'
end
בדומה לג'אווהסקריפט, ניתן להשתמש במשפט if כדרך מקוצרת לדעת אם למשתנה יש ערך.
רק שימו לב שהערכים הבאים הם evaluated כ true בשפת רובי:
  • מערך ריק
  • המספר 0 (אפס) - בשונה מרוב שפות התכנות
  • מחרוזת ריקה 
בקיצור: ברובי הכל evaluated כ true, מלבד false ו nil. כאשר רוצים להבחין בין false ו nil - עלינו להשתמש במתודה ?nil

השמה קלה


עוד תרגיל תחבירי שדומה לג'אווהסקירפט היא בדיקה מקוצרת עם ערך הוא nil - והשמת ערך ברירת-מחדל במקום:
data = {}


# long
if data[:currency].nil?
  currency = 'USD'
else
  currency = data[:currency]
end
puts currency # USD


# short
currency = data[:currency] || 'USD'
puts currency # USD

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

התחביר המקוצר - נחמד בהרבה.

ברובי יש תחביר אפילו יותר מקוצר, שמשתמשים בו לא-מעט, בכדי לקצר מקרה של הגנה והשמה לאותו משתנה עם ערך ברירת-מחדל:
currency = nil

# short
currency = currency || 'USD'
puts currency # USD

# even-shorter
currency ||= 'USD'
puts currency # USD
סבבה!

עוד תכונה "מקצרת" היא שמשפטי if מחזירים בעצמם ערכים (השורה האחרונה בביטוי):
def born_in_the_USA?
  false
end

data[:currency] = if born_in_the_USA?
  @@usa_citizens += 1
  'USD'
else
  'ruble'
end

puts data[:currency] # 'ruble'
הערה קטנה: שימו לב שברובי אין operators של ++ או --. משתמשים ב 1 =+.

ומה עם הקיצור ל if-else שאנו מכירים מג'אווה בצורת "?" - אי אפשר להשתמש בו ברובי?
# shorthand
data[:currency] = born_in_the_USA? ? 'USD' : 'ruble'

puts data[:currency] # 'ruble'
אפשר!


גם משפט case מחזיר תמיד ערך. בהזדמנות זו כדאי להציג את התחביר שלהם, שהוא מעט שונה:
def name_number(number)
  case number
    when 0
      'nullus'
    when 1
      'uno'
    when 2..10000
      'other number'
    when /\d+\$/
      "that's money"
    else
      "don't know"
  end
end

puts name_number 0        # nullus
puts name_number 1        # uno
puts name_number 7        # other number
puts name_number '2$'     # that's money
puts name_number 'google' # don't know
כמה הבדלים:
  • משתמשים במילה "when" ולא "switch" (כל הכבוד!)
  • ניתן להשתמש בטווחים (כמו בפאסקל - אם אני זוכר נכון)
  • ניתן להשתמש ב regex
  • ניתן לערבב בין כולם באותו ה case
שימו לב שהביטוי האחרון בפונקציה הוא ערך ההחזרה שלה, ובמקרה שלנו זהו ה case statement.



ארגומנטים לפונקציה


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

נניח לדוגמה את קיום פונקציה foo הבאה:
def foo(a, b, c)
  @@y = a + b * c
end
כאשר a, b, c הם פרמטרים, שכיוון שזו שפה דינאמית - לא מגדירים את הטיפוסים שלהם.

אם נקרא לפונקציה עם ארגומנט יחיד
foo(3)
נקבל שגיאה: "Argument Error: wrong number of arguments" עם כל הדינאמיות, רובי מצפה שכל הארגומנטים יישלחו (בניגוד לג'אווהסקריפט, למשל, שתציב undefined בפרמטרים להם לא נשלחו ארגומנטים).

אפשר לאפשר לשלוח ארגומנט אחד, אם מגדירים ערכי ברירת מחדל לפרמטרים האחרים
def foo(a, b = 2, c = 5)
  @@y = a + b * c
end

foo 3
puts @@y # 15
מצב "מעצבן"[א] הוא בו אני רוצה לשלוח ערכים רק ל a ו c, אך "נאלץ" לשלוח גם ערך ל b כי הוא קודם בסדר ל c. למשל:
def goo(message, warning = false, log_externally = false)
  message += '!!!!!' if warning
  puts message
  send_log message if log_externally
end

goo 'hello', nil ,true # sending nil = sort of Annoying
(עברתי מ foo ל goo כדי לייצר דוגמה יותר ריאליסטית)

דרך אחת לפתור מצב זה הוא שימוש ב options hash:
def goo(message, options = {})
  message += '!!!!!' if options[:warning]
  puts message
  send_log message if options[:log_externally]
end

goo 'hello', { log_externally: true }
החיסרון בדרך זו היא הצורך בתיעוד - מה בעצם options אומר.

הו לא! זה לא מספיק טוב! לא עבור רובי - חובה למצוא פתרון פשוט יותר!

רובי 2.0 הציגה יכולת שנקראת Keyword Arguments, שבאה פעם אחת ולתמיד לפתור את המצב הלא-נוח שתואר עד כה.
def goo(message, warning: false, log_externally: false)
  message += '!!!!!' if warning
  puts message
  send_log message if log_externally
end

goo 'hello', log_externally: true
אין מחויבות על סדר הארגומנטים שנשלחים עם keyword - ממש כמו hash, אבל יש לנו "תיעוד" מובנה בחתימה של הפונקציה.

צילומסך מ Tutorial מפורסם של רובי (Ruby Bits) בו המרצה קופץ על המסך כדי לקרוא סדרה של קריאות התפעלות מיכולת ה keywoard arguments.
הסימן 1UP בא לסמן קוד שהוא "!Awesome", ופה בדיוק הופיעו חמישה כאלו ברציפות.




מה בכל זאת מפריע לי ב keyword arguments של רובי?


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

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

כדי לפענח את קוד הרובי (parsing), לא כתבו parser בצורה ידנית. במקום זאת, הגדירו את סט המבנים האפשרי בשפה (להלן parser.y) ואז בעזרת generator של parsers בשם Bison (וריאציה של YaCC[ב]) - מקמפלים parser שמפענח את קוד הרובי - ניתן למצוא אותו כקובץ בשם parse.c.
לא תמצאו את הקובץ הזה ב Git Repository של רובי, מכיוון שהוא נבנה בזמן ההתקנה עבור המעבד / מערכת ההפעלה הספציפית.

אצלי (חלונות 7, 64 ביט, רובי 1.9) גודל הקובץ הוא כחצי מגה או 17,000 שורות מורכבות של קוד. לא משהו שמישהו היה כותב בעצמו. שפת PHP, למשל, משתמשת בגישה דומה.

החל מרובי 1.9, מפרשן ברירת-המחדל הפך להיות YARV (קיצור של Yet another Ruby VM[ג]).
בעת הפעלת התוכנה YARV "מקמפל" את התוכנה ממש לפני ההרצה לשפה בסיסית יותר - הנקראת YARV instructions. העקרון דומה ל JIT Compiler של ג'אווה, חוץ מזה שבג'אווה מקמפלים משפת ByteCode לשפת מכונה, וברובי מ עץ Syntax שפוענח - לשפת "ByteCode" (ה YARV instructions) שתעבור אינטרפרטציה מעתה תוך כדי ריצה.

מיותר לציין שהמעבר מ MRI ל YARV מציג שיפור ביצועים משמעותי מאוד לקוד רובי.

הנה דוגמה לפענוח של קוד רובי ל YARV instructions, שמציגה "על הדרך", עוד צורה להגדיר פרמטרים ברובי - args* - המקבילה הישירה (והקצת-יותר-גמישה) של ה varags בג'אווה. למה יותר גמישה? כי רובי לא תחייב את המתכנת להציב את ה varargs דווקא בסוף רשימת הפרמטרים רחמנא ליצלן! אולי יותר נוח / אלגנטי עבורו לשים אותה דווקא באמצע?


לכל scope בשפה, רובי מנהלת בזיכרון Local Table (מזכיר במשהו את ה Activation Frames של שפת ++C) שם מנוהלים המשתנים המקומיים / פרמטרים של הפונקציה או הבלוק.

הטבלה המקומית מגדירה את הערכים, עם הטיפוסים שלהם. בכדי לאפשר args* (טיפוס = Rest) באמצע רשימת הארגומנטים, עלינו להבחין בין ארגומנטים שנשלחו לפני (טיפוס = Arg), לארגומנטים שמגיעים אחרי (טיפוס = Post). המפרשן של רובי יקרא את הארגומנטים שלפני ואחרי, ומה שיישאר - ילך ל args*.

שימו לב ל YARV instructions משמאל - זהו בעצם הקוד המקומפל (סוג של Bytecode) אותו המפרשן מפענח ומריץ בזמן הרצת התוכנית.

בואו עכשיו נראה איך נראית פונקציה פשוטה עם ערך ברירת-מחדל לפרמטר:




ועכשיו איך נראית אותה הפונקציה, עם Keyword Argument:


מ-ס-ו-ב-ך.

נכון: מה שהסתבך הוא ה byte code. לא משהו שמפריע לפריון של המפתח. אבל... בתוכנה אין ארוחות חינם[ד].
byte code מסובך יותר משפיע על:
  • ביצועים (קצת)
  • יציבות / אמינות (קצת)
  • קלות בביצוע debug (קצת)
  • קושי לבצע שינויים משמעותיים בפלטפורמה - לדוגמה שיפור התמיכה ב parallelism וב concurrency.

שפת Go, למשל, (שאני מאוד מחבב) - החליטה לוותר על Generics בשפה בכדי לשמור על קומפילציה מהירה.
ברור ששפת Go (שהיא שפה ל System Programming) היא בערך ההיפך הגמור משפת רובי (שפת high level שמתמחה במהירות פיתוח גבוהה) - ולכן הגיוני שההחלטות שלה בתחום יהיו הפוכות לגמרי לאלו של רובי.

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

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

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

למשל, בואו נתבונן על כלי קצת פחות מוכר בשפת רובי: ה Flip Flop Operator (בקיצור FFO):
(1..20).each do |x|
  puts x if (x == 5) .. (x == 10)
end
FFO הוא הנקודתיים בין 2 תנאי ה if. משמעותו: קיים את התנאי כל עוד התנאי הראשון מתקיים עד הרגע בו התנאי השני מפסיק להתקיים. את הקוד הנ"ל אפשר לכתוב בעזרת "קטן מ..." ו"גדול מ...". האם שיפור הקריאות מצדיק הוספה של אופרטור נוסף לשפה?

הנה דוגמה שקצת יותר מצדיקה שימוש באופרטור שכזה... איתור מקטעים (flip..flop) ברצף:
[3,5,5,19,100,10,1,0,10,2].each do |x|
  puts x if (x == 5) .. (x == 10)
end

# result => 5, 5, 19, 100, 10
נחמד - אבל האמת: כמה פעמים נתקלתם בבעיה שכזו בחייכם? האם נכון להוסיף רכיב לשפה בכדי לספק פתרון אלגנטי?

הייתה כבר בקשה רשמית להסיר את האופרטור מהשפה, אך הבקשה לא נכללה בתכולה של גרסה 2.0. מאטצ' הוסיף שלא יציג שינויים לא תואמים לשפה ברובי 2 - אולי זה יקרה ברובי 3...





סיכום


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


שיהיה בהצלחה!




----

קישורים רלוונטיים

Rubular - "מחשבון" regex אונליין לרובי


---

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

[ב] YaCC הוא קיצור של Yet another Compiler Compiler - ונחשב הכלי הנפוץ בתחום (ביחד, אולי עם ANTLR).

[ג] הידוע גם בשם (KRI (Koichi's Ruby Interpreter על שם המחבר שלו, בהתאמה ל MRI שנכתב ע"י מאטצ'.

[ד] יש מיתוס, בקרב אלו שלא חוו מספיק tradeoffs בתוכנה על בשרם, ש "אם נשים את האנשים המוכשרים ביותר - הם ימצאו דרך 'למחוק' את ה tradeoff ולהעלים אותו". בקשה זו היא כמו לקוחה מהמיתולוגיה היוונית - והתוצאה שלה גם היא לעתים יוונית: טרגדיה.
סיפור מפורסם הוא של ספינת המלחמה Vasa בו זימן אליו מלך שוודיה את אדריכל הספינות המפורסם בעולם (באותה התקופה) כדי שיבנה את ספינת המלחמה הטובה בעולם: ספינה שהיא גם ספינת משא (לחיילים) הדורשת מקום רב ויציבות, וגם ספינת קרב - הדורשת זריזות ויכולת תמרון. גם וגם. זה היה פרויקט אדיר, ומרשים - שלא נראה כמותו באותם הימים. לאחר עבודה שכללה מאמצים אנושיים אדירים ומפוארים - הספינה הושקה למים. היא הצליחה לשלב גמישות קרבית ונשיאת חיילים - למרחק של 1300 מטר בלבד, שם משהו השתבש והיא שקעה למצולות. הטיטאניק בגרסה המקוצרת.

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

חשוב לציין שכן ניתן "לרמות" tradeoffs במידה מסוימת, וזה ע"י החלפה של הבחירה ב tradeoff ברגעים שונים בתוך אותו התהליך. למשל כמו האופן בו Cassandra "מרמה" את ה CAP Theorem (שטוען שלא ניתן להשיג גם זמינות וגם עקביות במידע מחולק (partitioned)) - אבל Cassandra מאפשרת לכל query בודד לבחור בין יותר זמינות או יותר עקביות בנתונים, וכך "כמערכת" - Cassandra מספקת גם וגם.



אין תגובות:

הוסף רשומת תגובה