added code for performance tests, writing advancement

.gitignore

@@ -20,10 +20,10 @@
 # these rules might exclude image files for figures etc.
 # *.ps
 # *.eps
-*.pdf
+#*.pdf
 
 ## Generated if empty string is given at "Please type another file name for output:"
-.pdf
+guide.pdf
 
 ## Bibliography auxiliary files (bibtex/biblatex/biber):
 *.bbl
@@ -301,3 +301,5 @@ TSWLatexianTemp*
 # Uncomment the next line to have this generated file ignored.
 #*Notes.bib
 
+.idea
+/out

code/escape/EscapeJava.java

@@ -0,0 +1,59 @@
+public class EscapeJava {
+
+    public static void main(String[] args) {
+
+        for (int i = 0; i < 100; i++) {
+
+        }
+        var a = calculate(generateGrid(100), 100);
+
+        System.out.println(a);
+    }
+
+    public static int escape(double cx, double cy, int maximum, double bounds) {
+        int i = 0;
+        double x = 0;
+        double y = 0;
+
+        while (Math.sqrt(x * x + y * y) < bounds && i < maximum) {
+            y = 2 * x * y + cy;
+            x = x * x - y * y + cx;
+            i++;
+        }
+        return i;
+    }
+
+    static class Complex {
+        public double real;
+        public double imag;
+
+        Complex(double real, double imag) {
+            this.real = real;
+            this.imag = imag;
+        }
+    }
+
+    public static Complex[][] generateGrid(int n) {
+        Complex[][] grid = new Complex[n][n];
+        for (int yi = 0; yi < n; yi++) {
+            for (int xi = 0; xi < n; xi++) {
+                double cx = -2.0 + (4.0/n) * xi;
+                double cy = -2.0 + (4.0/n) * yi;
+
+                grid[yi][xi] = new Complex(cx, cy);
+            }
+        }
+        return grid;
+    }
+
+    public static int[][] calculate(Complex[][] grid, int n) {
+        int[][] results = new int[n][n];
+        for (int yi = 0; yi < n; yi++) {
+            for (int xi = 0; xi < n; xi++) {
+                Complex c = grid[yi][xi];
+                results[yi][xi] = escape(c.real, c.imag, 10, 2);
+            }
+        }
+        return results;
+    }
+}

code/escape/escape_julia.jl

@@ -0,0 +1,32 @@
+using Plots
+using BenchmarkTools
+
+function escape(z, c, maximum, bounds)
+    i = 0
+    while abs(z) < bounds && i < maximum
+        z = z^2 + c
+        i += 1
+    end
+    return i
+end
+
+tries = 1
+maxima = 100
+
+samples = zeros(maxima)
+function grid(n)
+    return reduce(hcat, [[i + j * im for j=range(-2, 2, length=n)] for i=range(-2, 2, length=n)])
+end
+
+function calculate(grid, i)
+    return escape.(0, grid, i, 2)
+end
+
+for i in 2:maxima
+    cgrid = grid(i)
+    samples[i] = @belapsed calculate($cgrid, 10) evals = 10 samples=10
+    println(i)
+end
+
+Plots.plot(samples)
+#Plots.plot(samples)

code/escape/escape_python.py

@@ -0,0 +1,41 @@
+import timeit
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+
+def escape(z, c, maximum: int, bounds: float):
+    i = 0
+    while abs(z) < bounds and i < maximum:
+        z = z ** 2 + c
+        i += 1
+    return i
+
+maxima = 100
+
+v_escape = np.vectorize(escape)
+
+def grid(n):
+    return np.array([[ complex(a,b) for b in np.linspace(-2, 2, num=n)] for a in np.linspace(-2, 2, num=n)], dtype=np.csingle)
+
+def calculate(grid, i):
+    return v_escape(0, grid, i, 2)
+
+samples = np.zeros(maxima)
+
+for i in range(2,maxima+1):
+    cgrid = grid(i)
+    duration = min(timeit.Timer(lambda : calculate(cgrid, 10)).repeat(10, 10))
+
+    samples[i-1] = duration
+    print(i)
+
+plt.grid(visible=True)
+plt.plot(samples, label="python")
+#plt.plot(, label ="julia")
+plt.legend()
+plt.xlabel("Rastergröße n")
+plt.ylabel("Zeit in Sekunden")
+plt.show()
+
+print(",".join(map(str, samples)))

code/escape/escape_r.r

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

code/escape/plotting.jl

@@ -0,0 +1,11 @@
+using Plots
+
+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, 3.22e-6, 3.47e-6, 4.75e-6, 5.17e-6, 6.51e-6, 7.57e-6, 9.13e-6, 9.58e-6, 1.159e-5, 1.239e-5, 1.497e-5, 1.524e-5, 1.782e-5, 1.855e-5, 
+2.126e-5, 2.174e-5, 2.429e-5, 2.56e-5, 2.86e-5, 2.973e-5, 3.259e-5, 3.386e-5, 3.699e-5, 3.821e-5, 4.167e-5, 
+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]
+
+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))
+
+savefig("mandelbrot_time.png")

literatur.bib

@@ -5,13 +5,39 @@
   publisher = {CRC Press}
 }
 
