Go to google takeout. Deselect. go down to youtube at the bottom. Change the exports to subscriptions/playlists/channels Hmm. Way too clunk. The playlistso nly have vid id. Not good enough. Could write script I guess.

https://www.reddit.com/r/DataHoarder/wiki/index/

https://www.reddit.com/r/DataHoarder/comments/dxn6fx/is_there_any_way_to_export_a_youtube_playlist/

youtube-dl is the way to go I guess

youtube-dl --flat-playlist --dump-json https://www.youtube.com/playlist?list=PLqggUNm8QSqldCY-MrUktblGeaQOVRt2L > prog10.json

https://github.com/yt-dlp hmm this is better?

https://www.youtube.com/playlist?list=WL

yt-dlp --cookies-from-browser firefox --flat-playlist --dump-json "https://www.youtube.com/playlist?list=WL" > watchlater.json

chatgpt made this script for extraction

import json
import glob
import os

# Path to the directory containing your JSON files
JSON_DIR_PATH = './'
MARKDOWN_FILE_PATH = './all_playlists.md'

def load_playlists(json_dir_path):
    """
    Load playlists data from all JSON files in the specified directory.
    """
    playlists = {}
    json_files = glob.glob(os.path.join(json_dir_path, '*.json'))
    
    for file_path in json_files:
        with open(file_path, 'r') as file:
            filename = os.path.basename(file_path)
            playlists[filename] = []
            for line in file:
                try:
                    playlists[filename].append(json.loads(line))
                except json.JSONDecodeError as e:
                    print(f"Error decoding JSON from file {file_path}: {e}")
    return playlists

def playlists_to_markdown(playlists):
    """
    Convert a list of playlists to a markdown string.
    """
    markdown_str = "# YouTube Playlists\n\n"
    for filename, videos in playlists.items():
        markdown_str += f"## {filename}\n\n"
        for video in videos:
            title = video.get('title', 'No title available')
            video_id = video.get('id', 'No ID available')
            url = f"https://www.youtube.com/watch?v={video_id}" if video_id != 'No ID available' else 'No URL available'

            markdown_str += f"### [{title}]({url})\n\n"
        markdown_str += "---\n\n"
    return markdown_str

def save_to_file(content, filename):
    """
    Save a string to a markdown file.
    """
    with open(filename, 'w') as file:
        file.write(content)

if __name__ == "__main__":
    playlists = load_playlists(JSON_DIR_PATH)
    markdown_content = playlists_to_markdown(playlists)
    save_to_file(markdown_content, MARKDOWN_FILE_PATH)
    print(f"All playlists saved to {MARKDOWN_FILE_PATH}")


YouTube Playlists

watch later

Claudio Sacerdoti Coen: A taste of ELPI

William Farmer: An Alternative Approach to Formal Mathematics

Josef Urban: Autoformalization - ten years into the game

Staged Relational Interpreters: Running Backwards, Faster

Wasm Research Day 2024 – Andreas Rossberg, Engineering a Formal Language Spec

Tutorial: “Cool Trick in Matrix Analysis” by Frederik vom Ende

2021 LLVM Dev Mtg “A New Approach to Removing Redundant Conditions in LLVM”

Mohammad Abdulaziz: Formalising the Theory of Combinatorial Optimisation

Jaques Carette: Unavoidable Mathematics

“On the Mathematical Necessity of the Infinite” by Hugh Woodin

[PLDI’24] Reyjavik - EGRAPHS (Jun 24th)

OPLSS’24: Steve Zdancewic [3/4]

Ekaterina Verbitskaia “Enabling Relational Programming through Specialization”

Nicolas Thiéry: Categories, axioms, constructions in SageMath: Modeling mathematics for fun/profit

C*-Algebra Course Lecture 1

OPLSS’24: Paul Downen [4/4]

OPLSS’24: Steve Zdancewic [2/4]

13 - Multi-Way / Worst-Case Optimal Join Algorithms (CMU Advanced Databases / Spring 2023)

Introduction to the seL4 proofs - seL4 Summit 2020

GHC’s Runtime System - Ben Gamari - 2023 GHC Contributor’s Workshop

Introduction to Haskell execution and garbage collection internals – Maxim Koltsov

Call C code quickly and compatibly with CFFI (Zachary Voase)

How to Write a Paper in a Weekend (By Prof. Pete Carr)

Lennart Augustsson - MicroHaskell

Dedukti & LambdaPi - Frederic Blanqui

Locknote: How Badly Do We Want Correct Compilers? - John Regehr - NDC TechTown 2023

DEF CON 31 - Revolutionizing ELF binary patching w Shiva - ElfMaster

Tuning Linux for Performance - I Wanna Go Fast! - Anthony Nocentino - PSConfEU 2023

Linux Performance Tools, Brendan Gregg, part 1 of 2

Understanding Linux Interrupt Subsystem - Priya Dixit, Samsung Semiconductor India Research

[ICFP’22] Beyond Relooper: Recursive Translation of Unstructured Control Flow to Structu…

Peter Koepke: FOL from a Naproche perspective

Guillaume Allais: Syntaxes for Binding and their Semantics

Josef Urban: Theorem Proving and AI

Steve Awodey: What is HoTT?

Freek Wiedijk: Even more on HOL Light (3)

Optimal transport for fluid simulations - Bruno Levy - Shape seminar

Interactive Theorem Proving, Guest Lecture - Introduction to HOL, by Magnus Myreen

Generation of Compiler Backends from Formal Models of Hardware (Gus Smith’s PhD Defense)

Stephen Mell: Linear Logic is a Language for Structured Data

Milner Award Lecture: The Type Soundness Theorem That You Really Want to Prove (and now you can)

Datalog

Mario Carneiro: Lessons from Metamath

HC34-T2: Heterogeneous Compilation in MLIR

Evan Patterson: Domain specific Logics for Scientific Modeling Theory and Practice

Steve Vickers: “The Fundamental Theorem of Calculus: point-free”

Lie Algebras - Lecture 1: part 1/2

On Voevodsky’s univalence principle - André Joyal

NCNGT 2022 – An introduction to Teichmüller theory

Aaron Naber - Introduction to Yang Mills Theory 1 [2017]

Anthony Zee Group Theory in a Nutshell for Physicists 1/5 part 1

Andrej Bauer & Mario Carneiro: Type universes

Distributed Systems 7.2: Linearizability

The Stern-Brocot tree, matrices and wedges | Real numbers and limits Math Foundations 97

Andrej Bauer: Constructive Mathematics - How to not believe in the Law of Excluded Middle

Stanislaw Krajewski: Can our understanding of numbers be programmed into a computer?

Volker Halbach: Self-reference, truth, and provability

Anton Freund:Well ordering principles and a uniform Kruskal theorem

Albert Visser: Provability Logic and Modalised Fixed Points

Volker Halbach: Self-reference and intensionality in metamathematics

Ralf Schindler: How many real numbers are there?

The Art of Ordinal Analysis

Fedor Pakhomov: Kripke-Platek set theory

Interactive Theorem Proving, Guest Lecture - Introduction to Agda, by Jeremy Siek

CS208 W05P03 Interactive Proof with Or and Not

Maaike Zwart, “Distributive Laws in the Boom Hierarchy”

Mojo🔥: a deep dive on ownership with Chris Lattner

Quantum Optics 1: Review of basic quantum mechanics

OntologyTalk: An Interview with Dr. Chad Brown, Part 1

OntologyTalk: An Interview with Prof. Stephan Schulz

Lógica Clásica de Orden Superior: Automatización y Aplicaciones Seleccionadas

Simon Peyton Jones | Making a Faster Curry with Extensional Types

David McAllester - Dependent Type Theory from the Perspective of Mathematics, Physics, and (…)

Duality in Action

Emmanuel Candès - A Taste of Conformal Prediction

Current Status on Black Holes and Information Paradox - Suvrat Raju (Part 1)

Proof Complexity and Meta-Complexity Tutorial (1)

Proof complexity - an introduction - Avi Wigderson

