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

ג'וליה (באנגלית: Julia) היא שפת תכנות עילית מהירה ודינמית, לתכנות כללי, טכני ומדעי. השפה מצטיינת במיוחד בתכנות המדעי ובביצוע מהיר של אנליזות נומריות, אולם מתאימה גם לכתיבה של תוכנות לקוח ושרת באפליקציות רשת, לתכנות מערכות Low level<ref name="LowLevelSystemsProgrammingInJulia"></ref>, לשימוש כשפת מִפרט לפני מימוש<ref name="spec"></ref> ולשאר שימושים כלליים.<ref></ref><ref></ref><ref name="infoworld"></ref><ref></ref>

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

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

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

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

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

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

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

===JuliaHub===
העניין ההולך וגובר של חברות שונות בג'וליה הביא ביולי 2015 להקמתה של חברת Julia Computing<ref>[https://juliacomputing.com/ Julia Computing]</ref> בידי ויראל ב. שאה, דיפאק וינצ'הי, אלן אדלמן, ג'ף בזאנסון, סטפן קרפינסקי וקינו פישר.<ref></ref> החברה שינתה את שמה ל־JuliaHub בנובמבר 2022. JuliaHub עוסקת במתן שירותים בתשלום בתחומי התמיכה, ההכשרה והייעוץ, בהפצת סביבת JuliaPRO שמותאמת לתכנות מדעי, ובאינטגרציה עם טכנולוגיות ענן.<ref>[https://software.intel.com/sites/default/files/managed/8a/d2/parallel-universe-issue-29.PDF Julia: A high-level language for supercomputing], Intel - The Parallel Universe - Issue 29</ref>

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

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

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

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

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

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

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

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

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

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

ברית מודל האקלים משתמשת בג'וליה על שרתים מבוססי ARM.<ref></ref> for climate change modeling<ref name="Julia_Nvidia"></ref>

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

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

{| class="wikitable"
|-
! rowspan="2" | שנה
! colspan="3" | נרשמים
! colspan="3" | משתתפים בפועל (בכנסי האונליין: מספר צופים בהרצאות)
! colspan="3" | מספר הרצאות
! rowspan="2" | הערות
|-
! מס'
! ±
! %±
! מס'
! ±
! %±
! מס'
! ±
! %±
|-
! 2014
| -
| -
| -
| -
| -
| -
| 22
| -
| -
| כנס פיזי באוניברסיטת שיקגו, ארצות הברית.
|-
! 2015
| -
| -
| -
| -
| -
| -
| 62
|40
|182%
| כנס פיזי ב־MIT, ארצות הברית.
|-
! 2016
| 250<ref></ref>
| -
| -
| 250
| -
| -
| 65
|3
|5%
| כנס פיזי ב־MIT, ארצות הברית.
|-
! 2017
| +300<ref></ref>
|50
|20%
| +300
|50
|20%
| 85
|20
|24%
| כנס פיזי בברקלי, ארצות הברית.
|-
! 2018
| 350<ref></ref>
|50
|17%
| 350
|50
|17%
| 97
|12
|14%
| כנס פיזי בלונדון, אנגליה.
|-
! 2019
| +370<ref></ref>
|20
|6%
| +370
|20
|6%
| 117
|20
|20%
| כנס פיזי בבולטימור, מרילנד, ארצות הברית.
|-
! 2020
| 10,000
|9630
|2,603%
| 28,900
|28,530
|7,711%
| 162
|45
|34%
| כנס אונליין.
|-
! 2021<ref></ref>
| 20,000
|10,000
|100%
| 43,000
|14,100
|49%
| 314
|152
|93%
| כנס אונליין.
|-
! 2022<ref></ref>
| 7,986
|12,014
|60%
| 51,000
|8,000
|19%
| 229
|85
|27%
| כנס אונליין. לראשונה ההרצאות התקיימו במספר שפות.
|-
! 2023
| 565
| 195 ביחס לכנס הפיזי האחרון ב־2019.<br>לא היה רישום להשתתפות אונליין.
| 52% ביחס לכנס הפיזי האחרון ב־2019.<br>לא היה רישום להשתתפות אונליין.
| 565 פיזית,<br>29,000 אונליין
| 195 ביחס לכנס הפיזי האחרון ב־2019.<br> 22,000 אונליין ביחס לכנס אונליין ב־2022.
| 52% פיזית<br> 43% אונליין ביחס לכנס אונליין ב־2022.
| 354
| 125
| 54%
| כנס פיזי ב־MIT במסצ'וסטס, ארצות הברית. התקיים ביחד עם כנסי JuMP-dev, SciMLCon והכנס לכבוד יום ההולדת של אלן אדלמן. לא דווחו סטטיסטיקות לאחר הכנס.
|-
! 2024<ref></ref>
| 600+
| 35
| 6%
| 600+
| 35
| 6%
| 330+
| 24
| 7%
| כנס פיזי באיידנהובן, הולנד. בשיתוף עם כנס PyData.
|}

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

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

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