+@inproceedings{alfonsecaRepresentationFractalCurves1996,
+  title = {Representation of Fractal Curves by Means of {{L}} Systems},
+  booktitle = {Proceedings of the Conference on {{Designing}} the Future},
+  author = {Alfonseca, Manuel and Ortega, Alfonso},
+  year = {1996},
+  month = jun,
+  pages = {13--21},
+  publisher = {ACM},
+  address = {Lancaster United Kingdom},
+  doi = {10.1145/253341.253348},
+  urldate = {2024-06-15},
+  isbn = {978-0-89791-806-0},
+  langid = {english},
+  file = {C:\Users\Home\Zotero\storage\6TV36I8X\Alfonseca und Ortega - 1996 - Representation of fractal curves by means of L sys.pdf}
+}
+
+@misc{alJuliaMicroBenchmarks,
+  title = {Julia {{Micro-Benchmarks}}},
+  author = {{al}, Stefan Karpinski, Viral Shah, Alan Edelman, et, Jeff Bezanson},
+  urldate = {2024-06-16},
+  abstract = {The official website for the Julia Language. Julia is a language that is fast, dynamic, easy to use, and open source. Click here to learn more.},
+  howpublished = {https://julialang.org/benchmarks/},
+  langid = {english},
+  file = {C:\Users\Home\Zotero\storage\DXSTVQMX\benchmarks.html}
+}
+
 @article{atellaRenderingHypercomplexFractals,
   title = {Rendering {{Hypercomplex Fractals}}},
   author = {Atella, Anthony},
   langid = {english}
 }
 
-@phdthesis{bezanson2015,
+@phdthesis{bezansonAbstractionTechnicalComputing2015,
   title = {Abstraction in {{Technical Computing}}},
   author = {Bezanson, Jeffrey Werner},
   year = {2015},
@@ -39,11 +65,28 @@
   langid = {english}
 }
 
+@article{caiStudyMandelbrotSets2013,
+  title = {A {{Study}} on {{Mandelbrot Sets}} to {{Generate Visual Aesthetic Fractal Patterns}}},
+  author = {Cai, Zong Wen and Lam, Artde D. Kin Tak},
+  year = {2013},
+  month = feb,
+  journal = {Applied Mechanics and Materials},
+  volume = {311},
+  pages = {111--116},
+  issn = {1662-7482},
+  doi = {10.4028/www.scientific.net/AMM.311.111},
+  urldate = {2024-06-15},
+  abstract = {The fractal pattern is a highly visual aesthetic image. This article describes the generation method of Mandelbrot set to generate fractal art patterns. Based on the escape time algorithm on complex plane, the visual aesthetic fractal patterns are generated from Mandelbrot sets. The generated program development, a pictorial information system, is integrated through the application of Visual Basic programming language and development integration environment. Application of the development program, this article analyzes the shape of the fractal patterns generated by the different power orders of the Mandelbrot sets. Finally, the escape time algorithm has been proposed as the generation tools of highly visual aesthetic fractal patterns.},
+  langid = {english},
+  file = {C:\Users\Home\Zotero\storage\WKRIEMXV\Cai und Lam - 2013 - A Study on Mandelbrot Sets to Generate Visual Aest.pdf}
+}
+
 @misc{carbonellePYPLPopularityProgramming2023,
   title = {{{PYPL}} ({{Popularity}} of {{Programming Language}}) {{Index}}},
   author = {Carbonelle, Pierre},
   year = {2023},
-  urldate = {2024-06-12}
+  urldate = {2024-06-12},
+  annotation = {Programmers: \_:n92}
 }
 
 @misc{christPlotsJlUser2022,
@@ -60,8 +103,35 @@
   archiveprefix = {arxiv},
   langid = {english},
   keywords = {Computer Science - Graphics,I.3.3},
-  note = {Comment: 22 pages, 6 figures, 6 code listings},
+  note = {Comment: 22 pages, 6 figures, 6 code listings}
-  file = {/home/roman/snap/zotero-snap/common/Zotero/storage/Q44MJU9D/Christ et al. - 2022 - Plots.jl -- a user extendable plotting API for the.pdf}
+}
+
+@misc{cormullionLuxorJlDokumentation,
+  title = {Luxor.Jl {{Dokumentation}}},
+  author = {{cormullion}}
+}
+
+@misc{CRANContributedPackages2024,
+  title = {{{CRAN}} Contributed Packages},
+  year = {2024},
+  month = jun,
+  urldate = {2024-06-12}
+}
+
+@article{dagostinoHardwareSoftwareSolutions2021,
+  title = {Hardware and {{Software Solutions}} for {{Energy-Efficient Computing}} in {{Scientific Programming}}},
+  author = {D'Agostino, Daniele and Merelli, Ivan and Aldinucci, Marco and Cesini, Daniele},
+  year = {2021},
+  journal = {Scientific Programming},
+  volume = {2021},
+  number = {1},
+  pages = {5514284},
+  issn = {1875-919X},
+  doi = {10.1155/2021/5514284},
+  urldate = {2024-06-16},
+  abstract = {Energy consumption is one of the major issues in today's computer science, and an increasing number of scientific communities are interested in evaluating the tradeoff between time-to-solution and energy-to-solution. Despite, in the last two decades, computing which revolved around centralized computing infrastructures, such as supercomputing and data centers, the wide adoption of the Internet of Things (IoT) paradigm is currently inverting this trend due to the huge amount of data it generates, pushing computing power back to places where the data are generated---the so-called fog/edge computing. This shift towards a decentralized model requires an equivalent change in the software engineering paradigms, development environments, hardware tools, languages, and computation models for scientific programming because the local computational capabilities are typically limited and require a careful evaluation of power consumption. This paper aims to present how these concepts can be actually implemented in scientific software by presenting the state of the art of powerful, less power-hungry processors from one side and energy-aware tools and techniques from the other one.},
+  langid = {english},
+  file = {C\:\\Users\\Home\\Zotero\\storage\\BTZJL6BY\\D’Agostino et al. - 2021 - Hardware and Software Solutions for Energy-Efficie.pdf;C\:\\Users\\Home\\Zotero\\storage\\2XTBXHRV\\5514284.html}
 }
 
 @article{danischMakieJlFlexible2021,
@@ -126,6 +196,14 @@
   langid = {english}
 }
 
+@inproceedings{heiland2023patterns,
+  title = {Patterns in Deep {{Mandelbrot}} Zooms},
+  booktitle = {Algorithmic Pattern Salon},
+  author = {{Heiland-Allen}, Claude},
+  year = {2023},
+  publisher = {Then Try This}
+}
+
 @article{januszekComparativeAnalysisEfficiency2018,
   title = {Comparative Analysis of the Efficiency of {{Julia}} Language against the Other Classic Programming Languages},
   author = {Januszek, Tomasz and Pleszczy{\'n}ski, Mariusz},
@@ -134,6 +212,12 @@
   volume = {8}
 }
 
+@misc{JuliaRegistries2024,
+  title = {Julia {{Registries}}},
+  year = {2024},
+  month = apr
+}
+
 @book{kennethFractalGeometryMathematical2007,
   title = {Fractal Geometry: Mathematical Foundations and Applications},
   author = {Kenneth, Falconer},
@@ -147,11 +231,31 @@
   langid = {english}
 }
 
-@misc{MATLABFileexchange,
+@misc{MATLABFileexchange2024,
   title = {{{MATLAB Fileexchange}}},
+  year = {2024},
+  month = jun,
   urldate = {2024-06-12}
 }
 
+@article{mcandrewLindenmayerSystemsFractals,
+  title = {Lindenmayer Systems, Fractals, and Their Mathematics},
+  author = {McAndrew, Alasdair},
+  abstract = {Students are always asking for applications of mathematics. But more often than not, textbooks are filled with ``applications'' which are unimaginative, contrived, unrealistic, and uninteresting. However, there are of course numerous areas in which mathematics can be, and is, deployed to great effect. The purpose of this article is to introduce one such area: Lindenmayer systems, which beautifully joins mathematics and graphics, and investigate some of the mathematics---in particular their fractal dimension---and also the beauty of some of the graphics. We claim that the simplicity of the systems, and the complexity of their outputs, make for a simple way to introduce complexity---and modelling of the natural world---into a mathematics course, especially a course on finite mathematics, geometry, or computational mathematics.},
+  langid = {english},
+  file = {C:\Users\Home\Zotero\storage\RCRTNNL4\McAndrew - Lindenmayer systems, fractals, and their mathemati.pdf}
+}
+
+@article{mollickEstablishingMooreLaw2006,
+  title = {Establishing {{Moore}}'s {{Law}}},
+  author = {Mollick, Ethan},
+  year = {2006},
+  journal = {IEEE Annals of the History of Computing},
+  number = {28},
+  urldate = {2024-06-16},
+  file = {C:\Users\Home\Zotero\storage\H5QQ7CV9\stamp.html}
+}
+
 @article{monroRenderingAlgorithmsDeterministic1995,
   title = {Rendering Algorithms for Deterministic Fractals},
   author = {Monro, D.M. and Dudbridge, F.},
@@ -161,11 +265,37 @@
   number = {1},
   pages = {32--41},
   doi = {10.1109/38.364961},
-  keywords = {Approximation algorithms,Data structures,Displays,Fractals,Graphics,Particle measurements,Rendering (computer graphics),Software algorithms,Software performance,Spirals},
+  keywords = {Approximation algorithms,Data structures,Displays,Fractals,Graphics,Particle measurements,Rendering (computer graphics),Software algorithms,Software performance,Spirals}
-  file = {/home/roman/snap/zotero-snap/common/Zotero/storage/FRJNGNDE/scholar.bib}
 }
 
-@article{perkel2019,
+@inproceedings{pereiraEnergyEfficiencyProgramming2017,
+  title = {Energy Efficiency across Programming Languages: How Do Energy, Time, and Memory Relate?},
+  shorttitle = {Energy Efficiency across Programming Languages},
+  booktitle = {Proceedings of the 10th {{ACM SIGPLAN International Conference}} on {{Software Language Engineering}}},
+  author = {Pereira, Rui and Couto, Marco and Ribeiro, Francisco and Rua, Rui and Cunha, J{\'a}come and Fernandes, Jo{\~a}o Paulo and Saraiva, Jo{\~a}o},
+  year = {2017},
+  month = oct,
+  pages = {256--267},
+  publisher = {ACM},
+  address = {Vancouver BC Canada},
+  doi = {10.1145/3136014.3136031},
+  urldate = {2024-06-16},
+  isbn = {978-1-4503-5525-4},
+  langid = {english},
+  file = {C:\Users\Home\Zotero\storage\G93UJZXJ\Pereira et al. - 2017 - Energy efficiency across programming languages ho.pdf}
+}
+
+@misc{pereiraOriginalWorkSLE,
+  title = {{Original work in SLE'17}},
+  author = {Pereira, Rui and Couto, Marco and Ribeiro, Francisco and Rua, Rui and Cunha, J{\'a}come and Fernandes, Jo{\~a}o Paulo and Saraiva, Jo{\~a}o},
+  urldate = {2024-06-16},
+  abstract = {The tools and graphical data pointed by this page are included in the research paper "Energy Efficiency across Programming Languages: How does Energy, Time and Memory Relate?", accepted at the International Conference on Software Language Engineering (SLE) - Rui Pereira, Marco Couto, Francisco Ribeiro},
+  howpublished = {https://sites.google.com/view/energy-efficiency-languages/home},
+  langid = {ngerman},
+  file = {C:\Users\Home\Zotero\storage\7XFB6PKR\home.html}
+}
+
+@article{perkelJuliaComeSyntax2019,
   title = {Julia: Come for the Syntax, Stay for the Speed},
   shorttitle = {Julia},
   author = {Perkel, Jeffrey M.},
@@ -179,18 +309,18 @@
   doi = {10.1038/d41586-019-02310-3},
   urldate = {2024-06-14},
   copyright = {http://www.springer.com/tdm},
-  langid = {english},
+  langid = {english}
-  file = {/home/roman/snap/zotero-snap/common/Zotero/storage/QPIWTYK8/Perkel - 2019 - Julia come for the syntax, stay for the speed.pdf}
 }
 
-@book{prusinkiewicz,
+@book{prusinkiewiczAlgorithmicBeautyPlants,
   title = {The Algorithmic Beauty of Plants},
-  author = {Prusinkiewicz, Przemyslaw and Lindenmayer, Aristid},
+  author = {Prusinkiewicz, Przemyslaw and Lindenmayer, Aristid}
-  file = {/home/roman/snap/zotero-snap/common/Zotero/storage/ULXJ7GC2/abop.pdf}
 }
 
-@misc{PyPiPythonPackage,
+@misc{PyPi2024,
   title = {{{PyPi}} ({{Python Package Index}})},
+  year = {2024},
+  month = jun,
   urldate = {2024-04-17}
 }
 
@@ -226,6 +356,20 @@
   month = apr
 }
 
+@article{sternemannPlatonischeFraktaleIm,
+  title = {{Platonische Fraktale im Unterricht}},
+  author = {Sternemann, Wilhelm and Canisianum, Gymnasium},
+  langid = {ngerman},
+  file = {C:\Users\Home\Zotero\storage\EMF9UT6A\Sternemann und Canisianum - Platonische Fraktale im Unterricht.pdf}
+}
+
+@book{vanrossumPythonReferenceManual1995,
+  title = {Python Reference Manual},
+  author = {Van Rossum, Guido and Drake Jr, Fred L},
+  year = {1995},
+  publisher = {Centrum voor Wiskunde en Informatica Amsterdam}
+}
+
 @phdthesis{walterFraktaleGeometrischenElemente2018,
   type = {{Diplomarbeit}},
   title = {{Fraktale: Die geometrischen Elemente der Natur}},
@@ -239,7 +383,26 @@
   keywords = {Fraktalgeometrie}
 }
 
-@misc{zotero-27,
+@book{weitzKonkreteMathematikNicht2021,
-  title = {{{CRAN}} Contributed Packages},
+  title = {Konkrete {{Mathematik}} (Nicht Nur) F{\"u}r {{Informatiker}}},
-  urldate = {2024-06-12}
+  author = {Weitz, Edmund},
+  year = {2021},
+  edition = {2}
+}
+
+@inproceedings{wuB2BridgingCode2020,
+  title = {B2: {{Bridging Code}} and {{Interactive Visualization}} in {{Computational Notebooks}}},
+  shorttitle = {B2},
+  booktitle = {Proceedings of the 33rd {{Annual ACM Symposium}} on {{User Interface Software}} and {{Technology}}},
+  author = {Wu, Yifan and Hellerstein, Joseph M. and Satyanarayan, Arvind},
+  year = {2020},
+  month = oct,
+  pages = {152--165},
+  publisher = {ACM},
+  address = {Virtual Event USA},
+  doi = {10.1145/3379337.3415851},
+  urldate = {2024-06-16},
+  isbn = {978-1-4503-7514-6},
+  langid = {english},
+  file = {C:\Users\Home\Zotero\storage\24JV4AF8\Wu et al. - 2020 - B2 Bridging Code and Interactive Visualization in.pdf}
 }

preambel.tex

@@ -3,7 +3,9 @@
 \usepackage[pdftex]{graphicx}
 \DeclareGraphicsExtensions{.pdf,.jpeg,.jpg,.png}
 \usepackage[cmex10]{amsmath}
-\usepackage{algorithmic}
+\usepackage{amssymb}
+\usepackage{algorithm}
+\usepackage{algpseudocode}
 \usepackage{array}
 \usepackage{url}
 \usepackage[autostyle=true,german=quotes]{csquotes}
@@ -50,4 +52,8 @@
 \newcommand{\dahe}[0]{d.\,h.}
 \newcommand{\ua}[0]{u.\,a.}
 
+\algnewcommand{\algorithmicand}{\textbf{and }}
+\algnewcommand{\algorithmicor}{\textbf{or }}
+\algnewcommand{\OR}{\algorithmicor}
+\algnewcommand{\AND}{\algorithmicand}
 

seminararbeit.tex

@@ -1,8 +1,10 @@
 \documentclass[conference,compsoc,final,a4paper]{IEEEtran}
 
+
+
 %% Bitte legen Sie hier den Titel und den Autor der Arbeit fest
 \newcommand{\autoren}[0]{Schöne, Roman}
-\newcommand{\dokumententitel}[0]{Julia als Werkzeug für Fraktale Geometrie}
+\newcommand{\dokumententitel}[0]{Julia als Werkzeug für Visualisierungen in der Fraktalen Geometrie}
 
 \input{preambel} % Weitere Einstellungen aus einer anderen Datei lesen
 
@@ -45,49 +47,120 @@ Am Ende einfügen
 % Unterunterabschnitte mit \subsubsection
 % -------------------------------------------------------
 \section{Einleitung}
-Schon im 19. Jahrhundert beschäftigten sich Mathematiker 
+
-Die Grundlagenarbeit der fraktalen Geometrie beruht auf Werken des Mathematikers Gaston Julia und seinem Konkurrenten Pierre Fatou anfangs des 20. Jahrhunderts \autocite{walterFraktaleGeometrischenElemente2018}.
+Schon im Jahr 1890 beschäftigte sich der Mathematiker Peano mit einer Kurve, die anschließend nach Ihm benannt wurde, die durch jeden Punkt einer 2-dimensionalen Oberfläche durchläuft \autocite{alfonsecaRepresentationFractalCurves1996}. Gefolgt 1904 mit Helge von Koch, der sich mit der nach ihm benannten Kochschen Schneeflocke auseinandersetzte. Die Entdeckungen aus der damaligen Zeit wurden von Mathematiker aus dem 19. Jahrhundert als \enquote{Monster} bezeichnet, da diese seltsame Eigenschaften aufweisen \autocite{smithFractalGeometryHistory2011}
-Diese Errungenschaften griff der Mathematiker Benoît Mandelbrot um die 1970er Jahre in seinem Buch \textit{The Fractal Geometry of Nature} wieder auf und verlieh dem Bereich der fraktalen Geometrie an wachsender Popularität. \autocite{smithFractalGeometryHistory2011}
+Weitere Grundlagenarbeit der fraktalen Geometrie beruht auf Werken des Mathematikers Gaston Julia und seinem Konkurrenten Pierre Fatou anfangs des 20. Jahrhunderts. Julia und Fatou erforschten das Verhalten der Iterationen von Funktionen der Form $f_c(z) = z^2 + c$ mit $z, c \in \mathbb{C}$ \autocite{walterFraktaleGeometrischenElemente2018}. 
-Die Begründer Gaston und Julia besaßen zur damaligen Zeit noch keine Computer, mit denen Sie ihren Forschungsobjekte darstellen konnten. \autocite{walterFraktaleGeometrischenElemente2018}
+Diese Errungenschaften griff der Mathematiker Benoît Mandelbrot um die 1970er Jahre in seinem Buch \textit{The Fractal Geometry of Nature} wieder auf und verlieh dem Bereich der fraktalen Geometrie an wachsender Popularität. In seinem Werk bedient sich Mandelbrot an einer Vielzahl von Visualisierungen für die betrachteten Fraktale. \autocite{smithFractalGeometryHistory2011}
-In seinem Werk bedient sich Mandelbrot an einer Vielzahl von Visualisierungen für die untersuchten Fraktale.
+Zu Ehren Ihrer Forschungsarbeiten wurden Objekte aus der fraktalen Geometrie nach Ihnen benannt.
+Die Mandelbrot-Menge $\mathbb{M}$ ist die Menge der komplexen Zahlen $c \in \mathbb{C}$, deren Konvergenz-Verhalten für die Iteration  $f_c(z_i) = z_{i+1} = z^2 _i + c$ unter Wahl von $z_0 = 0$ beschränkt ist. Da sich die komplexen Zahlen als Punkte einer auffassen lassen, lässt sich die Mandelbrot-Menge in Form einer Rastergrafik visualisieren. Mithilfe der Darstellung lassen sich neue Vermutungen über die Eigenschaften der Mandelbrot-Menge aufstellen, welche ohne Visualisierung schwer zu erkennen sind.
+Die Begründer Gaston und Julia besaßen zur damaligen Zeit noch keine Computer, mit denen Sie ihre Forschungsobjekte darstellen konnten. \autocite{walterFraktaleGeometrischenElemente2018}
+Mit dem Lauf der Zeit wächst die Rechenleistung der verfügbaren Computer stetig an und erschließt neue Möglichkeiten innerhalb der Forschung. Nach \textit{Moore's Law} \autocite{mollickEstablishingMooreLaw2006} verdoppelt sich die Anzahl der Komponenten die auf einen Chip passt jedes Jahr. Innerhalb der 70er Jahre wurde die Mandelbrotmenge mithilfe von ASCII-Art visualisiert \autocite{weitzKonkreteMathematikNicht2021}. Aktuell steht uns die Rechenleistung zur Verfügung Einblicke in die Welt der Fraktale mittels hochauflösender Rastergrafik zu gelangen.
 Die resultierenden Bilder wecken aufgrund der Ästhetik auch das Interesse vieler Nicht-Mathematiker sich mit dem Themengebiet zu befassen
 \autocite{smithFractalGeometryHistory2011}.
+In der Informatik, die einen Spagat zwischen Formalwissenschaft und Ingenieurswissenschaft bildet, stellt sich die Herausforderung die Vielzahl an Objekten aus dem Zoo der fraktalen Geometrie auf effiziente und anschauliche Weise zu visualisieren.
 
-Mit dem Lauf der Zeit
 
 \section{Hintergrund}
 
-
+Für das Angehen von technischen Problemen werden ist populärste Ansatz zwei Sprachen zu verwenden. Eine Sprache mit leichter Syntax auf hoher Ebene wird in Kombination mit einer Sprache auf niedriger Abstraktionsebene mit hoher Performanz verwendet. Ein bekanntes Beispiel ist die Python-Bibliothek \textit{NumPy}, die in C geschrieben ist \autocite{bezansonAbstractionTechnicalComputing2015}. Ein anderer Ansatz zur Lösung dieses Problems war es vorerst Algorithmen innerhalb von Skriptsprachen zu schreiben und diese später in hardware-nahe Sprachen zu übertragen. Dieses Vorgehen ist mit einem hohen zeitlichen Aufwand und einer hohen Fehleranfälligkeit während des Übertragungsprozess verbunden \cite{perkelJuliaComeSyntax2019}.
-\section{Die Programmiersprache Julia}
+Julia wird als eine Lösung für diese Problematik, dem \textit{Zwei Sprachen Problem} angesehen.
-
 Ein Team aus unabhängigen Entwicklern entschied sich 2009 den Startschuss für die Entwicklung von Julia zu setzen. Bis zur ersten Veröffentlichung von Julia verliefen 3 weitere Jahre .
-Im August 2018 wurde die Veröffentlichung von Julia 1.0.0 bekanntgegeben \autocite{januszekComparativeAnalysisEfficiency2018}.\\
+Im August 2018 wurde die Veröffentlichung von Julia 1.0.0 bekanntgegeben \autocite{januszekComparativeAnalysisEfficiency2018}.
-Das Ziel von Julia ist das \textit{Zwei Sprachen Problem} zu lösen.
+Julia ist eine dynamische Programmiersprache in welcher Variablen zwingend definiert werden müssen, bevor diese zum Einsatz kommen \autocite{cabuttoOverviewJuliaProgramming2018}. Eine Vielzahl an Elementen aus imperativen, funktionalen und objekt-orientieren Programmiersprachen lassen sich in Julia wiederfinden. Julia wurde für wissenschaftliches Berechnen konzeptioniert, aber ermöglicht auch allgemeine Programmierung. Die Inspiration von Julia liegt in den Sprachen Lisp, Perl, Lua und Ruby \autocite{bezansonJuliaLanguageDocumentation}. Wichtige Merkmale die Julia von anderen dynamischen Programmiersprachen abgrenzt sind nach Julia-Handbuch:
-Für das Angehen von technischen Problemen werden ist populärste Ansatz zwei Sprachen zu verwenden. Eine Sprache mit leichter Syntax auf hoher Ebene wird in Kombination mit einer Sprache auf niedriger Abstraktionsebene verwendet. Ein bekanntes Beispiel ist die Python-Bibliothek \textit{NumPy}, die in C geschrieben ist.
+\begin{itemize}
-\autocite{bezanson2015}.
+	\item Eine sehr schlanke Standard-Bibliothek, die alle grundlegenden numerischen Operationen und Typen bereitstellt
-
+	\item Ein breit aufgestellte Sprache um Objekte zu konstruieren und deren Typen zu beschreiben
+	\item Die Möglichkeit, dass Funktionen eine große Breite an unterschiedlichen Parametertypen entgegennehmen
+	\item Eine gute Performanz, die derer statisch-kompilierter Sprachen wie beispielsweise C nahekommt
+\end{itemize} \autocite{bezansonJuliaLanguageDocumentation}.
+Die Einsatzmöglichkeiten beschränken sich nicht auf einen konkreten Bereich. Julia stellt einen Werkzeug zur Lösung von Problemen innerhalb der Informatik, Mathematik, Ingenieurswissenschaft, Medizin und Wirtschaft dar \autocite{cabuttoOverviewJuliaProgramming2018}. Von höherem Interesse ist für uns der Einsatz von Julia innerhalb Mathematik, konkreter als Werkzeug für Visualisierungen im Teilgebiet der fraktalen Geometrie.
 \section{Kriterien}
 
-Im folgenden Abschnitt betrachten wir die ausgewählten Kriterien:
+Im folgenden Abschnitt betrachten wir die ausgewählten Kriterien bezüglich der Programmiersprache Julia und stellen jeweils die Relation der einzelnen Kriterien zur Fraktalen Geometrie her. Diese lassen sich unterteilen in generelle Eigenschaften der Programmiersprache Julia und welche, die speziell für Visualisierung innerhalb fraktale Geometrie von hoher Signifikanz sind. Wir evaluieren im Laufe der nächsten Abschnitte, weshalb die ausgewählten Kriterien für unsere Fragestellung relevant sind.
 
 \begin{itemize}
-    \item Performance
+    \item Performanz
     \item Parallelisierbarkeit
     \item Verfügbarkeit Softwarepakete
     \item Entwicklungsumgebungen
+    \item Nachhaltigkeit
 \end{itemize}
 
-Tests werden durchgeführt auf <Prozessor> <Betriebssystem> <Arbeitsspeicher> und <Julia-Version>
+Am Ende jedes Abschnitts beurteilen wir, wie gut das jeweilig genannte Kriterium durch Julia umgesetzt wurde.
-\subsection{Performance}
+
+\subsection{Performanz}
+
+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.\\~\\
+\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.
+Demnach verwenden wir für die Visualisierung der Mandelbrot-Menge als Rastergrafik einen quadratischen Bildausschnitt mit Umkreismittelpunkt bei $0 + 0i$ und Seitenlänge 4. Um eine $n \times n$ Rastergrafik zu erhalten zerlegen wir unseren Ausschnitt in $n \times n$ Quadrate mit Seitenlänge $\frac{4}{n}$. Aus jedem Rasterquadrat wählen wir eine komplexe Zahl $z_{ij}$ als Repräsentanten für dieses Quadrat aus. Wir bestimmen für jedes $z_{ij}$ ob es nach einer festgelegten Anzahl an Iterationen ins Unendliche divergiert.\\
+Wir nehmen an, dass alle $z_{ij}$ Teil der Mandelbrot-Menge sind, wenn unsere maximale Iteration erreicht wurde und somit die Kreisscheibe nicht verlassen wurde. Diese Methodik fasst sich in Form des \textit{Escape Time Algorithm} \autoref{alg:escape_time_algorithm} zusammen. \autocite{caiStudyMandelbrotSets2013}.
+
+\begin{algorithm}
+	\caption{Escape Time Algorithmus}\label{alg:escape_time_algorithm}
+	\begin{algorithmic}
+		\Function{EscapeTime}{$z, c, t_{max}$}
+			\State $t \gets 0$
+			\While{$|z| < 2$ \AND $t < t_{max}$}
+				\State $z \gets z^2 + c$
+				\State $t \gets t + 1$
+			\EndWhile
+			\State \Return $t$
+		\EndFunction
+	\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.
+
+\begin{figure}[h!]
+	\label{fig:mandelbrot_time}
+	\includegraphics[width=\columnwidth]{images/mandelbrot_time_log.png}
+	\caption{Zeitaufwand in Abhängigkeit der Rastergröße}
+\end{figure}
+
+% Validierung der Daten über Standardabweichung
+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}
+
+Im letzten Jahrhundert verhielt sich der Energieverbrauch zwischen unterschiedlichen Programmiersprachen nahezu analog zueinander. Innerhalb des 20. Jahrhunderts legen Computerhersteller und Softwareentwickler einen größeren Wert auf eine effizientere Energienutzung \autocite{pereiraEnergyEfficiencyProgramming2017}. Neben dem Energieaufwand für Berechnungen wird weitere Energie für Kühlung, Anzeige, Lagerung und Kommunikation verwendet \autocite{dagostinoHardwareSoftwareSolutions2021}. Bedeutet die überdurchschnittliche Performanz, dass Julia auch energieeffizienter ist? Der Energieverbrauch wird durch die Gleichung: 
+\begin{equation*}
+	\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}
 
 \subsection{Parallelisierbarkeit}
 
+Die Berechnung eines Bildes der Mandelbrot-Menge und der Julia-Menge lässt sich auf eine einfache Weise parallelisieren. Der Rechenaufwand für das große Bild kann in mehrere Teilprobleme, die Berechnung der jeweiligen Pixel, aufgeteilt werden. Dies ist von hohem Nutzen, da die Berechnungskosten für einzelne Pixel mit hohem Rechenaufwand verbunden ist \autocite{drakopoulosOverviewParallelVisualisation2003}. Julia unterstützt die vier folgenden Wege zur Parallelisierung von Programmen \autocite{bezansonJuliaLanguageDocumentation}:
+\begin{enumerate}
+	\item \textbf{Koroutinen} Julia bietet die Option die Ausführung von Abläufen zu Pausieren und an späterer Stelle wieder neu zu starten oder zu synchronisieren. Diese Berechnungslast kann auf unterschiedliche Threads verteilt werden.
+	\item \textbf{Multithreading} Aufgaben können auf unterschiedliche Threads oder \acs{CPU}-Kerne aufgeteilt werden. Die unterschiedlichen Threads teilen sich denselben Speicher.
+	\item \textbf{Verteiltes Berechnen} Mithilfe des verteilten Berechnens können mehrere Julia-Prozesse, mit jeweils eigenem Speicher, laufen. Diese müssen nicht zwanghaft auf demselben Computer ausgeführt werden. Die Standard-Bibliothek \texttt{Distributed} bietet die Möglichkeit die Berechnungen von Funktionen auszulagern.
+	\item \textbf{Berechnen auf der GPU} Statt die Berechnungen auf der CPU stattfinden zu lassen, können Berechnungen auf die \ac{GPU} ausgelagert werden.
+\end{enumerate} 
+
+Für allgemeine Probleme ist der leichteste Weg Multithreading zur Beschleunigung der Berechnungen einzusetzen \autocite{bezansonJuliaLanguageDocumentation}. Die Bereitstellung der Bibliothek für Verteiltes Berechnen reduziert zusätzlichen Aufwand seitens des Entwicklers sich um die Koordination der einzelnen Systeme zu kümmern. Eine Skalierung der Rechenleistung für große Projekte durch Julia von Haus aus gewährleistet.
+
 \subsection{Softwarepakete}
 
-Neben den Standardbibliotheken, die mit der Installation einer Programmiersprache mitgeliefert werden, steht Nutzern die Möglichkeit offen eigene Softwarepakete zu entwickeln.
+In folgendem Abschnitt betrachten wir ob die durch das Julia Ecosystem bereitgestellte Ressourcen ausreichen um die Vielfalt unterschiedlicher Fraktale darzustellen. Dazu gehen wir nach einem \textit{Top-Down}-Prinzip vor. Erstmalig wird das Julia Ecosystem auf einer allgemeinen Ebene evaluiert. Im weiteren Verlauf werden einzelne Softwarepakete im Rahmen als Hilfsmittels für die fraktale Geometrie bewertet. Wir überprüfen ob eine Auswahl von Fraktalen mithilfe Julia visualisiert werden können und wie gut die dafür existierenden Strategien umgesetzt sind. Wir unterteilen dabei die Fraktale in folgende Mengen, die nicht zwingend disjunkt zueinander sind.
-Um die Pakete der Öffentlichkeit zur Verfügung zu stellen, können diese in Paketverzeichnisse im Internet hochgeladen werden. \autoref{table:packages} zeigt eine Auswahl von Verzeichnissen für Sprachen aus dem Bereich des wissenschaftlichen Berechnens.
 
-\begin{table}[ht!]
+\begin{itemize}
+	\item Fraktale, die Teilmenge der komplexen Zahlenebene sind. Beispiele dafür sind die Mandelbrot-Menge, sowie die Julia-Menge \autocite{walterFraktaleGeometrischenElemente2018}.
+	\item Fraktale, die sich mithilfe eines Lindenmayer-Systems darstellen lassen, beispielsweise die Peano-Kurve oder die Kochsche Schneeflocke \autocite{alfonsecaRepresentationFractalCurves1996}
+	\item 3-dimensionale Fraktale, wie zum Beispiel den Menger-Schwamm oder eine 3-dimensionale Form des Sierpinski-Dreiecks \autocite{sternemannPlatonischeFraktaleIm}
+\end{itemize}
+
+\subsubsection*{Julias Ecosystem}
+
+Neben den Standardbibliotheken, die mit der Installation einer Programmiersprache mitgeliefert werden, steht Nutzern die Möglichkeit offen eigene Softwarepakete zu entwickeln. Diese Pakete kapseln viele Funktionalitäten im Fokus eines Spezifischen Anwendungsbereichs bspw. Statistik. Um die Pakete der Öffentlichkeit zur Verfügung zu stellen, können diese in Paketverzeichnisse im Internet hochgeladen werden. Diese Möglichkeiten erweitern das traditionelle Verständnis von Softwarentwicklung im Sinner einer kollaborativen Zusammenarbeit von Entwicklern unabhängig ihres Standorts. \autocite{decanTopologyPackageDependency2016}.\autoref{table:packages} zeigt eine Auswahl von Verzeichnissen für Sprachen aus dem Bereich des wissenschaftlichen Berechnens basierend auf \autocite{PyPi2024} \autocite{MATLABFileexchange2024} \autocite{CRANContributedPackages2024} \autocite{JuliaRegistries2024} \autocite{carbonellePYPLPopularityProgramming2023}.
+
+\begin{table}[h!]
     \centering
     \renewcommand{\arraystretch}{1.1}
     \caption{Paketanzahl nach Sprache und Paketverzeichnis}
@@ -105,27 +178,83 @@ Um die Pakete der Öffentlichkeit zur Verfügung zu stellen, können diese in Pa
         \end{tabular}
     \end{footnotesize} 
 \end{table}
-Nach dem \ac{PYPL} Index wird Python als populärste Programmiersprache evaluiert. Julia hingegen belegt hingegen Platz 24 \autocite{carbonellePYPLPopularityProgramming2023}.
+
+Nach dem \ac{PYPL} Index wird Python als populärste Programmiersprache evaluiert. Julia hingegen belegt hingegen Platz 24 \autocite{carbonellePYPLPopularityProgramming2023}. Zwischen beiden Enden liegen die Programmiersprache R und MATLAB. Da MATLAB keinen klassischen Paketmanager besitzt wird hier zum Vergleich die Anzahl der von Nutzer bereit gestellten Programme auf dem MATLAB FileExchange verwendet. Aufallend ist das MATLAB trotz einer proprietären Lizenz eine höhere Anzahl an Paketen bzw. Programmen bereitstellt.
 Diese hohe Popularität erklärt weshalb die Anzahl zwischen Paketen auf \ac{PyPi}, dem Python Package Index, und \textit{JuliaRegistry} sich dem Verhältnis 50:1 nähert.
 Aufgrund des relativ jungen Alters, mit Veröffentlichung von Julia im Jahr 2012 \autocite{cabuttoOverviewJuliaProgramming2018} und der niedrigeren Popularität, besitzt Julia im Vergleich zu den restlichen ausgewählten Programmiersprachen die geringste Anzahl an Paketen.
 
-Kann trotz geringerer Paketanzahl eine diverse Anzahl an Fraktalen visualisiert werden?
+\subsubsection*{Schildkröten und Kurven}
-
+Eine häufig verwendete Strategie zur Darstellung von Fraktalen Kurven sind die von Seymour Papert im Jahr 1980 entwickelten Turtle-Grafiken.
-Wir betrachten folgende Auswahl an klassischen Fraktalen, nach \autocite{walterFraktaleGeometrischenElemente2018}.
+Dabei bewegt sich eine unsichtbare \enquote{Schildkröte} über eine Leinwand und hinterlässt eine farbige Spur. Dabei ist die Schildkröte auf eine Anzahl an Aktionen beschränkt, die aus der Perspektive der Schildkröte geschehen \autocite{alfonsecaRepresentationFractalCurves1996}. Diese können beispielsweise sein:
 \begin{itemize}
-    \item Cantor Menge
+	\item[F] Die Schildkröte bewegt sich einen Schritt nach vorne und hinterlässt dabei eine farbige Spur
-    \item Sierpinski-Dreieck
+	\item[+] Die Schildkröte dreht sich um den Winkel $\alpha$ nach links
-    \item Koch-Kurve
+	\item[-] Die Schildkröte dreht sich um den Winkel $\alpha$ nach rechts
-    \item Raumfüllende Kurven
+\end{itemize}
-    \item Mandelbrot-Menge und Julia Mengen
+Alleine mit einer kleinen Auswahl an Aktionen können komplexe Fraktale erschaffen werden. in Julia wird das Zeichnen von Turtle Grafiken durch das Paket \texttt{Luxor.jl} abgedeckt. Neben unserem Beispiel an 3 Aktionen stellt \texttt{Luxor.jl} 17 weitere möglichen Aktionen zur Bewegung der Schildkröte bereit \autocite{cormullionLuxorJlDokumentation}. 
+
+Mithilfe der Regeln der Turtle-Grafiken lassen sich Lindenmayer Systeme, kurz L-System, darstellen. Ein L-System liefert eine Liste an Ersetzungsregeln die alle gleichzeitig auf eine Zeichenkette angewendet werden. \autocite{mcandrewLindenmayerSystemsFractals}. Diese Ersetzungsregeln können beispielsweise auf Zeichenketten bzw. die Aktionen unserer Schildkröte, bestehend aus F, +, - angewendet werden. 
+Der übrigbleibende Aufwand besteht nur noch darin das L-System in die Aktionen einer Turtle-Grafik zu übersetzen. Das Softwarepaket \texttt{Lindenmayer.jl} abstrahiert uns diesen Arbeitsaufwand weg.
+
+\subsubsection*{Fraktale in $\mathbb{C}$}
+
+Die Mandelbrot-Menge, sowie die Julia-Menge liegen innerhalb der komplexen Zahlen. Mithilfe der Stratege die Mandelbrot-Menge in Form eines Rasters unter Nutzung des \textit{Escape Time Algorithmus} \autoref{alg:escape_time_algorithm} erhalten wir ein Raster bzw. eine Matrix mit den Fluchtzeiten der jeweiligen Eingabewerte. 
+Für vielseitige Visualisierungen ist eine einheitliche Schnittstelle für Farbmodelle und Rastergrafiken vonnöten. Diese geforderte Funktionalität wird durch das Julia-Paket \texttt{JuliaImages.jl} realisiert. Das Paket \texttt{Makie.jl} liefert eine Darstellungsmöglichkeit für 2-dimensionale Rastergrafiken in Form interaktiver Anwendungen mithilfe Benutzereingaben wie bspw. Textboxen, Knöpfe, Slider \autocite{danischMakieJlFlexible2021}. 
+
+\subsubsection*{3-dimensionale Fraktale}
+
+Neben der Möglichkeit 2-dimensionale Rastergrafiken zu erzeugen bietet \texttt{Makie.jl} die Option innerhalb eines 3-dimensionalen Raumes Objekte darzustellen. Mithilfe eines Voxel-Systems können fraktale Objekte mithilfe Würfeln angenähert werden. Neben Würfeln bieten Polygone und Linien weitere Grundbausteine für die Erstellung komplexer Objekte. \autocite{danischMakieJlFlexible2021}. Weitere Möglichkeiten zur Erstellung von 3-dimensionalen Objekten sind das angeben eines Volumens oder das Laden von \texttt{.obj}-Dateien. Die Konstruktion von größeren Objekten erstellt sich aufgrund der zusätzlichen Dimension als schwieriges Unterfangen dar \autocite{danischMakieJlFlexible2021}.
+
+\subsection{Entwicklungsumgebungen}
+
+Die Julia Programmiersprache ist auf macOS, Windows und Linux frei erhältlich
+Mit der Veröffentlichung einer neuen Programmiersprache müssen auch Entwicklungsumgebungen geschaffen werden. Eine Entwicklungsumgebung bietet dem Programmierer nützliche Werkzeuge um Code effizient zu erstellen und zu verändern. Der Typ der Entwicklungsumgebung bzw. \ac{IDE} lässt sich in 3 unterschiedliche Typen kategorisieren:
+
+\begin{itemize}
+	\item eigenständiger Texteditor, die für das Schreiben einer spezifischen Programmiersprache oder einer engen Auswahl an zusammenhängender Programmiersprachen konzipierte wurde. Ein Beispiel für einen solchen Editor ist RStudio für R.
+	\item Erweiterung eines schon existierenden Texteditor, die konzipiert um eine große Breite an Sprachen abzudecken. Ein Beispiel für einen solchen Texteditor ist Visual Studio Code, welches viele Sprachen durch Hinzufügen von Erweiterungen unterstützt.
+	\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}
 
-\subsection{Entwicklungsmgebungen}
+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.
 
+% abgerufen 16.06.2024
+\begin{table}[h!]
+	\centering
+	\renewcommand{\arraystretch}{1.1}
+	\caption{Einordnung Entwicklungsumgebungen}
+	\label{table:ides}
+	\begin{footnotesize}
+		\begin{tabular}{llcr}
+			\toprule
+			\acs{IDE} & Kategorie & Entwicklung & Letzter Release\\
+			\midrule
+			Julia (VS Code) & Erweiterung & Ja & 08.05.2024\\
+			Juno (Atom) & Erweiterung & Nein & 20.11.2020\\
+			Julia (IntelliJ) & Erweiterung & Nein & 23.04.2019\\
+			Julia-Studio & Eigenständig & Nein & 05.11.2013\\
+			Pluto & Notebook & Ja & 08.05.2024\\
+			IJulia (Jupyter) & Notebook & Ja & 02.06.2023\\
+			%Quarto & Notebook & ja & 03.06.2024\\
+			\bottomrule
+		\end{tabular}
+	\end{footnotesize} 
+\end{table}
 
+Aus \autoref{table:ides} ist zu erkennen, dass die Unterstützung von Julia in Form von Notebooks weiterhin gewährleistet ist. Eine eigenständige Entwicklungsumgebung an der aktiv gearbeitet wird ist in unserer Auswahl nicht zu finden. Aus der Kategorie der \textit{Erweiterungen} wird alleinig Julia für Visual Studio Code unterstützt. Zu bemerken ist das die Programmiersprache Julia, sowie auch alle der genannten Entwicklungsumgebungen \acs{IDE} aus \autoref{table:ides} einer proprietären Lizenz unterworfen ist \autocite{bezansonJuliaLanguageDocumentation}. Dies sorgt für eine hohe Zugänglichkeit.
 
 \section{Ergebnis}
 
+Im Gesamtbild liegen die Stärken der Programmiersprache Julia in der überdurchschnittlichen Geschwindigkeit als Skriptsprache. Die Kombination mit einer guten Energieeffizienz trägt dazu bei, dass Julia als grüne Programmiersprache angesehen werden kann. Für sehr große numerische Berechnungen über mehrere Computer eignet sich Julia aufgrund der gegebenen Unterstützung durch Bibliotheken. Im Allgemeinen erkennen wir dass Julia eine wesentlich geringere Anzahl an Softwarepaketen aufgrund der kleineren Community aufweist. Für Funktionalitäten die noch in keinem vorherig veröffentlichten Julia-Paket untergebracht wurde muss selbst Hand angelegt werden oder auf eine andere Sprache umgestiegen werden. Das Starten eines größeren Entwicklungsprojektes wird aufgrund der Verfügbarkeit in Visual Studio Code stattfinden müssen, da restlichen Entwicklungsumgebung an denen aktuell entwickelt wird Notebooks sind. Notebooks eignen sich sehr gut für die spontane Darstellung und für ein \enquote{Proof of Concept} von Ideen. Die allgemeine Entwicklung wird durch recht hohe Kompilierzeiten beeinflusst. Der Entwicklungsstart verzögert sich mit zunehmender Größe an Abhängigkeiten, da diese im Vorhinein erst kompiliert werden müssen. Die Suchen von Fehlern im Debug-Prozess kann situationsbedingt einen hohen zeitlichen Anspruch in Kauf nehmen. Die Auswahl an Softwarepaketen decken die betrachteten Anwendungsfälle der fraktalen Geometrie (Fraktale Kurven, Mandelbrot-Menge, Julia-Menge und 3-dimensionale Fraktale) ab. Julia als Skriptsprache liefert Schnittstellen die viele technische Details abstrahieren und Programmierer sich während des Arbeitsprozesses auf die wesentliche Entwicklung fokussieren können. Julia wird seines Versprechen ein Werkzeug für numerisches Berechnen zur Erstellung von Visualisierungen im Bereich der fraktalen Geometrie gerecht.
+
+\section{Einschränkungen}
+
+Aufgrund der eingeschränkten Zeit, die zur Erstellung dieses Artikels verfügbar ist konnte nur ein Performanz Test für die 3 Programmiersprachen Julia, Python und Java durchgeführt werden. Die Aufnahme weiterer Programmiersprachen wie die restlichen im Artikel aufgezählten Sprachen R, MATLAB und C liefert ein ausführlicheres Bild bezüglich der Vergleichbarkeit der Programmiersprachen untereinander. Die Messungen der Performanz-Test wurden auf einem fest gewählten Computer durchgeführt. Eine Durchführung auf einem weiteren Computer liefert eine zweite Menge an Messwerten die Aussagen über die Vergleichbarkeit der Messergebnisse bezüglich der verwendeten Hardware liefert.
+Für die Performanz der jeweiligen Sprachen erhalten wir ein zeitliches Abbild, da neuere Versionen die Performanz optimalerweise anheben oder verschlechtern können.
+Die Untersuchung der ausgewählten Entwicklungsumgebungen für Julia liefert auch ein temporäres Bild, da jederzeit die Entwicklung an einer Entwicklungsumgebung wieder neu gestartet werden kann oder andererseits auch zum Stillstand kommen kann. Unter anderem liefert die Auswahl der Entwicklungsumgebungen nur eine eingeschränkte Sicht auf die Realität. Die untersuchte Auswahl wurde aufgrund der Popularität der Entwicklungsumgebung getroffen, die wir keiner genauen Messung unterzogen haben. Entwicklern steht auch jederzeit die Möglichkeit offen, eine hier nicht aufgezählte Entwicklungsumgebung zu wählen.
+Die Einschränkungen bezüglich einer getroffenen Auswahl ist auf die ausgewählten Softwarepakete übertragbar. Es existieren Pakete innerhalb des Julia-Paketverzeichnisses, die nicht untersucht wurden, aber auch Möglichkeiten zur Visualisierung von Fraktalen liefern. 
+
+
 \section{Ausblick}
 
 
@@ -143,6 +272,9 @@ Wir betrachten folgende Auswahl an klassischen Fraktalen, nach \autocite{walterF
 \acro{PyPi}{Python Package Index}
 \acro{PYPL}{PopularitY of Programming Language}
 \acro{CRAN}{Comprehensive R Archive Network}
+\acro{IDE}{Integrated Devolopment Environment}
+\acro{CPU}{Central Processing Unit}
+\acro{GPU}{Grapics Processing Unit}
 \end{acronym}
 
 % Literaturverzeichnis