Manuel Hermenegildo on How to Best Teach Prolog

David S Warren on the Mathematics of Prolog

Lecture 1: Introduction to p-adic numbers

New Directions in Cylindrical Algebraic Decomposition

Simple Orbit Tutorial | GMAT (NASA’s General Mission Analysis Tool)

Christian Jendreiko on Generative Logic, Teaching Prolog in Art & Design

Inverted Pendulum on a Cart [Control Bootcamp]

Michael Rathjen: Proof Theory: From Arithmetic to Set Theory

Mark Bickford: Constructive Set Theory in Nuprl Type Theory

Matthew Croughan - Nix The Planet - SCaLE 21x

1. Introduction and the geometric viewpoint on physics.

Angluin’s Algorithm for Learning DFAs | Ullas Aparanji | CSAUSS17

Automata Learning – Infinite Alphabets and Application to Verification

Efficient P2P Databases with IPLD Prolly Trees - Mauve Signweaver

Lecture 1: Overview (Discrete Differential Geometry)

Intro to Tree Transducers

Tree language to bottom up tree automaton

Intro to Tree Automata

GReTA seminar: In the Groove - Part 2

GReTA seminar #24: “Tutorial on Graph Transformation Concepts and Applications”

Fast and Small - What are the Costs of Language Features - Andreas Fertig

GTC 2022 - CUDA: New Features and Beyond - Stephen Jones, CUDA Architect, NVIDIA

How CUDA Programming Works | GTC 2022

How GPU Computing Works | GTC 2021

Lisp Ireland, February 2024 Meetup - Lisp & Hardware Verification with ACL2

Composition Intuition by Conor Hoekstra | Lambda Days 2023

[Private video]

Linux fstab File Basics | What you need to know

Linux HowTo | Build Your Own Ubuntu

Learning the Linux File System

Why does this Rust program leak memory?

Unsafe Rust is not C

Unsafe Rust and Miri by Ralf Jung - Rust Zürisee June 2023

Rust NYC: Jon Gjengset - Demystifying unsafe code

Writing Unsafe Rust

Modernizing verified crypto with Rust: introducing HACL-Rust and Eurydice

understanding mmap, the workhorse behind keeping memory access efficient in linux

Advanced SIMD Algorithms in Pictures - Denis Yaroshevskiy - Meeting C++ 2023

Turner, Bird, Eratosthenes: An Eternal Burning Thread

Introduction to SolveSpace

Learn 3D Design with SolveSpace

“Control Flow Integrity in the Linux Kernel” - Kees Cook (LCA 2020)

Hardware-Assisted Fine-Grained Control-Flow Integrity: Adding Lasers to Intel’s CET/IBT

Towards a Policy-Agnostic Control-Flow Integrity Implementation

Heap profiling Rust programs with DHAT

2019 LLVM Developers’ Meeting: A. Warzynski “Writing an LLVM Pass: 101”

Fuzzing combined with symbolic execution: a demonstration on SymCC and AFL.

Symbolic execution by compilation with SymCC

GReTA seminar: In the Groove

Heather Macbeth | Approaches to the formalization of differential geometry

Virus.Win9x.CIH/Chernobyl Destroying a Physical Computer

Debugging millions of crashes - Stack Walk Episode 5

A first look into how WinDbg works

Stephen Kell - Dragging Unix into the 1980s (and beyond?) - liveness and source-level reflection

Dan Ingalls - 40 Years Of Fun With Computers

Keynote: Kids programming with Smalltalk by Hilaire Fernandes

Workshop: Develop end user GUI application with Cuis by Hilaire Fernandes

John Harrison: Adventures in Verifying Arithmetic (IJCAR A)

The Origins of APL - 1974

HACKENBUSH: a window to a new world of math

Introduction to Proof Theory I: Sequent Calculus

René Thiemann: Certifying Termination Proofs: From Term Rewriting to SMT Solving and Back (FSCD A)

[IWC 2021] The quest for modular confluence of rewrite rules in type theory

GEO1004 | 2022 – Course introduction

Boundary Representation (B-Rep) - Techniques For Geometric Modeling - CAD/CAM/CAE

TopoTalk 01

The Continuity of Splines

1.1 Welcome to “Introduction to Parametric Modeling”

Simon Peyton Jones (Epic Games) Talk - IRIF’s Distinguished Talk Series

Calculus WITHOUT limits!

The Art of SIMD Programming by Sergey Slotin

2016 LLVM Developers’ Meeting: N. Lopes “Undefined Behavior: Long Live Poison!”

Mr. Me

Shoehorn with Teeth

Joel Hass - Lecture 1 - Algorithms and complexity in the theory of knots and manifolds - 18/06/18

big plot holes in reality

Joe Kachmar Presents: Low-Level Programming in Haskell with Levity Polymorphism

The Inner Donkey - A Donkey’s Personality

The World’s Most Aggressive Telemarketer - Key & Peele

5-3 Matroids

Peter Zoller: Introduction to quantum optics - Lecture 1

What is FOC? (Field Oriented Control) And why you should use it! || BLDC Motor

Compose Conference - Pi-Forall: How to use and implement a dependently-typed language

Atomic Clocks Lecture III

Fernando Brandao: Quantum speed-ups for semidefinite programming

Banach Spaces part 1

[Private video]

GRCon16 - Sniffing and Dissecting nRF24L with GNU Radio and Wireshark, Marc Newlin

Everything you always wanted to know About Antennas (but were afraid to ask) || Frank Rutter K3AW

HIW 2014: Dependent Haskell

Position Tracking for Virtual Reality using Wi-Fi

Cosmology, Max Tegmark | Lecture 1 of 3

F-algebras or: How I Learned to Stop Worrying and Love the Type System

Live-Coding Mathematics Your First Clojure Proof - Frederic Peschanski

CS 436: Distributed Computer Systems - Lecture 1

“A Quantum Future of Computation, “ Matthias Troyer, Microsoft Research

010 Quantum algorithms for matrix multiplication

Lamport TLA+ Course Lecture 1: Introduction to TLA+ (Old Mirror, See Description)

DEFCON 20: Making Sense of Static - New Tools for Hacking GPS

F*: Tactics, SMT, and metaprogramming

Collaborative Music with Elm and Phoenix - Josh Adams

Stanford Lecture: Donald Knuth - “Bayesian trees and BDDs” (2011)

LambdaConf 2015 - A Practical Introduction to Haskell GADTs Richard Eisenberg

Bay Area Category Group - Delimited continuations and co-monads

Bartosz Milewski: Haskell – The Pseudocode Language for C++ Template Metaprogramming (Part 1)

A Tutorial on Reinforcement Learning I

Andreas Doering: “Topos mini-course 1”

User-Friendly Tools for Random Matrices I

The meta-theory of dependent type theories - Vladimir Voevodsky

Spectral Methods for Matrices and Tensors

Khronos Meetup Oslo: Lisping on the GPU

Lecture 1 (CEM) – Introduction to CEM

CS75 (Summer 2012) Lecture 9 Scalability Harvard Web Development David Malan

Friday Hacks #112 - Make your own LLVM compiler - NUS Hackers

18 MPI Domain Decomposition

What Sparsity and l1 Optimization Can Do For You

Hierarchical Interpolative Factorization

Chebfun

Customized Computer Generated Hologram (CGH) [Part 1/3]

[Private video]

Wavelets And Multiresolution Analysis Part 1

Supersymmetry & Grand Unification: Lecture 1

Renormalization Group 1 - Shankar

001 Introduction to fast direct solvers for elliptic PDEs - Gunnar Martinsson

Modern Optimization Methods in Python | SciPy 2015 Tutorial | Mike McKerns

Multibody Dynamics and Control with Python | SciPy 2015 Tutorial | Jason Moore & James Crist

Numerical Algebraic Geometry

CGAL Part 1 of N Introduction

IGS’16 Summer School: Laplace-Beltrami: The Swiss Army Knife of Geometry Processing

IGS’16 Summer School: Optimization in Geometry Processing

