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

**ג'וליה** (באנגלית: **Julia**) היא שפת תכנות עילית מהירה ודינמית, לתכנות כללי, טכני ומדעי. השפה מצטיינת במיוחד בתכנות המדעי ובביצוע מהיר של אנליזות נומריות, אולם מתאימה גם לכתיבה של תוכנות לקוח ושרת באפליקציות רשת, לתכנות מערכות Low level, לשימוש כשפת מִפרט לפני מימוש ולשאר שימושים כלליים.

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

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

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

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

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

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

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

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

ביולי 2021 הודיעה Julia Computing שגייסה 24 מיליון דולר בסבב A שהובילה חברת Dorilton Ventures, שבבעלותה גם צוות פורמולה 1 וויליאמס רייסינג שאף הוא חבר ל־Julia Computing. לדבריו של המנהל המסחרי של וויליאמס: "ההשקעה בחברות שבונות טכנולוגיית ענן עילית מהווה מיקוד אסטרטגי לדורילטון, והפלטפורמה המגוונת של ג'וליה, עם יכולותיה המהפכניות בסימולציה ומידול רלוונטית מאוד לעסק שלנו. אנו מצפים להטמיע את Julia COmputing בספורט המתקדם בעולם מבחינה טכנולוגית."

ביוני 2023 גייסה החברה, תחת שמה החדש "JuliaHub", השקעה אסטרטגית חדשה של 13 מיליון דולר בהובלת AE Industrial Partners HorizonX ("AEI HorizonX"), פלטפורמת הון סיכון שהוקמה בהשתתפות חברת בואינג ומשתמשת בעצמה בג'וליה.

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

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

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

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

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

CERN משתמשת בג'וליה כדי לנתח מידע שמגיע ממאיץ LHC (ניסוי LHCb)

נכון ל־2022 ג'וליה התקבלה באוניברסיטאות כגון MIT, אוניברסיטת סטנפורד, UC Berkeley ואוניברסיטת קייפ טאון. השפה נמצאת בשימוש גם בחברות כגון אמאזון, IBM, מחקר הבינה המלאכותית של ג'יי פי מורגן וASML אחזקות. השפה בשימוש בכל מעבדות האנרגיה הלאומי בארצות הברית.

ברית מודל האקלים משתמשת בג'וליה על שרתים מבוססי ARM. for climate change modeling

ב-2023 אמאזון יצרה תמיכה בג'וליה לצורכי מחשוב קוואנטי ולמידת מכונה דרך Amazon SageMaker

### JuliaCon
מאז 2014 מקיימת הקהילה של ג'וליה כנס שנתי המכוון למפתחים ומשתמשים. Juliacon הראשון התקיים בשיקגו, ומאז הכנס מתקיים מדי שנה. הכנס התארח במספר מקומות לאורך קיומו, בהם MIT ואוניברסיטת מרילנד בבאלטימור, ומספר המשתתפים בו עלה מעשרות בודדות בתחילתו לעשרות אלפים משתתפים בפועל בתחילת העשור השני של המאה ה-21..

### קהילת ג'וליה
קהילת ג'וליה נוכחת במספר פלטפורמות: טוויטר, לינקדאין, פייסבוק, Slack, Zulip, דיסקורד, Discourse, Stack Overflow, יוטיוב, ועוד. מאז מאי 2017 ועד דצמבר 2023, הועסק מנהל קהילה לשפת ג'וליה. בתחילה היה זה אלכס ארסלנד ששימש בתפקיד עד סוף 2019 ומאז ועד דצמבר 2023 שימש בתפקיד לוגן קילפטריק. לא דווח על מנהל קהילה חדש מאז.

### מימון
שפת ג'וליה הפכה לפרויקט ממומן על ידי המלכ"ר NumFOCUS (שמממן גם פרויקטים כמו NumPy, pandas ו-Ipython) ב-2014, כדי להבטיח את השרידות של הפרויקט לטווח ארוך. באפריל 2024 התמנה לוגן קילפטריק, לשעבר מנהל קהילת ג'וליה, לנשיא NumFocus.

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

טים הולי עבד על שיפור המהירות של ג'וליה 1.9 ב"מעבדת הולי" באוניברסיטת וושינגטון בסנט לואיס, במימון .

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

## מאפיינים
אלו המאפיינים העיקריים של השפה:
* 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 על טיפוסים פרמטריים, אך בניגוד לג'וליה הטיפוסים שלה סטטיים ולא דינמיים, ויש לה שלבים נפרדים לקומפילציה ולהרצה. הטבלה הבאה מספקת השוואה בין השפות:

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

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

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

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


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

```jlcon
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 נותן למשתמש גישה למצבים השונים, וההיסטוריה של הפקודות נשמרת גם בין שימושים. ניתן לבדוק קוד בצורה אינטראקטיבית, וניתן לשמור אותו ולהריץ מתוך קובץ עם סיומת `.jl` ואז להריץ משורת הפקודה בעזרת:


```console
$ julia <filename>
```


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

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

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

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

## קובצי הרצה מקומפלים
ניתן לקמפל תוכנות ג'וליה לקבצים בינאריים בעזרת PackageCompiler.jl. ניתן ליצור גם קובצי הרצה קטנים יותר אם משתמשים בתת-סט סטטי של השפה דרך StaticCompiler.jl, שאינו תומך ב־dispatch בזמן ריצה או ב־garbage collection, מאחר ששני אלו דורשים את קובצי ההרצה של ג'וליה עצמה.

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

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

### פלטפורמות נוכחיות ועתידיות
מאחר שג'וליה משתמשת ב-JIT, היא מייצרת קבצים בינאריים ישירות, עוד לפני שהקוד רץ, ולא משתמשת ב-Bytecode. לג'וליה יש ארבע רמות תמיכה, מ-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 בגרסאות מאוחרות יותר, אם כי עדיין יש קובצי התקנה לא רשמיים לגרסה 1.5.1. ל-PowerPC 64 ביט יש תמיכה ב-tier 3, משמע "ייתכן שההידור יצליח".

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

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

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

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

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

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

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

## גרסאות

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

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

## דוגמאות
### שימוש אינטראקטיבי ב-REPL

```julia
julia> println("hola mundo")
hola mundo
```

```julia
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
julia> "LᴬTₑX"
"LᴬTₑX"
```


### יצירת [[קבוצת מנדלברוט]]

```julia
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
```


### סטטיסטיקות על מערך

```julia
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
```


## ראו גם
* MATLAB
* GNU Octave
* שפת R
* Mathematica
* SageMath

## קישורים חיצוניים

* 

## הערות שוליים

קטגוריה:שפות תכנות