ג'וליה (שפת תכנות)

מתוך ויקיפדיה, האנציקלופדיה החופשית
ג'וליה
Julia
Julia Programming Language Logo.svg
Juliacap.jpg
פרדיגמות Multiple dispatch (פרדיגמה עיקרית), תכנות פרוצדורלי, תכנות פונקציונלי, Meta,‏ Multistaged[1]
תאריך השקה 2012[9][10]
מתכנן ג'ף בזאנסון, אלן אדלמן, סטפן קרפינסקי, ויראל ב. שאח
מפתח ג'ף בזאנסון, סטפן קרפינסקי, ויראל ב. שאח ואחרים[2][3]
גרסה אחרונה 1.6.2 (14.7.2021)
טיפוסיות

דינמית,[4] חזקה,[5] בטוחה, מפורשת, פרמטרית

--
הושפעה על ידי MATLAB עריכת הנתון בוויקינתונים
רישיון MIT (השפה עצמה),[2] GPL v2;[6][7] הגדרה ב-makefile יכולה להסיר את ספריות ה-GPL.[8]
סיומת jl.
JuliaLang.org
לעריכה בוויקינתונים שמשמש מקור לחלק מהמידע בתבנית OOjs UI icon info big.svg

ג'וליה (באנגלית: Julia) היא שפת תכנות עילית מהירה ודינמית, לתכנות כללי, טכני ומדעי. השפה מצטיינת במיוחד בתכנות המדעי ובביצוע מהיר של אנליזות נומריות, אולם מתאימה גם לכתיבה של תוכנות לקוח ושרת באפליקציות רשת, לתכנות מערכות Low level[11], לשימוש כשפת מִפרט לפני מימוש[12] ולשאר שימושים כלליים.[13][14][15][16]

לג'וליה תחביר דומה לשפות אחרות מאותו תחום (MATLAB,‏ R, פייתון, SciLab וכולי), והיא מספקת מהדר JIT מתקדם (ולמעשה Just Ahead Of Time, כי הקוד כולו מהודר מראש),[17][18] מערכת טיפוסים דינמית עם פולימורפיזם פרמטרי, עיבוד מקבילי מבוזר ויכולת לתקשר ישירות עם פונקציות בפורטרן, C ופייתון. בנוסף לאלו יש לג'וליה ספריה רחבת היקף של פונקציות מתמטיות, ויכולת לעבוד במבנה של מחברת דרך דפדפן, באמצעות IJulia, שהוא שיתוף פעולה עם קהילת IPython. קהילת המפתחים של ג'וליה תורמת דרך חבילות חיצוניות, ואלה משולבות בסביבת העבודה באמצעות מנהל חבילות מובנה.

לג'וליה יש מנגנון של איסוף זבל בטכניקה של חישוב ביטויים מוקדם (Eager evaluation). הספריות שלה ברובן כתובות גם הן בג'וליה, ביניהן ספריות לאלגברה ליניארית, ליצירת מספרים אקראיים, ל-FFT ולטיפול בביטויים רגולריים. כמה מהספריות, כגון זו של ה-FFT, נכללו בעבר כחלק מהשפה, אך הופרדו מאוחר יותר לחבילות עצמאיות,[19] ובנוסף לאלו קיימות גם ספריות ב-C ובפורטרן. תוכנות בג'וליה מאורגנות בדרך כלל סביב הגדרות הפונקציות, ובמסגרת קונספט ה-Multiple dispatch, רוב המשקל הוא על הצירופים השונים של סוגי משתנים.[20]

ישנם מספר כלי פיתוח שתומכים בתכנות בג'וליה, כמו Visual Studio Code שפותחו לו הרחבות שמוסיפות תמיכה בג'וליה, כמו גם יכולות ניפוי שגיאות ו-Linting. בנוסף ישנם כלי שילוב כגון Profiler, מנפה שגיאות, וחבילת Rebugger.jl שמאפשרת ניפוי שגיאות בהפעלות חוזרות.

היסטוריה[עריכת קוד מקור | עריכה]

העבודה על הפרויקט החלה בשנת 2009 על ידי ג'ף בזאנסון, סטפן קרפינסקי, ויראל ב. שאח ואלן אדלמן, במטרה ליצור שפה חופשית, עילית ומהירה. ב-14 בפברואר 2012 יצרו אתר בו הוסבר מדוע יצרו את השפה,[21] ובאותה שנה יצאה לאור גרסת קוד פתוח של השפה.[9] בראיון ב-2012 הסביר קרפינסקי את הבחירה בשם "ג'וליה": "למעשה, אין ממש סיבה. זה פשוט נראה כמו שם טוב." הוא סיפר כי בחר את השם בהמלצת חבר.[22]

רציונל[עריכת קוד מקור | עריכה]

הודעה מטעם יוצרי השפה על הסיבות ליצירתה, צוין כי הם משתמשים כבדים של Matlab עם ניסיון במגוון שפות תכנות, ואינם מרוצים מהכלים הקיימים לתכנות מדעי. הכלים הקיימים, לדבריהם, טובים כל אחד בתחומו, אך כושלים בתחומים אחרים. הם רצו תוכנה חופשית, שתהיה מהירה כמו C ודינמית כמו Ruby. שתהיה לה ההומואיקוניות (התייחסות זהה לקוד ומידע) של Lisp, עם הסימנים המתמטיים שיש ב-Matlab. שתהיה שפת דבק כמו Shell, קלה ללימוד, אבל לא משעממת להאקרים מנוסים. ומעבר לכל אלו, שתהיה בעלת יכולת לעבודה אינטראקטיבית, אבל גם תאפשר עבודה בתצורת עריכה והרצה.[23]

תפוצה[עריכת קוד מקור | עריכה]