Python Powered Computational Geometry

The Convex Geometry of Inverse Problems

01. Algebraic geometry - Sheaves (Nickolas Rollick)

Ugo Bruzzo - Algebraic geometry for physicists, part 1

ECE 804 - Spring 2013 - Lecture 001 with Dr. Michael Robinson

Semantic Foundations for Probabilistic Programming

A Personal Viewpoint on Probabilistic Programming

Stanford Lecture: Donald Knuth - “Fun With Binary Decision Diagrams (BDDs)” (June 5, 2008)

PLSE: Leonardo de Moura, “The Lean Theorem Prover”

Gordon Plotkin - Robin Milner: A Craftsman of Tools for the Mind

Patrick Hayden | The Quantum Computational Universe - 1 of 2

Fermions & Spin Liquids I - Lee

Connections between physics and deep learning

Analyzing Programs with Z3

Erik Demaine: Algorithms Meet Art, Puzzles, and Magic

Mini Crash Course: Tensor Networks

Tensor Network Renormalization - G. Vidal - 2/24/2015

Intro to Recursion (Haskell)

Tutorial “Homotopy Theory and Topological Defects” - Randall Kamien

Introduction to Fluid Mechanics II - Brenner

The Density Matrix Renormalization Group I - White

Prof. Zahid Hasan, “Topological Insulators, Berry Phase and Helical Dirac Fermions”, Part 1 of 4

Steven Kivelson | Superconductivity and Quantum Mechanics at the Macro-Scale - 1 of 2

Felienne Hermans: Program Derivation for Functional Languages - λC 2016

MuniHac 2016: Beautiful folds are practical, too

Applied String Theory (Lecture 1) Dam Thanh Son

Introduction to Plasma Physics I: Magnetohydrodynamics - Matthew Kunz

Topological States of Matter

06 Introduction to Dependent Types

ICFP 2014: Depending on Types - Stephanie Weirich

ZuriHac2016: Parallelizing and Distributing Scientific Software in Haskell

ZuriHac 2016: Generic (and type-level) Programming with Generics-sop

Into the Core - Squeezing Haskell into Nine Constructors by Simon Peyton Jones

André JOYAL - 1/4 A crash course in topos theory : the big picture

A first proof with Coq (Frobenius rule)

Five Stages of Accepting Constructive Mathematics

Conal Elliott - Generic FFT - Silicon Valley Haskell

Jeffrey Brown - FGL, Digraphs With Text

William Oliver: “Quantum Engineering of Superconducting Qubits”

ZuriHac 2016: Monad Homomorphisms

Conor McBride - Worldly Type Systems

Conor McBride - Dependently-Typed Metaprogramming 1/8: Introduction via Vectors

The Algebra of Algebraic Data Types

Devon Stewart - Higher Order Abstract Syntax

Generic Programming in Haskell (1 of 2): Introduction

C9 Lectures: Dr. Ralf Lämmel - Going Bananas

Recursion Schemes

Phil Freeman - Fun with Profunctors

Co-Monads - Presented by David Overton

Parsing Stuff in Haskell

Category Theory Lulz - Ken Scambler

David Sankel: The Intellectual Ascent to Agda

The Lost Art of Denotational Semantics

Bartosz Milewski - Truth about Types (Lambda Days 2016)

Category Theory, The essence of interface-based design - Erik Meijer

Bartosz Milewski. Categories for the Working C++ Programmer

Elementary Category Theory and Some Insightful Examples

Topological quantum computing with Majorana Fermions

Topological Superconductors (Lecture 1) - Anthony Leggett - 2016

Seth Lloyd: Quantum Machine Learning

A Scalable Quantum Programming Language - Benoit Valiron - June 9 2015

SIUC Seminar Louis Kauffman Non Commutativity and Discrete Physics

Knots and Quantum Theory | Edward Witten, Charles Simonyi Professor

SIUC Seminar Louis Kauffman Introduction to Topological Quantum Computing

Programming in Agda - Lecture 1 - Ulf Norell

Bob Coecke: “A survey of categorical quantum mechanics”

John Baez: “Duality in logic and physics”

John Baez: “Network Theory: Overview”

Functional Patterns in C++, 1. Functors

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 12 of 13

Lenses, Folds, and Traversals

Erlang Factory SF 2016 - Keynote - John Hughes - Why Functional Programming Matters

[Deleted video]

Philip Wadler and Erik Meijer: On Programming Language Theory and Practice

Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

C9 Lectures: Greg Meredith - Monadic Design Patterns for the Web - Introduction to Monads

MIT Godel Escher Bach Lecture 1

Adventure with Types in Haskell - Simon Peyton Jones (Lecture 1)

BayHac Free Monads Talk

Exact Real Arithmetic in Haskell - Mitchell Riley - BFPG 2015-05

“Strange Loops: Capturing Knots With Powerful Notations” by Katherine Ye

“Propositions as Types” by Philip Wadler

EmberConf 2016: How to Build a Compiler by James Kyle

SLAM A 00

HAR 2009 - l Design and Build a 2 MeV Cyclotron

Quantum Cooling to (Near) Absolute Zero

Introduction to Scott Miller and Dragon Innovation - DragonInnovation.com

László Miklós Bíró - Tempest, the hidden source of data leakage

Beaglebone: Introduction to GPIOs - Using Device Tree Overlays under Linux 3.8+

Transparent Microchip Experiments - Part 2 - MOSFETs

Parsing with Derivatives

DIY No Frills AD9850/Arduino Antenna Analyzer

Introduction to Phase Locked Loops

Category Theory by Tom LaGatta

Brian Beckman: Don’t fear the Monad

Netflix JavaScript Talks - Async JavaScript with Reactive Extensions

1. Course introduction

[Deleted video]

Tobias Jesso Jr. - How Could You Babe

PLD FPGA Design flow (Sec 4-1)

CYMATICS: Science Vs. Music - Nigel Stanford

Ady Stern (Weizmann Institute) Topological Quantum Computing III

#1 – Introduction to FPGA and Verilog

Correlated Electrons in Two Dimensions: The Fractional Quantum Hall Effect and More

Aharonov-Bohm Interferometry in Non-abelian Quantum Hall States

Experiments on Macroscopic Quantum Coherence (Lecture 1) - Anthony Leggett 2012

Prof. Nick Bonesteel, “Topological Quantum Computation”, Lecture 1 of 3

Burrello 1

Kevin Walker’s lectures on Topological Quantum Field Theory (part 1 of 8)

Niles Johnson: Visualizations of the Hopf fibration

Topological Quantum Field Theory and the Cobordism Hypothesis – Part 1

Quantum Techniques for Stochastic Mechanics - Part 1 of 4

Steve Simon - Topological Quantum Computing (Part 1) - CSSQI 2012

The Physics of Superconducting Devices - Anthony Leggett - Lecture #1 - 2014

Welcome Address

Ady Stern (Weizmann Institute) Topological Quantum Computing II

Quantum Computing & the Entanglement - John Preskill

John Preskill - Introduction to Quantum Information (Part 1) - CSSQI 2012

Quantum Information | John Preskill

Supersymmetry, Jim Gates | Lecture 1 of 3 (Muslim defending child rape in description/comments)

Richard Feynman Computer Science Lecture - Hardware, Software and Heuristics

Morse Theory: Lecture 1

Quantum Transport, Lecture 1: Introduction

Lighting a match with water

3. Integrator & Diffrentiator.mpg

Group Theory 15 , Generators of Cyclic Groups

Henriques: Extended Conformal Field Theories from Frobenius Algebras (Part 3)

Physics@FOM Veldhoven 2012, Charles Kane, Master class

D19ILL tutorialPart1 Broadband

[Deleted video]

Praise a Wicked Game - Fatboy Slim vs Chris Isaak

Mod-22 Lec-44 Boundary - Layer Theory (Contd. )

The Idea of a Riemann Surface

Lecture - 1 Representations of Dynamical Systems

Introduction

