Roadmaps
+1,2 Tsd. Lernende
AnmeldenBeitreten
Roadmaps
+1,2 Tsd. Lernende
Anmelden
3 Pfade · Python ist live

Wähle deinen Pfad.

Python142 Themen · ~119 StundenLive

Python-Grundlagen für Quants

  1. Python-Syntax und Ihr erstes Programm45 Min.Einsteiger
  2. Ganzzahlen und Gleitkommazahlen30 Min.Einsteiger
  3. Strings und f-Strings30 Min.Einsteiger
  4. Booleans und Vergleiche30 Min.Einsteiger
  5. Bedingungen: if, elif, else30 Min.Einsteiger
  6. for-Schleifen und range30 Min.Einsteiger
  7. while-Schleifen, break und continue30 Min.Einsteiger
  8. Funktionen definieren und aufrufen40 Min.Einsteiger
  9. Funktionsargumente und Standardwerte40 Min.Einsteiger
  10. Gültigkeitsbereich und Closures40 Min.Einsteiger
  11. List Comprehensions30 Min.Einsteiger
  12. Listen40 Min.Einsteiger
  13. Tupel und Entpacken30 Min.Einsteiger
  14. Dictionaries40 Min.Einsteiger
  15. Sets30 Min.Einsteiger
  16. Textdateien lesen und schreiben40 Min.Einsteiger
  17. CSV-Dateien35 Min.Einsteiger
  18. JSON-Daten35 Min.Einsteiger
  19. Ausnahmen und Fehlerbehandlung45 Min.Einsteiger
  20. Module und Importe35 Min.Einsteiger
  21. Pakete und Projektstruktur40 Min.Einsteiger
  22. Virtuelle Umgebungen und pip35 Min.Einsteiger
  23. Git-Grundlagen40 Min.Einsteiger
  24. Jupyter-Notebooks35 Min.Einsteiger
  25. Reproduzierbare Forschungs-Workflows40 Min.Einsteiger
  26. Klassen und Objekte45 Min.Einsteiger
  27. Spezielle Methoden (__repr__, __eq__)40 Min.Einsteiger
  28. Dataclasses35 Min.Einsteiger
  29. Ableitungen im Code40 Min.Einsteiger
  30. Integrale im Code40 Min.Einsteiger
  31. Vektoren und Skalarprodukte40 Min.Einsteiger
  32. Matrizen und lineare Gleichungssysteme45 Min.Einsteiger
  33. Zufallsvariablen und Erwartungswert45 Min.Einsteiger

NumPy & pandas für Marktdaten

  1. NumPy-Arrays und dtypes45 Min.Einsteiger
  2. Indizierung und Slicing von Arrays35 Min.Einsteiger
  3. Vektorisierung45 Min.Einsteiger
  4. Broadcasting40 Min.Einsteiger
  5. pandas-Series40 Min.Einsteiger
  6. pandas-DataFrames45 Min.Einsteiger
  7. Daten auswählen mit loc und iloc40 Min.Einsteiger
  8. groupby und Aggregation40 Min.Einsteiger
  9. Tabellen zusammenführen und verknüpfen40 Min.Einsteiger
  10. Einfache Renditen35 Min.Mittelstufe
  11. Log-Renditen35 Min.Mittelstufe
  12. DatetimeIndex und zeitbasierte Indizierung40 Min.Mittelstufe
  13. Resampling40 Min.Mittelstufe
  14. Gleitende Fenster40 Min.Mittelstufe
  15. Umgang mit fehlenden Daten40 Min.Mittelstufe
  16. Ausreißer erkennen40 Min.Mittelstufe
  17. Kapitalmaßnahmen: Splits und Dividenden45 Min.Mittelstufe
  18. Liniendiagramme mit matplotlib35 Min.Mittelstufe
  19. Kerzendiagramme40 Min.Mittelstufe
  20. Histogramme und Verteilungen35 Min.Mittelstufe

Wahrscheinlichkeit & Monte-Carlo-Simulation

  1. Mittelwert und Varianz von Renditen40 Min.Mittelstufe
  2. Schiefe und Kurtosis40 Min.Mittelstufe
  3. Fat Tails und Normalitätstests45 Min.Mittelstufe
  4. Hypothesentests: der t-Test45 Min.Mittelstufe
  5. Lineare Regression (OLS)55 Min.Mittelstufe
  6. Volatilität45 Min.Mittelstufe
  7. Die Sharpe-Ratio40 Min.Mittelstufe
  8. Drawdowns40 Min.Mittelstufe
  9. Zufallszahlengeneratoren und Seeds40 Min.Mittelstufe
  10. Ziehen aus Verteilungen45 Min.Mittelstufe
  11. Monte-Carlo-Schätzung50 Min.Mittelstufe
  12. Monte-Carlo-Fehler und Konvergenz50 Min.Mittelstufe

