i21023/Vortrag-Bad-Honnef
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add studienarbeit latex code

Browse Source
This commit is contained in:
julian 2024-07-20 01:08:57 +02:00
parent f81307ed68
commit 4fa62b8a74
49 changed files with 15259 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
Studienarbeit/#main.tex# Normal file
View File

@ -0,0 +1,108 @@
%!TEX root = ./main.tex
%%**************************************************************
%%
%% DHBW Heidenheim - Template for Bachelor Thesis
%%
%% Bevor usisng this template please have a look at the REAMDME.md file
%%
%%**************************************************************
\input{ads/header}
\input{content/glossary}
\begin{document}
% Cover
\begin{spacing}{1}
\input{ads/cover}
\end{spacing}
\newpage
\pagenumbering{Roman}
% Restriction notices
\ifDocType{T2\_3100}{%
% no restricition notices for semester paper
}{%
\input{ads/restrictionNotices}
\newpage
}%
% Declaration
\input{ads/declaration}
\newpage
% Abstract
\input{content/abstract}
\newpage
% only page number in footer
\pagestyle{plain}
% space bevore chapter headline
\RedeclareSectionCommand[beforeskip=\chapterMargin]{chapter}
% Contents
\begin{spacing}{1.1}
\begingroup
% set subchapter depth
\setcounter{tocdepth}{2}
\tableofcontents
\clearpage
\endgroup
\end{spacing}
\newpage
% Acronyms
\cleardoublepage
\input{content/acronyms}
% List of Figures
\cleardoublepage
\listoffigures
%List of Tables
\cleardoublepage
\listoftables
% List of Listings
\cleardoublepage
\lstlistoflistings
\cleardoublepage
\pagenumbering{arabic}
\pagestyle{headings}
%Content
\foreach \i in {01,02,03,04,05,06,07,08,09,...,99} {%
\edef\FileName{content/chapter/\i .tex}%
\IfFileExists{\FileName}{%
\input{\FileName}
}
{%
% No chapter available
}
}
\clearpage
% Bibilography
\cleardoublepage
\printbibliography
% Glossar
\cleardoublepage
\printglossary[style=altlist,title=\glossaryPhrase]
\input{content/glossary}
% Appendix
\clearpage
\appendix
\input{content/appendix}
\end{document}

1
Studienarbeit/.#main.tex Symbolic link
View File

@ -0,0 +1 @@
julianschmidt@MacBook-Air-von-Julian.local.5733

BIN
Studienarbeit/.DS_Store vendored Normal file
View File

Binary file not shown.

5
Studienarbeit/.latexmkrc Normal file
View File

@ -0,0 +1,5 @@
$pdf_mode = 1;
$bibtex_use = 2;
$biber = 'biber %O %S';
$pdflatex = 'pdflatex -interaction=errorstopmode -file-line-error %O %S';

21
Studienarbeit/LICENSE Normal file
View File

@ -0,0 +1,21 @@
MIT License
Copyright (c) 2017 Prof. Dr. Rolf Assfalg, Stefan Schneider, Andreas Kießling
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

57
Studienarbeit/ads/cover.tex Normal file
View File

@ -0,0 +1,57 @@
%!TEX root = ../main.tex
\begin{titlepage}
\begin{longtable}{p{8cm} p{8cm}}
\raggedright {\raisebox{\ht\strutbox-\totalheight}{\includegraphics[height=2.5cm]{images/cover/logo-dhbw.pdf}}} &
% no company logo for semester paper and special documents
\ifDocType{T2\_3100}{}{%
\ifSpecialDocument{}{%
\raggedleft {\raisebox{\ht\strutbox-\totalheight}{\includegraphics[height=2.5cm]{images/cover/logo-company.png}}}
}%
}%
\end{longtable}
\enlargethispage{20mm}
\begin{center}
\doublespacing{
\vspace*{12mm} {\LARGE\textbf \documentTitle }}\\
\vspace*{12mm} {\large\textbf {\documentTypePhrase}}\\
% degre only for bachelor thesis
\ifDocType{T2\_3300}{
\vspace*{12mm} \degreePhrase\\
\vspace*{3mm} {\textbf \degree}\\
}
\IfStrEq{\showLecture}{true}{
\vspace*{12mm} \lecturePhrase\\
\vspace*{0mm} {\textbf \lecture}\\
}
\vspace*{12mm} \departmentPhrase{} \department\\
\vspace*{0mm} \locationUniversityPhrase{} \locationUniversity\\
\vspace*{12mm} \documentAuthorPhrase\\
\vspace*{3mm} {\large\textbf \documentAuthor}\\
\vspace*{12mm} \releaseDate\\
\end{center}
\vfill
\begin{spacing}{1.2}
\begin{tabbing}
mmmmmmmmmmmmmmmmmmmmmmmmmm \= \kill
%\textbf{\documentPeriodPhrase} \> \documentPeriod\\
\textbf{\matriculationNumberPhrase, \coursePhrase} \> \matriculationNumber, \course\\
% no company for the semester paper and special documents
\ifDocType{T2\_3100}{}{%
\ifSpecialDocument{}{%
\textbf{\companyPhrase} \> \companyName, \companyLocation\\
}%
}%
\textbf{Betreuer}/\textbf{\tutorPhrase} \> \tutor\\
% evaluator only for bachelor thesis
\ifDocType{T2\_3300}{%
\textbf{\evaluatorPhrase} \> \evaluator
}{}
\end{tabbing}
\end{spacing}
\end{titlepage}

37
Studienarbeit/ads/declaration.tex Normal file
View File

@ -0,0 +1,37 @@
%!TEX root = ../main.tex
\thispagestyle{empty}
\section*{\declarationPhrase}
\vspace*{2em}
\iflang{de}{%
\ifMultipleAuthors{Wir versichern}{Ich versichere} hiermit, dass \ifMultipleAuthors{wir unsere}{ich meine}
{\documentTypePhrase} mit dem Thema: {\itshape \documentTitle }
selbstständig verfasst und keine anderen als die angegebenen Quellen und Hilfsmittel benutzt \ifMultipleAuthors{haben}{habe}.
}
\iflang{en}{%
Hereby \ifMultipleAuthors{we}{I} solemnly declare:
\begin{enumerate}
\item that this {\documentTypePhrase}, titled {\itshape \documentTitle } is entirely the product of \ifMultipleAuthors{our}{my}
own scholarly work, unless otherwise indicated in the text or references, or acknowledged below;
\item \ifMultipleAuthors{we}{I} have indicated the thoughts adopted directly or indirectly from other sources at the appropriate
places within the document;
\item this {\documentTypePhrase} has not been submitted either in whole or part, for a degree at this or
any other university or institution;
\item \ifMultipleAuthors{we}{I} have not published this {\documentTypePhrase} in the past;
\item the printed version is equivalent to the submitted electronic one.
\end{enumerate}
\ifMultipleAuthors{We are}{I am} aware that a dishonest declaration will entail legal consequences.
}
\vspace{3em}
\releaseLocation, 02. Juni 2024
\vspace{4em}
\rule{6cm}{0.4pt}\\
\documentAuthor

190
Studienarbeit/ads/header.tex Normal file
View File

