added java, added abstract

code/escape/EscapeJava.java

@@ -1,13 +1,30 @@
+import java.util.Arrays;
+
 public class EscapeJava {
 
+    public static final int TIMES = 100;
+    public static final int SAMPLES = 100;
+
+
     public static void main(String[] args) {
 
-        for (int i = 0; i < 100; i++) {
+        double[] collectedTimes = new double[TIMES];
 
+        for (int i = 0; i < TIMES; i++) {
+            long[] samples = new long[SAMPLES];
+            for (int j = 0; j < SAMPLES; j++) {
+                long start = System.nanoTime();
+
+                int[][] a = calculate(generateGrid(i), i);
+
+                long end = System.nanoTime();
+
+                long elapsed = end - start;
+                samples[j] = elapsed;
             }
-        var a = calculate(generateGrid(100), 100);
+            collectedTimes[i] = Arrays.stream(samples).mapToDouble(v -> v/10e9).min().orElse(-1);
-
+        }
-        System.out.println(a);
+        Arrays.stream(collectedTimes).forEach(System.out::print);
     }
 
     public static int escape(double cx, double cy, int maximum, double bounds) {

code/escape/escape_r.r

@@ -1 +0,0 @@
-print("Hello World!")

code/escape/plotting.jl

@@ -5,7 +5,8 @@ julia = [0.0, 1.0e-7, 1.8e-7, 7.7e-7, 8.7e-7, 1.07e-6, 1.15e-6, 1.92e-6, 2.07e-6
 4.336e-5, 4.725e-5, 4.867e-5, 5.202e-5, 5.382e-5, 5.779e-5, 5.915e-5, 6.279e-5, 6.515e-5, 6.954e-5, 7.14e-5, 7.586e-5, 7.852e-5, 8.25e-5, 8.412e-5, 8.887e-5, 9.101e-5, 9.651e-5, 9.814e-5, 0.00010355, 0.00010568, 0.00011116, 0.00011269, 0.00012852, 0.00012288, 0.0001267, 0.00013474, 0.00014044, 0.00014456, 0.00014922, 0.00014065, 0.00014837, 0.00015679, 0.00016271, 0.00017158, 0.00017285, 0.00017419, 0.00018128, 0.0001911, 0.0001933, 0.00019551, 0.000201, 0.00020375, 0.00021234, 0.00021678, 0.0002227, 0.00022203, 0.00023396, 0.00023608, 0.00024611, 0.0002485, 0.00025686, 0.00025998, 0.00028007, 0.00027173, 0.00029188, 0.00029561, 0.0003034, 
 0.00029744, 0.00031477, 0.00032206, 0.00032118, 0.00033668, 0.00034382, 0.00033966, 0.00035046]
 python = [0.0,0.00031380000291392207,0.00025610000011511147,0.00031159998616203666,0.00046729997848160565,0.0006291999889072031,0.0007088000129442662,0.0009128999954555184,0.0011289999820291996,0.0013609000016003847,0.001609999977517873,0.0019226000003982335,0.002330099989194423,0.002574399986770004,0.003032499982509762,0.0034342000144533813,0.0038216999964788556,0.004292600002372637,0.004810100013855845,0.005347700003767386,0.00572350001311861,0.0059822000039275736,0.006690000009257346,0.008154400013154373,0.007896700000856072,0.008509200008120388,0.009380699979374185,0.011195500002941117,0.010733599978266284,0.011301899998215958,0.012100699997972697,0.012966299982508644,0.013867000001482666,0.014945900009479374,0.015346600004704669,0.0171083000022918,0.017600999999558553,0.01917200000025332,0.019611700001405552,0.020756400015670806,0.02259920001961291,0.022717799991369247,0.024586399988038465,0.025809999991906807,0.027109600021503866,0.0284422000113409,0.029261999996379018,0.03057730000000447,0.03182669999659993,0.03341880001244135,0.0346443000016734,0.0363655999826733,0.03682919999118894,0.03883169998880476,0.04012370001873933,0.04190379998181015,0.04300249999505468,0.045164600014686584,0.04605689999880269,0.048204599996097386,0.04926480000722222,0.05131660000188276,0.05256020001252182,0.054735399986384436,0.05606679999618791,0.05820769999991171,0.05975050001870841,0.06165849999524653,0.06384149999939837,0.0649013000074774,0.06690839998191223,0.06886699999449775,0.07080449999193661,0.07281830001738854,0.07495880001806654,0.07750579999992624,0.07883770001353696,0.08088160000625066,0.0831389999948442,0.0849789000058081,0.08767300000181422,0.08954230000381358,0.09114279999630526,0.09454550000373274,0.0954963999975007,0.09848089999286458,0.1000732000102289,0.10207809999701567,0.10474749997956678,0.10740999999688938,0.11033900000620633,0.11297870002454147,0.11501249999855645,0.11821519999648444,0.11931799998274073,0.12164580001262948,0.12419120001140982,0.1279017000051681,0.1299593999865465,0.13209350002580322]
+java = [2.99E-8, 6.99E-8, 1.899E-7, 1.601E-7, 1.399E-7, 1.799E-7, 1.699E-7, 2.101E-7, 3.0E-7, 2.599E-7, 4.0E-7, 4.499E-7, 5.299E-7, 5.899E-7, 6.4E-7, 6.9E-7, 7.899E-7, 8.9E-7, 9.8E-7, 8.499E-7, 1.0E-6, 1.0899E-6, 1.13E-6, 1.26E-6, 1.27E-6, 1.28E-6, 1.4199E-6, 1.47E-6, 1.67E-6, 1.79E-6, 1.8601E-6, 2.0799E-6, 2.62E-6, 2.6699E-6, 2.8E-6, 2.97E-6, 2.22E-6, 2.35E-6, 2.39E-6, 2.5499E-6, 2.7899E-6, 2.79E-6, 2.96E-6, 3.06E-6, 4.69E-6, 4.89E-6, 5.01E-6, 5.33E-6, 5.43E-6, 5.5899E-6, 5.8199E-6, 6.4099E-6, 6.46E-6, 6.73E-6, 4.69E-6, 4.98E-6, 5.1201E-6, 6.0901E-6, 5.3801E-6, 5.66E-6, 5.81E-6, 6.0099E-6, 6.2E-6, 6.45E-6, 6.74E-6, 6.95E-6, 7.1999E-6, 7.3701E-6, 7.4401E-6, 7.81E-6, 7.9299E-6, 8.18E-6, 8.48E-6, 8.5899E-6, 8.84E-6, 9.02E-6, 9.26E-6, 9.51E-6, 9.72E-6, 1.004E-5, 1.036E-5, 1.048E-5, 1.055E-5, 1.085E-5, 1.12801E-5, 1.137E-5, 1.36101E-5, 1.21901E-5, 1.235E-5, 1.264E-5, 1.27E-5, 1.289E-5, 1.316E-5, 1.354E-5, 1.369E-5, 1.406E-5, 1.45499E-5, 1.45999E-5, 1.522E-5, 1.51999E-5]
 
-plot(2:100, [julia[2:100] python[2:100]], label=["Julia" "Python"], xlabel="Rastergröße n", ylabel="Zeit in Sekunden", leg=:topleft, yaxis=:log10, ylims=(10e-9, 1))
+plot(2:100, [julia[2:100] python[2:100] java[2:100]], label=["Julia" "Python" "Java"], xlabel="Rastergröße n", ylabel="Zeit in Sekunden", leg=:topleft, yaxis=:log10, ylims=(10e-9, 1))
 
-savefig("mandelbrot_time.png")
+savefig("./images/mandelbrot_time_log.png")

seminararbeit.tex

@@ -37,7 +37,8 @@
 
 % Kurze Zusammenfassung des Dokuments
 \begin{abstract}
-Am Ende einfügen
+In dieser Arbeit wird die Programmiersprache Julia bzgl. der Eignung für Visualisierungen innerhalb der fraktalen Geometrie untersucht. Betrachtet werden die Kriterien Performanz, Nachhaltigkeit, Parallelisierbarkeit, Verfügbarkeit von Softwarepaketen und Entwicklungsumgebungen.
+Das Ergebnis zeigt, dass Julia einen Kompromiss als Skriptsprache mit der Performanz bildet. Der Einsatz von Julia in einem ausgeweiteten Rahmen, lässt sich mithilfe der gegebenen Parallelisierung beschleunigen und nachhaltig gestalten. Das Julia-Ecosystem bietet aktuell die ausreichenden Mittel um Fraktale Kurven, Fraktale mittels Rastergrafiken darzustellen oder diese in 3-dimensionaler Form betrachten zu können. Die Erstellung eigener Visualisierungen gestaltet sich durch eine eingeschränkte Wahl von Entwicklungsumgebungen und einer hohen Kompilierzeit meist als langwieriger Prozess.
 \end{abstract}
 
 % Inhaltsverzeichnis erzeugen
@@ -92,7 +93,7 @@ Am Ende jedes Abschnitts beurteilen wir, wie gut das jeweilig genannte Kriterium
 
 Für die Gestaltung interaktiver Software und der Erstellung von Bildern bzw. von Animationen bezüglich Fraktalen wird ein Anspruch auf eine schnelle Verarbeitung der Eingaben gesetzt. Besonders für Programme mit denen in Echtzeit verschiedene Formen von Fraktalen erkundet werden können ist eine gute Performanz von hoher Relevanz.
 Da viele Programmiersprachen heutzutage alle notwendigen Funktionalität zur Lösungen unterschiedlichen Problemtypen bereitstellen, spielt die Effizienz eine höhere Rolle innerhalb der Auswahl der Sprache, als im Vergleich zur Umsetzbarkeit \autocite{januszekComparativeAnalysisEfficiency2018}\\
-In folgendem Abschnitt werden Performanz-Tests in den Programmiersprachen Julia 1.10.2, Python 3.12.2 und Java durchgeführt. Die verwendete \ac{CPU} ist ein AMD Ryzen 5 3600 unter Windows 10 mit 16GB verfügbaren Arbeitsspeicher. Der zu testende Code wird aus Sicht eines Einsteigers der jeweiligen Programmiersprache geschrieben. Der Code macht keinen Gebrauch von explizit verwendeter Parallelisierung. Außerdem vermeiden wir Optimierung einzugehen die von genaueren Wissen technischer Details, der jeweiligen Programmiersprache ausgehen. Die Zeiten werden mithilfe des Julia Package \texttt{BenchmarkTools.jl} und des Python Moduls \texttt{timeit} erfasst. Jeder parametrisierte Aufruf eine Funktion wird 10-Mal durchgeführt. Aus den 10 Aufrufen wählen wir das Minimum aus. Dieses Vorgehen liefert eine Untergrenze der Ausführungszeit des Codes. Die Kompilierzeit der jeweiligen Sprache wird in unseren Tests nicht miteinbezogen.\\~\\
+In folgendem Abschnitt werden Performanz-Tests in den Programmiersprachen Julia 1.10.2, Python 3.12.2 und Java Open-JDK 19.0.2 durchgeführt. Die verwendete \ac{CPU} ist ein AMD Ryzen 5 3600 unter Windows 10 mit 16GB verfügbaren Arbeitsspeicher. Der zu testende Code wird aus Sicht eines Einsteigers der jeweiligen Programmiersprache geschrieben. Der Code macht keinen Gebrauch von explizit verwendeter Parallelisierung. Außerdem vermeiden wir Optimierung einzugehen die von genaueren Wissen technischer Details, der jeweiligen Programmiersprache ausgehen. Die Zeiten werden mithilfe des Julia Package \texttt{BenchmarkTools.jl}, des Python Moduls \texttt{timeit} und in Java per Aufruf der Methode \texttt{System.nanoTime()} erfasst. Jeder parametrisierte Aufruf eine Funktion wird 10-Mal durchgeführt. Aus den 10 Aufrufen wählen wir das Minimum aus. Dieses Vorgehen liefert eine Untergrenze der Ausführungszeit des Codes. Die Kompilierzeit der jeweiligen Sprache wird in unseren Tests nicht miteinbezogen.\\~\\
 \subsubsection*{Performanz-Test}
 Die Elemente der Mandelbrot-Menge $\mathbb{M}$ können nicht genau bestimmt werden. Es ist dennoch möglich Näherungsbilder der Mandelbrot-Menge $\mathbb{M}$ zu skizzieren \autocite{weitzKonkreteMathematikNicht2021}. Wir überprüfen die Performanz von Julia indem wir die beanspruchte Zeit für die Erstellung eine solchen Näherungsbildes betrachten. Komplexe Zahlen sind im Kontext dieses Tests festgelegt als Datenstruktur bestehende aus zwei 64-Bit Fließkommazahlen nach Spezifikation IEEE-754.
 Die Mandelbrot-Menge ist nach Definition Teilmenge der komplexen Zahlen. Es lässt sich zeigen, dass alle Elemente der Mandelbrotmenge vollständig in der Kreisscheibe um 0 mit dem Radius 2 liegen \autocite{walterFraktaleGeometrischenElemente2018}. Diese Eigenschaft machen wir uns in unserem Näherungsbild zu nutze.
@@ -113,7 +114,7 @@ Wir nehmen an, dass alle $z_{ij}$ Teil der Mandelbrot-Menge sind, wenn unsere ma
 	\end{algorithmic}
 \end{algorithm}
 
-Der \textit{Escape Time Algorithm} \autoref{alg:escape_time_algorithm} muss für ein quadratisches $n \times n$ Raster $n^2$-Mal durchlaufen werden. Für die Anzahl der gesamten Ausführungen der \texttt{while}-Schleife des \textit{Escape Time Algorithm} kann die obere Schranke $n^2 \cdot t_{max}$ bestimmt werden. Die obere Schranke wird erreicht wenn alle $z_{ij}$ Teil der Mandelbrotmenge sind. Abbildung \autoref{fig:mandelbrot_time} stellt die benötigte Zeit zur Berechnung des Rasters unter maximaler Iteration $t_{max} = 10$ logarithmisch dar.
+Der \textit{Escape Time Algorithm} \autoref{alg:escape_time_algorithm} muss für ein quadratisches $n \times n$ Raster $n^2$-Mal durchlaufen werden. Für die Anzahl der gesamten Ausführungen der \texttt{while}-Schleife des \textit{Escape Time Algorithm} kann die obere Schranke $n^2 \cdot t_{max}$ bestimmt werden. Die obere Schranke wird erreicht wenn alle $z_{ij}$ Teil der Mandelbrotmenge sind. Abbildung \autoref{fig:mandelbrot_time} stellt die benötigte Zeit zur Berechnung des Rasters unter maximaler Iteration $t_{max} = 10$ dar. Auf der Y-Achse lässt sich die Zeit in Sekunden logarithmisch ablesen. Auf der X-Achse liegen die betrachteten Rastergrößen $n$ von 1 bis 100.
 
 \begin{figure}[h!]
 	\label{fig:mandelbrot_time}
@@ -121,9 +122,7 @@ Der \textit{Escape Time Algorithm} \autoref{alg:escape_time_algorithm} muss für
 	\caption{Zeitaufwand in Abhängigkeit der Rastergröße}
 \end{figure}
 
-% Validierung der Daten über Standardabweichung
+Python, Julia und Java weisen ein ähnliches logarithmisches Wachstumsverhalten auf, sind jedoch auf der Y-Achse versetzt. Die Berechnungszeit für Julia und Java liegt für kleinere Werte für $n$, relativ nah beieinander. Python hingegen benötigt für kleine Rastergrößen schon wesentlich länger. Unter den gemessenen Sprachen ist Java die schnellste, darauffolgend Julia und das Schlusslicht bildet Python.
-Python und Julia weisen ein ähnliches logarithmisches Wachstumsverhalten.
-Für den letzten Wert $n=100$ zeigt Julia eine eindeutig bessere Performanz als Python. Mit einer Zeit von $\approx 3.5046 \cdot 10^{-4}$ ist es im Vergleich zu Python $\approx 1.3209 \cdot 10^{-1}$ mit einem Faktor von $\approx 377$-Mal effizienter. Unser Resultat deckt sich mit dem Ergebnis von \autocite{januszekComparativeAnalysisEfficiency2018}, welche anstelle des \textit{Escape Time Algorithm} Matrixmultiplikation zweier quadratischer Matrizen verwenden.
 
 \subsection{Nachhaltigkeit}
 
@@ -132,7 +131,7 @@ Im letzten Jahrhundert verhielt sich der Energieverbrauch zwischen unterschiedli
 	\text{Energie} = \text{Zeit} \times \text{Leistung}
 \end{equation*}
 beschrieben \autocite{pereiraEnergyEfficiencyProgramming2017}. Visualisierungen innerhalb der Fraktalen Geometrie können einen hohen Rechenaufwand in Anspruch nehmen. Beispielsweise spielt die numerische Präzision Berechnung eines kleinen \enquote{Sichtfensters} in die Mandelbrot-Menge einen limitierenden Faktor. Desto kleiner das Sichtfenster ist, desto mehr Zeit wird in Anspruch genommen dies zu Berechnen \autocite{heiland2023patterns}. Durch Verwendung von Zahlen mit arbiträrer Präzision kann diese Rechendauer, die einer 64-Bit Fließkommazahl übersteigen. Ein weiterer Anwendungsfalls ist die Wahl eines hohen $t_{max}$ innerhalb des \textit{Escape Time Algorithmus} \autoref{alg:escape_time_algorithm} welches ein genaueres Bild der Mandelbrotmenge liefert, aber auf der Gegenseite eine höhere Rechenzeit benötigt. Für die Darstellungen von Kurven, wie beispielsweise der Koch-Kurve $n$-ter Iteration wächst der Rechenaufwand mit wachsenden $n$ mit an. Es lässt sich schließen dass in genauere und präzisere Berechnung ein höherer Energieaufwand einfließt.
-Ein Vergleich über die Energieeffizienz von Programmiersprachen liefert, dass kompilierte Sprachen im Durchschnitt schneller sind als Sprachen mit Virtueller Maschine, gefolgt von interpretierten Sprachen \autocite{pereiraEnergyEfficiencyProgramming2017}. Dieser Vergleich wurde anfangs ohne Julia durchgeführt. Im Anschluss wurde Julia in der Version 1.3.1 hinzugefügt und in einem Vergleich mit 9 weiterer Sprachen evaluiert. Julia liegt in der neuen Durchführung auf Platz 2/10 würde sich in im ursprünglichen Vergleich auf Platz 5/27 einordnen bezüglich des Energieverbrauchs. \autocite{pereiraOriginalWorkSLE}
+Ein Vergleich über die Energieeffizienz von Programmiersprachen liefert, dass kompilierte Sprachen im Durchschnitt schneller sind als Sprachen mit Virtueller Maschine, gefolgt von interpretierten Sprachen \autocite{pereiraEnergyEfficiencyProgramming2017}. Dieser Vergleich wurde anfangs ohne Julia durchgeführt. Im Anschluss wurde Julia in der Version 1.3.1 hinzugefügt und in einem Vergleich mit 9 weiterer Sprachen evaluiert. Julia liegt in der neuen Durchführung auf Platz 2/10. \autocite{pereiraOriginalWorkSLE}
 
 \subsection{Parallelisierbarkeit}
 
@@ -170,10 +169,10 @@ Neben den Standardbibliotheken, die mit der Installation einer Programmiersprach
             \toprule
             Sprache & Paketverzeichnis & PYPL Rank & Anzahl Pakete\\
             \midrule
-            Python3 & \acs{PyPi}          & 1  & 548.169\\
+            Python3 & \acs{PyPi}          & 1  & 553.784\\
-            R      & \acs{CRAN}   & 6  & 20.919\\
+            R      & \acs{CRAN}   & 6  & 21.046\\
             MATLAB & FileExchange  & 14 & 11.693\\
-            Julia  & JuliaRegistry & 24 & 10.968\\
+            Julia  & JuliaRegistries & 24 & 11.066\\
             \bottomrule
         \end{tabular}
     \end{footnotesize} 
@@ -216,7 +215,7 @@ Mit der Veröffentlichung einer neuen Programmiersprache müssen auch Entwicklun
 	\item Notebooks, die eine Ansammlung an Zellen mit ausführbaren Code oder Notizen meist in Form von Markdown bieten. Die Entwicklung von Code in Notebooks geschieht in einer iterativen und interaktiven Form. Diese kommen meist innerhalb des Data-Science Bereichs zum Einsatz \autocite{wuB2BridgingCode2020}. In der Praxis unterstützen Notebooks meist mehrere Sprachen oder es ist möglich diese per Erweiterung hinzuzufügen.
 \end{itemize}
 
-Wir klassifizieren eine Auswahl an Entwicklungsumgebungen für Julia. Für jede Entwicklungsumgebung fassen wir auf ob deren Entwicklung noch aktiv verfolgt wird. Die Arbeit an einer \acs{IDE} klassifizieren wir als gestoppt oder pausiert, wenn seit Anfang des Jahres 2023 kein neuer Release erschienen ist.
+Wir klassifizieren eine Auswahl an Entwicklungsumgebungen für Julia. Für jede Entwicklungsumgebung fassen wir auf ob deren Entwicklung noch aktiv verfolgt wird. Die Daten erhalten wir durch die Repositories der jeweiligen Projekte auf Github. Die Arbeit an einer \acs{IDE} klassifizieren wir als gestoppt oder pausiert, wenn seit Anfang des Jahres 2023 kein neuer Release erschienen ist.
 
 % abgerufen 16.06.2024
 \begin{table}[h!]
@@ -225,16 +224,16 @@ Wir klassifizieren eine Auswahl an Entwicklungsumgebungen für Julia. Für jede
 	\caption{Einordnung Entwicklungsumgebungen}
 	\label{table:ides}
 	\begin{footnotesize}
-		\begin{tabular}{llcr}
+		\begin{tabular}{llc}
 			\toprule
-			\acs{IDE} & Kategorie & Entwicklung & Letzter Release\\
+			\acs{IDE} & Kategorie & Entwicklung\\
 			\midrule
-			Julia (VS Code) & Erweiterung & Ja & 08.05.2024\\
+			Julia (VS Code) & Erweiterung & Ja\\
-			Juno (Atom) & Erweiterung & Nein & 20.11.2020\\
+			Juno (Atom) & Erweiterung & Nein\\
-			Julia (IntelliJ) & Erweiterung & Nein & 23.04.2019\\
+			Julia (IntelliJ) & Erweiterung & Nein\\
-			Julia-Studio & Eigenständig & Nein & 05.11.2013\\
+			Julia-Studio & Eigenständig & Nein\\
-			Pluto & Notebook & Ja & 08.05.2024\\
+			Pluto & Notebook & Ja\\
-			IJulia (Jupyter) & Notebook & Ja & 02.06.2023\\
+			IJulia (Jupyter) & Notebook & Ja\\
 			%Quarto & Notebook & ja & 03.06.2024\\
 			\bottomrule
 		\end{tabular}
@@ -258,8 +257,6 @@ Die Einschränkungen bezüglich einer getroffenen Auswahl ist auf die ausgewähl
 \section{Ausblick}
 
 
-
-
 % --------------------------------------------------------------------
 \section*{Abkürzungen}
 \addcontentsline{toc}{section}{Abkürzungen}
@@ -282,4 +279,37 @@ Die Einschränkungen bezüglich einer getroffenen Auswahl ist auf die ausgewähl
 \AtNextBibliography{\small}
 \printbibliography
 
+\section{Appendix}
+
+\subsection*{Code-Schnipsel}
+
+Die Code-Schnipsel, sowie die erhaltenen Testdaten der Performanz-Tests lassen sich unter \href{https://gitty.informatik.hs-mannheim.de/2211275/wia}{Gitea} der Hochschule Mannheim finden.
+
+\subsection*{Paketverzeichnisse}
+	Erhalt der Daten am 08.07.2024.
+	\begin{enumerate}
+		\item \textbf{\acs{PyPi}:} \url{https://pypi.org/}
+		\item \textbf{\acs{CRAN}:} \url{https://cran.r-project.org/web/packages/available_packages_by_name.html}
+		\item \textbf{MATLAB FileExchange:} \url{https://de.mathworks.com/matlabcentral/fileexchange/?s_tid=gn_mlc_fx_files}
+		\item \textbf{JuliaRegistries:} \url{https://github.com/JuliaRegistries/General/blob/master/Registry.toml}
+	\end{enumerate}
+
+\subsection*{Entwicklungsumgebungen}
+	Erhalt der Daten am 08.07.2024.
+	\begin{enumerate}
+		\item \textbf{Julia (VS Code):} \url{https://github.com/julia-vscode/julia-vscode}
+		\item \textbf{Juno (Atom):} \url{https://github.com/JunoLab/Atom.jl}
+		\item \textbf{Julia (IntelliJ):} \url{https://github.com/JuliaEditorSupport/julia-intellij}
+		\item \textbf{Julia-Studio:} \url{https://github.com/forio/julia-studio}
+		\item \textbf{Pluto:} \url{https://github.com/fonsp/Pluto.jl}
+		\item \textbf{IJulia (Jupyter):} \url{https://github.com/JuliaLang/IJulia.jl}
+	\end{enumerate}
+	
+	
+	
+
+
+
+
+
 \end{document}