Mod-01 Lec-01 Fibers and Yarns : Terms Definitions and Relations

Mod-01 Lec-01 Introduction to Helicopter Aerodynamics and Dynamics

Mod-01 Lec-01 Importance of Thermal Radiation

Mod-01 Lec-01 Introduction to Plasmas

Mod-01 Lec-01 Introduction: Vertex cover and independent set

Differential Topology with Prof. John W. Milnor Lecture III

Lecture 2: Differential Geometry of Curves

Intro to differential forms (part 1)

Lecture 01 Introduction to Computer Vision

Functional Analysis - Lecture 3 - UCCS MathOnline

Mathematical Statistics I - Lecture 1 - UCCS MathOnline

Breakbot - Baby I’m Yours (feat. Irfane) [Official Video]

Math448Lecture01

Optimization Math442Lecture01pt1

[Private video]

[Private video]

[Private video]

[old series] Abstract Algebra Lecture 01 Part 1

AlgTop0: Introduction to Algebraic Topology

Real Analysis, Lecture 1: Constructing the Rational Numbers

Functional Analysis - Lecture 1 - UCCS MathOnline

Gohan Goes Mystic For First Time (HD) DBZ Dragon Ball Z

Deadlift 275 Nov 21 2012

Lecture 20 | Introduction to Linear Dynamical Systems

Lecture 16 | Introduction to Linear Dynamical Systems

Lecture 2 | Convex Optimization I (Stanford)

prog3.json

Multi-Party Computation: From Theory to Practice

Introduction to Grobner Bases - Prof. Bernd Sturmfels

Nonlinear algebra, Lecture 1: “Polynomials, Ideals, and Groebner Bases”, by Bernd Sturmfels

Marta Kwiatkowska, “Probabilistic model checking of labelled Markov processes”

Matrix-free Construction of HSS Representations Using Adaptive Randomized Sampling

Randomized Numerical Linear Algebra: Overview

Randomized Algorithms for Computing Full Matrix Factorizations

The Fast Multipole Method

ICFP 2018 Keynote Address: Gradual Typing

Relational Algebra by Way of Adjunctions

ICFP 2018 Keynote Address: The Role of Functional Programming and DSLs in Hardware

Fault Tolerant Functional Reactive Programming

Ready, Set, Verify! Applying hs-to-coq to Real-World Haskell Code

Teaching How to Program using Automated Assessment and Functional Glossy Games

Static Interpretation of Higher-Order Modules in Futhark - Functional GPU Programming in the Large

What’s the Difference? A Functional Pearl on Subtracting Bijections

ICFP 2018 Keynote Address: Conveying the Power of Abstraction

ELAGB - Brice Boyer: LinBox : 15 years

ELAGB - Martin Albrecht: The M4RI and M4RIE libraries

Factorizing Finite Automata: The Holonomy Decomposition

ETAPS 2016 - K: a semantic framework for programming languages and formal analysis tools - G. Rosu

SPIN 2016 - Model Checking: What Have We Learned, What Will Machines Learn? - Pierre Wolper

Integer Programming in Polynomial Time, Shmuel Onn, Osaka Japan

DAY3 2 15: Invited tutorial (Shmuel Onn)

Advances in Numerical Algebraic Geometry with Applications

Chordal Structure and Polynomial Systems

Recent Progress on Computing Groebner Bases

Numerical Algebraic Geometry

Introduction to Tropical Algebraic Geometry (1 of 5)

Maxim Kontsevich: What is tropical mathematics? [2013]

Bernd Sturmfels (University of California, Berkeley) / Lecture 1 : Elementary Introduction

Bernd Sturmfels (UC Berkeley) / Introduction to Non-Linear Algebra : Tropical Algebra I / 2014-06-05

Nonlinear algebra, Lecture 3: “Elimination and Implicitization”, by Bernd Sturmfels

Norbert Schuch: Matrix product states and tensor networks (I)

Tips and Tricks for Optimal Scheduling with End-to-End Analytics and Gurobi

Macaulay 2 Tutorial I

Nonlinear algebra, Lecture 6: “Tropical Algebra”, by Bernd Sturmfels

On Optimal Algorithms and Assumption Factories

Multiparty Computation Research

Nonlinear algebra, Lecture 7: “Toric Varieties”, by Mateusz Michalek

“Your Secrets are Safe with Julia: A Compiler for Secure Computation” by Jason Dagit

Great Ideas in Theoretical Computer Science: Epilogue: Why Max-Cut is My Favorite (Spring 2015)

Analysis of Boolean Functions at CMU - Lecture 1: The Fourier expansion and basic formulas

Spring 2015 Lecture 16 Godel’s Incompleteness Theorems default

Analysis of Boolean Functions. Part I | Ryan O’Donnell | Лекториум

“Hackett: a metaprogrammable Haskell” by Alexis King

ECE 804 - Fall 2011 - Lecture 001 with Dr. Seth Sullivant - Aug. 26, 2011

Prof. Dr. Eva Riccomagno - Algebraic Statistics I (SEAMS SCHOOL)

Bernd Sturmfels (Univ. of California at Berkeley) / An Invitation to Algebraic Statistics

Stanford Lecture: Donald Knuth - “Trees and chordal graphs” (2012)


programming.json

Introduction to Type Inference

Phil Freeman - Embedded DSLs in Haskell

Marta Kwiatkowska, “Probabilistic model checking of labelled Markov processes”

Rustan Leino, Microsoft Research - Program Verification: Yesterday, Today, Tomorrow

​Proof Theory of Homotopy Type Theories by Ulrik Buchholtz (Carnegie Mellon University, USA)

Lecture 1 | A survey of automated theorem proving | John Harrison | Лекториум

Olivia Caramello - 1/4 Introduction to categorical logic, classifying toposes…

Efficiently coding for modern CPUs by Edward Kmett

Functional Programmers Paris - Building a language, in Haskell, with an LLVM backend

Bartosz Milewski - Arrows are strong profunctors

John Leo: Dependent Types in GHC

Phil Freeman - PureScript’s Typesystem

Edward Kmett - Type Classes vs. the World

Backpack to Work: Towards Backpack in Practice

Gershom Bazerman on “Homological Computations for Term Rewriting Systems” [PWL NYC]

LambdaConf 2015 - The Art of Program Derivation and Parallel Computation Gershom Bazerman

Simon Peyton Jones on Getting from A to B fast route finding on slow computers [PWL London]

A Categorical View of Computational Effects

Lecture 1 — Distributed File Systems | Stanford University

Solving QBF by Counterexample-Guided Abstraction Refinement

ICAPS 2017: Tutorial : AI Planning for Robotics and Human-Robot Interaction

ICAPS 2017: Tutorial : Knowledge Engineering in Planning: Representation Matters

ICAPS 2014 Invited Talk: Peter Wurman

Revisiting Combinators by Edward Kmett

CVPR18: Tutorial: Part 1: Generative Adversarial Networks

ICAPS 2016: ROSPlan Tutorial

Functional DevOps in a Dysfunctional World

Code Generation with llvm-hs by Stephen Diehl

ZuriHac 2015 - Performance

CVPR18:Tutorial: Inverse Reinforcement Learning for Computer Vision

ICAPS 2014: Tutorial on Constraint-Based Temporal Reasoning (Part 1)

Alexey Kuleshevich: massiv - Haskell arrays that are easy and fast

Category Theory III 2.1: String Diagrams part 1

Category Theory III 2.2, String Diagrams part 2

Spatial: A Language and Compiler for Application Accelerators

JuMP-dev 2018 | Developing new optimization methods with JuliaSmoothOptimizers | Abel Siqueira

JuMP-dev 2018 | Systematically building MIP formulations using JuMP and Julia | Joey Huchette

RI Seminar: Michael Kaess : Robust and Efficient Real-time Mapping for Autonomous Robots

Category Theory III 3.1, Adjunctions and monads

Factor Graphs for Flexible Inference in Robotics and Vision | Frank Dellaert | Robotics@MIT