@ -0,0 +1,190 @@
%!TEX root = ../main.tex
% show warning for old LaTeX syntax
\RequirePackage[l2tabu, orthodox]{nag}
\documentclass[
pdftex,
oneside,
12pt, % fontsize
parskip=half, % Space (in lines) between paragraphs
headheight = 12pt, % Header hight
headsepline, % Line after header
footheight = 16pt, % Footer height
footsepline, % Line before footer
abstract=true, % Abstract headline
DIV=calc, % Calculate print space
BCOR=8mm, % BCOR settings (Bindekorrektur)
headinclude=false, % Exclude header from print space
footinclude=false, % Exclude footer from print space
listof=totoc, % Show List of Figures/Tables in Contents
toc=bibliography, % Show Bibliography in Contents
]{scrreprt} % Koma-Script report-class, long document: scrreprt, short document: scrbook
\usepackage{xstring}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
% iflang command definition
\newcommand{\iflang}[2]{%
\IfStrEq{\documentLanguage}{#1}{#2}{}%
}
% ifDocType comand definition
\newcommand{\ifDocType}[3]{%
\IfStrEq{\documentType}{#1}{#2}{#3}%
}
% ifMultipleAuthors definition
\newcommand{\ifMultipleAuthors}[2]{%
\IfStrEq{\multipleAuthors}{true}{#1}{#2}%
}
% ifSpecialDocument definition
\newcommand{\ifSpecialDocument}[2]{\IfStrEqCase{\documentType}{%
{T2_1000}{#2\ignorespaces}%
{T2\_2000}{#2\ignorespaces}%
{T2\_3100}{#2\ignorespaces}%
{T2\_3300}{#2\ignorespaces}%
}[#1\ignorespaces]%
}
% Include main settings
\input{settings/main}
% Include document settings
\input{settings/document}
% Load language specific Strings
\input{lang/\documentLanguage}
% Load language specific babel package
\iflang{de}{\usepackage[english, ngerman]{babel}}
\iflang{en}{\usepackage[ngerman, english]{babel}}
% Add comment feature
\newcommand{\comment}[1]{\par {\bfseries \color{blue} #1 \par}}
%%%%%%% Package Includes %%%%%%%
\usepackage[margin=\margin,foot=1cm]{geometry}
\usepackage[activate]{microtype}
\usepackage[onehalfspacing]{setspace}
\usepackage{makeidx}
\usepackage[autostyle=true,german=quotes]{csquotes}
\usepackage{longtable}
\usepackage{enumitem}
\usepackage{graphicx}
\usepackage{pdfpages}
\usepackage{xcolor}
\usepackage{float}
\usepackage{array}
\usepackage{calc}
\usepackage[right]{eurosym}
\usepackage{wrapfig}
\usepackage{pgffor}
\usepackage[perpage, hang, multiple, stable]{footmisc}
\usepackage[printonlyused]{acronym}
\usepackage{listings}
\usepackage[obeyFinal,backgroundcolor=yellow,linecolor=black]{todonotes}
\usepackage{rotating}
\usepackage{lscape}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{\documentFont}
\usepackage[%
pdftitle={\documentTitle},
pdfauthor={\documentAuthor},
pdfsubject={\documentType},
pdfcreator={pdflatex, LaTeX with KOMA-Script},
pdfpagemode=UseOutlines, % Show Contents while opening
pdfdisplaydoctitle=true, % Show document title instead of file name
pdflang={\documentLanguage}, % Document language
]{hyperref}
\usepackage{bookmark}
\usepackage[nonumberlist,toc]{glossaries}
\usepackage{fontawesome5}
\usepackage{forest}
\usepackage{pgf-pie}
\usepackage{float}
% Generate glossary
\makeglossaries{}
% Load colors
\defineColors{}
% Set Titel, Autor and Date
\title{\documentTitle}
\author{\documentAuthor}
\date{\datum}
% PDF link settings
\hypersetup{%
colorlinks=true,
linkcolor=LinkColor,
citecolor=LinkColor,
filecolor=LinkColor,
menucolor=LinkColor,
urlcolor=LinkColor,
linktocpage=true,
bookmarksnumbered=true
}
% Captions fontsize
\addtokomafont{caption}{\small}
% Bibliographie settings
\iflang{de}{%
\usepackage[
backend=biber, % recommended. Alternative: bibtex
bibwarn=true,
bibencoding=utf8, % If .bib file is encoded with utf8, otherwise ascii
sortlocale=de_DE,
style=numeric
%style=\quoteStyle,
]{biblatex}
}
\iflang{en}{%
\usepackage[
backend=biber, % recommended. Alternative: bibtex
bibwarn=true,
bibencoding=utf8, % If .bib file is encoded with utf8, otherwise ascii
sortlocale=en_US,
style=\quoteStyle,
]{biblatex}
}
\usepackage{amsthm}
\usepackage{tikz}
\usetikzlibrary{shapes,arrows,positioning,calc, positioning, fit, backgrounds,arrows.meta}
\usepackage{pgfplots} % Add this line to import the necessary package
\theoremstyle{definition}
\newtheorem{definition}{Definition}[section]
\addbibresource{bibliographie.bib}
% Hurenkinder und Schusterjungen verhindern
% http://projekte.dante.de/DanteFAQ/Silbentrennung
\clubpenalty = 10000 % schließt Schusterjungen aus (Seitenumbruch nach der ersten Zeile eines neuen Absatzes)
\widowpenalty = 10000 % schließt Hurenkinder aus (die letzte Zeile eines Absatzes steht auf einer neuen Seite)
\displaywidowpenalty=10000
% Graphicspath
\graphicspath{{images/}}
% frequently used programing languages
\lstloadlanguages{PHP,Python,Java,C,C++,bash}
\listingsettings{}
% Rename Listings
\renewcommand\lstlistingname{\listingPhrase}
\renewcommand\lstlistlistingname{\listListingPhrase}
\def\lstlistingautorefname{\authorListingPhrase}
% Spaces in tables
\setlength{\tabcolsep}{\tableColumnMargin}
\renewcommand{\arraystretch}{\tableRowMargin}

51
Studienarbeit/ads/restrictionNotices.tex Normal file
View File

@ -0,0 +1,51 @@
%!TEX root = ../main.tex
\thispagestyle{empty}
\section*{\restrictionNoticesPhrase}
\vspace*{2em}
\iflang{de}{%
Die vorliegende {\documentTypePhrase} mit dem Titel {\itshape{} \documentTitle{}\/} enthält
unternehmensinterne bzw. vertrauliche Informationen der {\companyName}, ist deshalb mit einem
Sperrvermerk versehen und wird ausschließlich zu Prüfungszwecken am Studiengang {\department}
der Dualen Hochschule Baden-Württemberg {\locationUniversity} vorgelegt. Sie ist ausschließlich zur
Einsicht durch den zugeteilten Gutachter, die Leitung des Studiengangs und ggf. den Prüfungsausschuss
des Studiengangs bestimmt. Es ist untersagt,
\begin{itemize}
\item den Inhalt dieser Arbeit (einschließlich Daten, Abbildungen, Tabellen, Zeichnungen usw.) als
Ganzes oder auszugsweise weiterzugeben,
\item Kopien oder Abschriften dieser Arbeit (einschließlich Daten, Abbildungen, Tabellen,
Zeichnungen usw.) als Ganzes oder in Auszügen anzufertigen,
\item diese Arbeit zu veröffentlichen bzw. digital, elektronisch oder virtuell zur Verfügung zu stellen.
\end{itemize}
Jede anderweitige Einsichtnahme und Veröffentlichung – auch von Teilen der Arbeit – bedarf der
vorherigen Zustimmung durch den Verfasser und {\companyName}.
}
%http://www.ib.dhbw-mannheim.de/fileadmin/ms/bwl-ib/Downloads_alt/Leitfaden_31.05.pdf
\iflang{en}{%
The {\documentTypePhrase} on hand
\begin{center}{\itshape{} \documentTitle{}\/}\end{center}
contains internal resp.\ confidential data of {\companyName}. It is intended solely for inspection by the
assigned examiner, the head of the {\department} department and, if necessary, the Audit
Committee \locationUniversityPhrase{} {\locationUniversity}. It is strictly forbidden
\begin{itemize}
\item to distribute the content of this paper (including data, figures, tables, charts etc.) as a whole or
in extracts,
\item to make copies or transcripts of this paper or of parts of it,
\item to display this paper or make it available in digital, electronic or virtual form.
\end{itemize}
Exceptional cases may be considered through permission granted in written form by the author
and {\companyName}.
}
\vspace{3em}
\releaseLocation, \releaseDate
\vspace{4em}
\rule{6cm}{0.4pt}\\
\documentAuthor

587
Studienarbeit/bibliographie.bib Normal file
View File

@ -0,0 +1,587 @@
@article{marlow_haskell_2010,
title = {Haskell 2010 language report},
journaltitle = {Available online http://www. haskell. org/(May 2011)},
author = {Marlow, Simon and {others}},
date = {2010},
}
@article{schwabbauer_use_1975,
title = {Use of the latent image technique to develop and evaluate problem-solving skills},
volume = {41},
issn = {0002-9335},
abstract = {This project involved designing, developing and evaluating a simulation module, utilizing the latent image technique. The general topic chosen for this simulation was the laboratory characterization of anemias. Target learner populations included medical technology students, physician assistant students, and pathology residents. Members of all three groups participated in the evaluation of the module and responded to its use in varied settings.},
pages = {457--462},
number = {12},
journaltitle = {The American Journal of Medical Technology},
shortjournal = {Am J Med Technol},
author = {Schwabbauer, M. L.},
date = {1975-12},
pmid = {2010},
keywords = {Anemia, Hematuria, Humans, Iowa, Medical Laboratory Science, Models, Psychological, Physician Assistants, Problem Solving, Teaching, Teaching Materials},
}
@online{goetz_jep_2016,
title = {{JEP} 286: Local-Variable Type Inference},
url = {https://openjdk.org/jeps/286},
titleaddon = {{JEP} 286: Local-Variable Type Inference},
author = {Goetz, Brian},
urldate = {2024-04-25},
date = {2016-03-08},
langid = {english},
file = {JEP 286\: Local-Variable Type Inference:/Users/julianschmidt/Zotero/storage/6TH6X9NA/286.html:text/html},
}
@online{darcy_java_2010,
title = {The Java Community Process({SM}) Program - {JSRs}: Java Specification Requests - detail {JSR}\# 334},
url = {https://jcp.org/en/jsr/detail?id=334},
titleaddon = {{JSR} 334: Small Enhancements to the {JavaTM} Programming Language},
author = {Darcy, Joe},
urldate = {2024-04-25},
date = {2010-11-16},
langid = {english},
file = {The Java Community Process(SM) Program - JSRs\: Java Specification Requests - detail JSR# 334:/Users/julianschmidt/Zotero/storage/JKYYJAC8/detail.html:text/html},
}
@online{darcy_jep_2011,
title = {{JEP} 126: Lambda Expressions \& Virtual Extension Methods},
url = {https://openjdk.org/jeps/126},
titleaddon = {{JEP} 126: Lambda Expressions \& Virtual Extension Methods},
author = {Darcy, Joseph D.},
date = {2011-11-01},
}
@inproceedings{odersky_pizza_1997,
location = {Paris, France},
title = {Pizza into Java: translating theory into practice},
isbn = {978-0-89791-853-4},
url = {http://portal.acm.org/citation.cfm?doid=263699.263715},
doi = {10.1145/263699.263715},
shorttitle = {Pizza into Java},
eventtitle = {the 24th {ACM} {SIGPLAN}-{SIGACT} symposium},
pages = {146--159},
booktitle = {Proceedings of the 24th {ACM} {SIGPLAN}-{SIGACT} symposium on Principles of programming languages - {POPL} '97},
publisher = {{ACM} Press},
author = {Odersky, Martin and Wadler, Philip},
urldate = {2024-04-25},
date = {1997},
langid = {english},
file = {Volltext:/Users/julianschmidt/Zotero/storage/RSQWTLP7/Odersky und Wadler - 1997 - Pizza into Java translating theory into practice.pdf:application/pdf},
}
@online{cimadamore_jep_2011,
title = {{JEP} 101: Generalized Target-Type Inference},
url = {https://openjdk.org/jeps/101},
titleaddon = {{JEP} 101: Generalized Target-Type Inference},
author = {Cimadamore, Maurizio},
urldate = {2024-04-25},
date = {2011-02-22},
file = {JEP 101\: Generalized Target-Type Inference:/Users/julianschmidt/Zotero/storage/NXVIDL23/101.html:text/html},
}
@book{gosling_java_2005,
location = {Upper Saddle River, {NJ}},
edition = {3},
title = {The Java Language Specification, 3rd Edition},
isbn = {978-0-321-24678-3},
abstract = {Written by the inventors of the language, this book provides the mostauthoritative technical reference for all serious programmers seeking to sharpenand hone their Java programming skills. As the definitive reference book, itprovides programmers with complete, precise, and detailed coverage of theentire Java programming language and defines the current state and evolutionof the language. Java 1.5 aka "Tiger"( and soon to be Java 5.0) will be releasedin the fall of 2004, and this reference supplies coverage on the most recentupdates to the Java language including generics, a tool developers have beenasking to be included in the language for years.},
pagetotal = {684},
publisher = {Addison Wesley},
author = {Gosling, James and Joy, Bill and Jr, Guy L. Steele and Bracha, Gilad},
date = {2005-06-14},
file = {jls3.pdf:/Users/julianschmidt/Zotero/storage/2A3STVHH/jls3.pdf:application/pdf},
}
@online{buckley_java_2004,
title = {The Java Community Process({SM}) Program - {JSRs}: Java Specification Requests - detail {JSR}\# 14},
url = {https://www.jcp.org/en/jsr/detail?id=14},
titleaddon = {{JSR} 14: Add Generic Types To The {JavaTM} Programming Language},
author = {Buckley, Alex},
urldate = {2024-04-25},
date = {2004-09-30},
langid = {english},
file = {The Java Community Process(SM) Program - JSRs\: Java Specification Requests - detail JSR# 14:/Users/julianschmidt/Zotero/storage/43BSC4VI/detail.html:text/html},
}
@online{noauthor_jdk_nodate,
title = {{JDK} 7 Features},
url = {https://openjdk.org/projects/jdk7/features/},
urldate = {2024-04-25},
file = {JDK 7 Features:/Users/julianschmidt/Zotero/storage/7XCG2WCR/features.html:text/html},
}
@online{noauthor_jdk_nodate-1,
title = {{JDK} 10},
url = {https://openjdk.org/projects/jdk/10/},
urldate = {2024-04-25},
file = {JDK 10:/Users/julianschmidt/Zotero/storage/4B425SGD/10.html:text/html},
}
@online{nutter_first_nodate,
title = {A First Taste of {InvokeDynamic}},
url = {http://blog.headius.com/2008/09/first-taste-of-invokedynamic.html},
abstract = {Greetings, readers!
Over the past couple weeks I've had a few departures from typical {JRuby} development. I consider it a working vacation. I'm hoping to report on all of it soon, but for now we'll focus on one of the most exciting items: {JSR}-292, otherwise known as},
author = {Nutter, Charles Oliver},
urldate = {2024-04-25},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/SNC2TWBT/first-taste-of-invokedynamic.html:text/html},
}
@inproceedings{plumicke_well-typings_2011,
location = {New York, {NY}, {USA}},
title = {Well-typings for Javaλ},
isbn = {978-1-4503-0935-6},
url = {https://dl.acm.org/doi/10.1145/2093157.2093171},
doi = {10.1145/2093157.2093171},
series = {{PPPJ} '11},
abstract = {In the last decade Java has been extended by some features, which are well-known from functional programming languages. In Java 8 the language will be expanded by closures (λ-expressions). In our contribution we give a formal definition for an abstract syntax of a reduced language Javaλ with closures, define the type system, and formalize the subtyping relation. We define the set of types as an extension of the generic type definition for Java 5 types. Finally, we give a type inference system, which describes the typings of Javaλ expressions and statements and we present a type inference algorithm. The type inference algorithm is an adaptation of a type inference algorithm for a typed λ--calculus. The inferred types are well-typings. A well-typing is a conditional type for an expression, where the conditions are given by a set of consistent coercions.},
pages = {91--100},
booktitle = {Proceedings of the 9th International Conference on Principles and Practice of Programming in Java},
publisher = {Association for Computing Machinery},
author = {Plümicke, Martin},
urldate = {2024-04-24},
date = {2011-08-24},
keywords = {code generation, language design, program design and implementation, type inference, type system},
file = {Full Text PDF:/Users/julianschmidt/Zotero/storage/MV3KS9G9/Plümicke - 2011 - Well-typings for Javaλ.pdf:application/pdf},
}
@article{stadelmeier_global_2022,
title = {Global Type Inference for Featherweight Generic Java - Prototype Implementation (Artifact)},
rights = {https://creativecommons.org/licenses/by/4.0/legalcode},
url = {https://drops.dagstuhl.de/entities/document/10.4230/DARTS.8.2.18},
doi = {10.4230/DARTS.8.2.18},
abstract = {We implemented a prototype of the type inference algorithm described in the paper "Global Type Inference for Featherweight Generic Java". Our type inference algorithm for Featherweight Generic Java ({GFJ}) is able to calculate the missing types in a Typeless Featherweight Generic Java ({FGJ}-{GT}) program. Inserting those types generates a valid {GFJ} program. We demonstrate this with a prototype implementation. The prototype is a web application which accepts {GFJ}-{GT} programs as input and shows the respective {GFJ} program after the type inference.},
journaltitle = {{DROPS}-{IDN}/v2/document/10.4230/{DARTS}.8.2.18},
author = {Stadelmeier, Andreas and Plümicke, Martin and Thiemann, Peter},
urldate = {2024-04-24},
date = {2022},
langid = {english},
note = {Publisher: Schloss Dagstuhl – Leibniz-Zentrum für Informatik},
file = {Full Text PDF:/Users/julianschmidt/Zotero/storage/3YMFJLVR/Stadelmeier et al. - 2022 - Global Type Inference for Featherweight Generic Ja.pdf:application/pdf},
}
@inproceedings{plumicke_introducing_2017,
location = {New York, {NY}, {USA}},
title = {Introducing Scala-like function types into Java-{TX}},
isbn = {978-1-4503-5340-3},
url = {https://doi.org/10.1145/3132190.3132203},
doi = {10.1145/3132190.3132203},
series = {{ManLang} 2017},
abstract = {This paper considers the realisation of lambda expressions in Java 8 on the basis of a global type inference algorithm, which we have introduced in Java-{TX}. We demonstrate that the Java 8 approach has indeed some benefits but also a number of drawbacks. In order to eliminate the drawbacks, we take into consideration the approaches in a former experimental Java version (strawman approach) and in Scala. We show that an integration of these approaches eliminates the drawbacks without losing the benefits of the Java 8 approach. Additionally, we adapt our global type inference algorithm to this extended language.},
pages = {23--34},
booktitle = {Proceedings of the 14th International Conference on Managed Languages and Runtimes},
publisher = {Association for Computing Machinery},
author = {Plümicke, Martin and Stadelmeier, Andreas},
urldate = {2024-04-24},
date = {2017-09-27},
keywords = {type inference, function types, Java, lambda expressions},
file = {Plümicke und Stadelmeier - 2017 - Introducing Scala-like function types into Java-TX.pdf:/Users/julianschmidt/Zotero/storage/T433TNLU/Plümicke und Stadelmeier - 2017 - Introducing Scala-like function types into Java-TX.pdf:application/pdf},
}
@online{noauthor_zotero_nodate,
title = {Zotero {\textbar} Downloads},
url = {https://www.zotero.org/download/},
urldate = {2024-03-31},
}
@incollection{quissanga_comparative_2023,
title = {Comparative Study of Information Security in Mobile Operating Systems: Android and Apple {iOS}},
isbn = {978-1-80355-651-2},
shorttitle = {Comparative Study of Information Security in Mobile Operating Systems},
abstract = {This theme addresses information security in mobile operating systems: Android and {iOS}, compare vulnerabilities, and propose security policies, the methodology is qualitative based on bibliographic reference, documentary, and quantitative techniques, which allowed to evaluate the study in detail, the data collected in a systematic way, investigating security measures in mobile phones. It was performed the search to Google Academic® and the Portal de Periódicos Capes. As for the data analysis, it was done in a descriptive way. However, it was concluded that the {iOS} system presents greater information security compared to Android. Virus infections are not of concern at the moment, but other cyber attacks, spywares capture confidential information by taking to the remote server. The attacks can be identified by the victims online, in industrial, and by targeting them individually. Android and {iOS} operating systems are preferred by cybercriminals. As for cyber attacks, social networks are the focus. For security policies, we propose preventive, detective, and corrective measures, assign difficult passwords, use modern {WPA} encryption, Noroot firewall, the Privacy Badger tool for blocking websites, Panopticlick for test web, {VeraCrypt} to encrypt documents, and the Signal app that encrypts calls.},
author = {Quissanga, Fernando},
date = {2023-04-28},
doi = {10.5772/intechopen.109652},
file = {Volltext:/Users/julianschmidt/Zotero/storage/XHZC3NJK/Quissanga - 2023 - Comparative Study of Information Security in Mobil.pdf:application/pdf},
}
@article{garg_comparative_2021,
title = {Comparative analysis of Android and {iOS} from security viewpoint},
volume = {40},
issn = {1574-0137},
url = {https://www.sciencedirect.com/science/article/pii/S1574013721000125},
doi = {10.1016/j.cosrev.2021.100372},
abstract = {Smartphone usage has increased exponentially in the recent years. Android and {iOS} are the most popular smartphone platforms, while the ease of use along with the computational power to handle a wide array of applications attracts millions of users worldwide, also raises the security concerns on these platforms. This paper presents a comparative analysis between Android and {iOS} on a wide range of security aspects. It analyzes data for the period 2015-2019 and gives a detailed snapshot of not only the quantum of vulnerabilities, but also their impact. In addition, the paper leverages the well-established security triad i.e. {CIA} (Confidentiality, Integrity, Availability) to compare both the operating systems. The comprehensive and pragmatic approach taken in the paper makes it easier to infer that Android is more susceptible to security breaches and malware attacks as compared to {iOS}. Hence, researchers should divert their efforts and focus on finding solutions to problems pertaining to Android. The paper concludes by laying down future research directions and scope of work, which can be leveraged not only by application developers, but also by researchers. This will help make Android safer for users and will further increase its demand as a mobile operating system.},
pages = {100372},
journaltitle = {Computer Science Review},
shortjournal = {Computer Science Review},
author = {Garg, Shivi and Baliyan, Niyati},
urldate = {2024-05-02},
date = {2021-05-01},
keywords = {Android, {iOS}, Malware, Security, Smartphones, Vulnerabilities},
file = {ScienceDirect Snapshot:/Users/julianschmidt/Zotero/storage/WKZLXY52/S1574013721000125.html:text/html},
}
@online{corrons_flashlight_2019,
title = {Flashlight Apps on Google Play Request Up to 77 Permissions},
url = {https://decoded.avast.io/luiscorrons/flashlight-apps-on-google-play-request-up-to-77-permissions/},
abstract = {Recently, {FaceApp} was widely discussed on the Internet, because the company behind it is Russian, and the app requests permission to access, among other things, photos. It is clear that {FaceApp} is not malicious, although it raises valid privacy concerns. However, is this just a special case, or should we be concerned about all the […]},
titleaddon = {Avast Threat Labs},
author = {Corrons, Luis},
urldate = {2024-05-02},
date = {2019-09-10},
langid = {american},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/LXZ4YZN2/flashlight-apps-on-google-play-request-up-to-77-permissions.html:text/html},
}
@book{gosling_java_2014,
location = {Upper Saddle River, {NJ}},
edition = {Java {SE} 8 edition},
title = {The Java® language specification},
isbn = {978-0-13-390069-9},
pagetotal = {758},
publisher = {Addison-Wesley},
author = {Gosling, James and Joy, Bill and Steele, Guy L. and Bracha, Gilad and Buckley, Alex},
date = {2014},
note = {{OCLC}: ocn873760233},
keywords = {Java (Computer program language)},
file = {Gosling et al. - 2014 - The Java® language specification.pdf:/Users/julianschmidt/Zotero/storage/QQVBP9E3/Gosling et al. - 2014 - The Java® language specification.pdf:application/pdf},
}
@book{noauthor_java_nodate,
title = {The Java Language Specification, Java {SE} 8 Edition (Java Series)},
}
@online{noauthor_chapter_nodate,
title = {Chapter 9. Interfaces},
url = {https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html},
titleaddon = {Java® {SE} 8 Release Contents ("Specification")},
urldate = {2024-05-06},
file = {Chapter 9. Interfaces:/Users/julianschmidt/Zotero/storage/GKDPQTFN/jls-9.html:text/html},
}
@online{goetz_java_2010,
title = {The Java Community Process({SM}) Program - {JSRs}: Java Specification Requests - detail {JSR}\# 335},
url = {https://www.jcp.org/en/jsr/detail?id=335},
titleaddon = {{JSR} 335: Lambda Expressions for the {JavaTM} Programming Language},
author = {Goetz, Brian},
urldate = {2024-05-06},
date = {2010-11-16},
file = {The Java Community Process(SM) Program - JSRs\: Java Specification Requests - detail JSR# 335:/Users/julianschmidt/Zotero/storage/KJ77QXGF/detail.html:text/html},
}
@online{noauthor_openjdk_nodate,
title = {{OpenJDK}: Project Lambda},
url = {https://openjdk.org/projects/lambda/},
urldate = {2024-05-06},
file = {OpenJDK\: Project Lambda:/Users/julianschmidt/Zotero/storage/SWMFTZ94/lambda.html:text/html},
}
@online{noauthor_introduction_nodate,
title = {Introduction - {HaskellWiki}},
url = {https://wiki.haskell.org/Introduction},
urldate = {2024-05-09},
}
@online{noauthor_introduction_nodate-1,
title = {Introduction - {HaskellWiki}},
url = {https://wiki.haskell.org/Introduction},
urldate = {2024-05-09},
file = {Introduction - HaskellWiki:/Users/julianschmidt/Zotero/storage/AHZGWBQT/Introduction.html:text/html},
}
@article{marlow_haskell_2010-1,
title = {Haskell 2010 language report},
journaltitle = {Available online http://www. haskell. org/(May 2011)},
author = {Marlow, Simon and {others}},
date = {2010},
file = {haskell2010.pdf:/Users/julianschmidt/Zotero/storage/YYJ5IGAG/haskell2010.pdf:application/pdf},
}
@book{pierce_types_2002,
location = {Cambridge, Massachusetts London, England},
title = {Types and programming languages},
isbn = {978-0-262-16209-8},
pagetotal = {623},
publisher = {The {MIT} Press},
author = {Pierce, Benjamin C.},
date = {2002},
}
@book{stallman_gnu_2004,
location = {Boston, Mass},
title = {{GNU} Make: a program for directing recompliation ; {GNU} make version 3.81},
isbn = {978-1-882114-83-2},
shorttitle = {{GNU} Make},
pagetotal = {184},
publisher = {Free Software Foundation},
author = {Stallman, Richard and {McGrath}, Roland and Smith, Paul D.},
date = {2004},
}
@online{noauthor_java_nodate-1,
title = {Java Development Kit Version 17 {API} Specification},
url = {https://docs.oracle.com/en/java/javase/17/docs/specs/man/javac.html#directory-hierarchies},
urldate = {2024-05-19},
langid = {english},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/S5D5X3CK/javac.html:text/html},
}
@book{terry_compilers_1997,
location = {London},
title = {Compilers and compiler generators: an introduction with C++},
isbn = {978-1-85032-298-6},
shorttitle = {Compilers and compiler generators},
pagetotal = {579},
publisher = {International Thomson Computer Press},
author = {Terry, Patrick D.},
date = {1997},
file = {Terry und Terry - 1997 - Compilers and compiler generators an introduction.pdf:/Users/julianschmidt/Zotero/storage/6JKV89EJ/Terry und Terry - 1997 - Compilers and compiler generators an introduction.pdf:application/pdf},
}
@report{plumicke_java-tx_2022,
title = {Java-{TX}: The language},
url = {https://www.dhbw-stuttgart.de/forschung-transfer/technik/schriftenreihe-insights/},
abstract = {Java-{TX} ({TX} steht für Type {eXtended}) ist eine Erweiterung von Java, deren wesentliche neue Eigenschaften globale Typinferenz und echte Funktion- stypen sind. Funktionstypen werden in Java-{TX} ähnlich wie bei Scala eingeführt. Zusätzlich werden sie in das Zieltypen-Konzept von Java in- tegriert, wie es im sogenannten Stawman-Ansatz vorgeschlagen wurde. Diese Erweiterungen führen zu einer neuen Überladungseigenschaft, die Methodendeklaration mit Durchschnittstypen erlaubt. Darüber hinaus haben Java-{TX}-Methoden allgemeinste Typen. Zusätzlich werden Typ- parameter von Klassen und Methoden automatisch generiert. Schließlich werden Parameter von Funktionstypen heterogen übersetzt.},
institution = {Fakultät Technik der Dualen Hochschule Baden-Württemberg Stuttgart},
author = {Plümicke, Martin and Zink, Etienne},
date = {2022-01},
langid = {english},
file = {Prof. Dr. habil. Plümicke und Zink - 2022 - Java-TX The language.pdf:/Users/julianschmidt/Zotero/storage/DFCLDI9R/Prof. Dr. habil. Plümicke und Zink - 2022 - Java-TX The language.pdf:application/pdf},
}
@online{noauthor_maven_nodate,
title = {Maven – Introduction},
url = {https://maven.apache.org/what-is-maven.html},
urldate = {2024-05-20},
file = {Maven – Introduction:/Users/julianschmidt/Zotero/storage/B9499E36/what-is-maven.html:text/html},
}
@online{rose_value_2014,
title = {Value Types for Java},
url = {https://cr.openjdk.org/~jrose/values/values-0.html},
abstract = {This is a sketch of proposed enhancements to the Java Virtual Machine instruction set, and secondarily to the Java Language, to support small immutable, identityless value types. (They may also be considered as identityless aggregates, user-defined primitives, immutable records, or restricted classes.) This is an early draft, intended to describe the overall approach. Readers are expected to be familiar with the {JVM} bytecode instruction set.},
author = {Rose, John and Goetz, Brian and Steele, Guy},
urldate = {2024-05-26},
date = {2014-04},
file = {Value Types for Java:/Users/julianschmidt/Zotero/storage/2BXYZARN/values-0.html:text/html},
}
@online{softwarealchemy_streamline_2024,
title = {Streamline Your Java Code: A Cheat Sheet for Mastering Streams},
url = {https://medium.com/javarevisited/streamline-your-java-code-a-cheat-sheet-for-mastering-streams-e8500f4495fe},
shorttitle = {Streamline Your Java Code},
abstract = {Java Streams, introduced in Java 8, revolutionized how we work with collections. They offer a declarative and functional approach to…},
titleaddon = {Javarevisited},
author = {{SoftwareAlchemy}},
urldate = {2024-05-25},
date = {2024-04-23},
langid = {english},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/2W523K54/streamline-your-java-code-a-cheat-sheet-for-mastering-streams-e8500f4495fe.html:text/html},
}
@online{baeldung_java_2016,
title = {The Java 8 Stream {API} Tutorial {\textbar} Baeldung},
url = {https://www.baeldung.com/java-8-streams},
abstract = {The article is an example-heavy introduction of the possibilities and operations offered by the Java 8 Stream {API}.},
author = {{Baeldung}},
urldate = {2024-05-25},
date = {2016-06-15},
langid = {american},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/KH3BN6ZN/java-8-streams.html:text/html},
}
@online{nero_all_2023,
title = {All about Java class loaders},
url = {https://www.infoworld.com/article/3700054/all-about-java-class-loaders.html},
abstract = {Here's a quick look at the three types of class loaders and everything you need to know to work with them in your Java programs.},
titleaddon = {{InfoWorld}},
author = {Nero, Rafael del},
urldate = {2024-05-25},
date = {2023-06-29},
langid = {english},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/8E5TQLJK/all-about-java-class-loaders.html:text/html},
}
@online{baeldung_class_2024,
title = {Class Loaders in Java {\textbar} Baeldung},
url = {https://www.baeldung.com/java-classloaders},
abstract = {Have a look at the behind-the-scenes of loading Java classes during runtime to the {JVM}.},
author = {{Baeldung}},
urldate = {2024-05-25},
date = {2024-05-11},
langid = {american},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/4XWFE8UP/java-classloaders.html:text/html},
}
@online{noauthor_for-each_nodate,
title = {The For-Each Loop},
url = {https://docs.oracle.com/javase/8/docs/technotes/guides/language/foreach.html},
urldate = {2024-05-23},
file = {The For-Each Loop:/Users/julianschmidt/Zotero/storage/H8NNNKR8/foreach.html:text/html},
}
@online{noauthor_java_nodate-2,
title = {Java® Platform, Standard Edition \& Java Development Kit Version 21 {API} Specification},
url = {https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/List.html},
abstract = {declaration: module: java.base, package: java.util, interface: List},
urldate = {2024-05-29},
langid = {english},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/XU4PK5LJ/List.html:text/html},
}
@online{piquerez_variances_nodate,
title = {Variances},
url = {https://docs.scala-lang.org/tour/variances.html},
titleaddon = {Scala Documentation},
author = {Piquerez, Adrien and Thompson, Jamie and et. al.},
urldate = {2024-05-30},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/J377ZJ6M/variances.html:text/html},
}
@online{wagner_creating_2021,
title = {Creating Variant Generic Interfaces - C\#},
url = {https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/covariance-contravariance/creating-variant-generic-interfaces},
abstract = {Learn how to create variant generic interfaces with covariant or contravariant generic type parameters.},
author = {Wagner, Bill and Martinez, Jason and Warren, Genevieve and et.al.},
urldate = {2024-05-30},
date = {2021-09-15},
langid = {english},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/FKDNJJ4G/creating-variant-generic-interfaces.html:text/html},
}
@misc{zink_heterogene_2022,
title = {Heterogene Übersetzung echter Funktionstypen},
author = {Zink, Etienne},
date = {2022-05-30},
}
@book{vandevoorde_c_2010,
location = {Boston, Mass.},
title = {C++ templates: the complete guide},
isbn = {978-0-201-73484-2},
shorttitle = {C++ templates},
pagetotal = {528},
publisher = {Addison-Wesley},
author = {Vandevoorde, David and Josuttis, Nicolai M.},
date = {2010},
file = {C++ Templates-The Complete Guide.pdf:/Users/julianschmidt/Zotero/storage/NS577488/C++ Templates-The Complete Guide.pdf:application/pdf;Table of Contents PDF:/Users/julianschmidt/Zotero/storage/HIL2ULZY/Vandevoorde und Josuttis - 2010 - C++ templates the complete guide.pdf:application/pdf},
}
@book{naftalin_java_2007,
location = {Beijing ; Sebastopol, {CA}},
title = {Java generics and collections},
isbn = {978-0-596-52775-4},
pagetotal = {273},
publisher = {O'Reilly},
author = {Naftalin, Maurice and Wadler, Philip},
date = {2007},
note = {{OCLC}: ocm76810468},
keywords = {Java (Computer program language), Object-oriented programming (Computer science)},
file = {Naftalin und Wadler - 2007 - Java generics and collections.pdf:/Users/julianschmidt/Zotero/storage/CHFZTFU4/Naftalin und Wadler - 2007 - Java generics and collections.pdf:application/pdf},
}
@online{noauthor_openjdk_nodate-1,
title = {{OpenJDK} Repository - Javac},
url = {https://github.com/openjdk/jdk/blob/master/src/jdk.compiler/share/classes/com/sun/tools/javac},
abstract = {{OpenJDK} Repository - javac},
titleaddon = {{GitHub}},
urldate = {2024-06-01},
langid = {english},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/IVHPFRJX/javac.html:text/html},
}
@online{noauthor_gcc--cxx_nodate,
title = {gcc-in-cxx - {GCC} Wiki},
url = {https://gcc.gnu.org/wiki/gcc-in-cxx},
urldate = {2024-06-01},
file = {gcc-in-cxx - GCC Wiki:/Users/julianschmidt/Zotero/storage/L86FUZPB/gcc-in-cxx.html:text/html},
}
@misc{stallman_using_2024,
title = {Using the {GNU} Compiler Collection For gcc version 14.1.0},
url = {https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc.pdf},
publisher = {Free Software Foundation},
author = {Stallman, Richard and {GCC Developer Community}},
date = {2024},
}
@incollection{goos_variance-based_2002,
location = {Berlin, Heidelberg},
title = {On Variance-Based Subtyping for Parametric Types},
volume = {2374},
isbn = {978-3-540-43759-8 978-3-540-47993-2},
url = {http://link.springer.com/10.1007/3-540-47993-7_19},
pages = {441--469},
booktitle = {{ECOOP} 2002 — Object-Oriented Programming},
publisher = {Springer Berlin Heidelberg},
author = {Igarashi, Atsushi and Viroli, Mirko},
editor = {Magnusson, Boris},
editorb = {Goos, Gerhard and Hartmanis, Juris and Van Leeuwen, Jan},
editorbtype = {redactor},
urldate = {2024-06-01},
date = {2002},
doi = {10.1007/3-540-47993-7_19},
note = {Series Title: Lecture Notes in Computer Science},
}
@online{jetbrains_java_2023,
title = {Java Programming - The State of Developer Ecosystem in 2023 Infographic},
url = {https://www.jetbrains.com/lp/devecosystem-2023},
abstract = {Learn about the latest Java trends, usage, and popularity in {JetBrains}' annual report.},
titleaddon = {{JetBrains}: Developer Tools for Professionals and Teams},
author = {{Jetbrains}},
urldate = {2024-06-01},
date = {2023},
langid = {english},
file = {Snapshot:/Users/julianschmidt/Zotero/storage/XXVZB5AH/java.html:text/html},
}
@online{oracle_type_nodate,
title = {Type Inference (The Java™ Tutorials {\textgreater} Learning the Java Language {\textgreater} Generics (Updated))},
url = {https://docs.oracle.com/javase/tutorial/java/generics/genTypeInference.html},
author = {{Oracle}},
urldate = {2024-06-01},
file = {Type Inference (The Java™ Tutorials > Learning the Java Language > Generics (Updated)):/Users/julianschmidt/Zotero/storage/UG9UXUUI/genTypeInference.html:text/html},
}
@book{thompson_haskell_2011,
location = {Harlow, England ; New York},
edition = {3rd ed},
title = {Haskell: the craft of functional programming},
isbn = {978-0-201-88295-7},
shorttitle = {Haskell},
pagetotal = {585},
publisher = {Addison Wesley},
author = {Thompson, Simon},
date = {2011},
keywords = {Functional programming (Computer science)},
}
@online{noauthor_asm_nodate,
title = {{ASM}},
url = {https://asm.ow2.io/},
urldate = {2024-06-02},
file = {ASM:/Users/julianschmidt/Zotero/storage/JRXGAA3X/asm.ow2.io.html:text/html},
}
@online{noauthor_antlr_nodate,
title = {{ANTLR}},
url = {https://www.antlr.org/},
urldate = {2024-06-02},
file = {ANTLR:/Users/julianschmidt/Zotero/storage/9KDGUILD/www.antlr.org.html:text/html},
}
@online{noauthor_raw_nodate,
title = {Raw Types (The Java™ Tutorials {\textgreater} Learning the Java Language {\textgreater} Generics (Updated))},
url = {https://docs.oracle.com/javase/tutorial/java/generics/rawTypes.html},
urldate = {2024-06-02},
file = {Raw Types (The Java™ Tutorials > Learning the Java Language > Generics (Updated)):/Users/julianschmidt/Zotero/storage/QYJ4KVMB/rawTypes.html:text/html},
}
@online{noauthor_string_nodate,
title = {String (Java Platform {SE} 8 )},
url = {https://docs.oracle.com/javase/8/docs/api/java/lang/String.html},
urldate = {2024-06-02},
file = {String (Java Platform SE 8 ):/Users/julianschmidt/Zotero/storage/GHKI499F/String.html:text/html},
}
@inproceedings{stadelmeier_java_2015,
location = {Cottbus, Deutschland},
title = {Java type inference as an Eclipse plugin},
url = {https://subs.emis.de/LNI/Proceedings/Proceedings246/article18.html},
eventtitle = {45. Jahrestagung der Gesellschaft für Informatik, Informatik 2015, Informatik, Energie und Umwelt},
pages = {1841--1852},
author = {Stadelmeier, Andreas},
date = {2015-09-28},
}

18
Studienarbeit/content/abstract.tex Normal file
View File

@ -0,0 +1,18 @@
%!TEX root = ../main.tex
\pagestyle{empty}
% override abstract headline
\renewcommand{\abstractname}{Abstract}
\begin{abstract}
Seit rund 15 Jahren wird an der Dualen Hochschule Baden Württemberg Campus Horb an einer Java-Erweiterung
namens Java-TX (Type eXtended) auf Basis von Java 8 geforscht. Java-TX zielt darauf ab, die
Java-Programmiersprache durch funktionale Programmierkonzepte wie globale Typinferenz und echte
Funktionstypen für Lambda-Ausdrücke zu erweitern. Im Bereich des Compilerbaus gilt die Selbstübersetzung eines
Compilers als wichtiges Qualitätsmerkmal. Aus diesem Grund wird im Rahmen dieser Arbeit der in Java verfassten
Java-TX-Compiler so weit es möglich ist, in Java-TX übersetzt. Dabei werden der Funktionsumfang und die
Praxistauglichkeit des aktuellen Java-TX-Zustands untersucht und bestehende Probleme sowie fehlende
Funktionen aufgezeigt. Zusätzlich werden durch die Überarbeitung des Quellcodes die Vorteile von Java-TX im
Vergleich zu Java demonstriert.
\end{abstract}

16
Studienarbeit/content/acronyms.tex Normal file
View File

@ -0,0 +1,16 @@
%!TEX root = ../main.tex
\addchap{\acronymsPhrase}
\begin{acronym}[YTMMM]
\acro{Java-TX}{Java-Type eXtended}
\acro{GNU}{GNU's Not Unix}
\acro{JVM}{Java Virtual Machine}
\acro{JDK}{Java Development Kit}
\acro{WSL}{Windows Subsystem for Linux}
\acro{IDE}{Integrated Development Environment}
\acro{GCC}{GNU Compiler Collection}
\acro{Bash}{Bourne Again Shell}
\end{acronym}

85
Studienarbeit/content/appendix.tex Normal file
View File

@ -0,0 +1,85 @@
% !TeX root = ../main.tex
\addchap{\appendixPhrase}
\section{Sourcecode des Bash Skripts zur Kompilierung} \label{app:bash}
\begin{lstlisting}[language=bash]
#!/bin/bash
SRCDIR="javatx-src/main/java"
DESTDIR="out/src"
TESTDESTDIR="out/tests"
DEPENDENCIES="dependencies/*"
JAVAC_FLAGS="-g:none -nowarn"
JAVATX_COMPILER_PATH="JavaTXcompiler.jar"
COMPILED_CLASSES="lib/classes"
#remove all files, if the script is called with parameter "clean"
if [ "$1" = "clean" ]; then
rm -r "$DESTDIR"
exit 0
fi
if [ "$1" != "" ]; then
echo "invalid argument: $1"
exit 1
fi
#find all .java/.jav files and store paths in an array
#note: somehow absolute paths don't work correctly with find -newer
#JAVA_FILES=($(find "$SRCDIR" -name "*.java" -exec realpath {} \;))
#JAV_FILES=($(find "$SRCDIR" -name "*.jav" -exec realpath {} \;))
JAVA_FILES=($(find "$SRCDIR" -name "*.java"))
JAV_FILES=($(find "$SRCDIR" -name "*.jav"))
#create empty arrays for .class file paths
JAVA_CLASSES=()
JAV_CLASSES=()
JAVA_CHANGED=()
JAV_CHANGED=()
mkdir -p $DESTDIR
#fill class files arrays by subsituting .java/.jav -> .class for each file
for file in "${JAVA_FILES[@]}"; do
#substitute destination dir with source dir
class_name="$DESTDIR${file#$SRCDIR}"
#substitute *.java -> *.class
class_name="${class_name%.java}.class"
#if .class file does not exists or .class file older than .java file
if [ ! -f "$class_name" ] || [ "$(find "$file" -prune -newer "$class_name")" ]; then
JAVA_CHANGED+=("$file")
JAVA_CLASSES+=("$class_name")
fi
done
for file in "${JAV_FILES[@]}"; do
#substitute destination dir with source dir
class_name="$DESTDIR${file#$SRCDIR}"
#substitute *.jav -> *.class
class_name="${class_name%.jav}.class"
#if .class file does not exists or .class file older than .jav file
if [ ! -f "$class_name" ] || [ "$(find "$file" -prune -newer "$class_name")" ]; then
JAV_CHANGED+=("$file")
JAV_CLASSES+=("$class_name")
fi
done
if [ "${#JAV_CHANGED[@]}" -ne 0 ]; then
echo "java -jar $JAVATX_COMPILER_PATH -d $DESTDIR -cp "$SRCDIR:$DEPENDENCIES:$COMPILED_CLASSES" ${JAV_CHANGED[@]}"
java -jar $JAVATX_COMPILER_PATH -d $DESTDIR -cp "$SRCDIR:$DEPENDENCIES:$COMPILED_CLASSES" "${JAV_CHANGED[@]}"
if [ $? -ne 0 ]; then
echo "Fehler beim Kompilieren der Jav-Dateien. Beende das Skript."
exit 1
fi
fi
if [ "${#JAVA_CHANGED[@]}" -ne 0 ]; then
echo "javac -d $DESTDIR -cp "$SRCDIR:$DESTDIR:$DEPENDENCIES" $JAVAC_FLAGS ${JAVA_CHANGED[@]}"
javac -d $DESTDIR -cp "$SRCDIR:$DESTDIR:$DEPENDENCIES" $JAVAC_FLAGS "${JAVA_CHANGED[@]}"
fi
\end{lstlisting}

401
Studienarbeit/content/chapter/01.tex Normal file
View File

</
 @ -0,0 +1,401 @@
%!TEX root = ../../main.tex
\chapter{Grundlagen}
\ac{Java-TX} basiert auf Java 8 und wurde um zwei wesentliche Funktionen erweitert, die man aus funktionalen Programmiersprachen wie Haskell kennt: Globale Typinferenz und echte Funktionstypen. Im folgenden Kapitel werden diese beiden Konzepte genauer erläutert.
Zunächst soll aber ein Einblick gegeben werden, was bezüglich dieser Funktionen in Java möglich ist.
\section{Typinferenz in Java}
Java unterstützt verschiedene Arten lokaler Typinferenz. Das bedeutet, dass der Programmierer an bestimmten Stellen des Codes den Datentyp einer Variable nicht explizit angeben muss, sondern der Compiler diesen anhand des Kontext ableiten kann. In diesem Abschnitt werden einige dieser Mechanismen vorgestellt.
\subsection{Typinferenz bei generischen Methoden}
Mit der Einführung von generischen Methoden in Java 5 \cite{buckley_java_2004}, wurde auch eine einfache Form der Typinferenz für die Parameter dieser Methoden eingeführt \cite{gosling_java_2005}[S.451 ff]. Konkret ist es möglich, den Compiler einen generischen Typ einer Methode anhand der Parametertypen inferieren zu lassen.
Die Methode \texttt{of} in \texttt{java.util.List} dient als Beispiel zur Veranschaulichung für diese Art von Typinferenz. Sie erzeugt eine Liste des generischen Typs \texttt{T} mit dem übergebenen Parameter als Element. Im folgenden ist die Signatur dieser Methode für einen einzelnen Parameter\footnote{Es gibt mehrere Versionen der Methode \texttt{of} in \texttt{java.util.List} mit einer unterschiedlichen Anzahl an Parametern} dargestellt.
%TODO: Anmerkung hinzufügen: dies ist die Definition für List.of() mit einem Parameter. Es gibt noch weitere Definitionen für mehrere Parameter.
\begin{verbatim}
public interface List<E> extends SequencedCollection<E> {
...
static <E> List<E> of(E e1);
...
}
\end{verbatim}
Ohne Typinferenz müsste man der Methode beim Aufruf explizit den generischen Typen angeben, wie in \autoref{lst:list_of_type_explizit} gezeigt ist.
\begin{lstlisting}[caption=List.of() mit explizitem Typ, label=lst:list_of_type_explizit, language=java]
List<Integer> intList = List.<Integer>of(1);
\end{lstlisting}
Die Typinferenz erlaubt es allerdings diese explizite Typangabe wegzulassen, da der generische Typ \texttt{T} implizit aus den Typen der Parameterliste resultiert. Dieser kompaktere Aufruf ist in \autoref{lst:list_of_type_implizit} zu sehen.
\begin{lstlisting}[caption=List.of() mit implizitem Typ, label=lst:list_of_type_implizit, language=java]
List<Integer> intList = List.of(1);
\end{lstlisting}
Mit der Veröffentlichung von Java 8 wurde diese Form der Typinferenz weiter verbessert und erweitert \cite{cimadamore_jep_2011}, so dass nun auch komplexere Typinferenz, wie in \autoref{lst:java8_typinferenz} gezeigt wird, möglich ist. Vor Java 8 war dies nicht möglich \cite{cimadamore_jep_2011, oracle_type_nodate}.
\begin{lstlisting}[caption=Verbesserungen für Typinferenz in Java 8 (Beispiel aus {\cite{oracle_type_nodate}[Target Types]}), label=lst:java8_typinferenz, language=java]
public class A{
public static void main(String[] args){
// In Java 7: error: incompatible types: List<Object> cannot be converted to List<String>
// In Java 8: korrekt
processStringList(Collections.emptyList());
}
void processStringList(List<String> list){
//...
}
}
\end{lstlisting}
\subsection{Der Diamond Operator}
Java unterstützt seit Version 7 den sogenannten Diamond Operator \texttt{<>} \cite{darcy_java_2010}. Dieser ermöglicht es, den Typ beim Instanziieren einer generischen Klasse nicht explizit anzugeben, sondern vom Compiler errechnen zu lassen \cite{gosling_java_2014}[S.482 ff]. Ein Beispiel dafür ist in \autoref{lst:java7diamond} zu sehen. Der Typ der Liste auf der rechten Seite der Zuweisung muss nicht explizit angegeben werden, sondern kann vom Compiler anhand des Kontextes abgeleitet werden.
\begin{lstlisting}[caption=Java 7 Diamond Operator, label=lst:java7diamond, language=java]
List<String> list = new ArrayList<>();
\end{lstlisting}
Vor Java 7 musste dieser Typ explizit angegeben werden, wie in Listing \ref{lst:java7nodiamond} zu sehen ist.
\begin{lstlisting}[caption=Java Generics ohne Diamond Operator, label=lst:java7nodiamond, language=java]
List<String> list = new ArrayList<String>();
\end{lstlisting}
Erwähnt sei hierbei auch, dass \texttt{List<String> = new ArrayList();} nicht das gleiche ist wie \texttt{List<String> = new ArrayList<>();} ist. Im ersten Fall wird die Liste als Raw Type erstellt \cite{oracle_type_nodate}[Type Inference and Instantiation of Generic Classes]. Aus diesem Grund ist die Angabe des Diamond Operators in diesem Fall wichtig, um den generischen Typen zu erhalten.
\subsection{Typinferenz bei Lambda Ausdrücken}
Auch in Lambda-Ausdrücken, welche in Version 8 hinzugefügt wurden, erlaubt Java lokale Typinferenz \cite{darcy_jep_2011}. Der Typ der Parameter einer Lambda-Funktion kann vom Compiler anhand des Kontextes abgeleitet werden \cite{gosling_java_2014}[S.603 ff], wie in \autoref{lst:lambda} zu sehen ist.
Die Methode \texttt{forEach} in Zeile 2 wendet dabei einen gegebenen Lambda Ausdruck auf jeden Eintrag der Liste an. In diesem Fall würde sie jedes Element der Liste ausgeben. Auf Lambda-Ausdrücke wird in \autoref{sec:lambda_java} ausführlich eingegangen.
Wie man sehen kann, muss der Typ des Parameters \texttt{s} in Zeile 2 vom Programmierer nicht explizit angegeben werden, da der Compiler weiß, dass es sich bei der Liste \lstinline|list| um eine Liste von Strings handelt. Ein Element der Liste muss somit ein String sein.
\begin{lstlisting}[caption=Java 8 Lambda-Ausdrücke, label=lst:lambda, language=java]
List<String> list = new ArrayList<>();
list.forEach(s -> System.out.println(s));
\end{lstlisting}
Es steht dem Entwickler jedoch frei den Typ des Parameters explizit anzugeben, wie in \autoref{lst:lambda_explicit} gezeigt ist.
\begin{lstlisting}[caption=Lambda-Ausdruck mit explizitem Typ, label=lst:lambda_explicit, language=java]
List<String> list = new ArrayList<>();
list.forEach((String s) -> System.out.println(s));
\end{lstlisting}
\subsection{Der Typplatzhalter var}
Ein weiteres Beispiel für lokale Typinferenz ist der Platzhalter \lstinline|var|, welcher mit Java 10 eingeführt wurde \cite{goetz_jep_2016}. Er ermöglicht den Typ einer lokalen Variablen nicht explizit anzugeben zu müssen, wenn dieser unmittelbar aus dem Kontext hervorgeht \cite{goetz_jep_2016}. Ein Beispiel dafür ist in \autoref{lst:java10var} zu sehen.
\begin{lstlisting}[caption=Java 10 var Platzhalter, label=lst:java10var, language=java]
var list = new ArrayList<String>();
\end{lstlisting}
Da der Compiler für den Typcheck den Typ der rechten Seite der Zuweisung ohnehin berechnen muss, ist es ein Leichtes den \texttt{var} Platzhalter zur Kompilierzeit durch den tatsächlichen Typ zu ersetzen. Im Beispiel von oben wäre dies der Typ \texttt{ArrayList<String>}. Die Möglichkeiten sind jedoch schnell erschöpft. So ist es nicht möglich, den Typ einer Methode oder eines Feldes mit \texttt{var} zu deklarieren. Außerdem muss bei der Verwendung die Initialisierung der Variable mit der Deklaration erfolgen \cite{goetz_jep_2016}. Eine Zuweisung zum Literal \glqq{}null\grqq{} ist demnach ebenfalls ungültig. Diese Einschränkungen sind in \autoref{lst:java10var_limits} zu sehen.
\begin{lstlisting}[caption=Ungültige Verwendung des \lstinline|var| Schlüsselworts, label=lst:java10var_limits, language=java]
//Ungueltiger Code
var x;
x = 10;
//Ungueltiger Code
var y = null;
\end{lstlisting}
\section{Typinferenz in Java-TX} \label{sec:java_tx_typeinference}
Trotz verschiedener Arten der lokalen Typinferenz, die in den letzten Jahren zu Java hinzugefügt wurden, müssen bis heute die Typen in Methodensignaturen und Feldern explizit vom Entwickler angegeben werden. In funktionalen Programmiersprachen wie Haskell existiert hingegen eine globale Typinferenz. Diese erlaubt es auch die Typen der Parametern und des Rückgabewerts einer Methode vom Compiler ableiten zu lassen \cite{thompson_haskell_2011}[S.323 ff].
In \autoref{lst:haskell_add} ist die Funktion \lstinline|add|, welche zwei numerische Werte addiert, in Haskell gegeben.
Wie man sehen kann, beinhaltet der Quellcode keinerlei Typinformationen. Dennoch ist Haskell eine statisch typisierte Sprache \cite{marlow_haskell_2010}[S.3]. Das bedeutet, dass sämtliche Typinformationen bereits zur Kompilierzeit überprüft werden \cite{pierce_types_2002}[S.2]. Der Haskell Compiler inferiert die Typen also zur Kompilierzeit. Im Fall der Funktion \lstinline|add|, wird der Typ \lstinline|add :: Num a => (a, a) -> a| errechnet. Dieser Typ bedeutet, dass die Funktion \lstinline|add| zwei Werte vom Typ \lstinline|a| entgegennimmt und einen Wert vom selben Typ zurückgibt. \lstinline|a| muss dabei von der Typklasse \lstinline|Num| sein, was in Haskell die numerischen Typen einschließt \cite{marlow_haskell_2010}[S.76, 81]. Die Funktion \lstinline|add| kann also sowohl mit ganzen Zahlen, als auch mit Gleitkommazahlen aufgerufen werden.
\begin{lstlisting}[caption=Funktion add in Haskell, label=lst:haskell_add, language=gnuplot]
add (x, y) = x+y
\end{lstlisting}
Eines der primären Ziele von \ac{Java-TX} ist es daher, die globale Typinferenz in Java zu ermöglichen, um auch Typen von Feldern und Methodensignaturen vom Compiler inferieren lassen zu können.
Ein Beispiel für die Funktion \lstinline|add| in \ac{Java-TX} ist in \autoref{lst:simple_typeinference_wo_types} zu sehen.
\begin{lstlisting}[caption=Untypisierte Methode add, label=lst:simple_typeinference_wo_types, language=java]
import java.lang.Integer;
class Add{
public add(a, b) {
return a + b;
}
}
\end{lstlisting}
In diesem Beispiel werden ähnlich wie in \autoref{lst:haskell_add} sowohl die Parametertypen, als auch der Rückgabetyp nicht angegeben. Diese Typen werden zur Kompilierzeit anhand des Kontextes abgeleitet. Die resultierenden Typen der Methode sind in \autoref{lst:simple_typeinference_w_types} gegeben. Der Compiler weiß, dass der Operator \lstinline|+| nur für numerische Datentypen und Zeichenketten definiert ist. Da der Algorithmus für die globalen Typinferenz allerdings sehr rechenintensiv ist, werden nur explizit importierte Typen berücksichtigt. In diesem Beispiel wird nur \lstinline|java.lang.Integer| importiert, daher spielen andere numerische Typen und Zeichenketten keine Rolle. Neben den Parametern berechnet der Compiler auch einen möglichen Rückgabetyp. In diesem Fall hat dieser auch den Datentyp \lstinline|java.lang.Integer|, da die Addition von zwei Integern wieder einen Integer ergibt.
\begin{lstlisting}[caption=Von Typinferenz errechnete Typen für \autoref{lst:simple_typeinference_wo_types}, label=lst:simple_typeinference_w_types, language=java]
import java.lang.Integer;
class Add{
public Integer add(Integer a, Integer b) {
return a + b;
}
}
\end{lstlisting}
Ähnlich wie C++ Templates erlaubt dieses Vorgehen es Methoden für verschiedene Datentypen mit gleicher Implementierung nur einmal zu definieren. Der Unterschied besteht darin, dass \ac{Java-TX} den Code für alle Typen, die importiert wurden und die verwendeten Funktionalitäten unterstützen, generiert. C++ generiert den Code nur für die Typen, mit denen das Template explizit aufgerufen wird \cite{vandevoorde_c_2010}[Abschnitt 2.1.2]. Dies ermöglicht es, den Code zu vereinfachen und die Wartbarkeit zu erhöhen. Ein Beispiel dazu ist in \autoref{lst:globaltypeinference2} zu sehen.
\newpage
\begin{lstlisting}[caption=Methodenüberladungen durch Typinferenz, label=lst:globaltypeinference2, language=java]
import java.lang.Integer;
import java.lang.String;
import java.lang.Double;
public class Add{
public add(a, b) {
return a + b;
}
}
\end{lstlisting}
In diesem Fall erzeugt der Compiler die Methode \lstinline|add| jeweils mit der Signatur für die Datentypen \lstinline|java.lang.Integer|, \lstinline|java.lang.String| und \lstinline|java.lang.Double|, wie in \autoref{lst:globaltypeinference2result} gezeigt ist. Denkbar wären mit diesen Imports auch weitere valide Methodensignaturen wie \lstinline{Double add(Integer a, Double b)} oder \lstinline{Double add(Double a, Integer b)}, welche allerdings aktuell nicht untersützt werden.
\begin{lstlisting}[caption=Resultat der Typinferenz für \autoref{lst:globaltypeinference2}, label=lst:globaltypeinference2result, language=java]
import java.lang.Integer;
import java.lang.String;
import java.lang.Double;
public class Add{
public Integer add(Integer a, Integer b) {
return a + b;
}
public Double add(Double a, Double b) {
return a + b;
}
public String add(String a, String b) {
return a + b;
}
}
\end{lstlisting}
\section{Anonyme Funktionen in Java} \label{sec:lambda_java}
Durch die Arbeiten an \glqq{}Project Lambda\grqq{} \cite{noauthor_openjdk_nodate} wurden anonyme Funktionen, sogenannte Lambda Ausdrücke, in Java 8 implementiert \cite{goetz_java_2010}. Lambda Ausdrücke ermöglichen in Java eine kompaktere Schreibweise, um Interfaces zu implementieren, welche nur eine einzige abstrakte Methode enthalten. Diese Interfaces werden als funktionale Interfaces bezeichnet \cite{gosling_java_2014}[S.321 ff].
\subsection{Funktionale Interfaces und Lambda Ausdrücke} \label{sec:lambda}
Ein Beispiel für ein funktionales Interface ist das Interface \lstinline{java.lang.Runnable}, welches nur eine abstrakte Methode mit dem Namen \texttt{run} enthält. \texttt{run} hat keine Parameter und keinen Rückgabewert. Eine Implemetierung dieses Interfaces kann z.B. verwendet werden, um das Verhalten eines Threads zu definieren. Vor der Einführung von Lambda Ausdrücken, war die einfachste Möglichkeit dies zu tun die Verwendung von anonymen Klassen \cite{gosling_java_2014}[S.491 ff]. Dies ist in \autoref{lst:runnable_wo_lambda} zu sehen.
\begin{lstlisting}[caption=Erstellung eines Threads mit einer anonymen Klasse, label=lst:runnable_wo_lambda, language=java]
class Main{
public void startThread(){
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello from Thread");
}
});
t.start();
}
}
\end{lstlisting}
Durch diese Verwendung einer anonymen Klasse, kann eine spezielle Implementierung der Methode \lstinline{run()} erstellt werden, ohne eine neue Klasse zu erstellen, die das Interface implementiert. Allerdings erfordert diese Lösung viel Boilerplate Code, welcher die Lesbarkeit des Codes erschwert. Die eigentliche Logik des Threads ist lediglich durch den Aufruf der \lstinline|println| Methode in Zeile 6 definiert.
Durch die Einführung von Lambda Ausdrücken kann der benötigte Code für diesen Anwendungsfall deutlich reduziert werden. Ein Lambda Ausdruck kann ein beliebiges funktionales Interface, bzw. dessen abstrakte Methode implementieren. \autoref{lst:runnable_w_lambda} zeigt wie der Code in \autoref{lst:runnable_wo_lambda} durch die Verwendung von Lambda ausdrücken reduziert werden kann.
\newpage
\begin{lstlisting}[caption=Erstellung eines Threads mit einem Lambda Ausdruck, label=lst:runnable_w_lambda, language=java]
class Main{
public void startThread(){
Thread t = new Thread(() -> System.out.println("Hello from Thread"));
t.start();
}
}
\end{lstlisting}
Wie man sehen kann benötigt man für die gleiche Funktionalität nun nur noch 6, statt 11 Zeilen Code. Zusätzlich ist der Code auf das Wesentliche reduziert, wodurch die Lesbarkeit verbessert wurde.
Wie bereits erwähnt, haben Lambda Ausdrücke in Java keinen eigenen Typen, sondern werden immer einem funktionalen Interface zugeordnet. Man spricht in diesem Kontext von sogenannten Zieltypen (engl. target types). Der Typ muss immer aus dem Kontext hervorgehen. In \autoref{lst:runnable_w_lambda} wird der Lambda Ausdruck dem Interface \lstinline{java.lang.Runnable} zugeordnet. Der Compiler erkennt, dass der Konstruktor der Klasse Thread das funktionale Interface \lstinline{java.lang.Runnable} erwartet und kann somit den Lambda Ausdruck diesem Interface zuordnen.
Auf Grund dieser Tatsache ist der Code in \autoref{lst:lambda_with_var} nicht gültig. Der Compiler kann den Typ nicht errechnen, da der Lambda Ausdruck unendlich viele Typen annehmen kann. Dies sind alle funktionalen Interfaces, deren abstrakte Methode keinen Parameter erwarten und \texttt{void} zurückgeben.
\begin{lstlisting}[caption=Lambda Ausdruck mit var, label=lst:lambda_with_var, language=java]
//Ungueltige Syntax
var lambda = () -> System.out.println("Hello World!");
\end{lstlisting}
Die Java Standardbibliothek stellt dem Entwickler bereits einige funktionale Interfaces zur Verfügung. Einige davon sind in \autoref{tab:java_functional_interfaces} aufgelistet.
\begin{table}[H]
\centering
\begin{tabular}{|l|l|}
\hline
\textbf{Interface} & \textbf{Abstrakte Methode} \\ \hline
java.lang.Runnable & void run() \\ \hline
java.util.concurrent.Callable<V> & V call() \\ \hline
java.util.function.Consumer<T> & void accept(T t) \\ \hline
java.util.function.Supplier<T> & T get() \\ \hline
java.util.function.Function<T, R> & R apply(T t) \\ \hline
java.util.function.Predicate<T> & boolean test(T t) \\ \hline
\end{tabular}
\caption{Gängige funktionale Interfaces in der Java Standardbibliothek}
\label{tab:java_functional_interfaces}
\end{table}
Wie man \autoref{tab:java_functional_interfaces} entnehmen kann, sind die funktionalen Interfaces der Java Standardbibliothek mit generischen Typparametern definiert. So können die Interfaces für beliebige Referenztypen verwendet werden. Dies bedeutet allerdings auch das die funktionalen Interfaces invariant sind.
Bevor diese Eigenschaft aber näher spezifiziert wird, müssen einige Begriffe geklärt werden, die in diesem Zusammenhang relevant sind.
Invarianz, Kovarianz und Kontravarianz sind Begriffe, die in der Typtheorie verwendet werden, um die Beziehung zwischen Typen zu beschreiben. Die folgenden Definitionen sind angelehnt an \cite{goos_variance-based_2002}[Abschnitt 1].
\vspace{1em}
Sei C<T> ein generischer Typ mit dem Typparameter T und A, B Typen mit A $\subtype$\footnote{$\subtype$ steht in diesem Dokument für die Subtyp Beziehung, d.h. A ist ein Subtyp von B} B und A $\neq$ B.
\begin{definition}[Invarianz]
C<T> ist invariant im Bezug auf den Typparameter T, wenn
$\texttt{C<A>} \not\subtype \texttt{C<B>} \text{ und } \texttt{C<B>} \not\subtype \texttt{C<A>}$
\end{definition}
\begin{definition}[Kovarianz]
C<T> ist kovariant im Bezug auf den Typparameter T, wenn $\texttt{C<A>} \subtype \texttt{C<B>}$.
\end{definition}
\begin{definition}[Kontravarianz]
C<T> ist kontravariant im Bezug auf den Typparameter T, wenn $\texttt{C<A>} \supertype \texttt{C<B>}$.
\end{definition}
\begin{definition}[Varianz]
C<T> ist variant im Bezug auf den Typparameter T, wenn er entweder kovariant oder kontravariant ist.
\end{definition}
\vspace{2em}
Generell ist zu erwähnen, dass die Eingabewerte eines Funktionstypen kontravariant und der Rückgabewert kovariant ist. Nach \cite{plumicke_java-tx_2022} gilt also folgende Definition für die Subtypisierung von Funktionstypen.
\begin{definition}[Subtypisierung für Funktionstypen] \label{def:subtyping_of_function_types}
Gegeben seien die Funktionstypen
\begin{center}
$(\tau_1, \tau_2, ..., \tau_n) \rightarrow \tau_0$ \\
$(\theta_1, \theta_2, ..., \theta_n) \rightarrow \theta_0$
\end{center}
Es gilt:
\begin{center}
$(\tau_1, \tau_2, ..., \tau_n) \rightarrow \tau_0 \subtype (\theta_1, \theta_2, ..., \theta_n) \rightarrow \theta_0$
$\forall i \in \{1, \ldots, n\}: \theta_i \subtype \tau_i$ \\
und $\tau_0 \subtype \theta_0$
\end{center}
\end{definition}
\vspace{2em}
Generische Typen sind in Java invariant \cite{naftalin_java_2007}[S.15 ff]. Daraus folgt unter anderem auch, dass Subtypisierung nicht wie erwartet möglich ist, z.B. ist
\[
\texttt{List<Integer>} \not\subtype \texttt{List<Number>}
\]
Diese Einschränkung besteht auch für Funktionstypen. Demnach ist
\[
\texttt{Function<Integer, Integer>} \not\subtype \texttt{Function<Integer, Number>}
\]
obwohl dies nach \autoref{def:subtyping_of_function_types} eine valide Subtypisierung wäre.
\subsection{Wildcards}
Um das Subtyp Problem für generische Datentypen zu lösen, wird in Java mit den sogenannten Wildcards use site Varianz ermöglicht. Wildcards bieten die Möglichkeit generische Typparameter kovariant oder kontravariant zu verwenden. Kovarianz wird dabei mit \lstinline|? extends| und Kontravarianz mit \lstinline|? super| erreicht \cite{naftalin_java_2007}[S.17 ff]. So ist durch die Verwendung von Wildcards folgende Subtypisierung möglich:
\[
\texttt{Function<Integer, Integer>} \subtype \texttt{Function<? super Integer, ? extends Number>}
\]
Als Java Quellcode ist dieses Beispiel in \autoref{lst:covariance} dargestellt.
\begin{lstlisting}[caption=Varianz in Java, label=lst:covariance, language=java]
Function<Integer, Integer> func1 = x -> x + 1;
Function<? super Integer, ? extends Number> func2 = func1;
\end{lstlisting}
Wie man sehen kann, wird die Funktion \lstinline{func1} der Funktion \lstinline{func2} zugewiesen. Daraus folgt, dass \lstinline|func2| ein Subtyp von \lstinline|func1| ist. Dabei ist der Parameter der Funktion \lstinline{func2} ein Supertyp des Parameters der Funktion \lstinline{func1} (Kontravarianz) und der Rückgabewert der Funktion \lstinline{func2} ein Subtyp von dem Rückgabewert der Funktion \lstinline{func1} (Kovarianz). Dies entspricht der Definition für die Subtypisierung für Funktionstypen aus \autoref{def:subtyping_of_function_types}. Use site Varianz führt zwar zu einer erhöhten Flexibilität, da der generische Typ an verschiedenen Stellen im Code unterschiedlich variiert werden kann, aber es erschwert auch die Lesbarkeit des Codes.
Außerdem muss sich der Entwickler um die korrekte Verwendung der Varianz kümmern, was leicht zu Typfehlern führen kann. Einfacher wäre es, wenn die Varianz direkt bei der Deklaration der generischen Typen festgelegt werden könnte. Dies wird als declaration site Varianz bezeichnet und wird von vielen Sprachen wie Scala oder C\# unterstützt \cite{piquerez_variances_nodate, wagner_creating_2021}. Declaration site Varianz ist allerdings weniger flexibel, da die Varianz des Typen immer die gleiche bleibt und nicht an verschiedenen Stellen im Code variiert werden kann.
\section{Echte Funktionstypen in Java-TX}
\ac{Java-TX} löst das Subtypisierung Problem durch die Einführung von echten Funktionstypen. Dadurch bekommen Lambda Ausdrücke echte Typen, welche nicht vom Kontext abhängig sind. Die Funktionstypen werden in \ac{Java-TX} laut \cite{plumicke_java-tx_2022} mit der folgenden Syntax definiert:
\begin{center}
$(\tau_1, \tau_2, ..., \tau_N) \rightarrow \tau_0 \equiv FunN\$\$<\tau_1, \tau_2, ..., \tau_N, \tau_0>$ \\
$(\tau_1, \tau_2, ..., \tau_N) \rightarrow void \equiv FunVoidN\$\$<\tau_1, \tau_2, ..., \tau_N>$
\end{center}
Außerdem sind Argumente der Funktionstypen automatisch kontravariant und der Rückgabewert kovariant. Dies erlaubt die Subtypisierung von Funktionstypen ohne use site Varianz, was zur besseren Lesbarkeit und weniger Fehleranfälligkeit führt.
Tatsächlich ist die Verwendung von Wildcards für die \ac{Java-TX} Funktionstypen nicht erlaubt \cite{plumicke_introducing_2017}[Abschnitt 6]. In \autoref{lst:subtyping_of_function_types} ist ein Beispiel für die Subtypisierung von Funktionstypen in \ac{Java-TX} zu sehen ist. Hier lässt sich die Funktion \lstinline{func1} der Funktion \lstinline{func2} zuweisen, da das Argument der Funktion \lstinline{func1} ein Supertyp des Arguments der Funktion \lstinline{func2} ist und der Rückgabewert der Funktion \lstinline{fun1} ein Subtyp des Rückgabewerts der Funktion \lstinline{fun2} ist, daher ist \lstinline|fun1| nach \autoref{def:subtyping_of_function_types} ein Subtyp von \lstinline|fun2|. Dieser Code ist leichter lesbar und verständlicher als der Java Code in \autoref{lst:covariance}. Außerdem korrespondiert er direkt mit der theoretischen Grundlage in \autoref{def:subtyping_of_function_types}.
\begin{lstlisting}[caption=Subtypisierung von Funktionstypen in Java-TX, label=lst:subtyping_of_function_types, language=java]
Fun1$$<Number, Integer> func1 = x -> x.intValue() + 1;
Fun1$$<Integer, Integer> func2 = func1;
\end{lstlisting}
Echte Funktionstypen ermöglichen in \ac{Java-TX} die Definition von Funktionen in einem beliebigen Kontext. Ein Beispiel hierzu ist in \autoref{lst:lambda_with_function_type} zu sehen. In diesem Fall inferiert der Compiler den Typ \lstinline|Fun2$$<Integer, Integer, Integer>|. In Java ist die Verwendung von \lstinline|var| in diesem Kontext nicht möglich, wie in \autoref{lst:lambda_with_var} gezeigt wurde.
\begin{lstlisting}[caption=Lambda Ausdruck ohne Typkontext, label=lst:lambda_with_function_type, language=java]
import java.lang.Integer;
public class Main{
main(){
var add = (x, y) -> x + y;
}
}
\end{lstlisting}
\section{GNU Make} \label{sec:make}
\ac{GNU} Make ist ein Build-Management-Tool, welches von Richard Stallman und Roland McGrath entwickelt wurde \cite{stallman_gnu_2004}[S.1]. Es wird hauptsächlich verwendet, um C Programme automatisiert zu kompilieren und zu linken. Make nutzt inkrementelle Kompilierung, d.h. es ermittelt mittels Timestamps welche Teile des Programms nach Änderungen des Quellcodes neu kompiliert werden müssen \cite{stallman_gnu_2004}[S.5].
Grundsätzlich werden bei Make verschiedene Regeln in einem sogenannten Makefile definiert. Diese Regeln bestehen aus Zielen (targets), Abhängigkeiten (prerequisites) und Befehlen (recipe)\cite{stallman_gnu_2004}[S.3]. Die Befehle werden ausgeführt, wenn die Abhängigkeiten neuer als die Ziele sind. Die Struktur einer Regel ist in \autoref{lst:make_rule} zu sehen.
\begin{lstlisting}[caption=Aufbau einer Makefile-Regel aus {\cite{stallman_gnu_2004}[S.3]}, label=lst:make_rule]
target ... : prerequisites ...
recipe
...
...
\end{lstlisting}
Ein einfaches Makefile für ein C-Programm könnte wie das Beispiel in \autoref{lst:sample_makefile} aussehen. Die Regeln in diesem Beispiel dienen zur Compilierung des Programms \texttt{edit}. Auf der linken Seite einer Regel steht nun immer die Quelldatei, die erstellt werden soll. Auf der rechten Seite stehen die Abhängigkeiten, die für die Erstellung der Quelldatei benötigt werden. Die Befehle, die ausgeführt werden, wenn die Abhängigkeiten neuer sind als das Ziel, stehen unterhalb der Regel. In diesem Fall wird das Programm \texttt{edit} aus den Objektdateien \texttt{main.o, kbd.o, command.o, display.o, insert.o, search.o, files.o} und \texttt{utils.o} gebaut. Die Objektdateien werden aus den entsprechenden Quelldateien erstellt. Mit dem Befehl \lstinline|make clean| können alle erstellten Dateien gelöscht werden. \lstinline|clean| ist hierbei ein sogenanntes Phony Target. Das bedeutet, dass es sich nicht um eine Datei handelt. Vielmehr wird der definierte Befehl ausgeführt, sobald der Benutzer \lstinline|make clean| aufruft \cite{stallman_gnu_2004}[S.31].
\begin{lstlisting}[caption=Beispiel eines Makefiles aus {\cite{stallman_gnu_2004}[S.4]}, label=lst:sample_makefile]
edit : main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
cc -o edit main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
main.o : main.c defs.h
cc -c main.c
kbd.o : kbd.c defs.h command.h
cc -c kbd.c
command.o : command.c defs.h command.h
cc -c command.c
display.o : display.c defs.h buffer.h
cc -c display.c
insert.o : insert.c defs.h buffer.h
cc -c insert.c
search.o : search.c defs.h buffer.h
cc -c search.c
files.o : files.c defs.h buffer.h command.h
cc -c files.c
utils.o : utils.c defs.h
cc -c utils.c
.PHONY : clean
clean :
rm edit main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
\end{lstlisting}
\ac{GNU} make bietet neben diesen grundlegenden make Funktionalitäten noch weitere mächtige Funktionen, z.B. die Möglichkeit Variablen zu definieren, shell Befehle innerhalb des Makefiles aufzurufen oder die Verwendung von Wildcards, um dynamische Makefiles zu erstellen.
Für Hochsprachen wie Java werden meistens spezielle Build-Management-Tools wie Maven oder Gradle verwendet \cite{jetbrains_java_2023}. Diese sind jedoch oft speziell auf diese Sprache entwickelt weniger flexibel als make.
\section{Selbstkompilierende Compiler}
Im Compilerbau gilt ein selbstkompilierender Compiler als Qualitätsmerkmal. Ein Compiler ist selbstkompilierend, wenn er in der Sprache geschrieben ist, die er kompiliert. Dies bedeutet, dass der Compiler in der Lage ist, seinen eigenen Quellcode zu kompilieren. In der Regel gibt es in jeder großen Programmiersprache mindestens einen Compiler, der selbstkompilierend ist. Bekannte Beispiel hierfür sind der \gls{javac} Compiler, der in Java geschrieben ist \cite{noauthor_openjdk_nodate-1} und Java Code kompiliert und der C++ Compiler der \ac{GCC}, der seit einigen Jahren in C++ geschrieben ist \cite{noauthor_gcc--cxx_nodate} und unter anderem C++ Code kompilieren kann \cite{stallman_using_2024}[S.5].
Laut \cite{terry_compilers_1997}[Abschnitt 3.4] bieten selbstkompilierende Compiler im Wesentlichen 4 Vorteile:
\begin{itemize}
\item Es stellt einen nicht trivialen Test der Funktionsfähigkeit des Compilers dar.
\item Sobald der selbstkompilierende Compiler einmal implementiert ist, ist die Entwicklung ohne die Abhängigkeit anderer Übersetzungssysteme möglich.
\item Alle Verbesserungen, die am Backend des Compilers vorgenommen werden, wirken sich sowohl auf den Compiler, als auch auf den generierten Code aus.
\item Es bietet eine umfassende Überprüfung der Selbstkonsistenz des Compilers. Der Compiler sollte in der Lage sein, seinen eigenen Quellcode zu kompilieren.
\end{itemize}
Der Prozess einen selbstkompilierenden Compiler zu erstellen, kann mit sogenannten T-Diagrammen visualisiert werden. In \autoref{fig:self_compiling_compiler_java_tx} ist ein solches Diagramm für einen selbstkompilierenden Compiler in \ac{Java-TX} zu sehen. Auf der linken eines T's ist dabei die Eingabesprache zu sehen, auf der rechten Seite die Ausgabesprache und in der Mitte die Sprache, in der der Compiler geschrieben ist. In diesem Fall ist das rote T der bereits bestehende Compiler in Java-TX, der den \ac{Java-TX} Code in Bytecode übersetzt. Der blaue T ist das langfristige Ziels des Projekts \JTXCinJTX, also ein Compiler der in \ac{Java-TX} geschrieben ist und \ac{Java-TX} Quelldateien in Bytecode kompiliert. Die Anordnung der T's symbolisiert, dass der ursprüngliche Compiler den neuen Compiler initial kompiliert.
\begin{figure}[h]
\centering
\begin{tikzpicture}[scale=2, every node/.style={scale=1}]
\draw[draw=blue] (1,0) -- (0,0) -- (0,1) -- (3,1) -- (3,0) -- (2,0) -- (2, -1.1) -- (1, -1.1) -- cycle;
\node at (0.5, 0.5) {Java-TX};
\node at (1.5, -0.6) {Java-TX};
\node at (2.5, 0.5) {Bytecode};
\draw[draw=red] (3.1,-1.1) -- (2.1,-1.1) -- (2.1,-0.1) -- (5.1,-0.1) -- (5.1,-1.1) -- (4.1,-1.1) -- (4.1, -2.2) -- (3.1, -2.2) -- cycle;
\node at (2.6, -0.6) {Java-TX};
\node at (3.6, -1.65) {Java};
\node at (4.6, -0.6) {Bytecode};