מאז ההכרזה, משתמשים ממעל 10,000 חברות כבר הורידו את ג'וליה, עם יותר מ-29 מיליון הורדות ביולי 2021 (עליה של 87%–113% בשנה), והיא נמצאת בשימוש ביותר מ-1,500 אוניברסיטאות. הכנס האקדמי JuliaCon למפתחי ומשתמשי ג'וליה נערך מדי שנה מאז 2014, ומשתתפים בו מעל 28,000 צופים.

Julia Computing[עריכת קוד מקור | עריכה]

העניין ההולך וגובר של חברות שונות בג'וליה הביא ביולי 2015 להקמתה של חברת Julia Computing[24] בידי ויראל ב. שאח, דיפאק וינצ'הי, אלן אדלמן, ג'ף בזאנסון, סטפן קרפינסקי וקינו פישר.[25] החברה עוסקת במתן שירותים בתשלום בתחומי התמיכה, ההכשרה והייעוץ, בהפצת סביבת JuliaPRO שמותאמת לתכנות מדעי, ובאינטגרציה עם טכנולוגיות ענן.[26]

ב-2017 גייסה Julia Computing השקעת גרעין של 4.6 מיליון דולר מקרנות ההשקעות ג'נרל קטליסט ופאונדר קולקטיב,[27] ובאותו חודש קיבלה מענק של 910,000 דולר מקרן אלפרד פ. סלואן לתמיכה בפיתוחי קוד פתוח של ג'וליה, ובהם 160,000 דולר לקידום גיוון באוכלוסיית ג'וליה.[28] בדצמבר 2019 קיבלה מימון של 1.1 מיליון דולר מהממשל האמריקאי כדי "לפתח כלי למידת מכונה מבוסס רכיבים נוירוניים להפחתת צריכת האנרגיה הכוללת של מערכות חימום, אוורור ומיזוג בבניינים."[29]

שימושים מרכזיים[עריכת קוד מקור | עריכה]

מספר גורמים בעלי מוניטין משתמשים בג'וליה, החל מבית ההשקעות בלאקרוק, שמשתמש בה לניתוח סדרות עתיות, ועד חברת הביטוח הבריטית אביבה, שמשתמשת בג'וליה לחישוב סיכונים. ב-2015 השתמש בנק הפדרל ריזרב של ניו יורק בג'וליה כדי לייצר מודלים של הכלכלה האמריקאית, וציינו שם כי השפה גרמה להערכות מבוססות המודל להיות מהירות פי עשרה מהמימוש הקודם ב-MATLAB. בכנס Juliacon של 2017[30] הכריזו ג'פרי רג'יר, קינו פישר ואחרים[31] שפרויקט סלסטה ליצירת קטלוגים אסטרונומיים השתמש בג'וליה כדי להשיג ביצועי שיא של 1.54 פטהפלופים תוך שימוש ב-1.3 מיליון תהליכונים[32] על 9,300 צמתי Knights Landing של מחשב העל Cray XC40, שהיה אז השישי ברשימת המחשבים המהירים בעולם.[33] בכך הצטרפה ג'וליה לרשימת השפות העיליות בהן נעשו חישובים ברמת הפטהפלופים, שכללה עד כה רק את C,‏ C++‎ ופורטרן.

שלושה מהיוצרים של ג'וליה קיבלו ב-2019 את פרס ג. ה. וילקינסון לתוכנה נומרית (שניתן כל ארבע שנים) על "יצירת ג'וליה, סביבה חדשנית ליצירת כלים עתירי ביצועים שמאפשרים ניתוח ופתרון של בעיות במחשוב מדעי."[34] בנוסף, אלן אדלמן, פרופסור למתמטיקה יישומית ב-MIT, נבחר לקבל את פרס סידני פרנבאך של חברת המחשוב של ה-IEEE ב-2019 על "פריצות דרך ייחודיות במחשוב עתיר ביצועים, באלגברה ליניארית ובמחשוב מדעי, ועל תרומות לשפת התכנות ג'וליה."[35]

Julia Computing ו-Nvidia הודיעו על זמינות של ג'וליה כמיכל מוכן מראש ברשימת המיכלים של ענן ה-GPU של NVIDIA (שמוכר בשם NGC).[36] כאשר NVIDIA, כחלק מההצעה להשתמש בג'וליה על x86 ועל ARM מציינת "ג'וליה מציעה חבילה של אקוסיסטם מפורט למחשוב עתיר ביצועים, כולל למידת מכונה, מדעי המידע, תחומים מדעיים שונים וויזואליזציה."[37]

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

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

JuliaCon[עריכת קוד מקור | עריכה]

מאז 2014[41] מקיימת הקהילה של ג'וליה כנס שנתי המכוון למפתחים ומשתמשים. Juliacon הראשון התקיים בשיקגו, ומאז הכנס מתקיים מדי שנה. הכנס התארח במספר מקומות לאורך קיומו, בהם MIT[42] ואוניברסיטת מרילנד בבאלטימור,[43] ומספר המשתתפים בו עלה מעשרות בודדות לקרוב ל-30,000[44] בכנס של שנת 2020, שהתקיים באופן מקוון.

קהילת ג'וליה[עריכת קוד מקור | עריכה]

קהילת ג'וליה[45] נוכחת במספר פלטפורמות: טוויטר,[46] לינקדאין,[47] פייסבוק,[48] Slack,‏[49] Zulip,[50] דיסקורד,[51] Discourse,‏[52] Stack Overflow,[53] יוטיוב,[54] ועוד.[55] מאז מאי 2017, מועסק מנהל קהילה לשפת ג'וליה. בתחילה היה זה אלכס ארסלנד[56] ששימש בתפקיד עד סוף 2019 וכעת משמש בתפקיד לוגן קילפטריק.[57]

מימון[עריכת קוד מקור | עריכה]

