First draft

src/content/projects/astro-rewrite.mdx

@@ -0,0 +1,7 @@
+---
+title: Astro Rewrite
+description: "Next.js entwickelt sich rasend - zu schnell für mich, um Features und Sicherheitsupdates immer zu verfolgen. Und React für einen Blog? Unnötig. Eine einfache statische Lösung aber mit Komponenten? Astro ist genau das. Also: Willkommen zum neuen Anstrich in Astro!"
+repository: "https://git.c0ntroller.de/c0ntroller/frontpage"
+published: 2023-04-03T13:07:27.205Z
+---
+

src/content/projects/infoscreen.mdx

@@ -0,0 +1,129 @@
+---
+title: Infoscreen
+description: "Aus einem alten Monitor und einem Raspberry Pi wurde ein Küchen-Infoscreen, der Wetter, Kalender, Nachrichten und mehr anzeigt. Über mehrere Iterationen hinweg entwickelte sich das Projekt von einfachem JavaScript zu Electron und schließlich zurück zu einer Gatsby-basierten Anwendung."
+repository: "https://git.c0ntroller.de/c0ntroller/infoscreen"
+published: 2022-06-13T13:07:27.205Z
+---
+import { Image } from "astro:assets";
+import screenshot from "../../assets/md-content/screenshot.jpg";
+
+Hier gehts um einen Bildschirm der Informationen anzeigt.  
+Überraschend, ich weiß.
+
+## Wie sieht es aus?
+
+<Image src={screenshot} alt="Screenshot des Infoscreens" />
+
+Ich habe ein paar Dinge unkenntlich gemacht, um meine persönlichen Daten zu schützen.
+
+## Wie es begann
+
+Eines Tages habe ich mir einen coolen neuen und viel besseren Monitor für meinen PC gekauft.
+Aber was macht man mit dem alten, wenn man keinen Platz für einen dritten hat?
+
+Die Idee war simpel: Einfach einen Raspberry Pi anschließen und nützliche Informationen anzeigen lassen.
+Wetter, Nachrichten, Kalender und so weiter.
+Und um immer gut informiert zu sein, wurde der Bildschirm in der Küche platziert.
+
+## Geschichte
+### Die erste Iteration
+
+Am Anfang war es einfach eine Webseite in Vanilla JS und natürlich dem üblichen HTML und CSS.
+Ich hatte zu dem Zeitpunkt nicht viel Erfahrung in JS, aber ich versuchte "gute" Software-Entwicklungspraktiken zu verwenden, wie Klassenvererbung und [ES-Module](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules).
+
+Warum Web Technologien nutzen, wenn ich davon wenig Ahnung habe?
+Weil ich noch weniger Ahnung von anderen GUI-Technologien hatte.
+Außerdem nutzen viele Quellen, die ich benutzen wollte, REST-Schnittstellen und JSON, was einfach in JavaScript super einfach zu handhaben ist.
+
+Das ganze wurde lokal mit dem Standard-[PHP HTTP-Server](https://www.php.net/manual/en/features.commandline.webserver.php) gehostet und Chromium-Browser im Kiosk-Modus geöffnet.
+
+Wen der Code wirklich interessiert, der kann [hier](https://github.com/C0ntroller/infoscreen-old) den Repository der zweiten Version finden, die den Großteil des Codes der ersten Version nutzt.
+
+### Die zweite Iteration
+
+Beim zweiten Mal war die Idee, statt einen Chromium-Browser zu öffnen, eine Electron App zu schreiben.
+Klingt erstmal nicht so viel anders, aber ich dachte, dass es vielleicht performanter sein könnte, da zumindest etwas Bloat fehlt.
+
+Naja, es war nicht performanter.
+Der Code dafür ist trotzdem noch [hier](https://github.com/C0ntroller/infoscreen-old) zu finden.
+
+### Die dritte Iteration
+
+Einige Zeit später habe ich angefangen, mich mehr mit React zu beschäftigen.
+Irgendwie kam mir der Gedanke, dass was ich damals mit Vanilla JS versucht habe, in React viel einfacher und sauberer umzusetzen wäre.
+Also habe ich angefangen, den Code zu portieren.
+
+Ich habe auch schon von Frameworks für React gehört, die statische Seiten generieren können, wie [Next.JS](https://nextjs.org/) und [Gatsby](https://www.gatsbyjs.com/).
+Gatsby schien mir eine gute Wahl zu sein, also habe ich mich dafür entschieden.
+
+Diesmal wurde es in einem Docker-Container auf meinem eigenen Heimserver gehostet und der Pi öffnet wieder einen Chromium-Browser.
+
+Damit endet die Entwicklungsgeschichte.
+
+### Das Ende der Geschichte
+
+Und nun?<br/>
+Die brennensten Fragen mal geklärt:
+
+> Wird der Bildschirm genutzt?
+
+Nein. Er war eine ganze Weile in Betrieb, aber mittlerweile bin ich umgezogen und habe keinen schönen Platz mehr. Zudem muss ich sagen, dass man über die Zeit immer weniger drauf schaut...
+
+> Was gab es für coole Erweiterungen?
+
+Das war eigentlich eine der coolsten Sachen an dem Projekt.
+Denn um Nachts nicht geblendet zu werden, gab es einen Nachtmodus.
+Dieser bestand aus einem dunklen Hintergrund, dunkleren Farben und des Deaktivieren der großen Wetterkarte.<br/>
+Außerdem gab es einen Bewegungsmelder. Nach 10 Minuten ohne Bewegung wurde der Bildschirm dunkel geschaltet. 
+Sobald jemand den Raum betrat, wurde der Bildschirm wieder aktiviert.<br/>
+Zuletzt hab ich unseren [librespot](https://github.com/librespot-org/librespot) Server noch selbst dazu gebracht, den aktuell laufenden Song dem Infoscreen mitzuteilen.
+
+## Was war denn nun auf dem Bildschirm?
+
+Folgende Infos wurden zuletzt angezeigt:
+- Zeit
+- Wetter und Wetterkarte
+- zwei RSS News Feeds
+- ein Google Kalender
+- Abfahrten der nächsten Straßenbahnstation
+- derzeit laufendes Spotify oder (falls nichts läuft) Infos von meinen Pflanzensensoren
+
+Außerdem wird der Hintergrund durch ca. 20 Bilder rotiert.
+
+Wenn es spät wird, wird ein Nachtmodus aktiviert und die Wetterkarte durch ein süßes GIF von einem schlafenden Pikachu ersetzt.
+
+### Wetter
+
+Für das Wetter nutze ich zuerst die [DarkSky API](https://darksky.net/).
+Als Apple den Dienst gekauft und den kostenlosen Zugang beschränkt hat, war klar, dass ich eine Alternative brauche.
+
+Meine Wahl fiel auf [Pirate Weather](https://pirateweather.net/).
+Doch der Dienst war oft nicht zuverlässig.
+Wahrscheinlich sollte man eher einen anderen Dienst nutzen.
+
+### RSS News
+
+Hier hab ich mir einen Spaß erlaubt: 
+Dem Feed der [Tagesschau](https://www.tagesschau.de/) wurden einige wenige Artikel des [Postillons](https://www.der-postillon.com/) zugefügt.
+Manchmal musste man aber echt raten...
+
+### Google Calendar
+
+Hier wurde einfach die [Google Calendar API](https://developers.google.com/calendar) genutzt und das Ergebnis in einer Liste nach Tagen gruppiert angezeigt.
+
+### Haltestellenauskunft
+
+Die lokalen Verkehrsbetriebe haben eine API bereitgestellt, um die nächsten Abfahrten an einer Haltestelle abzufragen.
+Dokumentiert oder offiziell ist sie nicht so recht und ich habe gehört, dass sie seitdem auch stärker limitiert ist.
+Auf jeden Fall wurden einfach die nächsten beiden Haltestellen abgefragt und die Ankuftszeiten inkl. Verspätungen angezeigt.
+
+### Spotify
+
+Wie das funktioniert hat, ist gar nicht so simpel.
+Vielleicht sollte ich mal einen eigenen Blogpost dazu schreiben.
+
+Falls nichts lief, wurden stattdessen Infos von meinen Pflanzensensoren angezeigt.
+
+### Pflanzensensoren
+
+Hier wurden einfach einige Daten aus meinem [Home Assistant](https://www.home-assistant.io/) zu den Pflanzen in der Küche angezeigt.

src/content/projects/ol-git.mdx

@@ -0,0 +1,78 @@
+---
+title: Overleaf Sync with Git
+description: "Overleaf ist ein webbasierter LaTeX-Editor einfach echt gut in seinem Job. Aber ein Projekt backupen ohne Geld zu zahlen? Unmöglich, sogar wenn man seine Instanz selbst hosted. Das fand ich schlimm und hab ein Script geschrieben, dass ein bestimmtes Projekt regelmäßig über git sichert."
+repository: "https://git.c0ntroller.de/c0ntroller/overleaf-git-sync"
+published: 2022-10-18T17:56:27+02:00
+---
+
+## Das Problem
+
+Als ich in der Uni wichtige Paper wie meine Abschlussarbeit schreiben musste, wollte ich nicht böse überrascht werden und stattdessen so viele Backups wie möglich haben.
+Denn was wenn meine eigene Festplatte oder die der Overleaf-Instanz kaputt geht?
+
+Da die Arbeit eh mit LaTeX geschrieben werden sollte, bot sich eine selbstgehostete Instanz von [Overleaf](https://overleaf.com/) an.
+Overleaf ist einer der besten Editoren für LaTeX und da es webbasiert ist, kann ich von all meinen Geräten darauf zugreifen.
+Und da es am Ende nur ein Frontend für Ordner und Dateien ist, sollte es doch eine einfache Möglichkeit geben, die Projekte zu sichern, oder?
+
+Nö!<br/>
+Nicht nur gibt es kann die selbstgehostete Community-Version keine Projekte mit Cloud-Speicher oder git synchronisieren.
+Es gibt diese Möglichkeit in der zentralen Version, die von Overleaf selbst gehostet wird aber diese befindet sich hinter einer Paywall.
+
+Und der Preis dafür ist nichtmal gering, selbst als Student sollte ich damals 70€/Jahr zahlen!
+Das ist einfach nur Abzocke und Blödsinn.
+
+Da muss es doch einen besseren Weg geben.
+
+## Wo sind meine Daten?
+
+Erstmal habe ich Overleaf mit Docker aufgesetzt und ein kleines Projekt erstellt.
+
+Jetzt müssten die Dateien doch irgendwo auf der Festplatte liegen, oder?
+
+Wieder falsch.<br/>
+Also teilweise, Bilder findet man auf der Festplatte.
+Aber ich vermute den ganzen LaTeX-Kram pipen sie in die MongoDB, die der Service nutzt.
+
+Also nochmal von vorn.
+
+Gibt es eine API?
+Klar, das Frontend nutzt ja auch eine.
+Aber dokumentiert ist da nichts.
+Wir können dank OpenSource aber einfach ins Repo schauen - und finden eine Datei [`router.js`](https://github.com/overleaf/overleaf/blob/main/services/web/app/src/router.js).
+Jetzt musste ich nur noch herausfinden, wie man die API nutzt.
+
+## \*Hackervoice\*: I'm in
+
+Im Frontend kann man ganz gut nachvollziehen, wie das geht.
+Zuerst einmal erfolgt die Authentifizierung über Sessions-IDs.
+Beim Einloggen sendet man einen POST-Request an `/login` mit den Zugangsdaten und einem CSRF-Token, in diesem Moment wird die Session-ID gültig.
+
+Über die zuvor erwähnte Datei war gut nachvollziehbar, welche Routen wir nun nutzen konnten.
+Ich brauchte nur eine: Den Download eines ganzen Projekts.
+
+Und das war einfacher als erwartet, denn man kann auch das im Browser nachvollziehen: `/project/{id}/download/zip`
+
+Jetzt hatte ich alle Puzzleteile und konnte mir ein einfaches Python-Script schreiben, das diese Requests durchführt.
+
+## Was tun mit der Zip?
+
+Theoretisch hätte man hier etwas abkürzen können und einfach alle Befehle in Python mit `subprocess` ausführen können.
+Aber das fühlte sich falsch an und stattdessen habe ich liber zwei Bash-Skripte geschrieben.
+
+Das erste setzt den git-Ordner auf.
+Es klont das Repository, in dem wir unsere Sachen ablegen wollen und wechselt auf den Branch, den wir nutzen wollen.
+Dann wird die zuvor heruntergeladene Zip-Datei in diesem Ordner entpackt.
+
+Das zweite Bash-Script erstellt einen git-Commit und pusht die Änderungen ins Remote-Repository.
+
+Das wars auch schon.
+
+## Was könnte man besser machen?
+
+Das ganze ist mehr Script als nutzbares Programm, daher gibt es natürlich Dinge zu verbessern:
+
+- Eine `.env` Datei benutzen, statt ein Python-Dictionary für die Einstellungen und Zugangsdaten.
+- Mehr Sync-Methoden wie verschiedene Cloud-Speicher einbauen.
+- OAuth-Support (Werde ich wahrscheinlich eh nie machen).
+
+Das Projekt ist aber für mich hier abgeschlossen, also werden die anderen Punkte wohl auch nichts...

src/content/projects/photo-sync.mdx

@@ -0,0 +1,36 @@
+---
+title: Google Photo Sync
+description: "Irgendwelchen Apps vollen Zugriff auf seine Google Photos geben? Uff. Vor allem wenn es um Kleinigkeiten wie Bildschirmschoner geht. Also habe ich kurz gebastelt, um ein Album lokal zu halten und regelmäßig zu synchronisieren."
+repository: https://git.c0ntroller.de/c0ntroller/google-photo-album-sync
+published: 2022-08-08T12:19:20+02:00
+---
+
+Warum sollte ich für einen Bildschirmschoner auf meine Privatsphäre verzichten?
+
+## Storytime
+
+Auf meinem NVidia Shield mit Android TV wollte ich einen Bildschirmschoner einrichten.
+Es gibt natürlich viele davon und Google Photos als Quelle ist natürlich ein sehr einfacher Weg, wenn die eigenen Bilder sowieso dort liegen.
+
+Also die nächstbeste App installiert und einloggen.
+
+Oder auch nicht.
+
+Denn die App wollte nicht nur Zugriff auf meine Bilder.
+Sie wollte auch Zugriff auf meine persönlichen Daten, E-Mail-Adresse, Kontaktliste und andere Dinge.
+Ja ich weiß, ich rede hier über Privatsphäre und Datenschutz, aber nutze Google Photos - aber lieber hat Google meine Daten als irgendeine App, der ich nicht vertrauen kann.
+
+Aber vielleicht gibt es ja doch eine Möglichkeit - einfach die Bilder offline bereitstellen, dann bleibt der Google Account privat.
+
+## Die Lösung
+
+Ich hatte schon einige Erfahrung mit den Google APIs vom [Infoscreen](/projekt/infoscreen) und dem [Simple Callback Server](/projekt/simple-cb).
+
+Um auch Leuten ohne diese Erfahrung etas Hilfe zu geben, habe ich gleich eine CLI-Anwendung für das Setup erstellt.
+In der `README` sollte eigentlich ein guter Startpunkt sein, um seine eigenen Bilder zu synchen.
+
+## Was noch?
+
+Hat man mehrere Bilder mit gleichem Namen, kann noch etaws kaputtgehen.
+Grundsätzlich funktioniert aber auch dieser Fall.
+Theoretisch könnte man noch Hashing wie MD5 benutzen, um die Bilder besser zu unterscheiden.

src/content/projects/simple-cb.mdx

@@ -0,0 +1,34 @@
+---
+title: Simple Callback Server
+description: "Um große APIs wie von Google oder Spotify zu nutzen, wird häufig ein OAuth2-Flow benutzt. Für meine kleinen privaten Projekte reicht aber eigentlich auch der Refresh-Token, den man nach dem initialen Setup immer wieder verwenden kann. Um diesen Token aus dem Flow zu bekommen, habe ich einen Mini-Webserver erstellt, welcher einfach den Body der Request printed, sodass man den Token ganz einfach bekommt. Simpel aber effektiv."
+repository: "https://git.c0ntroller.de/c0ntroller/simple-callback-server"
+published: 2022-10-18T17:56:27+02:00
+---
+
+Das wahrscheinlich einfachste Projekt.
+
+## Was macht es?
+
+Das einfachste, was man sich vorstellen kann: Ein `express`-Server printed einfach alle Header und den POST-Body oder die GET-Parameter eines Aufrufs.
+Manchmal braucht man sowas eben.
+
+## Für was kann ich das benutzen?
+
+Am Ende eines OAuth2-Flows gibt es im Normalfall einen "Callback" an den "Dienst", den man betreibt und wo man den Nutzer authentifizieren will.
+Callback bedeutet hier einfach nur, dass die konfigurierte Server-URL mit einigen Parametern wie Tokens aufgerufen wird.
+
+In meinen eigenen Projekten bin der User aber ich selbst und jedes mal den Flow zu durchlaufen, ist mühselig.
+
+Stattdessen gibt es häufig einen Refresh-Token, der mit dem Callback mitgesendet wird.
+Der steckt aber nur im Callback und um ihn auszulesen, muss man den Callback auslesen.
+
+Nun, hier schließt sich der Kreis.
+
+## Klingt unnötig kompliziert
+
+Ist es. Aber OAuth2 ist nunmal kompliziert.
+
+## Und was ist mit `whoami`?
+
+Dass es einen Docker-Container gibt, der quasi genau das macht, ist mir leider erst viel später aufgefallen.
+Naja, dümmer bin ich nicht geworden.

src/content/projects/terminal.mdx

@@ -0,0 +1,109 @@
+---
+title: Terminal (veraltet)
+description: "Das hier beschriebene \"Terminal\" war meine erste eigene Webseite. Nur mit JavaScript programmiert, konnte man die Seite mit Befehlen navigieren. Später war dieses Terminal auch auf der zweiten Iteration eingebunden. Es gab echt viele Funktionen, Eastereggs und Shortcuts. Auch wenn es so nicht mehr verfügbar ist, habe ich hier noch die Dokumentation dazu."
+repository: https://git.c0ntroller.de/c0ntroller/frontpage
+published: 2022-10-18T17:56:27+02:00
+tags: 
+  - Veraltet
+  - JavaScript
+  - React
+---
+
+> [!info] Dieses Projekt ist veraltet.
+> Als Kontext: Die ersten Versionen meiner Website waren nur eine "CLI" in React.
+> Unschwer zu erkennen, dass sich das geändert hat.
+> Mittlerweile habe ich die CLI komplett entfernt.
+> Aus nostalgischen Gründen möchte ich die Dokumentation aber hier lassen.
+
+Hi und Willkommen auf meiner Website. 
+Dies ist die Dokumentation für meine CLI.
+Probiert sie mal aus, wenn ihr es noch nicht gemacht habt!
+
+## Warum?
+
+Vor allem aus Langeweile und weil ich Codeschreiben mag.
+Und auf meiner eigenen Webseite kann ich auch einfach nerdig sein und wilde Dinge programmieren.
+
+## Wie?
+### Frameworks
+
+Die Webseite ist komplett in [Next.js](https://nextjs.org/) geschrieben, einem JavaScript/React-Framework.
+Also ist das Backend letzlich in [Node.js](https://nodejs.org/).
+Die Projekteinträge sind in [AsciiDoc](https://projects.eclipse.org/projects/asciidoc.asciidoc-lang) verfasst.
+Das ganze hoste ich in einerm [Docker](https://www.docker.com/) Container auf meinem eigenen Server.
+
+### Der Beginn
+#### Ein eigener Platz im Internet
+Ich wollte schon immer mal eine eigene Webseite haben.
+Aber langweilig sollte sie auch nicht einfach sein.
+Eines Tages kam mir dann die Idee - wie wäre es mit einer Webseite, die im Grunde eine Konsole ist.  
+Klingt eigentlich nicht so schwer, es besteht ja nur aus einem Eingabefeld und einem Log/Verlauf.
+
+Aber ich wollte mehr:
+Der Code sollte so modular wie möglich sein, damit es in Zukunft einfach ist, Befehle, Projektlogs und Komponenten hinzuzufügen.
+Außerdem wollte ich coole Features wie Tab-Vervollständigung und Shortcuts.
+
+Aber da es schwer ist, Freunden oder Arbeitgebern, die sich nicht mit Informatik auskennen, ein CLI ohne Erklärung hinzuwerfen, entschied ich mich, auch einen "normalen" Frontend-Teil hinzuzufügen.
+
+#### Implementierung
+
+> Klingt eigentlich nicht so schwer [...]
+
+Unsinn. Es war schwer. Aber am Ende hat es sich gelohnt.  
+Alle Kommandos sind in einer Quelldatei nach einem spezifischen Format definiert, sodass man super einfach neue hinzufügen oder alte entfernen kann.
+Man kann Flags und andere Attribute hinzufügen und die Funktion definieren, die ausgeführt wird, wenn das Kommando ausgeführt wird.  
+Die Projektdateien sind in einer separaten Repository und Ordner auf meinem Server, der als Docker-Volume eingebunden ist.
+Somit kann man sie super einfach aktualisieren, ohne das ganze Projekt neu bauen zu müssen.
+
+Als die CLI fertig war, war sie für einige Monate meine Hauptseite.
+Dann habe ich den "normalen" Teil erstellt, der im Grunde ein Blog und mein Portfolio ist.
+
+#### Autodeployment
+Wir mögen hier maximale Automatisierung, also musste auch eine CI/CD-Pipeline her.
+Da ich mein eigenes Gitea zum Spielen habe, musste auch die Pipeline selbstgehostet sein.
+Also habe ich [Drone](https://www.drone.io/) benutzt.
+Der Docker-Container landet in der eigenen Registry, also ist es sicher, wenn ich mal geheime oder private Daten in das Projekt einfügen will.
+
+Die Projektdateien werden zuerst mit [Asciidoctor](https://asciidoctor.org/) gebaut, um ihre Gültigkeit zu überprüfen.
+Dann zieht ein Skript sie auf den Server.
+Da das Git-Verzeichnis der Projekte auf dem Server nur im Docker-Container eingebunden ist, reicht ein schnelles Neuladen, damit die Dateien auf dem Server verfügbar sind.
+
+## Die Zuuukuuunft
+
+Was wird es noch für Features geben?  
+Keine Ahnung.
+
+Wahrscheinlich wird es so sein, wie alles hier:
+Ich hab eine Idee (ob die gut oder schlecht ist, ist irrelevant) und setze sie entweder sofort um oder füge sie als Issue hinzu.
+
+## CLI Shortcuts
+Wie vorher erwähnt, gibt es einige Shortcuts, um die Bedienung zu erleichtern.
+
+| Key | Effect |
+|-----|--------|
+| <kbd>Tab</kbd> | Fügt die aktuellen Vorschläge aus der Autovervollständigung ein. |
+| <kbd>&#9650;</kbd> / <kbd>&#9660;</kbd> | Durchsuchen der letzten Befehle. |
+| <kbd>Ctrl</kbd>+<kbd>L</kbd> | Löscht den Verlauf. Ähnlich wie `clear`. |
+| <kbd>Ctrl</kbd>+<kbd>D</kbd> | Verlässt die Seite. Wenn das nicht funktioniert ([JavaScript-Einschränkung](https://developer.mozilla.org/en-US/docs/Web/API/Window/close)) geht es zurück in die Seitenhistorie. Ähnlich wie `exit`. |
+| <kbd>Ctrl</kbd>+<kbd>U</kbd>/<kbd>Ctrl</kbd>+<kbd>C</kbd> | Entfernt die aktuelle Eingabe. |
+| <kbd>Esc</kbd> | Schließt das Dialogmodal. |
+
+## Zeug, auf das ich stolz bin
+- Jede Zeile der Historie wird in einem eigenen Format geparst.
+  * `%{command}` wird als klickbares Kommando dargestellt.
+  * `#{link text|url}` wird als Link dargestellt.
+- Die Projektlogs werden dynamisch geladen. Sie können jederzeit aktualisiert werden.
+  * Aber sie werden im Backend gerendert. Für die Hauptseite (nicht die CLI) ist theoretisch kein JS notwendig.
+- Es gibt viele Eastereggs. Einige sind für bestimmte Personen, einige für mich und einige einfach nur zum Spaß.
+- Ich habe einige benutzerdefinierte Anmerkungen für Codeblöcke erstellt, die fehlerhaften Code anzeigen (falsche Syntax/wird nicht kompiliert/etc.).
+
+<div class="notCompiling">
+```rust
+// So sieht ein fehlerhafter Codeblock aus
+fn main() {
+  let x = 5;
+  x = 6;
+}
+```
+</div>
+

src/content/projects/tufast.mdx

@@ -0,0 +1,44 @@
+---
+title: TUfast TUD
+description: "TUfast is a browser extension that is used by multiple thousand users of the TU Dresden. It provides autologin to the most used portals, shortcuts, redirects, and more. I'm one of the developers."
+descriptionShort: "TUfast is a browser extension that is used by multiple thousand users of the TU Dresden."
+repository: https://github.com/TUfast-TUD/TUfast_TUD
+relatedWebsite: https://tu-fast.de/
+published: 2022-06-23T12:53:07.207Z
+---
+
+Meine Arbeit an einer Browser-Extension, die von tausenden Stundierenden genutzt wird.
+
+## Was ist TUfast?
+TUfast ist einen Browser-Erweiterung, die von einigen Studierenden der TU Dresden entwickelt wurde.
+Ursprünglich ein Ein-Mann-Projekt hab ich schon früh Pull Requests gestellt und somit mitentwickelt.
+Nach einer Zeit hat sich ein Team gebildet und die Extension wurde immer weiter verbessert und erweitert.
+
+Die Hauptfunktion besteht darin, einen Auto-Login auf all den verschiedenen Portalen der TU Dresden zu ermöglichen.
+Zusätzlich gibt es noch viele weitere Features, wie Shortcuts, Redirects von Suchmaschinen andere QoL-Features.
+Insgesamt hat die Extension mehrere tausend Nutzer.
+
+Das Projekt ist Open Source und [auf Github gehostet](https://github.com/TUfast-TUD/TUfast_TUD).
+
+TUfast ist eine Browser-Erweiterung, die von einigen Studierenden der TU Dresden entwickelt wurde.
+Die Hauptfunktion besteht darin, Benutzernamen und Passwörter auf verschiedenen Login-Seiten der TU-Portale einzufügen.
+Weitere Funktionen sind Shortcuts, Redirects von Suchmaschinen, Verbesserungen und mehr.
+Es hat mehrere tausend Nutzer.
+
+Das Projekt ist Open Source und [auf Github gehostet](https://github.com/TUfast-TUD/TUfast_TUD).
+Mittlerweile gibt es leider keinen richtigen Maintainer mehr, aber der Owner ist offen für Merge Requests und Hilfe.
+
+## Was habe ich gemacht?
+Ich war einer der ersten und einer der Hauptprogrammierer des Projekts.
+An einem Punkt haben wir beschlossen, die Codebase auf TypeScript umzustellen, [Manifest V3](https://developer.chrome.com/docs/extensions/mv3/intro/) zu unterstützen und dabei gleich mit all den bis dahin verteilten Scripten aufzuräumen.
+Zu diesem Zeitpunkt war der komplette Backendcode 100% meine Arbeit.
+
+Später wurde noch eine 2-Faktor-Authentifizierung für viele Logins hinzugefügt.
+Obwohl ich zu diesem Zeitpunkt nicht einmal mehr Student war, habe ich eine Implementierung des TOTP-Algorithmus gebaut, sodass der Auto-Login vollständig von der Extension übernommen werden konnte.
+Natürlich ist das absolut nicht optimal, 2FA so einfach zu automatisieren, aber die Realität ist, dass viele Studierende diese Funktion nutzen, um sich den Login zu erleichtern.
+Ich selbst würde es nicht nutzen, aber ich verstehe den Nutzen dahinter.
+
+## Weitere Informationen
+
+- [Repository](https://github.com/TUfast-TUD/TUfast_TUD)
+- [Website](https://tu-fast.de/)