טים הולי עבד על שיפור המהירות של ג'וליה 1.9 ב"מעבדת הולי" באוניברסיטת וושינגטון בסנט לואיס, במימון .<ref name=j19></ref>

מעבר לעבודתו של הולי, גרסה 1.9 יצאה גם בתמיכה של נאס"א, של הקרן הסביבתית של אאודי ושל יוזמות פילנתרופיות של אריק ו, פול אלן ומשפחתו, ו.<ref name=j19 />

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

{| class="wikitable"
|-
! שפה !! מערכת טיפוסים !! פונקציות גנריות !! טיפוסים פרמטריים
|-
| ג'וליה || דינמית || ברירת מחדל || כן
|-
| Common Lisp || דינמית || אפשרי || כן (אבל בלי Dispatch)
|-
| Dylan || דינמית || ברירת מחדל || חלקית (ללא Dispatch)
|-
| Fortress || סטטית || ברירת מחדל || כן
|}

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

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

==חישוב מקבילי==
ג'וליה אינה כופה על המשתמש סגנון ספציפי לחישוב מקבילי, ובמקום זאת מספקת אבני בניין מרכזיות לחישוב מקבילי. אלו נותנות את הגמישות הנדרשת לשימוש בסגנונות השונים של מיקבול, כמו גם יכולת לייצר סגנונות חדשים. הדוגמה הבאה מראה לולאת for מקבילית שמתנקזת לבסוף ל-reduction:
<syntaxhighlight lang="julia">
julia> using Distributed
julia> nheads = @distributed (+) for i = 1:200000000
 Int(rand(Bool))
 end
99998199
</syntaxhighlight>

==אינטראקטיביות==
ההפצה הרשמית של ג'וליה כוללת לולאת קריאה-פיענוח-הדפסה בשורת פקודה אינטראקטיבית (REPL),<ref></ref> עם היסטוריה, השלמת טאבים ומצבים ייעודיים לעזרה ולפקודות מעטפת,<ref></ref> כך שניתן יהיה להשתמש בה בשביל ניסויים בשביל לבדוק קוד במהירות.<ref></ref> המקטע הבא מציג סשן דוגמה המבצע חיבור מחרוזות<ref>ראו גם: לאינטרפולציה של מחרוזות, וראו דוגמת <code>string(greet, ", ", whom, ".\n")</code> לדרכים מומלצות לחיבור מחרוזות. לג'וליה יש פונקציות println ו-print, אך גם את המאקרו @printf (שאינו פונקציה!) כדי לקצר את זמן הריצה של עיצוב המחרוזת (בניגוד לפונקציה המקבילה ב-C).</ref>:
<syntaxhighlight lang="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!
</syntaxhighlight>

כאשר מוסיפים לפני פקודות <code>;</code> למצב מעטפת או <code>?</code> למצב עזרה, ה-REPL נותן למשתמש גישה למצבים השונים, וההיסטוריה של הפקודות נשמרת גם בין שימושים.<ref></ref> ניתן לבדוק קוד בצורה אינטראקטיבית, וניתן לשמור אותו ולהריץ מתוך קובץ עם סיומת <code>.jl</code> ואז להריץ משורת הפקודה בעזרת:<ref name="Learn Julia in Y"></ref>

<syntaxhighlight lang="console">
 $ julia <filename>