שפת ג'וליה הפכה לפרויקט ממומן על ידי המלכ"ר NumFOCUS (שמממן גם פרויקטים כמו NumPy,‏ pandas ו-Ipython) ב-2014, כדי להבטיח את השרידות של הפרויקט לטווח ארוך.[58] ד"ר ג'רמי קפנר ממעבדת לינקולן ב-MIT היה המממן המייסד של פרויקט ג'וליה בימיו הראשונים. בנוסף, תרומות מקרן גורדון ובטי מור, מקרן אלפרד פ. סלואן, מאינטל ומסוכנויות שונות כגון NSF,‏ DARPA, המכונים הלאומיים לבריאות, נאס"א ו-FAA סייעו רבות בהתפתחות הפרויקט.[59] מענקי המחקר של מוזילה, שמייצרת את הדפדפן פיירפוקס, מימנו ב-2019 חבר בצוות הרשמי של ג'וליה לפרויקט "מביאים את ג'וליה לדפדפן".[60][61][62][63][64] ג'וליה נתמכת גם על ידי תורמים פרטיים בגיטהאב.[65]

מאפיינים[עריכת קוד מקור | עריכה]

אלו המאפיינים העיקריים של השפה:

  • Multiple Dispatch: מאפשר להגדיר את תפקודן של פונקציות על בסיס הרכב הפרמטרים שלהן.
  • מערכת טיפוסים דינמית: יש טיפוסים לתיעוד, לאופטימיזציה ולתפעול פונקציות.
  • ביצועים מהירים, קרובים לאלו של שפות סטטיות כגון C.
  • מנהל חבילות מובנה.
  • מתוכננת לעיבוד מקבילי ומבוזר.
  • Coroutines: סוג של תהליכונים ירוקים עם יכולת ריבוי משימות שיתופית (בה התהליכון הוא שמעביר שליטה לתהליכון אחר).
  • טיפוסים שנוצרו על ידי המשתמש הם מהירים וקומפקטיים כמו טיפוסים מובנים תקניים.
  • תמיכה ביוניקוד, ובין השאר תמיכה ב-UTF-8.
  • יכולת לקרוא לפונקציות של פייתון, R, ג'אווה וסקאלה באמצעות שימוש בחבילות מתווכות.
  • יכולת להשתמש ישירות בפונקציות של שפת C, ללא צורך במעטפת או ב-API מיוחדים.
  • יכולות ניהול תהליכים בדומה ל-Shell.
  • כלים ומאקרואים בדומה ל-Lisp.
  • יכולות מרשימות בניהול תהליכים אחרים משורת הפקודה.
  • ייצור אוטומטי של קוד יעיל ומוכוון לטיפוסי משתנים שונים.
  • המרה וקידום של טיפוסים מספריים בצורה אלגנטית וניתנת להרחבה.
  • רישיון חופשי: MIT לשפה, GPL לחלקים מן הספריות.
  • יכולת לשמש ב-Notebooks.

Multiple Dispatch (ידוע ב-Lisp כ"מולטי-מתודות") היא הכללה של Single Dispatch - המנגנון הפולימורפי על בסיס תורשה שמשמש בשפות מונחות אובייקטים. בג'וליה כל הטיפוסים הקונקרטיים הם תת-טיפוסים של טיפוסים מופשטים, ובצורה ישירה או עקיפה הם גם תת-טיפוסים של הטיפוס Any, שנמצא בראש היררכיית הטיפוסים. בניגוד לשפות אחרות, לטיפוסים קונקרטיים בג'וליה לא יכולים להיות תת-טיפוסים, ולצורך זה משתמשים בקומפוזיציה (ראו תחת ירושה (תכנות)).

ג'וליה הושפעה מאוד מניבים שונים של Common Lisp, ויש לה הרבה מן המשותף עם שפת Dylan, גם היא שפה דינמית מבוססת Multiple dispatch, ועם Fortress שגם היא שפה לתכנות נומרי. בג'וליה, Dylan ו-Fortress, היכולת להרחיב היא ברירת מחדל, והפונקציות המובנות במערכת כולן גנריות וניתנות להרחבה. ב-Dylan ה-Multiple Dispatch הוא יסודי כמו בג'וליה: כל הפונקציות שמגדיר המשתמש ואפילו פונקציות בסיסיות כמו + הן גנריות. ועם זאת, מערכת הטיפוסים ב-Dylan לא תומכת באופן מלא בטיפוסים פרמטריים, שאופייניים יותר לשפות מהענף של ML (כמו OCAML ו-F#‎). ב-Common Lisp, מערכת האובייקטים (CLOS) לא מאפשרת Dispatch על טיפוסים פרמטריים, ונדרש פרוטוקול הרחבה לשפה לשם כך. Fortress מאפשרת Multiple dispatch על טיפוסים פרמטריים, אך בניגוד לג'וליה הטיפוסים שלה סטטיים ולא דינמיים, ויש לה שלבים נפרדים לקומפילציה ולהרצה. הטבלה הבאה מספקת השוואה בין השפות:

שפה מערכת טיפוסים פונקציות גנריות טיפוסים פרמטריים
ג'וליה דינמית ברירת מחדל כן
Common Lisp דינמית אפשרי כן (אבל בלי Dispatch)
Dylan דינמית ברירת מחדל חלקית (ללא Dispatch)
Fortress סטטית ברירת מחדל כן

כברירת מחדל, סביבת ההרצה של ג'וליה צריכה להיות מותקנת כאשר מריצים קוד שנכתב בשפה. בנוסף, ניתן ליצור גם קובץ הרצה עצמאי שאינו דורש את קוד המקור, בעזרת PackageCompiler.jl.[66]

המאקרואים התחביריים של ג'וליה, שמשמשים למטא-תכנות, דומים לאלו של Lisp בכך שהם חזקים יותר ממאקרואים של החלפת טקסט שאופייניים לקדם-מעבדים של שפות אחרות כמו C, בעיקר כי הם עובדים ברמת עצי תחביר מופשטים (Abstract Syntax Tree). מערכת המאקרואים של ג'וליה היא הגיינית, אך גם תומכת בלכידה מכוונת כשנדרש (כמו במקרה של מאקרואים אנאפוריים) באמצעות מבנהesc.