Bewertung von Anleihen und Optionen

  1. Barwert und Diskontierung40 Min.Mittelstufe
  2. Anleihepreise45 Min.Mittelstufe
  3. Rendite bis zur Fälligkeit45 Min.Mittelstufe
  4. Duration und Konvexität50 Min.Mittelstufe
  5. Zinskurven und Interpolation50 Min.Mittelstufe
  6. Auszahlungen von Optionen40 Min.Mittelstufe
  7. Put-Call-Parität40 Min.Mittelstufe
  8. Die Black–Scholes-Formel55 Min.Mittelstufe
  9. Delta45 Min.Mittelstufe
  10. Gamma45 Min.Mittelstufe
  11. Vega45 Min.Mittelstufe
  12. Theta und Rho45 Min.Mittelstufe
  13. Implizite Volatilität50 Min.Mittelstufe
  14. Nullstellensuche: Bisektion und Newton50 Min.Mittelstufe
  15. Binomialbäume55 Min.Mittelstufe
  16. Finite-Differenzen-Verfahren1 Std.Mittelstufe

Portfoliooptimierung

  1. Kovarianz- und Korrelationsmatrizen45 Min.Mittelstufe
  2. Rendite und Varianz eines Portfolios45 Min.Mittelstufe
  3. Minimum-Varianz-Portfolio50 Min.Mittelstufe
  4. Mittelwert-Varianz-Optimierung55 Min.Mittelstufe
  5. Die Effizienzlinie55 Min.Mittelstufe

Backtesting und Handelskosten

  1. Ein vektorisierter Backtester1 Std.Fortgeschritten
  2. Ein ereignisgesteuerter Backtester1 Std. 15 Min.Fortgeschritten
  3. Look-ahead-Bias50 Min.Fortgeschritten
  4. Transaktionskosten45 Min.Fortgeschritten
  5. Slippage45 Min.Fortgeschritten
  6. Realistische Orderausführung55 Min.Fortgeschritten

Alpha-Forschung und Risiko

  1. CAPM und Beta55 Min.Fortgeschritten
  2. Multifaktormodelle: Fama-French1 Std.Fortgeschritten
  3. Der Informationskoeffizient55 Min.Fortgeschritten
  4. Historischer VaR50 Min.Fortgeschritten
  5. Parametrischer VaR50 Min.Fortgeschritten
  6. Expected Shortfall50 Min.Fortgeschritten
  7. Stresstests55 Min.Fortgeschritten
  8. ARIMA-Modelle1 Std.Fortgeschritten
  9. GARCH-Volatilitätsmodelle1 Std.Fortgeschritten

Stochastische Modelle und Machine Learning

  1. Brownsche Bewegung50 Min.Fortgeschritten
  2. Geometrische Brownsche Bewegung55 Min.Fortgeschritten
  3. Das Itô-Lemma55 Min.Fortgeschritten
  4. Asiatische Optionen55 Min.Fortgeschritten
  5. Barriereoptionen1 Std.Fortgeschritten
  6. Antithetische Variablen45 Min.Fortgeschritten
  7. Kontrollvariablen50 Min.Fortgeschritten
  8. scikit-learn-Pipelines für Renditen1 Std.Fortgeschritten
  9. Feature Engineering für Finanzdaten1 Std.Fortgeschritten
  10. Walk-Forward-Validierung1 Std.Fortgeschritten

Marktdaten und Mikrostruktur

  1. Das Limit-Orderbuch1 Std.Fortgeschritten
  2. Orderfluss-Ungleichgewicht50 Min.Fortgeschritten
  3. Asynchroner Code mit asyncio1 Std.Fortgeschritten
  4. Datenstreaming mit Websockets55 Min.Fortgeschritten
  5. Das FIX-Protokoll1 Std.Fortgeschritten