Keynote: Tricks and Tips in Numerical Computing | Nick Higham | JuliaCon 2018

Hierarchical Tensor Decompositions in Julia | Frank Otto | JuliaCon 2018

Solving Partial Differential Equations With Julia | Chris Rackauckas | JuliaCon 2018

A practical introduction to metaprogramming in Julia | Andy Ferris | JuliaCon 2018

JuliaRobotics: Making robots walk with Julia | Robin Deits

Numerical Analysis in Julia | Sheehan Olver | JuliaCon 2018

Natural Language Processing workshop using Julia | Avik Sengupta | JuliaCon 2018

An Introduction to High Performance Custom Arrays | Matt Bauman | JuliaCon 2018

Symbolic Mathematics in Julia | John Lapyre | JuliaCon 2018

Sum-of-squares optimization in Julia (Benoît Legat, Université Catholique de Louvain)

LP/SDP Hierarchies and Sum of Squares Proofs 1

Challenges in Adiabatic Optimization


prog9.json

George Wilson - An Intuition for Propagators - Compose Melbourne 2019

Logic, Co-induction and Infinite Computation

Brendan Zabarauskas - Lost in a Universe of Types - Compose Melbourne 2019

2019 ADSI Summer Workshop: Algorithmic Foundations of Learning and Control, Ben Recht

Phebe Vayanos, Robust Optimization & Sequential Decision-Making

MBSE Colloquium: Sasa Rakovic, “Robust Model Predictive Control”

Pragmatic Algorithmic Game Theory

On Algorithmic Game Theory I

LSE Events | Tim Roughgarden | Game Theory Through the Computational Lens

Approximation Algorithms for Optimization under Uncertainty

Michael Arntzenius - DB ⋈ FP = Datafun: a new functional query language

MPC and MHE implementation in Matlab using Casadi | Part 1

JuMP-dev 2019 | Marcelo Forets | Reachset Approximation with JuMP

David I. Spivak - A topos-theoretic approach to systems and behavior (joint work with P. Schultz)

Correctness proofs of distributed systems with Isabelle/HOL


prog7.json

Leslie Lamport, 2013 ACM Turing Award Recipient - Part 1

Niklaus Wirth, 1984 ACM Turing Award Recipient

Lamport TLA+ Course Lecture 6: Two-Phase Commit (HD)

Lamport TLA+ Course Lecture 7: Paxos Commit (HD)

Lamport TLA+ Course Lecture 5: Transaction Commit (HD)

Lattices: Algorithms, Complexity, and Cryptography

A Practical Construction for Decomposing Numerical Abstract Domains

Fast Polyhedra Abstract Domain

Jörgen Brandt - Beyond state machines: services as petri nets - Code BEAM STO

John Valois on Wait-Free Synchronization [PWL NYC]

“Datafun: a functional query language” by Michael Arntzenius

Papers We Love San Diego - An Axiomatic Basis for Computer Programming

“Papers I Have Loved” by Casey Muratori

Michael Bernstein on A Unified Theory of Garbage Collection

“A Rehabilitation of Message-passing Concurrency” by Frank Pfenning [PWLConf 2018]

Jean Yang on An Axiomatic Basis for Computer Programming

What type of thing is a type? by Ron Garcia

PWLTO#11 – Peter Sobot on An Industrial-Strength Audio Search Algorithm

Logical Analysis of Hybrid Systems

Feedback Control of Hybrid Dynamical Systems

Real-Time Decision Making in Hybrid Systems

Real-Time Convex Optimization

Core-sets for Real-Time Tracking using Caratheodory Theorem, with Applications to Drones

“Everything Old is New Again: Quoted Domain Specific Languages” by Philip Wadler

Máté Karácsony: Zeldspar - The Road to Epiphany

Tech Mesh 2012 - Making EDSLs fly - Lennart Augustsson

Stanford Seminar - Concatenative Programming: From Ivory to Metal

Vitaly Bragilevsky - Type Theory Behind Glasgow Haskell Compiler Internals (Part 1) - λC 2018

Timed transition systems

Lecture 20 | MIT 6.832 (Underactuated Robotics), Spring 2019

Lecture 22 | MIT 6.832 (Underactuated Robotics), Spring 2019

Lecture 23 | MIT 6.832 (Underactuated Robotics), Spring 2019


prog6.json

Xing Gao 9/11/15 Part 1

Quantum Approximate Optimization Algorithms (Peter Shor, ISCA 2018)

Daniel Lidar - “Adventures in Quantum Optimization” (UMBC Colloquium 2018)

Language, Compiler, and Optimization Issues in Quantum Computing - Margaret Martonosi - June 10 2015

Game Semantics [1/4] - Dan R. Ghica - OPLSS 2018

Nonlinear algebra, Lecture 11: “Semidefinite Programming”, by Bernd Sturmfels

Nonlinear algebra, Lecture 12: “Primary Decomposition “, by Mateusz Michalek and Bernd Sturmfels

Nonlinear algebra, Lecture 13: “Polytopes and Matroids “, by Mateusz Michalek

Hyperbolic Optimization, Part I - A

Practical Boogie (on the example of VCC)

ACT@UCR Seminar: Systems as Wiring Diagram Algebras - Christina Vasilakopoulou

Statistical Inference and Privacy, Part I

Jules Hedges: Compositional Game Theory

Daniel Spielman “Miracles of Algebraic Graph Theory”

Jesús A. De Loera, “Algebraic, Geometric, and Topological Methods in Optimization”

Benedict Gross “Complex Multiplication: Past, Present, Future” Lecture 1

Bryna Kra “Dynamics of Systems with Low Complexity”

Peter Ozsvath “From Knots to Symplectic Geometry and Algebra”

Graph Sparsification I: Sparsification via Effective Resistances

Spectral Graph Theory I: Introduction to Spectral Graph Theory

The Unreasonable Effectiveness of Spectral Graph Theory: A Confluence of Algorithms, Geometry & …

High Performance Haskell by Harendra Kumar at #FnConf18

The Mathematics of Networks

ACT2018: Dan Ghica — Diagrammatic semantics for digital circuits

ORC IAP Seminar 2019 - Bartolomeo Stellato

The Geometry of Matroids

Constraints Liberate, Liberties Constrain — Runar Bjarnason

MuniHac 2018: Keynote: Beautiful Template Haskell

Rayon: Data Parallelism for Fun and Profit — Nicholas Matsakis

LambdaConf 2015 - Finally Tagless DSLs and MTL Joseph Abrahamson

Phil Freeman - Embedded DSLs in Haskell

Bryan O’Sullivan/ Facebook- Fast Code Nation: The Bright Side of High Level Languages

MuniHac 2018: Keynote: A low-latency garbage collector for GHC

MuniHac 2018: Keynote: The Curious Case of Pattern-Match Coverage Checking

Haskell Live-Coding, Session 8, Succinct Data Structures and Dynamization

Rohit Grover - Prototype Driven Development using Haskell - Compose Melbourne 2018

Tim McGilchrist - Dependently Typed State Machines - Compose Melbourne 2018

HaskellerZ - May 2018 - Andreas Herrmann - GHC Hacking Newcomer Guide

HaskellerZ - January 2019 - Michal Terepeta - Implementing Immutable Vectors in Haskell

TUTORIAL: In-memory Representations of Databases via Succinct Data Structures

Konstantin Ignatov - Succinct data structures for python

Haskell 2014: Reflection without Remorse: Revealing a hidden sequence to speed up monadic reflection

2018 09 27 - Simon Meier - Test-Driven Development of a Unification Algorithm

David Spivak: Categorical Databases

Gurobi Webinar: The Grain Drain: Large-Scale Grain Port Terminal Optimization with Biarri

Rust Async Programming in 2018 • Katharina Fey • GOTO 2018

Niko Matsakis - Rust: Putting Ownership to Use

Rust Cologne: The Cost of Zero Cost

A Modular Integration of SAT/SMT Solvers to Coq through Proof Witnesses

Network Analysis. Lecture 1. Introduction to Network Science