חישוב מקבילי[עריכת קוד מקור | עריכה]

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

julia> using Distributed
julia> nheads = @distributed (+) for i = 1:200000000
 Int(rand(Bool))
 end
99998199

אינטראקטיביות[עריכת קוד מקור | עריכה]

ההפצה הרשמית של ג'וליה כוללת לולאת קריאה-פיענוח-הדפסה בשורת פקודה אינטראקטיבית (REPL),[67] עם היסטוריה, השלמת טאבים ומצבים ייעודיים לעזרה ולפקודות מעטפת,[68] כך שניתן יהיה להשתמש בה בשביל ניסויים בשביל לבדוק קוד במהירות.[69] המקטע הבא מציג סשן דוגמה המבצע חיבור מחרוזות[70]:

julia> p(x) = 2x^2 + 1; f(x, y) = 1 + 2p(x)y
julia> println("Hello world!", " I'm on cloud ", f(0, 4), " as Julia supports recognizable syntax!")
Hello world! I'm on cloud 9 as Julia supports recognizable syntax!

כאשר מוסיפים לפני פקודות ; למצב מעטפת או ? למצב עזרה, ה-REPL נותן למשתמש גישה למצבים השונים, וההיסטוריה של הפקודות נשמרת גם בין שימושים.[71] ניתן לבדוק קוד בצורה אינטראקטיבית, וניתן לשמור אותו ולהריץ מתוך קובץ עם סיומת .jl ואז להריץ משורת הפקודה בעזרת:[72]

 $ julia <filename>