Hochleistungs-Python-Entwicklung

  1. Sauberer Code45 Min.Fortgeschritten
  2. Typannotationen und statische Prüfung45 Min.Fortgeschritten
  3. Testen mit pytest50 Min.Fortgeschritten
  4. Python-Code profilen50 Min.Fortgeschritten
  5. Heiße Schleifen optimieren55 Min.Fortgeschritten
  6. Numba1 Std.Fortgeschritten
  7. Cython1 Std.Fortgeschritten
  8. C++ mit pybind11 aufrufen1 Std.Fortgeschritten
  9. Threads und der GIL55 Min.Fortgeschritten
  10. Multiprocessing55 Min.Fortgeschritten
  11. SQL-Datenbanken55 Min.Fortgeschritten
  12. Parquet und Arrow50 Min.Fortgeschritten
  13. Zeitreihendatenbanken50 Min.Fortgeschritten

Produktivsysteme und Spitzenmodelle

  1. Eine Python-Bibliothek paketieren1 Std.Experte
  2. CI/CD für Quant-Code1 Std.Experte
  3. Geplante Pipelines1 Std.Experte
  4. TWAP-Ausführung1 Std.Experte
  5. VWAP-Ausführung1 Std.Experte
  6. Market Making1 Std. 30 Min.Experte
  7. Das Heston-Modell1 Std. 30 Min.Experte
  8. Lokale Volatilität1 Std. 30 Min.Experte
  9. Das SABR-Modell1 Std. 30 Min.Experte
  10. Modellkalibrierung1 Std. 30 Min.Experte
  11. Neuronale Netze für Prognosen1 Std. 30 Min.Experte
  12. Reinforcement Learning für den Handel2 Std.Experte
  13. Abschlussprojekt: eine durchgängige Pricing- oder Strategie-Bibliothek4 Std.Experte
Roadmap starten
C++93 Themen · ~86 StundenBald verfügbar

C++-Grundlagen

  1. Compiler und der Build-Prozess45 Min.Einsteiger
  2. CMake-Projekte45 Min.Einsteiger
  3. Sanitizer40 Min.Einsteiger
  4. Grundtypen und Initialisierung40 Min.Einsteiger
  5. Referenzen40 Min.Einsteiger
  6. Const-Korrektheit40 Min.Einsteiger
  7. Funktionen und Überladung40 Min.Einsteiger
  8. Lambdas40 Min.Einsteiger
  9. std::function40 Min.Einsteiger
  10. Klassen und Konstruktoren45 Min.Einsteiger
  11. RAII50 Min.Einsteiger
  12. Die Rule of Zero45 Min.Einsteiger
  13. Rohe Zeiger40 Min.Einsteiger
  14. std::unique_ptr45 Min.Einsteiger
  15. std::shared_ptr und weak_ptr45 Min.Einsteiger
  16. Move-Semantik1 Std.Einsteiger
  17. Wertkategorien50 Min.Einsteiger
  18. Ausnahmen45 Min.Einsteiger
  19. std::expected45 Min.Einsteiger

STL und Datenverarbeitung

  1. std::vector45 Min.Einsteiger
  2. std::array35 Min.Einsteiger
  3. std::map40 Min.Einsteiger
  4. std::unordered_map45 Min.Einsteiger
  5. Iteratoren40 Min.Einsteiger
  6. Ranges und Views45 Min.Einsteiger
  7. STL-Algorithmen45 Min.Einsteiger
  8. std::string40 Min.Einsteiger
  9. std::string_view35 Min.Einsteiger
  10. std::span35 Min.Einsteiger
  11. CSV-Dateien parsen50 Min.Einsteiger
  12. Binäre Datendateien lesen50 Min.Einsteiger
  13. chrono-Dauern40 Min.Einsteiger
  14. chrono-Zeitpunkte40 Min.Einsteiger

Generische Programmierung

  1. Funktions-Templates55 Min.Mittelstufe
  2. Klassen-Templates55 Min.Mittelstufe
  3. Concepts1 Std.Mittelstufe
  4. constexpr-Funktionen50 Min.Mittelstufe
  5. consteval und Tabellen zur Compilezeit50 Min.Mittelstufe
  6. CRTP1 Std.Mittelstufe
  7. Policy-basiertes Design1 Std.Mittelstufe
  8. Perfect Forwarding50 Min.Mittelstufe
  9. std::variant und std::visit55 Min.Mittelstufe
  10. std::optional40 Min.Mittelstufe