Network Analysis. Lecture 9. Graph partitioning algorithms

High-performance Tree Wrangling, the APL Way // Aaron Hsu // Dyalog ‘18

Patterns and Anti-patterns in APL // Aaron Hsu // Dyalog ‘17

6.875 (Cryptography) L12: Zero Knowledge I

Implementing In-memory Caches in Haskell

Array-oriented Functional Programming by Aaron W Hsu, Dhaval Dalal and Morten Kromberg at #FnConf18

Geometric deep learning

Mathieu Tanneau @ JuMP-dev 2019

Michael Garstka @ JuMP-dev 2019

Many-body Physics and Complexity I

Random Matrices: Theory and Practice - Lecture 1

“A (Not So Gentle) Introduction To Systems Programming In ATS” by Aditya Siram

Intro to ATS #1 – good programmers and best programmers

CppCon 2018: Bjarne Stroustrup “Concepts: The Future of Generic Programming (the future is here)”

Cedille Cast #1: Deriving Induction (Pt. 1)

Haskell Live-Coding, Session 25, Guanxi Review

“Type-Driven Program Synthesis” by Nadia Polikarpova

Constraint Solvers for the Working PL Researcher

Program Synthesis meets Machine Learning

The Four Big Bets (Illustrated via a Journey in Program Synthesis)

Program Synthesis for the Masses

Type-Driven Program Synthesis

Abstractions for Expressive, Efficient Parallel and Distributed Computing

Jane and the Compiler

JuMP-dev 2019 | Benoit Legat | Set Programming with JuMP

JuMP-dev 2019 | David Sanders | Rigorous global optimization in pure Julia

JuMP-dev 2019 | Marcelo Forets | Reachset Approximation with JuMP

JuMP-dev 2019 | Tillmann Weisser | JuliaMoments

How the chalk-engine crate works

CMU Advanced Database Systems - 22 Query Optimizer Implementation (Part I) (Spring 2019)

2019 EuroLLVM Developers’ Meeting: I. Wolff “The Helium Haskell compiler and its new LLVM backend”

CMU Advanced Database Systems - 23 Query Optimizer Implementation (Part 2) (Spring 2019)

CMU Advanced Database Systems - 17 Parallel Hash Join Algorithms (Spring 2019)

BOB 2019 - Joachim Breitner, Inspection Testing

BOB 2019 - Tikhon Jelvis, Analyzing Programs with SMT Solvers

Lamport TLA+ Course Lecture 5: Transaction Commit (HD)

Lamport TLA+ Course Lecture 6: Two-Phase Commit (HD)


feed.json

“An Introduction to Combinator Compilers and Graph Reduction Machines” by David Graunke

Relational Programming in miniKanren by William Byrd, Part 2/2

Charlie Kaufman | BAFTA Screenwriters’ Lecture Series

Monoidal Parsing - Boston Haskell Meetup

Majorana ‘Particle’ in Condensed Matter Systems by Sankar Das Sarma

The simple essence of automatic differentiation

Why GHC Core and Linear Logic Should be Best Friends

“Controlling Time and Space: understanding the many formulations of FRP” by Evan Czaplicki

Chap 2: Hadamard & Picard Conditions, Singular Value Expansion, Naive Reconstruction - 1

The Convex Geometry of Inverse Problems

Techniques for combinatorial optimization: Spectral Graph Theory and Semidefinite Programming

Lecture 9 | MIT 6.832 (Underactuated Robotics), Spring 2018

#2 Cyclone 5 and memory mapping

Lambda Days 2018 - Paweł Szulc - Understanding Distributed Calculi in Haskell

Embedded Linux with FPGA Device Drivers Basic #03

#4 Verilog, Linux, Qsys

Physics for Game Programmers: Understanding Constraints

Intro to Game Physics

CppCon 2015: Fedor Pikus “C++ Metaprogramming: Journey from simple to insanity and back”

Lec 1 | MIT 6.450 Principles of Digital Communications I, Fall 2006

Introduction to computer graphics, lecture 1: Introduction

The Physics of Superconducting Devices - Anthony Leggett - Lecture #1 - 2014

Topological Superconductivity in Quantum Materials and Devices

Machine Learning Quantum Phases of Matter - Simon Trebst - May 31, 2017

Topological States of Quantum Condensed Matter: Duncan Haldane

1. Resonance I

Lasers & Optoelectronics Lecture 1: Laser Basics (Cornell ECE4300 Fall 2016)

Lec 1 | MIT 2.71 Optics, Spring 2009

Introducing MRI: The Basics (1 of 56)

Lecture 12 | MIT 6.832 (Underactuated Robotics), Spring 2018

Lecture 11 | MIT 6.832 (Underactuated Robotics), Spring 2018

Real-time optimization algorithms for dynamic walking, running, and manipulating robots

2. Resonance II

Lec 2 | MIT 6.450 Principles of Digital Communications I, Fall 2006

VIVADO HLS Training - Introduction #01

Anthony Cowley - Framing the Discussion with EDSLs

Lecture 13 | MIT 6.832 (Underactuated Robotics), Spring 2018

The Physics of Superconducting Devices - Anthony Leggett - Lecture #6 - 2014

Lecture 2: Modular Arithmetic and Historical Ciphers by Christof Paar

Lecture 3: Stream Ciphers, Random Numbers and the One Time Pad by Christof Paar

Modern Cryptography with Haskell by Stephen Diehl

Efficiently coding for modern CPUs by Edward Kmett

Lecture 16 | MIT 6.832 (Underactuated Robotics), Spring 2018

Lecture 18 | MIT 6.832 (Underactuated Robotics), Spring 2018

Lecture 19 | MIT 6.832 (Underactuated Robotics), Spring 2018

Lecture 4: Stream Ciphers and Linear Feedback Shift Registers by Christof Paar

Haskell Live-Coding, Session 2.1, Q&A

Lecture 20 | MIT 6.832 (Underactuated Robotics), Spring 2018

Lecture 21 | MIT 6.832 (Underactuated Robotics), Spring 2018

ICSP 2016: Introduction to Stochastic Programming (Part I)

Stochastic Optimization Models on Power Systems | Camila Metello and Joaquim Garcia | JuliaCon 2017

The State of the Type System | Jeff Bezanson | JuliaCon 2017

Solving QBF by Counterexample-Guided Abstraction Refinement

CPP-06 Modern C++: Static, Numbers, Arrays, Non-owning pointers, Classes (2018, Igor)

06 - Miguel A. Morales - Wavefunction Optimization

J Bollinger Trapped ion Quantum Simulation, Computing and Sensing I July 2


prog10.json

Greybeard Qualification (Linux Internals) part 1: Process Structure and IPC

“Simple Code” Follow-up Part 1: A (Very) Simplified CPU Diagram

Lecture 1: MIT 6.800/6.843 Robotic Manipulation (Fall 2021) | “Anatomy of a manipulation system”

Algebraic geometry 1 Introduction

Rebuilding Operating Systems with Functional Principles | Dr Anil Madhavapeddy (Lecture 1)


prog8.json

Lecture 20 | MIT 6.832 (Underactuated Robotics), Spring 2019

Feedback Control of Hybrid Dynamical Systems

Real-Time Decision Making in Hybrid Systems

Validation, Synthesis and Optimization for Cyber-Physical Systems

Gurobi Optimization Application Demos

TSS_20170717 02 - Parametric Optimisation, Introduction to PLC

Backpack to Work: Towards Backpack in Practice

Grothendieck’s 1973 topos lectures - C. McLarty

David Spivak: Monadic Decision Processes for Hierarchical Planning

Funnel Libraries for Real-Time Robust Feedback Motion Planning (Anirudha Majumdar)

Neutron Stars and Black Holes (Lecture - 01: Diffuse Stars) by G Srinivasan

ICAPS 2018: David Speck on “Symbolic Planning with Edge-Valued Multi-Valued Decision Diagrams”

The design of functional numerical software - Dr Richard Mortier, University of Cambridge