מחברות Jupyter אינטראקטיביות יכולות לתמוך בג'וליה (למעשה ג'וליה, פייתון וR הן ההשראה לשם Jupyter[73]), וישנו גם פרויקט בשם Pluto.jl שמוגדר "מחברת ריאקטיבית" (מחברות שנשמרות בקובצי ג'וליה טהורים), ומהווה תחליף אפשרי למחברות Jupyter.

שילוב עם שפות אחרות[עריכת קוד מקור | עריכה]

ניתן לשלב את ג'וליה עם שפות רבות אחרות (כמו 10–20 השפות הנפוצות ביותר). הפקודה ccall משמשת כדי לקרוא לפונקציות מיוצאות ב-C, לקרוא פונקציות מספריות משותפות בפורטרן, לקרוא לחבילות שמאפשרות קריאה לשפות אחרות כמו פייתון, R,‏ MATLAB, ג'אווה וסקאלה.[74] ישנן גם חבילות שמאפשרות לשפות אחרות לקרוא לג'וליה, כמו pyjulia של שפת פייתון.

לג'וליה יש תמיכה בגרסת יוניקוד 13.0,[75] כאשר UTF-8 משמש במחרוזות (כברירת מחדל) ולקוד המקור של ג'וליה, כך שניתן להשתמש בסימנים מתמטיים נפוצים כאופרטורים, למשל ∈ במקום אופרטור in.

לג'וליה יש ספריות שתומכות בשפות Markup כגון HTML,‏ XML,‏ JSON ו-BSON, וספריות למסדי נתונים ולשימוש ברשת בכלל (כמו ספריה לטיפול ב-HTTP).

מנהל החבילות[עריכת קוד מקור | עריכה]

לג'וליה יש מנהל חבילות מובנה, והיא כוללת מערכת רישום כברירת מחדל.[76] חבילות בדרך כלל מופצות כקוד מקור שמנוהל ב-Github, אף על פי שישנן גם חלופות. ניתן גם להתקין חבילות בינאריות, בתור artifacts.[77] ניתן להשתמש במנהל החבילות של ג'וליה לתשאול והידור חבילות, וכן לניהול סביבות. ניתן גם להוסיף מערכות רישום נוספות שאינן מערכת הרישום הרשמית.[78]

מימוש[עריכת קוד מקור | עריכה]

הגרעין של ג'וליה ממומש בג'וליה וב-C, ביחד עם C++‎ לתלויות של LLVM. ה-Parsing והנמכת הקוד (למבנה קרוב יותר לקוד מכונה) ממומשים ב-FemtoLisp, שהוא ניב של Scheme.[79] פרויקט תשתית המהדר של LLVM משמשת בתור ה-Back end שיוצר קוד מכונה אופטימלי ב-32 או 64 ביט, על פי הפלטפורמה בה הקוד רץ. מלבד כמה יוצאי דופן (כמו PCRE), הספרייה הסטנדרטית ממומשת בג'וליה. התכונה הבולטת ביותר של המימוש של ג'וליה היא המהירות, כך שקוד בג'וליה לרוב ירוץ לכל הפחות בחצי המהירות של קוד אופטימלי מקביל ב-C, ובמהירות גבוהה בכמה סדרי גודל מאלו של פייתון או R.[80][81][82]

פלטפורמות נוכחיות ועתידיות[עריכת קוד מקור | עריכה]

מאחר שג'וליה משתמשת ב-JIT, היא מייצרת קבצים בינאריים ישירות, עוד לפני שהקוד רץ, ולא משתמשת ב-Bytecode. לג'וליה יש ארבע רמות תמיכה,[83] מ-tier 1 בה מובטח כי ג'וליה תצליח לרוץ, וישנם בינאריים רשמיים להתקנה, דרך tier 2 שם ג'וליה עובדת אך לא עוברת את כל הבדיקות ו-tier 3 הניסויית ועד tier 4 בה ג'וליה כפי הנראה פעלה לפחות פעם אחת בעבר, אך אינה פועלת כיום.

פלטפורמות של אינטל[עריכת קוד מקור | עריכה]

כל מעבדי IA-32 שמממשים ארכיטקטורת i686 נתמכים, וכך גם x86-64 (ידועה גם כ-amd64).

פלטפורמות ARM[עריכת קוד מקור | עריכה]

ג'וליה הותקנה עד כה בכמה פלטפורמות של ARM. ישנה תמיכה מלאה ב-tier 1 ב-ARMv8 AArch64, בעוד ARMv7 ו-ARMv6 AARCH32 נתמכים ברמה נמוכה יותר ובצורה פחות חלקה בג'וליה 1.0 אם כי יש להם קובצי התקנה רשמיים. התמיכה ב-ARM 32 ביט ירדה ל-tier 3 בגרסאות מאוחרות יותר,[84] אם כי עדיין יש קובצי התקנה לא רשמיים לגרסה 1.5.1.[85] ל-PowerPC 64 ביט יש תמיכה ב-tier 3, משמע "ייתכן שההידור יצליח".

יש פלטפורמות, כמו ראספברי פאי המקורי, להן צריך להדר את ג'וליה מקוד המקור עם דגלים ספציפיים. לחלקם יש בינאריים לא רשמיים שהודרו מראש והוראות כיצד להדר.[86][87] ג'וליה כיום נתמכת ב-Raspberry Pi OS,[88] עם תמיכה טובה יותר בפלטפורמות החדשות יותר בעלות מעבד ARMv7 ומעלה. קרן ראספברי פאי מקדמת כיום את התמיכה בג'וליה.[89]

פלטפורמות ווב[עריכת קוד מקור | עריכה]

ג'וליה עובדת בדפדפנים ובג'אווה סקריפט באמצעות JSExpr.jl.[90] ישנו פרויקט רדום בשם Julia-wasm שמאפשר ריצה של REPL ג'וליה בסביבת WebAssembly.[91] וישנם כלים להידור תוכנות שכתובות בג'וליה ל-WASM.[92]

פלטפורמות מיקרוסופט[עריכת קוד מקור | עריכה]

מערכת ההפעלה חלונות נתמכת בגרסאות 32 ו-64 ביט, מ-Windows 7 ומעלה. ב-Windows 10 גרסת ה-64 ביט נתמכת ברמה גבוהה יותר מגרסת 32 ביט.[93] Windows על מעבדי ARM אינו מוזכר כנתמך.[94]

פלטפורמות של אפל[עריכת קוד מקור | עריכה]

לג'וליה יש תמיכת tier 1 ב-macOS (מחשבי מק מבוססי אינטל), אך לא מוזכרת שום תמיכה במעבדי Apple M1. ג'וליה נחשבת עובדת סביר, אם כי בביצועים פחותים, על מתרגם רוזטה 2 של אפל.[95] עבודה על גרסת ג'וליה מקומית למעבדי M1 (ללא אמולציה) נמצאת בשלבים מתקדמים.

פלטפורמת אנדרואיד[עריכת קוד מקור | עריכה]

מאחר שג'וליה מתהדרת על ARM, בתיאוריה ניתן לכתוב אפליקציות אנדרואיד בעזרת ה-NDK, אך ג'וליה כיום מכוונת לרוץ על אנדרואיד רק בצורה עקיפה, משמע עם chroot של לינוקס,[96] או תחת termux.[97]

פלטפורמות GPU[עריכת קוד מקור | עריכה]

פלטפורמת CUDA של Nvidia נתמכת ב-tier 1, בסיוע חבילות חיצוניות. ישנן גם חבילות נוספות לתמיכה במאיצים אחרים כמו TPU של גוגל[98] ו-GPU של AMD שנתמכים ב-OpenCL לדוגמה. ישנה גם תמיכה ניסיונית ב-ROCm של AMD.[99] דף ההורדות באתר של ג'וליה מספק קובצי התקנה בינאריים וגם קוד מקור לכל הפלטפורמות שנתמכות באופן רשמי.

רישיונות[עריכת קוד מקור | עריכה]

השפה עצמה היא תחת רישיון MIT. ספריות שונות יוצאות תחת רישיונות שונים, כגון GPL,‏ LGPL ו-BSD, כך שהסביבה עליה נשענת השפה מוגדרת כולה תחת רישיון GPL, אם כי ניתן להדר אותה גם ללא החלקים שתחת GPL. ניתן להדר את השפה גם כספריה משותפת, כדי לשלב אותה עם קוד של המשתמש ב-C או בפורטרן, או עם ספריות צד שלישי. ג'וליה מאפשרת שילוב עם ספריות שנכתבו ב-C או פורטרן ללא התאמות ואפילו ללא הידור מחדש - ניתן להתממשק ישירות לספריות האלו אפילו מן הממשק האינטראקטיבי ולנסות אותן עם תגובות מידיות. הפרטים המלאים על רישוי החלקים השונים נמצאים במסמכי הרישוי של ג'וליה.

גרסאות[עריכת קוד מקור | עריכה]

גרסה זמן שחרור הערות
0.3 אוגוסט 2014
0.4 אוקטובר 2015
0.5 אוקטובר 2016
0.6 יוני 2017
0.7 8 באוגוסט 2018 גרסה לבדיקת חבילות ובדיקת עדכון שלהן לגרסה 1.0. כללה שינויים קלים בתחביר, לתחביר שמקובל גם ב-1.x.
1.0 8 באוגוסט 2018 יצאה לאור ביחד עם גרסה 0.7. הגרסה המועמדת ליציאה לאור כג'וליה 1.0 יצאה לאור ב-7 באוגוסט 2018, ויום אחריה יצאה לאור גרסת 1.0 הסופית.
1.1 ינואר 2019 כוללת "מחסנית חריגות".
1.2 אוגוסט 2019 כוללת תמיכה מובנית בדפדפנים.
1.3 דצמבר 2019 כוללת מיקבול מרובה תהליכונים שנשלט מהקוד.
1.4 מאי 2020 כוללת תחביר לעבודה עם מערכים על בסיס 0 ושינוי במודל הזיכרון.
1.5 אוגוסט 2020
1.6 יולי 2021 כוללת הידור מקבילי ושיפורי מהירות משמעותיים

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

חבילות שעבדו בגרסה 1.0.x עובדות גם ב-1.1.x ובגרסאות חדשות יותר, מתוך הבטחה מוצהרת לתאימות קדימה בתחביר. אמנם היו ממשקים לשפות אחרות שנתקלו בבעיה בהקשר של תהליכונים, למשל JavaCall.jl שמהווה ממשק לשפות JVM כמו ג'אווה או סקאלה, או Rcall.jl שמהווה ממשק לשפת R, אך יצרו מעקף לבעיה בגרסה 1.3.

דוגמאות[עריכת קוד מקור | עריכה]

שימוש אינטראקטיבי ב-REPL[עריכת קוד מקור | עריכה]

julia> println("hola mundo")
hola mundo
julia> x = 1
julia> y = 2
julia> if x<y
 println("smaller")
 else
 println("larger")
 end
es menor
julia> (x < y) ? "x is smaller than y" : (x > y) ? "x is larger than y" : "x is equal y"
"x is smaller than y"
julia> comparison(x, y) = println((x < y) ? "x=$x is smaller than y=$y" : (x > y) ? "x is larger than y" : "x is equal to y")
comparison (generic function with 1 method)
julia> comparison(4, 5)
x=4 is smaller than y=5

שימוש ביוניקוד[עריכת קוד מקור | עריכה]

julia> "LᴬTₑX"
"LᴬTₑX"

יצירת קבוצת מנדלברוט[עריכת קוד מקור | עריכה]

function mandel(z)
 c = z
 max = 80
 for n = 1:max
 if abs(z) > 2
 return n-1
 end
 z = z^2 + c
 end
 return max
end

סטטיסטיקות על מערך[עריכת קוד מקור | עריכה]

using LinearAlgebra: tr
using Statistics #importing std, mean etc.

function randmatstat(t)
 n = 5
 v = zeros(t)
 w = zeros(t)
 for i = 1:t
 a = randn(n,n)
 b = randn(n,n)
 c = randn(n,n)
 d = randn(n,n)
 P = [a b c d]
 Q = [a b; c d]
 v[i] = tr((P'*P)^4)
 w[i] = tr((Q'*Q)^4)
 end
 std(v)/mean(v), std(w)/mean(w)
end

ראו גם[עריכת קוד מקור | עריכה]

קישורים חיצוניים[עריכת קוד מקור | עריכה]

ויקישיתוף מדיה וקבצים בנושא ג'וליה בוויקישיתוף

הערות שוליים[עריכת קוד מקור | עריכה]

  1. ^ "Smoothing data with Julia's @generated functions". 5 בנובמבר 2015. נבדק ב-9 בדצמבר 2015. Julia's generated functions are closely related to the multistaged programming (MSP) paradigm popularized by Taha and Sheard, which generalizes the compile time/run time stages of program execution by allowing for multiple stages of delayed code execution. {{cite web}}: (עזרה)
  2. ^ 1 2 "LICENSE.md". GitHub.
  3. ^ "Contributors to JuliaLang/julia". GitHub.
  4. ^ Engheim, Erik (2017-11-17). "Dynamically Typed Languages Are Not What You Think". Medium (באנגלית). נבדק ב-2021-01-27.
  5. ^ "Is julia strongly checked(typed)?". JuliaLang (בAmerican English). 2018-08-07. נבדק ב-2021-01-27.
  6. ^ "Julia". Julia. NumFocus project. נבדק ב-9 בדצמבר 2016. Julia's Base library, largely written in Julia itself, also integrates mature, best-of-breed open source C and Fortran libraries for ... {{cite web}}: (עזרה)
  7. ^ "Non-GPL Julia?", Groups.google.com, נבדק ב-2017-05-31
  8. ^ "Introduce USE_GPL_LIBS Makefile flag to build Julia without GPL libraries". Note that this commit does not remove GPL utilities such as git and busybox that are included in the Julia binary installers on Mac and Windows. It allows building from source with no GPL library dependencies.
  9. ^ 1 2 "Why We Created Julia". Julia website. בפברואר 2012. נבדק ב-7 בפברואר 2013. {{cite web}}: (עזרה)
  10. ^ Gibbs, Mark (9 בינואר 2013). "Pure and Julia are cool languages worth checking out". Network World (column). נבדק ב-7 בפברואר 2013. {{cite web}}: (עזרה)
  11. ^ Green, Todd (10 באוגוסט 2018). "Low-Level Systems Programming in High-Level Julia". אורכב מ-המקור ב-5 בנובמבר 2018. נבדק ב-5 בנובמבר 2018. {{cite web}}: (עזרה)
  12. ^ Moss, Robert (26 ביוני 2015). "Using Julia as a Specification Language for the Next-Generation Airborne Collision Avoidance System" (PDF). ארכיון ארכיון מהמקור מ-1 ביולי 2015. נבדק ב-29 ביוני 2015. Airborne collision avoidance system {{cite web}}: (עזרה)
  13. ^ Bryant, Avi (15 באוקטובר 2012). "Matlab, R, and Julia: Languages for data analysis". O'Reilly Strata. אורכב מ-המקור ב-2014-04-26. {{cite web}}: (עזרה)
  14. ^ Singh, Vicky (23 באוגוסט 2015). "Julia Programming Language – A True Python Alternative". Technotification. {{cite web}}: (עזרה)
  15. ^ Krill, Paul (18 באפריל 2012). "New Julia language seeks to be the C for scientists". InfoWorld. {{cite journal}}: (עזרה)
  16. ^ Finley, Klint (3 בפברואר 2014). "Out in the Open: Man Creates One Programming Language to Rule Them All". Wired. {{cite journal}}: (עזרה)
  17. ^ Fischer, Keno; Nash, Jameson. "Growing a Compiler - Getting to Machine Learning from a General Purpose Compiler". Julia Computing Blog. נבדק ב-11 באפריל 2019. {{cite web}}: (עזרה)
  18. ^ "Creating a sysimage". PackageCompiler Documentation.
  19. ^ FFT זמינה כיום דרך FFTW (זוהי תלות, אחת מרבות, שהוצאה מהספרייה הסטנדרטית לחבילה כי היא תחת רישיון GPL, ולכן לא נכללת בג'וליה 1.0 כברירת מחדל.) "Remove the FFTW bindings from Base by ararslan · Pull Request #21956 · JuliaLang/julia". GitHub (באנגלית). נבדק ב-2018-03-01.
  20. ^ Julia Official Website (באנגלית)
  21. ^ Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman. "Why We Created Julia". JuliaLang.org. נבדק ב-5 ביוני 2017. {{cite web}}: (עזרה)תחזוקה - ציטוט: שימוש בפרמטר authors (link)
  22. ^ Torre, Charles. "Stefan Karpinski and Jeff Bezanson on Julia". Channel 9. MSDN. נבדק ב-4 בדצמבר 2018. {{cite web}}: (עזרה)
  23. ^ "Why We Created Julia". ארכיון ארכיון מהמקור מ-2016-01-18. נבדק ב-2012-04-19.
  24. ^ Julia Computing
  25. ^ "About Us – Julia Computing". juliacomputing.com. נבדק ב-2017-09-12.
  26. ^ Julia: A high-level language for supercomputing, Intel - The Parallel Universe - Issue 29
  27. ^ "Julia Computing Raises $4.6M in Seed Funding". אורכב מ-המקור ב-2019-05-10.
  28. ^ "Julia Computing Awarded $910,000 Grant by Alfred P. Sloan Foundation, Including $160,000 for STEM Diversity". juliacomputing.com. 2017-06-26. נבדק ב-2020-07-28.
  29. ^ "DIFFERENTIATE—Design Intelligence Fostering Formidable Energy Reduction (and) Enabling Novel Totally Impactful Advanced Technology Enhancements" (PDF).
  30. ^ "JuliaCon 2017". juliacon.org. נבדק ב-2017-06-04.
  31. ^ Fisher, Keno. "The Celeste Project". juliacon.org. נבדק ב-24 ביוני 2017. {{cite web}}: (עזרה)
  32. ^ Claster, Andrew (12 בספטמבר 2017). "Julia Joins Petaflop Club". Julia Computing (Press release). Celeste is written entirely in Julia, and the Celeste team loaded an aggregate of 178 terabytes of image data to produce the most accurate catalog of 188 million astronomical objects in just 14.6 minutes [..] a performance improvement of 1,000x in single-threaded execution. {{cite press release}}: (עזרה)
  33. ^ Shah, Viral B. (2017-11-15). "Viral B. Shah on Twitter" (באנגלית). נבדק ב-2019-09-15. @KenoFischer is speaking on Celeste in the @Intel theatre at @Supercomputing. 0.65M cores, 56 TB of data, Cori - world's 6th largest supercomputer.
  34. ^ "Julia language co-creators win James H. Wilkinson Prize for Numerical Software". MIT News. נבדק ב-2019-01-22.
  35. ^ "Alan Edelman of MIT Recognized with Prestigious 2019 IEEE Computer Society Sidney Fernbach Award | IEEE Computer Society" (Press release) (בAmerican English). 1 באוקטובר 2019. נבדק ב-2019-10-09. {{cite press release}}: (עזרה)
  36. ^ 1 2 "Julia Computing and NVIDIA Bring Julia GPU Computing to Arm". juliacomputing.com. 2019-12-03. נבדק ב-2019-12-03.
  37. ^ Patel, Chintan (2019-11-19). "NVIDIA Expands Support for Arm with HPC, AI, Visualization Containers on NGC | NVIDIA Blog". The Official NVIDIA Blog (בAmerican English). נבדק ב-2019-12-03.
  38. ^ Circuitscape/Circuitscape.jl, Circuitscape, 2020-02-25, נבדק ב-2020-05-26
  39. ^ "Conservation through Coding: 5 Questions with Viral Shah | Science Mission Directorate". science.nasa.gov. נבדק ב-2020-05-26.
  40. ^ JuliaSpace/SatelliteToolbox.jl, JuliaSpace, 2020-05-20, נבדק ב-2020-05-26
  41. ^ "JuliaCon 2014". juliacon.org. נבדק ב-2021-06-20.
  42. ^ "JuliaCon 2016 at MIT". mit.edu. נבדק ב-2021-06-20.
  43. ^ "JuliaCon 2019 at UMB". technical.ly. נבדק ב-2021-06-20.
  44. ^ "JuliaCon 2020 wrap up". julialang.org. נבדק ב-2021-06-20.
  45. ^ "Julia Community". julialang.org. נבדק ב-2021-07-05.
  46. ^ "Julia Twitter". twitter.com. נבדק ב-2021-07-05.
  47. ^ "Julia Language on LinkedIn". Linkedin.com. נבדק ב-2021-07-05.
  48. ^ "Julia Language on Facebook". Facebook.com. נבדק ב-2021-07-05.
  49. ^ "Julia Language on Slack". julialang.org. נבדק ב-2021-07-05.
  50. ^ "Julia Language on Zulip". zulipchat.com. נבדק ב-2021-07-05.
  51. ^ "Julia Language on Discord". discord.com. נבדק ב-2021-07-05.
  52. ^ "Julia Language on Discourse". julialang.org. נבדק ב-2021-07-05.
  53. ^ "Julia Language on Stack Overflow". stackoverflow.com. נבדק ב-2021-07-05.
  54. ^ "Julia Language on YouTube". youtube.com. נבדק ב-2021-07-05.
  55. ^ "Julia Language other Channels". julialang.org. נבדק ב-2021-07-05.
  56. ^ "Alex Arsland joins the Julia Language as Community Manager". julialang.org. נבדק ב-2021-07-05.
  57. ^ "Logan Kilpatrick joins the Julia Language as Community Manager". julialang.org. נבדק ב-2021-07-05.
  58. ^ "Julia: NumFOCUS Sponsored Project since 2014". numfocus.org. נבדק ב-2020-09-29.
  59. ^ "The Julia Language". julialang.org. נבדק ב-2019-09-22.
  60. ^ Cimpanu, Catalin. "Mozilla is funding a way to support Julia in Firefox". ZDNet (באנגלית). נבדק ב-2019-09-22.
  61. ^ "Julia in Iodide". alpha.iodide.io. נבדק ב-2019-09-22.
  62. ^ "Language plugins - Iodide Documentation". iodide-project.github.io. נבדק ב-2019-09-22.
  63. ^ "Mozilla Research Grants 2019H1". Mozilla (באנגלית). נבדק ב-2019-09-22. running language interpreters in WebAssembly. To further increase access to leading data science tools, we’re looking for someone to port R or Julia to WebAssembly and to attempt to provide a level 3 language plugin for Iodide: automatic conversion of data basic types between R/Julia and Javascript, and the ability to share class instances between R/Julia and Javascript.
  64. ^ "Literate scientific computing and communication for the web: iodide-project/iodide". iodide. 2019-09-20. נבדק ב-2019-09-22. We envision a future workflow that allows you to do your data munging in Python, fit a quick model in R or JAGS, solve some differential equations in Julia, and then display your results with a live interactive d3+JavaScript visualization ... and all that within within a single, portable, sharable, and hackable file.
  65. ^ "Sponsor the Julia Language". github.com. נבדק ב-2021-06-05.
  66. ^ "GitHub - JuliaLang/PackageCompiler.jl: Compile your Julia Package". The Julia Language. 2019-02-14. נבדק ב-2019-02-15.
  67. ^ "The Julia REPL · The Julia Language". docs.julialang.org. נבדק ב-2019-09-22.
  68. ^ "Introducing Julia/The REPL - Wikibooks, open books for an open world". en.wikibooks.org. נבדק ב-2019-09-22.
  69. ^ "Getting Started · The Julia Language". docs.julialang.org (באנגלית). נבדק ב-2018-08-15.
  70. ^ ראו גם: docs.julialang.org/en/v1/manual/strings/ לאינטרפולציה של מחרוזות, וראו דוגמת string(greet, ", ", whom, ".\n") לדרכים מומלצות לחיבור מחרוזות. לג'וליה יש פונקציות println ו-print, אך גם את המאקרו @printf (שאינו פונקציה!) כדי לקצר את זמן הריצה של עיצוב המחרוזת (בניגוד לפונקציה המקבילה ב-C).
  71. ^ "Julia Documentation". JuliaLang.org. נבדק ב-18 בנובמבר 2014. {{cite web}}: (עזרה)
  72. ^ "Learn Julia in Y Minutes". Learnxinyminutes.com. נבדק ב-2017-05-31.
  73. ^ https://www.youtube.com/watch?v=JDrhn0-r9Eg&t=379s
  74. ^ "Julia and Spark, Better Together". juliacomputing.com. 2020-06-02. נבדק ב-2020-07-14.
  75. ^ "Unicode 13 support by stevengj · Pull Request #179 · JuliaStrings/utf8proc". GitHub (באנגלית). נבדק ב-2020-03-29.
  76. ^ "JuliaRegistries / General". נבדק ב-2020-04-30.
  77. ^ "Pkg.jl - Artifacts". נבדק ב-2020-06-04.
  78. ^ "Pkg.jl - Registries". נבדק ב-2020-04-30.
  79. ^ Bezanson, Jeff (6 ביוני 2019). "JeffBezanson/femtolisp". GitHub. נבדק ב-16 ביוני 2019. {{cite web}}: (עזרה)
  80. ^ "Julia: A Fast Dynamic Language for Technical Computing" (PDF). 2012.
  81. ^ "How To Make Python Run As Fast As Julia". 2015.
  82. ^ "Basic Comparison of Python, Julia, R, Matlab and IDL". 2015. אורכב מ-המקור ב-2017-11-27.
  83. ^ "Julia Downloads". julialang.org. נבדק ב-2019-05-17.
  84. ^ "julia/arm.md". The Julia Language. 2019-11-29. נבדק ב-2019-11-29.
  85. ^ "Bring Julia code to embedded hardware (ARM)". JuliaLang (באנגלית). 2019-01-23. נבדק ב-2021-03-30.
  86. ^ 262588213843476. "Build Julia for RaspberryPi Zero". Gist (באנגלית). נבדק ב-2020-08-14.{{cite web}}: תחזוקה - ציטוט: numeric names: authors list (link)
  87. ^ "JuliaBerry: Julia on the Raspberry Pi". juliaberry.github.io. נבדק ב-2020-08-14.
  88. ^ "Julia available in Raspbian on the Raspberry Pi". Julia works on all the Pi variants, we recommend using the Pi 3.
  89. ^ "Julia language for Raspberry Pi". Raspberry Pi Foundation.
  90. ^ "Translate Julia to JavaScript". JuliaGizmos. 2019-07-07. נבדק ב-2019-07-25.
  91. ^ "julia-wasm". github.com (באנגלית). נבדק ב-2021-08-04.
  92. ^ "WebAssembly.jl". github.com (באנגלית). נבדק ב-2021-08-04.
  93. ^ "Using Julia on Android?". Julialang.org (באנגלית). נבדק ב-2021-08-04.
  94. ^ "Darwin/ARM64 tracking issue · Issue #36617 · JuliaLang/julia". GitHub (באנגלית). נבדק ב-2020-12-08.
  95. ^ Carlton, Sam (2020-12-08), ThatGuySam/doesitarm, נבדק ב-2020-12-08
  96. ^ "Using Julia on Android?". JuliaLang (בAmerican English). 2019-09-27. נבדק ב-2019-10-02.
  97. ^ "Currently supported platforms". Julialang.org (באנגלית). נבדק ב-2021-08-04.
  98. ^ "Julia on TPUs". JuliaTPU. 2019-11-26. נבדק ב-2019-11-29.
  99. ^ "AMD ROCm · JuliaGPU". juliagpu.org. נבדק ב-2020-04-20.