Numerik und Bewertung

  1. Lineare Algebra mit Eigen1 Std.Mittelstufe
  2. Zufallszahlengeneratoren50 Min.Mittelstufe
  3. Monte-Carlo-Bewertung1 Std.Mittelstufe
  4. Eine Bibliothek zur Optionsbewertung entwerfen1 Std. 15 Min.Mittelstufe
  5. Greeks per finite Differenzen55 Min.Mittelstufe
  6. Automatische Differentiation1 Std. 10 Min.Mittelstufe
  7. Nullstellensuche50 Min.Mittelstufe
  8. Numerische Integration50 Min.Mittelstufe

Tests, Benchmarks und Debugging

  1. Unit-Tests mit GoogleTest50 Min.Mittelstufe
  2. Abhängigkeiten mocken45 Min.Mittelstufe
  3. Benchmarking mit Google Benchmark55 Min.Mittelstufe
  4. Debugging mit GDB55 Min.Mittelstufe
  5. Speicherfehler finden mit ASan45 Min.Mittelstufe
  6. Undefiniertes Verhalten finden mit UBSan45 Min.Mittelstufe

Hardware und Speicher

  1. Die Cache-Hierarchie1 Std.Fortgeschritten
  2. Datenlayout: AoS vs. SoA1 Std.Fortgeschritten
  3. Sprungvorhersage55 Min.Fortgeschritten
  4. Inlining und Compiler-Optimierung55 Min.Fortgeschritten
  5. Memory-Pools1 Std.Fortgeschritten
  6. Eigene Allokatoren1 Std.Fortgeschritten
  7. Arena-Allokation55 Min.Fortgeschritten
  8. Small-Buffer-Optimierung50 Min.Fortgeschritten
  9. Flache Container50 Min.Fortgeschritten
  10. Profiling mit perf55 Min.Fortgeschritten
  11. Flame Graphs45 Min.Fortgeschritten
  12. SIMD-Intrinsics1 Std. 10 Min.Fortgeschritten
  13. Auto-Vektorisierung55 Min.Fortgeschritten

Nebenläufigkeit und lock-freies Design

  1. Threads50 Min.Fortgeschritten
  2. Mutexe und Sperren50 Min.Fortgeschritten
  3. Bedingungsvariablen50 Min.Fortgeschritten
  4. std::atomic55 Min.Fortgeschritten
  5. Das C++-Speichermodell1 Std. 15 Min.Fortgeschritten
  6. Ein sperrfreier SPSC-Ringpuffer1 Std. 30 Min.Fortgeschritten
  7. False Sharing55 Min.Fortgeschritten
  8. NUMA und CPU-Pinning1 Std.Fortgeschritten
  9. Thread-Pools1 Std.Fortgeschritten
  10. Aufgabenbasierte Parallelität mit Futures55 Min.Fortgeschritten

Handelssysteme

  1. Datenstrukturen eines Orderbuchs1 Std.Fortgeschritten
  2. Preis-Zeit-Priorität55 Min.Fortgeschritten
  3. Eine Matching-Engine1 Std. 30 Min.Fortgeschritten
  4. UDP-Multicast55 Min.Fortgeschritten
  5. Binäre Marktdatenprotokolle1 Std.Fortgeschritten
  6. Marktdaten-Handler1 Std. 15 Min.Fortgeschritten
  7. Das FIX-Protokoll55 Min.Fortgeschritten
  8. Order-Entry-Gateways1 Std.Fortgeschritten

Produktivsysteme und Spitzentechnik

  1. Kernel-Bypass-Netzwerke1 Std. 30 Min.Experte
  2. Tail-Latenz messen1 Std. 15 Min.Experte
  3. Python-Bindings mit pybind111 Std. 30 Min.Experte
  4. Eine Backtesting-Engine in C++2 Std.Experte
  5. Abschlussprojekt: eine Low-Latency-Trading-Engine4 Std.Experte

Von modernem C++ zu lock-freier Trading-Infrastruktur mit niedriger Latenz.

OxCaml71 Themen · ~66 StundenBald verfügbar

OCaml-Grundlagen

  1. opam und dune45 Min.Einsteiger
  2. Die OCaml-REPL30 Min.Einsteiger
  3. Werte und let-Bindungen40 Min.Einsteiger
  4. Funktionen40 Min.Einsteiger
  5. Rekursion40 Min.Einsteiger
  6. Listen40 Min.Einsteiger
  7. Options30 Min.Einsteiger
  8. Tupel und Records40 Min.Einsteiger
  9. Varianten40 Min.Einsteiger
  10. Pattern Matching45 Min.Einsteiger
  11. Unveränderlichkeit und persistente Daten35 Min.Einsteiger
  12. Funktionen höherer Ordnung45 Min.Einsteiger
  13. Pipelines und der Pipe-Operator35 Min.Einsteiger
  14. Ausnahmen40 Min.Einsteiger
  15. Der result-Typ40 Min.Einsteiger

Core und Daten

  1. Base und Core45 Min.Einsteiger
  2. Maps40 Min.Einsteiger
  3. Sets35 Min.Einsteiger
  4. Hashtabellen40 Min.Einsteiger
  5. Arrays40 Min.Einsteiger
  6. Veränderlicher Zustand und refs35 Min.Einsteiger
  7. S-Ausdrücke40 Min.Einsteiger
  8. sexp ableiten40 Min.Einsteiger
  9. compare und hash ableiten40 Min.Einsteiger
  10. Datum und Uhrzeit40 Min.Einsteiger
  11. Geldbeträge und Dezimalarithmetik40 Min.Einsteiger

Typen und Abstraktion

  1. Module55 Min.Mittelstufe
  2. Signaturen55 Min.Mittelstufe
  3. Funktoren1 Std. 10 Min.Mittelstufe
  4. First-Class-Module1 Std.Mittelstufe
  5. GADTs1 Std. 10 Min.Mittelstufe
  6. Phantom-Typen55 Min.Mittelstufe
  7. Typgetriebenes Design55 Min.Mittelstufe
  8. Inline-Tests45 Min.Mittelstufe
  9. Expect-Tests mit ppx_expect45 Min.Mittelstufe

Finanzen in OCaml

  1. Preise und Renditen55 Min.Mittelstufe
  2. Zeitreihen-Pipelines1 Std.Mittelstufe
  3. Zufallszahlen50 Min.Mittelstufe
  4. Monte-Carlo-Simulation1 Std.Mittelstufe
  5. Die Black–Scholes-Formel55 Min.Mittelstufe
  6. Die Greeks55 Min.Mittelstufe
  7. Persistente Orderbücher1 Std. 15 Min.Mittelstufe

Async und Netzwerk

  1. Deferred und Async1 Std.Mittelstufe
  2. Async-Pipes50 Min.Mittelstufe
  3. RPC1 Std.Mittelstufe
  4. TCP-Netzwerke55 Min.Mittelstufe
  5. Domains1 Std.Mittelstufe
  6. Effekte1 Std.Mittelstufe

Runtime und Performance

  1. Der OCaml-Garbage-Collector55 Min.Fortgeschritten
  2. Boxing und Allokation55 Min.Fortgeschritten
  3. Stack-Allokation und der Local-Modus1 Std. 5 Min.Fortgeschritten
  4. Der Unique-Modus1 Std.Fortgeschritten
  5. Der Once-Modus55 Min.Fortgeschritten
  6. Layouts1 Std.Fortgeschritten
  7. Unboxed-Typen1 Std.Fortgeschritten
  8. Unboxed-Zahlen55 Min.Fortgeschritten
  9. Unboxed-Records55 Min.Fortgeschritten
  10. SIMD-Vektortypen1 Std.Fortgeschritten
  11. SIMD-Intrinsics1 Std.Fortgeschritten
  12. Zero-Alloc-Prüfung1 Std.Fortgeschritten
  13. Benchmarking mit core_bench55 Min.Fortgeschritten
  14. Profiling mit perf55 Min.Fortgeschritten

Sichere Parallelität

  1. Der Portable-Modus1 Std.Fortgeschritten
  2. Der Contended-Modus1 Std.Fortgeschritten
  3. Datenrennenfreie Parallelität1 Std. 15 Min.Fortgeschritten
  4. Mode Crossing1 Std.Fortgeschritten
  5. Kinds1 Std.Fortgeschritten

Produktivsysteme und Spitzentechnik

  1. C-Interop und FFI1 Std. 10 Min.Experte
  2. Ein Low-Latency-Marktdaten-Handler2 Std.Experte
  3. Eine typisierte Order-Matching-Engine2 Std.Experte
  4. Abschlussprojekt: ein Trading-System in OxCaml4 Std.Experte

Funktionale Programmierung für Handelssysteme, mit den Performance-Erweiterungen von OxCaml.