HELIX: A Case Study of a Formal Verification of High Performance Program Generation

Preventing Data Races with Refinement Types

TSS_20170719 02 - Arduino, Part II

Meta-F*: Proof Automation with SMT, Tactics, and Metaprograms - Nikhil Swamy

Cody Roux - SMT for DSLs: a Tutorial

Interactive Theorem Proving with Lean

[LLVM Social] The Lean Theorem Prover

Towards Lean 4: An Optimized Object Model for an Interactive Theorem Prover

Isabelle meets Compilers - 13.09.2018

Procedural Macros in Rust (part 1)

FA’18 01: Overview - Logical Foundations of Cyber-Physical Systems

VeriPhy: Verified Controller Executables from Verified Cyber-Physical System Models

Rust at speed — building a fast concurrent database

Russ Tedrake (MIT): “Learning manipulation — and why I (still) like F=ma”

Automated Economic Reasoning with Quantifier Elimination

ICML 2019 A Tutorial on Attention in Deep Learning

ICAPS 2018: Richard E. Korf on “What is the Right Search Algorithm for My Problem?”

ICAPS 2018: Hannah Bast on “Route Planning in Large Transportation Networks: Surprisingly Hard …”

ICAPS 2018: Chiara Piacentini on “Compiling Optimal Numeric Planning to Mixed Integer Linear …”

Program Synthesis using Conflict-Driven Learning

ICML 2019 Tutorial: Meta-Learning: from Few-Shot Learning to Rapid Reinforcement Learning (Part 1)

Formally Verified Cryptographic Web Applications in WebAssembly

Applied Mixed Integer Programming: Beyond ‘The Optimum’

Parallelism in Linear and Mixed Integer Programming

Stanford Seminar - A Superscalar Out-of-Order x86 Soft Processor for FPGA

Introduction to Formal Verification with Symbiotic EDA Open Source Tools

Taking Resources to the Type Level – Vilem-Benjamin Liepelt

Lambda World 2018 - MirageOS, towards a smaller and safer OS - Romain Calascibetta

Functors of the World, Unite!

Making Algorithmic Music

Stuck macros: deterministically interleaving macro-expansion and typechecking

Yes, IHaskell Can Do That!

Type Driven Secure Enclave Development using Idris

A Tase Of ATS

The Best Refactoring You’ve Never Heard Of

Bidirectional Type Checking

Bowl Full of Lentils

Metamaterials and Topological Mechanics (Lecture - 01) by Tom Lubensky

Xavier Caruso: Ore polynomials and application to coding theory

Edward Kmett - Logic Programming in Haskell 3/4

Edward Kmett - Logic Programming in Haskell 4/4

SAS2018 - Deductive Verification in Decidable Fragments with Ivy (by K. McMillan and O. Padon)

Verification beyond programs - Rustan Leino

What’s Algebraic About Algebraic Effects and Handlers? [1/2] - Andrej Bauer - OPLSS 2018

Static Program Analysis (part 1/2) - Anders Møller - PLISS 2019

Heat Methods in Geometry Processing

seL4 Is Free – What Does This Mean For You?

Discretization of Elliptic Differential Equations Using Sparse Grids… (Cristoph Pflaum)

6.858 Fall 2014 Lecture 10: Symbolic execution

DEF CON 23 - Shoshitaishvili and Wang - Angry Hacking: The next gen of binary analysis

DEF CON 25 - Yan Shoshitaishvili - 25 Years of Program Analysis

Angr - a powerful binary analysis platform for CTFs. The Cyber Grand Challenge

Demystifying Binary Reverse Engineering

Introduction to Automated Binary Analysis (GPN17)

SoK: (State of) The Art of War: Offensive Techniques in Binary Analysis

Using Static Binary Analysis To Find Vulnerabilities And Backdoors In Firmware

Toward Efficient Gradual Typing for Structural Types by Deyaaeldeen Almahallawi

Galois Inc. Tech Talk: Formal Hardware Verification: Asynchronous, Analog, Mixed-Signal, and Mixed-T

Warsaw Quantum Computing Group, Ep III, “Introduction to programming quantum computers using pyQuil”

Simon Peyton Jones how GHC type inference engine actually works

Data-Centric Abstractions and Operator Formulation of Algorithms - Keshav Pingali - OPLSS 2018

Brendan Fong: A categorical introduction to profunctor optics, Part 1.

Introduction to Incr_dom: Writing Dynamic Web Apps in OCaml

OCaml All The Way Down

BOB Summer 2019 - Henning Thielemann, Expressive Linear Algebra in Haskell

NAMPI v2 - Armando Solar-Lezama - Program synthesis and ML join forces

Ashley Montanaro: Applying quantum algorithms to constraint satisfaction problems

“Easy Abstract Interpretation with SPARTA” by Arnaud Venet and Jez Ng

“Performance Matters” by Emery Berger

RustBelt: Logical Foundations for the Future of Safe Systems Programming

Writing Verified Software for Production - Rustan Leino - OPLSS 2019

Analysis and Synthesis of Floating-Point Routines - Zvonimir Rakamaric

Unboxed Types for OCaml

[PyEMMA 2018] Introduction to Markov state models

Benjamin Recht: Optimization Perspectives on Learning to Control (ICML 2018 tutorial)

2019 ADSI Summer Workshop: Algorithmic Foundations of Learning and Control, Ben Recht

A gentle introduction to network science: Dr Renaud Lambiotte, University of Oxford

Deep learning for technical computations and equation solving

Topological quantum phases - Alexei Kitaev


prog4.json

Chordal Graphs and Sparse Semidefinite Optimization

Circle Packing and Its Applications

Matroids as a Theory of Independence by Federico Ardila

Bernd Sturmfels(Univ. of California, Berkeley) / Lecture 5 : Matroids and Linear Spaces

Federico Ardila: “Algebraic Structures on Polytopes”

Avi Wigderson: “Proving Algebraic Identities”

Tamara G. Kolda: “Tensor Decomposition”

William Cook: “Information, Computation, Optimization…”

Factorization-based Sparse Solvers and Preconditions Lecture 2

Factorization-based Sparse Solvers and Preconditions, Lecture 3

Tutorial: Gait and Trajectory Optimization for Legged Robots

Introduction to Optimization and Optimal Control using the software packages CasADi and ACADO

“Stable Fluids” by Dan Piponi [PWLConf 2018]

AI for Imperfect-Information Games: Beating Top Humans in No-Limit Poker

Ankur Moitra : Tensor Decompositions and their Applications

The moment-SOS hierarchy – Jean Lasserre – ICM2018

New Frontiers in Imitation Learning

Submodular Optimization and Machine Learning - Part 1

Totally Unimodular Matrices in Linear Programming - Nate Veldt

Matrix Representation of FMM - Difeng Cai

HSS Solvers - Jimmy Vogel

Lecture 2 . Matroids (Federico Ardila)

SOS Seminar Lecture 9 - SOS and the Unique Games conjecture—a love hate relationship

SOS Seminar lecture 4 - Sparsest cut problem and ARV algorithm (updated)

Robert Sapolsky: The Biology of Humans at Our Best and Worst

Stanford’s Robert Sapolsky On Depression

Tensor Decompositions for Learning Hidden Variable Models

Princeton Day of Optimization 2018: Taking Control by Convex Optimization by Elad Hazan

Princeton Day of Optimization 2018: Graph Structure in Polynomial Systems Chordal … by Pablo Parrilo

Using Computational Group Theory

Lambda World 2018 - Opening Keynote by Edward Kmett

Lecture 4 . Hopf Algebras and Combinatorics (Federico Ardila)

Avi Wigderson: “Alternate Minimization and Scaling Algorithms”

Robert Bryant: “The Concept of Holonomy”

László Babai: “Groups, Graphs and Algorithms”

Solving optimization problems containing piecewise linear functions (Joey Huchette, MIT)

Discrete Optimization, Shmuel Onn, MSRI Berkeley, Lecture 1 of 7

Algebraic number theory and rings I | Math History | NJ Wildberger

