Skip to content
Snippets Groups Projects
Commit 591f264c authored by Jasper Clemens Gräflich's avatar Jasper Clemens Gräflich
Browse files

Update bibliography to good style

parent 773e3e7d
No related branches found
No related tags found
No related merge requests found
@online{rustlang22,
title = {Rust Programming Language},
author = {Rust Team},
url = {https://rust-lang.org},
date = {2022-01-25},
urldate = {2022-01-25}
@book{klabnik19,
title = {The Rust Programming Language},
author = {Steve Klabnik and Carol Nichols},
year = {2019},
publisher = {No Starch Press},
link = {https://rust-lang.org}
}
@online{lean22,
title = {Lean Theorem Prover},
author = {Leo de Moura and Sebastian Ullrich and Dany Fabian},
url = {https://leanprover.github.io/},
date = {2022-01-26},
urldate = {2022-01-26}
@article{moura15,
title = {The Lean theorem prover},
author = {Leonardo de Moura and Soonho Kong and Jeremy Avigad and Floris van Doorn and Jakob von Raumer},
year = {2015},
link = {https://leanprover.github.io/}
}
@online{z322,
title = {Z3 Theorem Prover},
author = {Microsoft},
url = {https://github.com/Z3Prover},
date = {2022-01-26},
urldate = {2022-01-26}
@inproceedings{moura08,
title = {Z3: An efficient SMT solver},
author = {Moura, Leonardo de and Bjørner, Nikolaj},
booktitle = {International conference on Tools and Algorithms for the Construction and Analysis of Systems},
pages = {337--340},
year = {2008},
organization = {Springer},
link = {https://github.com/Z3Prover}
}
@online{liquid22,
title = {LiquidHaskell},
author = {UCSD Progsys},
url = {https://ucsd-progsys.github.io/liquidhaskell-blog/},
date = {2022-01-26},
urldate = {2022-01-26}
@inproceedings{vazou14,
title = {Refinement types for Haskell},
author = {Vazou, Niki and Seidel, Eric L and Jhala, Ranjit and Vytiniotis, Dimitrios and Peyton-Jones, Simon},
booktitle = {Proceedings of the 19th ACM SIGPLAN international conference on Functional programming},
pages = {269--282},
year = {2014},
link = {https://ucsd-progsys.github.io/liquidhaskell-blog/}
}
% Paper?
@online{haskell22,
title = {Haskell},
author = {Haskell.org},
......@@ -38,12 +41,12 @@
urldate = {2022-01-26}
}
@online{ats22,
title = {The ATS Programming Language},
author = {Hongwei Xi},
url = {http://www.ats-lang.org/},
date = {2022-01-26},
urldate = {2022-01-26}
@misc{xi10,
title = {The ATS Programming Language},
author = {Xi, Hongwei},
year = {2010},
publisher = {Citeseer},
link = {http://www.ats-lang.org/}
}
@online{clippy22,
......@@ -54,7 +57,7 @@
urldate = {2022-02-04}
}
@online{expand22,
@online{tolnay22,
title = {Cargo Expand},
author = {David Tolnay},
url = {https://github.com/dtolnay/cargo-expand
......@@ -84,12 +87,16 @@
urldate = {2202-02-04}
}
@online{rustbelt22,
title = {RustBelt},
author = {Project RustBelt},
url = {https://plv.mpi-sws.org/rustbelt/},
date = {2022-01-26},
urldate = {2022-01-26}
@article{jung17rustbelt,
title = {RustBelt: Securing the foundations of the Rust programming language},
author = {Jung, Ralf and Jourdan, Jacques-Henri and Krebbers, Robbert and Dreyer, Derek},
journal = {Proceedings of the ACM on Programming Languages},
volume = {2},
number = {POPL},
pages = {1--34},
year = {2017},
publisher = {ACM New York, NY, USA},
link = {https://plv.mpi-sws.org/rustbelt/}
}
@online{emc22,
......@@ -126,20 +133,23 @@
@article{flanagan06,
author = {Cormac Flanagan and Stephen N. Freund and Aaron Tomb},
title = {Hybrid Types, Invariants, and Refinments For Imperative Objects},
journal = {FOOL/WOOD Workshop},
title = {Hybrid types, invariants, and refinements for imperative objects},
journal = {FOOL/WOOD},
volume = {6},
year = {2006},
url = {https://users.soe.ucsc.edu/~cormac/papers/fool06.pdf},
urldate = {2022-01-26}
link = {https://users.soe.ucsc.edu/~cormac/papers/fool06.pdf}
}
@article{lehmann17,
author = {Nico Lehmann and Éric Tanter},
title = {Gradual Refinement Types},
journal = {POPL’17},
year = {2017},
url = {https://pleiad.cl/papers/2017/lehmannTanter-popl2017.pdf},
urldate = {2022-01-26}
@article{lehmann2017gradual,
title = {Gradual refinement types},
author = {Lehmann, Nico and Tanter, {\'E}ric},
journal = {ACM SIGPLAN Notices},
volume = {52},
number = {1},
pages = {775--788},
year = {2017},
publisher = {ACM New York, NY, USA},
link = {https://pleiad.cl/papers/2017/lehmannTanter-popl2017.pdf}
}
@article{thomas19,
......@@ -154,51 +164,51 @@
@article{weiss21,
author = {Aaron Weiss and Olek Gierczak and Daniel Patterson and Amal Ahmed},
title = {Oxide: The Essence of Rust},
journal = {arXiv preprint arXiv:1903.00982},
year = {2021},
url = {https://arxiv.org/pdf/1903.00982.pdf},
urldate = {2022-01-26}
link = {https://arxiv.org/pdf/1903.00982.pdf}
}
@article{kan20,
author = {Shuanglong Kan and Zhe Chen and Davin Saán and Shang-Wei Lin and Yang Liu},
title = {An Executable Operational Semantics for Rust with the Formaliztion of Ownership and Borrowing},
journal = {arXiv preprint arXiv:1804.07608},
year = {2020},
url = {https://arxiv.org/pdf/1804.07608.pdf},
urldate = {2022-01-26}
link = {https://arxiv.org/pdf/1804.07608.pdf}
}
@mastersthesis{ullrich16,
author = {Sebastian Ullrich},
title = {Simple Verification of Rust Programs via Functional Purification},
school = {Karlsruhe Institute of Technology},
year = {2016},
url = {https://pp.ipd.kit.edu/uploads/publikationen/ullrich16masterarbeit.pdf},
urldate = {2022-01-26}
author = {Sebastian Ullrich},
title = {Simple Verification of Rust Programs via Functional Purification},
school = {Karlsruhe Institute of Technology},
year = {2016},
link = {https://pp.ipd.kit.edu/uploads/publikationen/ullrich16masterarbeit.pdf}
}
@mastersthesis{kooi21,
author = {Xiu Hong Kooi},
title = {Refinement Types in Real-World Programming},
school = {University pf Cambridge},
year = 2021,
url = {https://kooixiuhong.com/static/media/acs-dissertation.e8569509.pdf},
urldate = {2022-02-07}
author = {Xiu Hong Kooi},
title = {Refinement Types in Real-World Programming},
school = {University pf Cambridge},
year = 2021,
link = {https://kooixiuhong.com/static/media/acs-dissertation.e8569509.pdf}
}
@article{vekris16,
author = {Panagiotis Vekris and Bejamin Cosman and Ranjit Jhala},
title = {Refinement Types for TypeScript},
year = {2016},
url = {https://goto.ucsd.edu/~pvekris/docs/pldi16.pdf},
urldate = {2022-02-07}
@inproceedings{vekris2016refinement,
title = {Refinement types for TypeScript},
author = {Vekris, Panagiotis and Cosman, Benjamin and Jhala, Ranjit},
booktitle = {Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation},
pages = {310--325},
year = {2016},
link = {https://goto.ucsd.edu/~pvekris/docs/pldi16.pdf}
}
@article{reed15,
author = {Eric Reed},
title = {Patina: A Formalization of the Rust Programming Language},
title = {Patina: A formalization of the Rust programming language},
journal = {University of Washington, Department of Computer Science and Engineering, Tech. Rep. UW-CSE-15-03-02},
pages = {264},
year = {2015},
url = {https://dada.cs.washington.edu/research/tr/2015/03/UW-CSE-15-03-02.pdf},
urldate = {2022-02-07}
link = {https://dada.cs.washington.edu/research/tr/2015/03/UW-CSE-15-03-02.pdf}
}
@techreport{prusti19,
......
......@@ -60,13 +60,13 @@ Prof. Dr. Christoph Kreitz, Universität Potsdam\\[1\baselineskip]
# Überblick
Die Programmiersprache Rust \cite{rustlang22} bietet seinen Usern durch Ownership und Borrowing ein System, mit dem Race Conditions und Memory Corruption statisch erkannt werden können, da der Borrowchecker außerhalb von sogenannten \lstinline{unsafe}-Blöcken nicht zulässt, dass es zu einem Zeitpunkt mehrere Aliase mit Schreibzugriff auf eine Ressource gibt. Laut einer Analyse von Microsoft \cite{thomas19} lassen sich etwa 70 Prozent der in ihren Produkten vorkommenden Bugs auf solche Fehler zurückführen, die mit safe Rust nicht auftreten können.
Die Programmiersprache Rust \cite{klabnik19} bietet seinen Usern durch Ownership und Borrowing ein System, mit dem Race Conditions und Memory Corruption statisch erkannt werden können, da der Borrowchecker außerhalb von sogenannten \lstinline{unsafe}-Blöcken nicht zulässt, dass es zu einem Zeitpunkt mehrere Aliase mit Schreibzugriff auf eine Ressource gibt. Laut einer Analyse von Microsoft \cite{thomas19} lassen sich etwa 70 Prozent der in ihren Produkten vorkommenden Bugs auf solche Fehler zurückführen, die mit safe Rust nicht auftreten können.
Allerdings schützt Rusts Typsystem nicht vor anderen Fehlern, insbesondere kann man mit ihm nur grobe Spezifikationen ausdrücken. Einige Programmiersprachen wie Lean \cite{lean22} nutzen Dependent Types und Beweisobjekte, um präzise Aussagen über Code machen zu können, haben jedoch den Nachteil, dass nicht alle dieser Aussagen automatisch bewiesen werden können. Außerdem wird das Typsystem dadurch deutlich komplexer.
Allerdings schützt Rusts Typsystem nicht vor anderen Fehlern, insbesondere kann man mit ihm nur grobe Spezifikationen ausdrücken. Einige Programmiersprachen wie Lean \cite{moura15} nutzen Dependent Types und Beweisobjekte, um präzise Aussagen über Code machen zu können, haben jedoch den Nachteil, dass nicht alle dieser Aussagen automatisch bewiesen werden können. Außerdem wird das Typsystem dadurch deutlich komplexer.
Einen Mittelweg kann man mit sogenannten Refinement Types gehen. Bei ihnen werden Typen mit gewissen Bedingungen eingeschränkt, die von einem SMT-Solver wie Z3 \cite{z322} teilweise automatisch gelöst werden können. Ein User kann dadurch mit überschaubarem zusätzlichen Aufwand mehr Sicherheiten über den eigenen Code gewinnen.
Einen Mittelweg kann man mit sogenannten Refinement Types gehen. Bei ihnen werden Typen mit gewissen Bedingungen eingeschränkt, die von einem SMT-Solver wie Z3 \cite{moura08} teilweise automatisch gelöst werden können. Ein User kann dadurch mit überschaubarem zusätzlichen Aufwand mehr Sicherheiten über den eigenen Code gewinnen.
Refinement Types wurden bereits in verschiedenen Sprachen implementiert, zum Beispiel LiquidHaskell \cite{liquid22} als Erweiterung für die Sprache Haskell \cite{haskell22} oder ATS \cite{ats22}, bei dem Refinement Types builtin sind.
Refinement Types wurden bereits in verschiedenen Sprachen implementiert, zum Beispiel LiquidHaskell \cite{moura08} als Erweiterung für die Sprache Haskell \cite{haskell22} oder ATS \cite{xi10}, bei dem Refinement Types builtin sind.
Bisher findet die Forschung hauptsächlich an funktionalen Programmiersprachen statt, obwohl die Mehrheit der Anwendungen in einem imperativen Stil geschrieben wird. Rust ist eine imperative Programmiersprache, hat aber Einflüsse aus funktionalen Sprachen. Deshalb bietet es sich an, Rust um Refinement Types zu erweitern. Zusammen mit dem schon vorhandenen Typsystem erhält man eine ausdrucksstarke Spezifikationssprache, die sehr viele Anwendungsfälle abdeckt.
......@@ -85,7 +85,7 @@ Es gibt mehrere Projekte, Rust eine formale Semantik zu geben: Oxide \cite{weiss
## Verifikation von Rust
Es gibt schon einige Ansätze zur formalen Verifikation von Rust-Code. Das Projekt RustBelt \cite{rustbelt22} versucht, die \lstinline{unsafe}-Teile der Standardbibliothek von Rust formal zu verifizieren.
Es gibt schon einige Ansätze zur formalen Verifikation von Rust-Code. Das Projekt RustBelt \cite{jung17rustbelt} versucht, die \lstinline{unsafe}-Teile der Standardbibliothek von Rust formal zu verifizieren.
Das Crate *refinement* \cite{refinement22} implementiert Refinement Types, eine Überprüfung findet allerdings nur zur Laufzeit statt und es gibt einen gewissen Overhead für User, die selbst Casts durchführen und dabei auftretende Fehler zur Laufzeit behandeln müssen.
......@@ -107,7 +107,7 @@ Daher soll aufbauend auf einer der vorhandenen formalen Semantiken für Rusts Ow
Das Forschungsvorhaben lässt sich in drei Teile aufgliedern, die jeweils verschiedene Methoden erfordern:
Zu Beginn des Vorhabens möchte ich untersuchen, wie sich Refinement Types in eine formale Semantik für Rust einbinden lassen. Dazu vergleiche ich verschiedene bereits vorhandene Semantiken für Rust \cite{reed15, kan20, weiss21} nach ihrer Komplexität und Erweiterbarkeit, um eine der Semantiken als Grundlage für meine Arbeit auszuwählen. Dann möchte ich eine Formalisierung von Refinement Types \cite[siehe][]{rondon08, vekris16, kooi21} finden, die sich gut in die ausgewählte Semantik einpflegen lässt, und die Korrektheit der Semantik beweisen.
Zu Beginn des Vorhabens möchte ich untersuchen, wie sich Refinement Types in eine formale Semantik für Rust einbinden lassen. Dazu vergleiche ich verschiedene bereits vorhandene Semantiken für Rust \cite{reed15, kan20, weiss21} nach ihrer Komplexität und Erweiterbarkeit, um eine der Semantiken als Grundlage für meine Arbeit auszuwählen. Dann möchte ich eine Formalisierung von Refinement Types \cite[siehe][]{rondon08,vekris2016refinement, kooi21} finden, die sich gut in die ausgewählte Semantik einpflegen lässt, und die Korrektheit der Semantik beweisen.
Der zweite Teil beschäftigt sich mit der Implementation eines Systems, *Verdigris*, das Refinement Types für Rust umsetzt. Da Compiler-Plugins anscheinend deprecated werden sollen,^[Siehe \href{https://github.com/rust-lang/rust/pull/64675}{diesen Pull Request} und \href{https://github.com/rust-lang/rust/issues/29597}{dieses Issue}.] nutze ich vermutlich prozedurale Macros. Das System könnte auch als installierbares Subcommand für Cargo angeboten werden wie Clippy \cite{clippy22} und Expand \cite{expand22}.
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment