[{"content":"Hi, I\u0026rsquo;m Josh #I\u0026rsquo;m a Computer Science master\u0026rsquo;s student at ETH Zürich, majoring in Secure and Reliable Systems with a minor in Systems Software.\nI like working close to the metal. Most of what I\u0026rsquo;ve built lives somewhere between an operating system and a compiler — a capability-based microkernel, a reliable transport protocol over UDP, a simplex solver on a GPU, a fuzzer for SQLite — and when I step away from that it\u0026rsquo;s usually to point machine learning at something physical, like finding mining sites in satellite imagery.\nAlongside my studies I\u0026rsquo;ve spent three semesters as a teaching assistant on ETH\u0026rsquo;s continuing-education programme in data and machine learning, and a summer as a research assistant at EAWAG.\nHave a look at my projects, my experience, or what I\u0026rsquo;ve been reading. The quickest way to reach me is email, and most of my code is on GitHub.\n","date":null,"permalink":"https://josh.anderegg.xyz/","section":"","summary":"","title":""},{"content":"Where I\u0026rsquo;ve studied and worked.\n","date":null,"permalink":"https://josh.anderegg.xyz/experience/","section":"Experience","summary":"","title":"Experience"},{"content":"Coursework spanned hardware optimization, security and operating systems, with several courses involving hands-on projects.\nSelected projects # Automated Software Testing: In a group of 2 we designed tooling to automatically test SQLite and minimise the bug-triggering queries it found. Design of Parallel and High Performance Computing: In a group of 5 we implemented and analysed multiple variants of the revised simplex algorithm on an NVIDIA GPU in C++. Advanced Operating Systems: In a group of 5 we designed and implemented a capability-based microkernel operating system from (more or less) scratch for a multi-core microcontroller. Advanced Systems Lab: In a group of 4 we implemented multiple versions of the social force modelling algorithm dedicated to optimizing for code vectorization, cache locality and overall performance. Practical Work: I implemented and evaluated memory partitioning schemes in the LLVM-based Dynamatic high-level synthesis compiler. Master\u0026rsquo;s Thesis: Dynamatic + XLS: Integrating Dynamic and Static HLS — integrating Google\u0026rsquo;s XLS into the Dynamatic HLS compiler so that dynamically scheduled circuits can contain statically scheduled islands. Other coursework #Network Analysis, Network Security, Green Computing, Applied Cryptography, Automated Software Testing, System Security, Concepts of Object Oriented Programming, Information Security Lab, Governing the Energy Transition, Synthesis of Digital Circuits\n","date":"May 2027","permalink":"https://josh.anderegg.xyz/experience/master/","section":"Experience","summary":"With a Major in \u003cem\u003eSecure and Reliable Systems\u003c/em\u003e and a Minor in \u003cem\u003eSystems Software\u003c/em\u003e.","title":"Master of Science in Computer Science"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/c++/","section":"Tags","summary":"","title":"C++"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/compilers/","section":"Tags","summary":"","title":"Compilers"},{"content":"Description #My master\u0026rsquo;s thesis, currently in progress at ETH Zürich with the Digital Systems and Design Automation group.\nDynamatic compiles software-like descriptions into dynamically scheduled circuits: dataflow units wired together over handshake interfaces that decide when to fire at runtime. That lets a circuit exploit parallelism a static schedule has to give up on, because classical HLS has to budget for the longest possible execution path up front.\nDynamism isn\u0026rsquo;t free everywhere, though. A loop with a mostly linear body and no inter-loop dependencies can be scheduled statically at an initiation interval of 1 — wrapping it in ready-valid handshaking buys nothing and costs timing and area. Hybrid circuits, with statically scheduled islands embedded in a dynamic one, are known to open up new Pareto frontiers, but the prior work largely leans on closed-source commercial HLS, which makes a genuinely end-to-end hybrid flow hard to build.\nGoogle\u0026rsquo;s XLS is the piece that makes this tractable: it\u0026rsquo;s open source, it generates the kind of statically scheduled dataflow units Dynamatic needs, and it exposes an MLIR interface. The thesis builds the integration:\nA static region in the IR — a new MLIR operation in Dynamatic holding a nested region that describes a statically scheduled unit, with XLS synthesising that region down to RTL. Making the dynamic circuit aware of it — exposing the timing characteristics of XLS-generated units (latency, initiation interval, and above all the combinational delays at their interfaces) to Dynamatic\u0026rsquo;s buffer placement, so the surrounding dynamic circuit is buffered correctly. Memory accesses inside static regions, which the handshake-based memory interfaces don\u0026rsquo;t accommodate for free. Evaluation against purely dynamic Dynamatic output, against a commercial static HLS flow, and against the improvements reported in the literature. If time allows, two extensions: automatically identifying which regions benefit from static scheduling, and supporting more complex static regions, such as internal loops built on XLS\u0026rsquo;s state-feedback mechanism.\nThe work is being upstreamed into Dynamatic as a series of pull requests.\nDynamatic · XLS\n","date":"October 2026","permalink":"https://josh.anderegg.xyz/projects/dynamatic-xls/","section":"Projects","summary":"My master\u0026rsquo;s thesis: integrating Google\u0026rsquo;s XLS into the Dynamatic high-level synthesis compiler, so a dynamically scheduled circuit can contain statically scheduled islands.","title":"Dynamatic + XLS: integrating dynamic and static HLS"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/hardware/","section":"Tags","summary":"","title":"Hardware"},{"content":"A selection of the projects I\u0026rsquo;ve enjoyed working on most, from university coursework and research to things built for their own sake. Filter by the tags below.\n","date":null,"permalink":"https://josh.anderegg.xyz/projects/","section":"Projects","summary":"","title":"Projects"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/","section":"Tags","summary":"","title":"Tags"},{"content":"Description #Practical work on Dynamatic, an open-source high-level synthesis compiler that turns C into dynamically scheduled hardware circuits — unlike classical HLS, the schedule is decided at runtime by handshaking between components, so the circuit can exploit parallelism that a static schedule has to give up on.\nThat advantage disappears at the memory interface. Every access funnelled through a single memory port serialises, and the dataflow circuit stalls waiting on it. The work was to implement memory partitioning in the compiler: analysing array access patterns in the LLVM/MLIR representation, splitting arrays across multiple banks so independent accesses can proceed in parallel, and generating the corresponding memory interfaces in the emitted circuit.\nEvaluation ran the partitioned and unpartitioned versions of standard HLS benchmark kernels through the toolchain, comparing cycle counts against the resource cost of the extra banks and arbitration logic.\nLink to GitHub Repository\n","date":"July 2026","permalink":"https://josh.anderegg.xyz/projects/memory-partitioning-dynamatic/","section":"Projects","summary":"Implementing and evaluating memory partitioning schemes in the LLVM-based Dynamatic high-level synthesis compiler.","title":"Memory partitioning for Dynamatic"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/c/","section":"Tags","summary":"","title":"C"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/hpc/","section":"Tags","summary":"","title":"HPC"},{"content":"Description #Project for Advanced Systems Lab, where the entire grade rests on how fast you can make one numerical kernel run on a single core. Ours was the social force model, which simulates pedestrian crowds by treating each person as a particle driven by attractive and repulsive \u0026ldquo;social\u0026rdquo; forces from their destination, from other pedestrians and from obstacles.\nIn a team of four we started from a straightforward baseline implementation and worked through successive optimisation rounds:\nCost analysis — counting flops and establishing a roofline to know what the achievable ceiling actually was. Scalar optimisation — strength reduction on the force kernels, hoisting and precomputing invariants, replacing transcendental calls with cheaper approximations. Memory layout — moving from array-of-structs to struct-of-arrays and blocking the interaction loop so the working set stays in cache. Vectorisation — hand-written AVX intrinsics for the inner loops, with the data layout reshaped so loads stay aligned and contiguous. Each version was benchmarked against the baseline across a range of crowd sizes, which is where most of the interesting results came from — the fastest variant depends on whether the working set still fits in L2.\n(Source code not provided due to university policy)\n","date":"June 2026","permalink":"https://josh.anderegg.xyz/projects/social-force-modelling/","section":"Projects","summary":"In a group of 4 we wrote and progressively optimised a social force crowd simulation in C, tuning it for vectorisation, cache locality and raw throughput.","title":"Social Force Modelling"},{"content":"Description #Semester-long project for Advanced Operating Systems: a team of five building a capability-based microkernel for a multi-core ARM board, starting from a minimal bootstrap and adding one subsystem at a time.\nEverything above the kernel is a user-space process talking over message passing, so each milestone meant designing the protocol as much as the implementation:\nMemory management — a capability system for physical memory, with retyping and revocation, and a virtual memory manager built on top of it. Processes and dispatch — spawning, scheduling and inter-process communication, then bringing up the remaining cores and making IPC work across them. Services — a name server, a shell and the drivers behind it, with filesystem and network support layered on as ordinary user-space servers. Built and tested in a Docker image so the whole team compiled against an identical toolchain rather than five slightly different local setups.\n(Source code not provided due to university policy)\n","date":"May 2026","permalink":"https://josh.anderegg.xyz/projects/barrelquiche/","section":"Projects","summary":"In a group of 5 we designed and implemented a capability-based microkernel operating system from (more or less) scratch for a multi-core microcontroller.","title":"Barrelquiche"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/systems/","section":"Tags","summary":"","title":"Systems"},{"content":"Overview #Supported three courses within ETH\u0026rsquo;s CAS in Data and Machine Learning program over three semesters, working directly with professionals returning to study machine learning and computer science, from business-oriented discussions of AI and IT, through a theoretical grounding in computer science, to hands-on applied ML tooling.\nKey contributions # Designed lecture materials and paper exercises for the course AI and IT in Industry, and conducted oral assessments for 25 participants. Designed and implemented a pipeline to automate the generation and evaluation of exercises for the course Information Data and Computers. See more project details here. Created a larger ML project for the course Building AI/ML Applications using a RAG system built on publicly accessible Swiss law and case documents. See more project details here. Provided general support and assistance to help participants deepen their understanding of the lecture material and computer science more broadly. ","date":"January 2026","permalink":"https://josh.anderegg.xyz/experience/ta/","section":"Experience","summary":"In the context of the \u003ca href=\"https://inf.ethz.ch/continuing-education/cas-datamachinelearning.html\" target=\"_blank\" rel=\"noreferrer\"\u003eCAS in Data and Machine Learning\u003c/a\u003e I helped organise multiple courses, such as \u003cem\u003eAI and IT in Industry\u003c/em\u003e, \u003cem\u003eInformation Data and Computers\u003c/em\u003e and \u003cem\u003eBuilding AI/ML Applications\u003c/em\u003e. Activities included creating lecture materials, organizing exercises, conducting oral exams and in session support for participants.","title":"Teaching Assistant for CAS in Data and Machine Learning"},{"content":"Description #Project for Design of Parallel and High Performance Computing. In a team of five we implemented multiple variants of the revised simplex method on an NVIDIA GPU and compared them against established LP solvers.\nSimplex is an awkward fit for a GPU: it is inherently sequential at the level of pivots, and each iteration\u0026rsquo;s work depends on the one before. The parallelism has to come from inside an iteration — the pricing step that picks the entering variable, the ratio test, and the dense linear algebra on the basis — which is what the different variants trade off against each other.\nImplementation used a mix of cuBLAS/cuSPARSE routines and our own CUDA kernels where the library primitives did not fit the access pattern. Final benchmarks ran on a shared local machine, with each configuration in its own Docker container so runs stayed isolated and reproducible across the team.\nAs the final paper was part of the performance assessment of the course, a copy can be provided on request.\nLink to GitHub Repository\n","date":"December 2025","permalink":"https://josh.anderegg.xyz/projects/gpu-simplex-solver/","section":"Projects","summary":"In a group of 5 we implemented and analysed multiple variants of the revised simplex algorithm on an NVIDIA GPU in C++.","title":"GPU Revised Simplex Solver"},{"content":"Overview #Worked with two research group leaders on a shared project concerned with monitoring mining activities around the world using satellite imagery.\nKey contributions # Built a data pipeline for satellite imagery, Downloading terabytes of raw imagery, cleaning and stitching tiles and preparing it for model training. Trained and evaluated models using various algorithms and techniques. Documented and presented findings to the research group. Applied a computer science background to support other projects within the department. ","date":"September 2025","permalink":"https://josh.anderegg.xyz/experience/eawag/","section":"Experience","summary":"In the context of my civil service I worked as a research assistant in the department of \u003ca href=\"https://www.eawag.ch/en/department/siam/main-focus/\" target=\"_blank\" rel=\"noreferrer\"\u003eSystems Analysis, Integrated Assessment and Modelling\u003c/a\u003e at the Swiss Federal Institute of Aquatic Science and Technology. I worked on a project that used \n      \n    \u003ca href=\"https://josh.anderegg.xyz/projects/mad/\"\u003esatellite imagery to detect mining activities\u003c/a\u003e.","title":"Civil Service as a research assistant"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/machine-learning/","section":"Tags","summary":"","title":"Machine Learning"},{"content":"Description #Built during my civil service at EAWAG, MAD uses the YOLO object-detection model to locate mining activity around the globe from Sentinel-2 satellite imagery.\nMining sites are mapped inconsistently and often not at all, which makes it hard to study their environmental footprint at scale. Sentinel-2 covers the entire land surface every few days and is free, so the question was whether a detector could find the sites directly in the imagery.\nData pipeline. The bulk of the work was getting from raw satellite archives to something trainable: downloading terabytes of Sentinel-2 granules, filtering by cloud cover, selecting and normalising the relevant spectral bands, stitching and re-tiling scenes into fixed-size chips, and aligning them with georeferenced labels of known mining sites.\nModelling. Trained and evaluated YOLO variants on the resulting dataset, comparing band combinations and tiling strategies, and running inference over large unlabelled regions to surface candidate sites.\nLink to GitHub Repository\n","date":"June 2025","permalink":"https://josh.anderegg.xyz/projects/mad/","section":"Projects","summary":"Using the YOLO object-detection model to locate global mining activity from Sentinel-2 satellite imagery.","title":"Mining asset detection (MAD)"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/python/","section":"Tags","summary":"","title":"Python"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/rust/","section":"Tags","summary":"","title":"Rust"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/security/","section":"Tags","summary":"","title":"Security"},{"content":"Description #Project for Automated Software Testing, in a team of two.\nTruffuzz generates SQL and feeds it to SQLite hunting for crashes and wrong results. Purely random SQL is almost all syntactically invalid and gets rejected before it reaches anything interesting, so the generator is grammar-aware: it builds statements that type- check against the schema it just created, which gets the input past the parser and into the query planner where the interesting bugs live. Logic bugs — where SQLite returns the wrong rows rather than crashing — are caught by differential testing, running semantically equivalent query formulations against each other and flagging any disagreement.\nDisqillery handles the other half of the problem. A crashing input straight out of a fuzzer is typically hundreds of statements long and tells you nothing about the cause, so Disqillery repeatedly deletes statements, clauses and sub-expressions, keeping each reduction only if the bug still reproduces, until it reaches a minimal query that still triggers it.\nThe whole pipeline runs in Docker so campaigns are reproducible and a reported bug can be replayed exactly.\n(Source code not provided due to university policy)\n","date":"June 2025","permalink":"https://josh.anderegg.xyz/projects/truffuz/","section":"Projects","summary":"A fuzzer for SQLite built in a team of two in Rust, paired with a query minimiser that reduces every crashing input to a readable test case.","title":"Truffuzz / Disqillery"},{"content":"Description #The capstone project I designed for Building AI/ML Applications, part of ETH\u0026rsquo;s CAS in Data and Machine Learning.\nParticipants build a retrieval-augmented generation system over publicly accessible Swiss legislation and court decisions: ingesting and chunking the corpus, embedding it into a vector store, retrieving relevant passages for a natural-language question, and grounding an LLM\u0026rsquo;s answer in those passages with citations back to the source documents.\nThe brief was chosen because the domain punishes hallucination — a legal answer without a correct citation is worse than no answer — which makes retrieval quality, not prompt wording, the thing participants have to reason about.\n(Source code not provided due to university policy)\n","date":"May 2025","permalink":"https://josh.anderegg.xyz/projects/rag-system/","section":"Projects","summary":"A retrieval-augmented generation system over publicly available Swiss legislation and case law, built as the capstone project for an applied ML course.","title":"RAG system over Swiss law"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/teaching/","section":"Tags","summary":"","title":"Teaching"},{"content":"Description #Built while teaching assistant for Information, Data and Computers, part of ETH\u0026rsquo;s CAS in Data and Machine Learning.\nWriting and marking exercises by hand for every cohort did not scale, so I built a pipeline that generates randomised problem instances from templates, computes the reference solution for each instance, and emits them in a format Moodle can import and grade automatically. Each participant gets a different instance of the same problem, and grading is immediate.\n(Source code not provided due to university policy)\n","date":"November 2024","permalink":"https://josh.anderegg.xyz/projects/moodle-exercises/","section":"Projects","summary":"A pipeline that generates and auto-grades randomised exercises for an ETH continuing-education course, delivered straight into Moodle.","title":"Automated Moodle exercise generation"},{"content":"Description #My bachelor\u0026rsquo;s thesis, written with the ABZ group at ETH Zürich.\nWebTigerPython is a browser-based Python environment used in Swiss schools: no install, no toolchain, just a tab. The Oxocard is a small microcontroller with a display and sensors, designed for teaching. Bringing the two together means a student can write Python in the browser and watch it run on hardware in front of them — which is a different kind of lesson from printing to a console.\nThe hard part is that a browser tab cannot talk to a USB device the way a desktop IDE does. The integration routes code and results over MQTT instead: the platform publishes the program to the device, the device executes it and publishes sensor readings and output back, so the browser stays a thin client and no local installation is required. The front-end work — editor integration, device pairing, live output — was built in Vue.js and TypeScript alongside the existing platform.\nSince it is aimed at classrooms, a good deal of the thesis went on the failure modes: what happens when a device drops off mid-program, how errors on the hardware surface back in the editor, and keeping the whole thing usable without a teacher having to debug the network.\nLink to GitHub Repository\n","date":"September 2024","permalink":"https://josh.anderegg.xyz/projects/oxocard-for-webtp/","section":"Projects","summary":"My bachelor thesis: integrating a microcontroller with a browser-based Python learning platform, so students can program real hardware from a browser tab.","title":"Implementing the Oxocard for WebTigerPython"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/typescript/","section":"Tags","summary":"","title":"TypeScript"},{"content":"Coursework spanned theoretical foundations, systems and applied projects across networks, compilers and app design.\nSelected projects # Computer Networks: Implemented a QUIC-like transport protocol on top of UDP, including custom congestion control and connection handling. Compiler Design: Built a compiler for a C-like language end-to-end, from lexer and parser through to x86 assembly generation. Human Computer Interaction: Designed and built a flat management application, focusing on usability and interactive design. Optimization Methods for Engineers: Implemented and benchmarked a parallel particle swarm optimizer in Rust, a population-based metaheuristic for continuous optimisation. Bachelor Thesis: Implementing the Oxocard for WebTigerPython. As my bachelor thesis I integrated a microcontroller with a browser-based Python learning platform developed by the ABZ group at ETH. Other coursework #Algorithms and Datastructures, Discrete Mathematics, Introduction to Programming, Linear Algebra, Analysis I, Analysis II, Algorithms and Probability, Probability and Statistics, Digital Design and Computer Architecture, Systems Programming and Computer Architecture, Parallel Programming, Numerical Methods for Computer Science, Theoretical Computer Science, Data Modelling and Databases, Formal Methods and Functional Programming, Computer Systems, Computing Platforms, Visual Computing, Information Security, Introduction to Machine Learning, Contemporary European Politics\n","date":"September 2024","permalink":"https://josh.anderegg.xyz/experience/bachelor/","section":"Experience","summary":"With a focus on \u003cem\u003eSystems\u003c/em\u003e, \u003cem\u003eSecurity\u003c/em\u003e and \u003cem\u003eMachine Learning\u003c/em\u003e.","title":"Bachelor of Science in Computer Science"},{"content":"Description #A parallel particle swarm optimizer for finding minima of continuous functions, implemented and analysed in a team of two in Rust with a focus on parallel performance.\nPSO is a population metaheuristic: a swarm of candidate solutions moves through the search space, each particle pulled towards both its own best-known position and the swarm\u0026rsquo;s. It parallelises well in principle, since particle updates are independent within an iteration — the interesting part is the synchronisation around the shared global best, which is exactly where the speedup goes to die if you are careless about it.\nWe implemented several parallelisation strategies and benchmarked them against standard optimisation test functions, measuring both wall-clock speedup and solution quality — a faster variant that converges to a worse minimum is not actually a win. Rust\u0026rsquo;s ownership model made the shared-state variants considerably less nerve-racking to write than the equivalent C would have been.\nLink to GitHub Repository\n","date":"July 2024","permalink":"https://josh.anderegg.xyz/projects/mutant-ants/","section":"Projects","summary":"In a team of two we implemented and analysed a parallel particle swarm optimizer for finding minima of continuous functions in Rust.","title":"Parallel particle swarm optimizer"},{"content":"Description #Coursework for Compiler Design, built up over a semester into a complete compiler for Oat, a small C-like language with structs, arrays, function pointers and subtyping.\nThe front end lexes and parses source into an AST and type-checks it; the middle end lowers that AST to an LLVM-style SSA intermediate representation; the back end performs register allocation and emits x86-64 assembly that links and runs against a small C runtime. Written in OCaml, with the type system doing a lot of the heavy lifting on the IR transformations.\n(Source code not provided due to university policy)\n","date":"August 2023","permalink":"https://josh.anderegg.xyz/projects/oat/","section":"Projects","summary":"Implementing a compiler for a C-like language from lexer to final assembly using OCaml.","title":"Oat — a compiler for a C-like language"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/ocaml/","section":"Tags","summary":"","title":"OCaml"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/dart/","section":"Tags","summary":"","title":"Dart"},{"content":"Description #Course project for Human Computer Interaction during my bachelor\u0026rsquo;s. In a team of five we designed, implemented and user-tested an app for managing a shared flat — splitting expenses, tracking chores and coordinating the household.\nThe emphasis of the course was the process rather than the code: we went from paper prototypes and low-fidelity mockups through to a working application, running usability tests at each stage and folding the findings back into the design. Built in Flutter and Dart so a single codebase targeted both iOS and Android.\n(Source code not provided due to university policy)\n","date":"June 2023","permalink":"https://josh.anderegg.xyz/projects/hci/","section":"Projects","summary":"A cross-platform flat-management app designed, built and user-tested by a team of five for the Human Computer Interaction course.","title":"Flatmate Management App"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/ui/ux/","section":"Tags","summary":"","title":"UI/UX"},{"content":"","date":null,"permalink":"https://josh.anderegg.xyz/tags/networking/","section":"Tags","summary":"","title":"Networking"},{"content":"Description #Course project for Computer Networks: build a reliable, ordered byte stream on top of UDP — that is, re-derive the parts of TCP that UDP deliberately leaves out.\nThe implementation covers the connection handshake and teardown, sequence numbers and cumulative acknowledgements, retransmission driven by adaptive timeouts, a sliding window for flow control, and congestion control with slow start and congestion avoidance. Correctness was checked against a test harness that injects packet loss, reordering and duplication, so the protocol has to hold up on a deliberately hostile link.\n(Source code not provided due to university policy)\n","date":"July 2022","permalink":"https://josh.anderegg.xyz/projects/quic/","section":"Projects","summary":"A QUIC/TCP-style reliable transport protocol implemented from scratch over UDP in C, with its own connection handling and congestion control.","title":"Reliable transport protocol on top of UDP"},{"content":"What I\u0026rsquo;m reading, and what stuck with me — kept here in public mostly to force me to stay consistent about the habit.\n","date":null,"permalink":"https://josh.anderegg.xyz/blog/","section":"Reading list","summary":"","title":"Reading list"}]