</syntaxhighlight>

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

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

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

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

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

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

==מימוש==
הגרעין של ג'וליה ממומש בג'וליה וב-C, ביחד עם C++ לתלויות של LLVM. ה-Parsing והנמכת הקוד (למבנה קרוב יותר לקוד מכונה) ממומשים ב-FemtoLisp, שהוא ניב של Scheme.<ref name="JeffBezanson 2019"></ref> פרויקט תשתית המהדר של LLVM משמשת בתור ה-Back end שיוצר קוד מכונה אופטימלי ב-32 או 64 ביט, על פי הפלטפורמה בה הקוד רץ. מלבד כמה יוצאי דופן (כמו PCRE), הספרייה הסטנדרטית ממומשת בג'וליה. התכונה הבולטת ביותר של המימוש של ג'וליה היא המהירות, כך שקוד בג'וליה לרוב ירוץ לכל הפחות בחצי המהירות של קוד אופטימלי מקביל ב-C, ובמהירות גבוהה בכמה סדרי גודל מאלו של פייתון או R.<ref name="Julia-TR"></ref><ref></ref><ref></ref>

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

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

====פלטפורמות ווב====
ג'וליה עובדת בדפדפנים ובג'אווה סקריפט באמצעות JSExpr.jl.<ref name="JSExpr"></ref> ישנו פרויקט רדום בשם Julia-wasm שמאפשר ריצה של REPL ג'וליה בסביבת WebAssembly.<ref></ref> וישנם כלים להידור תוכנות שכתובות בג'וליה ל-WASM.<ref></ref>

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

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

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

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

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

==גרסאות==
{| class="wikitable"
|-
! גרסה
! זמן שחרור
! הערות
|-
| 0.3
| אוגוסט 2014
|
|-
| 0.4
| אוקטובר 2015
|
|-
| 0.5
| אוקטובר 2016
|
|-
| 0.6
| יוני 2017
|
|-
| 0.7
| 8 באוגוסט 2018
| גרסה לבדיקת חבילות ובדיקת עדכון שלהן לגרסה 1.0. כללה שינויים קלים בתחביר, לתחביר שמקובל גם ב-<span dir="ltr">1.x</span>.
|-
| 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
| כוללת הידור מקבילי ושיפורי מהירות משמעותיים.<ref></ref>
|-
| 1.7
| נובמבר 2021
| חזרה ל.<ref></ref> כוללת מחולל מהיר יותר של מספרים רנדומליים, תיקונו אבטחה.<ref></ref>
|-
| 1.8
| ספטמבר 2022
| כוללת שיפורים לשחרור תוכנות ג'וליה ללא קוד מקור, האצת קומפיילר (לעיתים ברמה של 25% שיפור), ושיפור של ה־Inlining שמאפשר להגדיר Inlining לפונקציה בזמן קריאה ולא רק בעת הגדרת הפונקציה.<ref></ref>
|-
| 1.9
| מאי 2023
| יכולת קימפול מלא לקוד native, והאצת קדם-קימפול שמאיצה ריצה של חבילות.
|-
| 1.10
| דצמבר 2023
| שיפור זמן טעינת חבילות, parser חדש, הודעות שגיאה משופרות.
|}

הגרסה המוקדמת ביותר שנתמכת עדיין היא <span dir="ltr">1.6.7</span>, עם תמיכה לטווח ארוך של שנה לפחות. תיקוני באגים משוחררים על בסיס חודשי.

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

== דוגמאות ==
=== שימוש אינטראקטיבי ב-REPL ===
<syntaxhighlight lang="julia">
julia> println("hola mundo")
hola mundo
</syntaxhighlight><syntaxhighlight lang="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
</syntaxhighlight>

=== שימוש ביוניקוד ===
<syntaxhighlight lang="julia">
julia> "LᴬTₑX"
"LᴬTₑX"
</syntaxhighlight>

=== יצירת קבוצת מנדלברוט ===
<syntaxhighlight lang="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
</syntaxhighlight>

=== סטטיסטיקות על מערך ===
<syntaxhighlight lang="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
</syntaxhighlight>

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

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

* 

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

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