Peter Zoller: Introduction to quantum optics - Lecture 1

RI Seminar: Oliver Kroemer : Learning Robot Manipulation Skills…

Lecture 1 . Polytopes (Federico Ardila)

Lecture 5 . Hopf Algebras and Combinatorics (Federico Ardila)

Jesus De Loera “One hundred years of Helly’s Theorem”

Jesús de Loera: “Variations of Carathéodory theorem for Integer Optimization”

ICML 2017 Tutorial: Recent Advances in Stochastic Convex and Non-Convex Optimization (audio fixed)

Algebraic number theory and rings II | Math History | NJ Wildberger

02. Algebraic geometry - Sheaves and morphisms (Diana Carolina Castañeda)

Manifolds as Haskell types

Daisy - A framework for sound accuracy analysis and optimization of numerical programs

On the Calculation of Functions in the Algebra of Physical Space

Exact Real Arithmetic for Geometry


prog2.json

LP/SDP Hierarchies and Sum of Squares Proofs 3

JuMP-dev 2018 | EMP.jl, a package for modelling Extended Mathematical Programming | Olivier Huber

JuMP-dev 2018 | Topology Optimization and JuMP | Mohamed Tarek

NeuroSAT: Learning a SAT Solver from Single-Bit Supervision

Solving Max-SAT by Decoupling Optimization and Satisfaction

Donald Knuth: “The Art of Computer Programming: Satisfiability and Combinatorics”

Category Theory III 4.2, Monad algebras part 3

Bedrock: A Software Development Ecosystem Inside a Proof Assistant

Day 1 Part 1: Introductory Intel x86: Architecture, Assembly, Applications

Day 1 Part 1: Intro to Software RE (Reverse Engineering)

Category Theory III 5.1, Eilenberg Moore and Lawvere

Category Theory III 5.2, Lawvere Theories

The Tensor Algebra Compiler

Introduction to LLVM Building simple program analysis tools and instrumentation

Understanding Compiler Optimization - Chandler Carruth - Opening Keynote Meeting C++ 2015

Semidefinite Programming Hierarchies I: Convex Relaxations for Hard Optimization Problems

CS410 2017 Lecture 6 (A Comedy of (entirely non-deliberate) Errors)

Galois, Inc. Tech Talk: Vellvm - Verifying the LLVM (Steve Zdancewic)

Richard Eisenberg on Dependent Types

Distributed Optimization via Alternating Direction Method of Multipliers

Type Theory Study Group, Special Topics on ABTs, Implementation and Theory with Jon Sterling

SMT Solving in Haskell - Matt Peddie

Unification

[In English] Functional Thursday #Special - Having an Effect by Oleg Kiselyov

Multiple Concepts of Equality in the New Foundations of Mathematics by Vladimir Voevodsky

Naïve Type Theory by Thorsten Altenkirch (University of Nottingham, UK)

“Elements of Mathematics” in the Digital Age by Marc Bezem (Universitetet i Bergen, Norway)

On Proofs of Equality as Paths by Andrew Pitts (University of Cambridge, UK)

Thomas Ball - Advances in Automated Theorem Proving

12 An Agda formalization of the transitive closure of block matrices

ICFP 2012. Lee Pike: Experience Report - a Do-It-Yourself High-Assurance Compiler.

How Helpful is Network Coding?

Networking coding - Muriel Medart, MIT

Fundamentals of Distributed Algorithms - Part 1

Fundamentals of Distributed Algorithms - Part 2

ITA 2010 - Multisource Network Coding, Raymond W. Yeung

A Little Taste of Dependent Types (David Thrane Christiansen)

Univalence from a computer science point-of-view - Dan Licata

CSE574-16-11: Wireless Protocols for IoT Part II: IEEE 802.15.4 Wireless Personal Area Networks

Computational Type Theory [1/5] - Robert Harper - OPLSS 2018

Purely Functional Array Programming [1/3] - Gabrielle Keller - OPLSS 2018

Barak A. Pearlmutter – Automatic Differentiation: History and Headroom

Automatic differentiation and machine learning

DeepSpec Summer School, Coq Intensive, Part 9 (July 15, 2017)

Parallel Algorithms [1/5] - Umut Acar - OPLSS 2018

Extending F* in F*: Proof automation and Metaprogramming for Typeclasses

Formal Verification of Verilog HDL with Yosys-SMTBMC (33c3)

Multi-Party Computation: From Theory to Practice

Introduction to Grobner Bases - Prof. Bernd Sturmfels

Nonlinear algebra, Lecture 1: “Polynomials, Ideals, and Groebner Bases”, by Bernd Sturmfels

Marta Kwiatkowska, “Probabilistic model checking of labelled Markov processes”


prog5.json

A Haskell Interface to SUNDIALS via inline-c

David Spivak - Category Theory - Part 1 of 6 - λC 2017

Lambda World 2018 - Introduction to the Unison programming language - Rúnar Bjarnason

The Limits of Proof

Silvio Micali: Proofs, Knowledge, and Computation

Shafi Goldwasser: From Basic Idea to Impact: the story of modern cryptography

IFL 2012. Fritz Henglein: Generic sorting and partitioning in linear time and fully abstractly

Haskell Live-Coding, Session 15, Back from ICFP

Sergey Bravyi: Improved classical simulation of quantum circuits dominated by Clifford gates

Introduction to Information Theory - Edward Witten

Propositional Proof Complexity: Fifteen (or so) Years After - Alexander Razborov

Proof complexity - an introduction - Avi Wigderson

Optimization in dynamical systems - Amir Ali Ahmadi

Robust sensitivity - Shachar Lovett

Outlier-Robust Estimation via Sum-of-Squares - Pravesh Kothari

Algebraic combinatorics: applications to statistical mechanics and complexity theory - Greta Panova

Noncommutative probability for computer scientists - Adam Marcus

Rigorous RG: a provably efficient and possibly practical algorithm for… - Umesh Vazirani

An update on SymbiFlow - a multiplatform FPGA project - Tim Ansell - ORConf 2018

Nonlinear algebra, Lecture 8: “Tensors”, by Bernd Sturmfels and Mateusz Michalek

Invariant Theory for Computer Scientists

An introduction to Invariant Theory - Harm Derksen

Tutorial 2: Algorithmic Invariant Theory

Tutorial 3: Geometric Invariant Theory

Semidefinite Hierarchies in Quantum Information

Stanford Seminar: Beyond Floating Point: Next Generation Computer Arithmetic

Alberto Bemporad | Embedded Model Predictive Control

Cassette: Dynamic, Context-Specific Compiler Pass Injection for Julia | J Revels | JuliaCon 2018

Flux: The Elegant Machine Learning Library | Mike Innes | JuliaCon 2018

Ju Gonçalves - Abstract nonsense | Code Mesh LDN 18

Hillel Wayne - Everything about distributed systems is terrible | Code Mesh LDN 18

Advanced Machine Learning Day 3: Neural Program Synthesis

Lesson 1: Deep Learning 2018

Exact Real Arithmetic for Geometry

Solving Simple Stochastic Optimization Problems with Gurobi

CTNT 2018 - “Computational Number Theory” (Lecture 1) by Harris Daniels

Fabian Immler : Verified numerics for ODEs in Isabelle/HOL

Laurent Théry : Proof and computation in Coq

Norbert Müller : Wrapping in exact real arithmetic

Eva Darulova : Programming with numerical uncertainties

Sylvie Boldo : Formal verification of numerical analysis programs

Fiat Cryptography: Automatic Correct-by-Construction Generation of Low-Level Cryptographic Code

Negative Dependence, Stable Polynomials, and All That

HELIX: A Case Study of a Formal Verification of High Performance Program Generation

Ramsey Theory 1: A Motivating Example

Morse Theory: Lecture 1

Polya explains the problem solving technique

Xing Gao 9/11/15 Part 1

GSS Spring 2016 - Clive Newstead: Species, Structures and Stuff

Alexey Radul - Probabilistic Programming Live-code