# Programming, Math, Science

This is a list of links to different freely available learning resources about computer programming, math, and science.

## Table of contents

* [AI](#ai)
  * [Machine Learning](#machine-learning)
  * [Computer Games AI](#computer-games-ai)
* [Algorithms](#algorithms)
* [Command Line and Tools](#command-line-and-tools)
* [Compilers and Interpreters](#compilers-and-interpreters)
* [Computer Graphics](#computer-graphics)
  * [Ray Tracing](#ray-tracing)
* [Computer Networks and Network Programming](#computer-networks-and-network-programming)
* [Cryptography](#cryptography)
* [Databases](#databases)
* [Design Patterns](#design-patterns)
* [Distributed Systems](#distributed-systems)
* [Game Programming](#game-programming)
* [GUI Programming](#gui-programming)
* [Hardware](#hardware)
* [Logical Games](#logical-games)
* [Math](#math)
  * [Algebra](#algebra)
  * [Category Theory](#category-theory)
  * [Probability and Statistics](#probability-and-statistics)
  * [Theoretical Computer Science](#theoretical-computer-science)
* [Multithreading and Concurrency](#multithreading-and-concurrency)
* [Operating Systems](#operating-systems)
* [Physics](#physics)
* [Programming Languages](#programming-languages)
  * [Assembly](#assembly)
  * [Basic](#basic)
  * [C](#c)
  * [C++](#cpp)
  * [Clojure](#clojure)
  * [Common Lisp](#common-lisp)
  * [D](#d)
  * [Erlang](#erlang)
  * [Go](#go)
  * [Haskell](#haskell)
  * [JavaScript](#javascript)
  * [Nim](#nim)
  * [OCaml](#ocaml)
  * [Pascal](#pascal)
  * [Prolog](#prolog)
  * [Pyret](#pyret)
  * [Python](#python)
  * [Racket](#racket)
  * [Regular expressions](#regular-expressions)
  * [Rust](#rust)
  * [Scheme](#scheme)
* [Retrocomputing](#retrocomputing)
* [Reverse engineering](#reverse-engineering)
* [Robotics](#robotics)
* [Text editors](#text-editors)
* [Version control tools](#version-control-tools)
* [Emulators and Virtual Machines](#emulators-and-virtual-machines)
* [Web programming](#web-programming)
* [Other](#other)
* [Other lists](#other-lists)

## AI

* [Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp](https://github.com/norvig/paip-lisp) by *Peter Norvig*

### Machine Learning

* [A Course in Machine Learning](http://ciml.info) by *Hal Daumé III*

* [Algorithms for Decision Making](https://algorithmsbook.com) by *Mykel J. Kochenderfer*, *Tim A. Wheeler*, and *Kyle H. Wray*

* [Deep Learning](https://www.deeplearningbook.org/) by *Ian Goodfellow, Yoshua Bengio and Aaron Courville*

* [Deep Learning Interviews](https://github.com/BoltzmannEntropy/interviews.ai) *Second Edition* by *Shlomo Kashani*

* [Dive into Deep Learning Compiler](https://tvm.d2l.ai/)

* [Machine Learning Engineering Book](http://www.mlebook.com/wiki) by *Andriy Burkov*

* [Mathematics for Machine Learning](https://mml-book.github.io/) by *Marc Peter Deisenroth, A. Aldo Faisal, and Cheng Soon Ong*

* [Physics-based Deep Learning](https://physicsbaseddeeplearning.org/intro.html) by *N. Thuerey, P. Holl, M. Mueller, P. Schnell, F. Trost, K. Um*

* [The Hundred Page Machine Learning Book](http://themlbook.com/wiki) by *Andriy Burkov*

### Computer Games AI

* [Game AI Pro](http://www.gameaipro.com) by *Steve Rabin*

* [Programming Starcraft AI](https://makingcomputerdothings.com/an-index-for-the-starcraft-ai-posts) by *Peter Kis*

## Algorithms

* [Algorithms](http://jeffe.cs.illinois.edu/teaching/algorithms/) by *Jeff Erickson*

* [Algorithms for Optimization](https://algorithmsbook.com/optimization) by *Mykel J. Kochenderfer* and *Tim A. Wheeler*

* [Algorithms for Modern Hardware](https://en.algorithmica.org/hpc) by *Sergey Slotin*

* [The Arcane Algorithm Archive](https://www.algorithm-archive.org/)

* [Competitive Programming Algorithms](https://cp-algorithms.com/)

* [Competitive Programmer's Handbook](https://cses.fi/book/index.php) by *Antti Laaksonen*

* [Exact String Matching Algorithms](http://www-igm.univ-mlv.fr/~lecroq/string) by *Christian Charras and Thierry Lecroq*

* [Introduction to High Performance Scientific Computing](https://web.corral.tacc.utexas.edu/CompEdu/pdf/stc/EijkhoutIntroToHPC.pdf) by *Victor Eijkhout* with *Edmond Chow* and *Robert van de Geijn*

* [Principles of Algorithmic Problem Solving](https://www.csc.kth.se/~jsannemo/slask/main.pdf) by *Johan Sannemo*

* [Problem Solving with Algorithms and Data Structures using Python](https://runestone.academy/runestone/books/published/pythonds/index.html) by *Brad Miller and David Ranum*

## Command line and tools

* [Curl Cookbook](https://catonmat.net/cookbooks/curl)

* [Curl Exercises](https://jvns.ca/blog/2019/08/27/curl-exercises) by *Julia Evans*

* [Effective Shell](https://effective-shell.com/) by *Dave Kerr*

* [How I'm still not using GUIs: A guide to the terminal](https://lucasfcosta.com/2019/02/10/terminal-guide-2019.html) by *Lucas Fernandes da Costa*

* [The Linux Command Handbook](https://www.freecodecamp.org/news/the-linux-commands-handbook) by *Flavio Copes*

## Compilers and Interpreters

* [Build Your Own Lisp](https://buildyourownlisp.com) by *Daniel Holden*

* [Crafting Interpreters](http://craftinginterpreters.com) by *Robert Nystrom*

* [Creating the Bolt Compiler](https://mukulrathi.co.uk/create-your-own-programming-language/intro-to-compiler) by *Mukul Rathi*

* [How Clang Compiles a Function](https://blog.regehr.org/archives/1605) by *John Regehr*

* [How LLVM Optimizes a Function](https://blog.regehr.org/archives/1603) by *John Regehr*

* [Let's Build a Compiler](https://xmonader.github.io/letsbuildacompiler-pretty) by *Jack Crenshaw*

* **Let's Write a Compiler** by *Brian Robert Callahan*
  * [Part 1: Introduction, selecting a language, and doing some planning](https://briancallahan.net/blog/20210814.html)
  * [Part 2: A lexer](https://briancallahan.net/blog/20210815.html)
  * [Part 3: A parser](https://briancallahan.net/blog/20210816.html)
  * [Part 4: Testing](https://briancallahan.net/blog/20210817.html)
  * [Part 5: A code generator](https://briancallahan.net/blog/20210818.html)
  * [Part 6: Input and output](https://briancallahan.net/blog/20210819.html)
  * [Part 7: Arrays](https://briancallahan.net/blog/20210822.html)
  * [Part 8: Strings, forward references, and conclusion](https://briancallahan.net/blog/20210826.html)

* [Make A Language](https://arzg.github.io/lang) - A series about making a programming language called *Eldiro* using the *Rust* programming language.

## Computer Graphics

* [3D Game Shaders For Beginners](https://github.com/lettier/3d-game-shaders-for-beginners)

* [3D Math Primer for Graphics and Game Development](https://gamemath.com/book/intro.html) by *Fletcher Dunn* and *Ian Parberry*

* **A Beginner's Guide to Coding Graphics Shaders** by *Omar Shehata*
  * [Part 1](https://gamedevelopment.tutsplus.com/tutorials/a-beginners-guide-to-coding-graphics-shaders--cms-23313)
  * [Part 2](https://gamedevelopment.tutsplus.com/tutorials/a-beginners-guide-to-coding-graphics-shaders-part-2--cms-24111)
  * [Part 3](https://gamedevelopment.tutsplus.com/tutorials/a-beginners-guide-to-coding-graphics-shaders-part-3--cms-24351)

* [A Gentle Introduction to D3D12](https://alextardif.com/DX12Tutorial.html) by *Alex Tardif*

* [A Primer on Bézier Curves](https://pomax.github.io/bezierinfo)

* [Collection of AMD Research Publications](https://gpuopen.com/learn/publications)

* [Computer Graphics from Scratch](https://gabrielgambetta.com/computer-graphics-from-scratch) by *Gabriel Gambetta*

* [Curves and Surfaces](https://ciechanow.ski/curves-and-surfaces) by *Bartosz Ciechanowski*

* **GPU Gems Books Series**
  * [GPU Gems](https://developer.nvidia.com/gpugems/gpugems/contributors)
  * [GPU Gems 2](https://developer.nvidia.com/gpugems/gpugems2/copyright)
  * [GPU Gems 3](https://developer.nvidia.com/gpugems/gpugems3/contributors)

* [GPU Performance for Game Artists](http://fragmentbuffer.com/gpu-performance-for-game-artists) by *Keith O’Conor*

* [I Am Graphics And So Can You](https://www.fasterthan.life/blog) - a series of blog posts about implementing a Vulkan renderer for Doom 3 by *Dustin H. Land*

* [Learn Computer Graphics From Scratch](https://www.scratchapixel.com)

* [Learn OpenGL](https://learnopengl.com) by *Joey de Vries*

* **Order Independent Transparency** by *Kostas Anagnostou*
  * [Part 1](https://interplayoflight.wordpress.com/2022/06/25/order-independent-transparency-part-1)
  * [Part 2](https://interplayoflight.wordpress.com/2022/07/02/order-independent-transparency-part-2)
  * [Part 3](https://interplayoflight.wordpress.com/2022/07/10/order-independent-transparency-endgame)

* **Probability Theory for Physically Based Rendering** by *Jacco Bikker*
  * [Part 1](https://jacco.ompf2.com/2019/12/11/probability-theory-for-physically-based-rendering)
  * [Part 2](https://jacco.ompf2.com/2019/12/13/probability-theory-for-physically-based-rendering-part-2)

* [The Book of Shaders](https://thebookofshaders.com/) by *Patricio Gonzalez Vivo and Jen Lowe*

* [Vulkan Guide](https://vkguide.dev)

* [Vulkan Tutorial](https://vulkan-tutorial.com) by *Alexander Overvoorde*

* [WebGL2 Fundamentals](https://webgl2fundamentals.org/)

### Ray Tracing

* [Getting Started With DirectX Raytracing](https://renderingpixels.com/2022/07/getting-started-with-directx-raytracing) by *Seppe Dekeyser*

* [How to build a BVH](https://jacco.ompf2.com/2022/04/13/how-to-build-a-bvh-part-1-basics) by *Jacco Bikker*

* [NVIDIA Vulkan Ray Tracing Tutorials](https://github.com/nvpro-samples/vk_raytracing_tutorial_KHR)

* [Physically Based Rendering: From Theory To Implementation](https://www.pbr-book.org/) by *Matt Pharr*, *Wenzel Jakob*, and *Greg Humphreys*

* [Ray Tracing Gems](https://link.springer.com/book/10.1007/978-1-4842-4427-2) by *Eric Haines and Tomas Akenine-Möller*

* [Ray Tracing Gems II](https://link.springer.com/book/10.1007/978-1-4842-7185-8) by *Adam Marrs, Peter Shirley, and Ingo Wald*

* [Ray Tracing in One Weekend: The Book Series](https://raytracing.github.io) by *Peter Shirley*

* [Vulkan Raytracing Tutorials](https://iorange.github.io)

## Computer Networks and Network Programming

* [An Introduction to Computer Networks](http://intronetworks.cs.luc.edu/current2/html) by *Peter L. Dordal*

* [Computer Networks: A Systems Approach](https://book.systemsapproach.org) by *Larry Peterson and Bruce Davie*

* [Computer Network Tutorials](https://www.geeksforgeeks.org/computer-network-tutorials)

* [HTTP2 Explained](https://daniel.haxx.se/http2) by *Daniel Stenberg*

* [HTTP/3 explained](https://http3-explained.haxx.se) by *Daniel Stenberg*

* [Networking 101](https://internalpointers.com/post-group/networking-101) by *Internal Pointers*

* [REST Servers in Go](https://eli.thegreenplace.net/2021/rest-servers-in-go-part-1-standard-library) by *Ely Bendersky*

## Cryptography

* [A Graduate Course in Applied Cryptography](https://toc.cryptobook.us) by *Dan Boneh* and *Victor Shoup*

* [Practical Cryptography for Developers](https://cryptobook.nakov.com) by *Svetlin Nakov*

## Databases

* [The Theory of Relational Databases](http://web.cecs.pdx.edu/~maier/TheoryBook/TRD.html) by *David Maier*

## Design Patterns

* [Data-Oriented Design](https://www.dataorienteddesign.com/dodbook) by *Richard Fabian*

* [Design Patterns & Refactoring](https://sourcemaking.com) *SourceMaking*

* [From design patterns to category theory](https://blog.ploeh.dk/2017/10/04/from-design-patterns-to-category-theory) by *Mark Seemann*

* [Game Programming Patterns](http://www.gameprogrammingpatterns.com) by *Robert Nystrom*

* [The Architecture of Open Source Applications](http://aosabook.org/en/index.html)

## Distributed systems

* [Testing Distributed Systems](https://asatarin.github.io/testing-distributed-systems) - Curated list of resources on testing distributed systems by *Andrey Satarin*.

## Game Programming

* [2D Game Development: From Zero To Hero](https://therealpenaz91.itch.io/2dgd-f0th) by *Daniele Penazzo*

* [Gentle Introduction to Realtime Fluid Simulation for Programmers and Technical Artists](https://shahriyarshahrabi.medium.com/gentle-introduction-to-fluid-simulation-for-programmers-and-technical-artists-7c0045c40bac) by *Shahriar Shahrabi*

* [Retro Rampage](https://github.com/nicklockwood/RetroRampage) a tutorial series in which you will learn how to build a Wolfenstein-like game from scratch, in Swift by *Nick Lockwood*

* [Roguelike Tutorial - In Rust](https://bfnightly.bracketproductions.com) by *Herbert Wolverson*

* [Reverse engineering the rendering of The Witcher 3](https://astralcode.blogspot.com/2018/11/reverse-engineering-rendering-of.html)

* [Scroll Back: The Theory and Practice of Cameras in Side-Scrollers](https://docs.google.com/document/d/1iNSQIyNpVGHeak6isbP6AHdHD50gs8MNXF1GCf08efg/pub) by *Itay Keren*

## GUI Programming

* [A Book about Qt5](https://qmlbook.github.io)

* [Sol on Immediate Mode GUIs](http://sol.gfxile.net/imgui)

## Hardware

* [Architecture of Consoles](https://www.copetti.org/writings/consoles) by *Rodrigo Copetti*

* [Modern Microprocessors: A 90-Minute Guide!](http://www.lighterra.com/papers/modernmicroprocessors) by *Jason Robert Carey Patterson*

* [Processor Design: An Introduction](http://www.gamezero.com/team-0/articles/math_magic/micro)

## Logical Games

* [Hex: A Strategy Guide](http://www.mseymour.ca/hex_book) by *Matthew Seymour*

## Math

* [A Gentle Introduction to Tensors](https://www.ese.wustl.edu/~nehorai/Porat_A_Gentle_Introduction_to_Tensors_2014.pdf) by *Boaz Porat*

* [A Programmer's Introduction to Mathematics](https://pimbook.org/) by *Jeremy Kun*

* [An Infinitely Large Napkin](https://venhance.github.io/napkin/Napkin.pdf) by *Evan Chen*

* [Approved Textbooks](https://aimath.org/textbooks/approved-textbooks) of the [*American Institute of Mathematics*](https://aimath.org/)

* [Book of Proof](https://www.people.vcu.edu/~rhammack/BookOfProof), Third Edition by *Richard Hammack*

* [Books by *Dr. Kenneth Kuttler*](https://klkuttler.com/)

* [Calculus Made Easy](http://calculusmadeeasy.org/) by [*Silvanus P. Thompson*](https://en.wikipedia.org/wiki/Silvanus_P._Thompson)

* [Euclid's Elements](https://mathcs.clarku.edu/~djoyce/java/elements/toc.html)

* [Paul's Online Math Notes](https://tutorial.math.lamar.edu/) by *Paul Dawkins*

### Algebra

* [Algebra: An Elementary Text-Book](http://onlinebooks.library.upenn.edu/webbin/book/lookupid?key=olbp36404) by [*George Chrystal*](https://en.wikipedia.org/wiki/George_Chrystal)

* [Immersive Linear Algebra](http://immersivemath.com/ila/index.html) by *J. Ström, K. Åström, and T. Akenine-Möller*

* [Interactive Linear Algebra](http://textbooks.math.gatech.edu/ila) by *Dan Margalit and Joseph Rabinoff*

* [Intermediate Algebra](https://saylordotorg.github.io/text_intermediate-algebra/index.html) by *Saylor Academy*

### Category Theory

* [Category Theory for Programmers](https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface) by *Bartosz Milewski*

* [Category Theory Illustrated](https://boris-marinov.github.io/category-theory-illustrated) by *Boris Marinov*

* [Category Theory: Lecture Notes and Online Books](https://www.logicmatters.net/categories/) - collection by *Peter Smith*

### Probability and Statistics

* [Bayes Rules! An Introduction to Applied Bayesian Modeling](https://www.bayesrulesbook.com/) by *Alicia A. Johnson, Miles Q. Ott, Mine Dogucu*

* [Digital textbook on probability and statistics](https://www.statlect.com) by *Marco Taboga*

* [Introduction to Probability for Data Science](https://probability4datascience.com/index.html) by *Stanley H. Chan*

* [Markov Chains for programmers](https://czekster.github.io/markov) by *Ricardo M. Czekster*

* [Probability and Statistics Cookbook](https://pages.cs.wisc.edu/~tdw/files/cookbook-en.pdf) by *Matthias Vallentin*

* [Seeing Theory](https://seeing-theory.brown.edu) - a book about statistics with interactive visualizations by *Daniel Kunin, Jingru Guo, Tyler Dae Devlin, and Daniel Xiang*

### Theoretical Computer Science

* [Foundations of Computer Science](http://infolab.stanford.edu/~ullman/focs.html) by *[Alfred V. Aho](https://en.wikipedia.org/wiki/Alfred_Aho)* and *[Jeffrey D. Ullman](https://en.wikipedia.org/wiki/Jeffrey_Ullman)*

* [Introduction to Theoretical Computer Science](https://introtcs.org) by [*Boaz Barak*](https://en.wikipedia.org/wiki/Boaz_Barak)

## Multithreading and Concurrency

* [A C++17 Thread Pool for High-Performance Scientific Computing](https://arxiv.org/abs/2105.00613) by *Barak Shoshany*

* [Is Parallel Programming Hard, And, If So, What Can You Do About It?](https://mirrors.edge.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html) by *Paul E. McKenney*

* [POSIX Threads Programming](https://hpc-tutorials.llnl.gov/posix) by *Blaise Barney*

* [The Little Book of Semaphores](https://greenteapress.com/wp/semaphores) by *Allen B. Downey*

## Operating Systems

* [Linux Insides](https://0xax.gitbooks.io/linux-insides/content/) by *0xAD*

* [Making our own executable packer](https://fasterthanli.me/series/making-our-own-executable-packer) by *Amos*

* [Operating Systems: Three Easy Pieces](https://pages.cs.wisc.edu/~remzi/OSTEP/) by *Remzi H Arpaci-Dusseau* and *Andrea C Arpaci-Dusseau*

* [Systems Programming: Lecture Notes](http://web.eecs.utk.edu/~huangj/cs360/lecture_notes.html) by *Jian Huang*

* [The Linux Documentation Project](https://tldp.org)

* [Writing a Simple Operating System — from Scratch](https://www.cs.bham.ac.uk/~exr/lectures/opsys/10_11/lectures/os-dev.pdf) by *Nick Blundell*

* [Writing an OS in Rust](https://os.phil-opp.com) by *Philipp Oppermann*

## Physics

* [A free introduction to quantum computing and quantum mechanics](https://quantum.country) by *Andy Matuschak and Michael Nielsen*

* [Motion Mountain](https://www.motionmountain.net) by *Christoph Schiller* - A free physics textbook
in 5 volumes.

* [Relativity: A Modern Primer](http://ramp-book.com) by *Kevin Han*

* [Structure and Interpretation of Classical Mechanics](https://mitpress.mit.edu/sites/default/files/titles/content/sicm_edition_2/book.html), Second Edition by *[Gerald Jay Sussman](https://en.wikipedia.org/wiki/Gerald_Jay_Sussman) and [Jack Wisdom](https://en.wikipedia.org/wiki/Jack_Wisdom)*

* [The Feynman Lectures on Physics](https://www.feynmanlectures.caltech.edu)

## Programming languages

### Assembly

* [A fundamental introduction to x86 assembly programming](https://www.nayuki.io/page/a-fundamental-introduction-to-x86-assembly-programming) by *Nayuki*

* [Learn Assembly Language](https://asmtutor.com) -  NASM x86 assembly language tutorial on Linux.

* **Let's Learn x86-64 Assembly!**
  * [Part 0 - Setup and First Steps](https://gpfault.net/posts/asm-tut-0.txt.html)
  * [Part 1 - Metaprogramming in Flat Assembler](https://gpfault.net/posts/asm-tut-1.txt.html)
  * [Part 2 - We're Writing a Virtual Machine](https://gpfault.net/posts/asm-tut-2.txt.html)
  * [Part 3 - Arithmetic and Logic](https://gpfault.net/posts/asm-tut-3.txt.html)

* [NASM Tutorial](https://cs.lmu.edu/~ray/notes/nasmtutorial)

* [Some Assembly Required: An approachable introduction to assembly](https://github.com/hackclub/some-assembly-required)

### Basic

* [BBC BASIC for SDL 2.0](https://www.bbcbasic.co.uk/bbcsdl/index.html)

### C

* [Coroutines in C](https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html) by *Simon Tatham*

* [How Does a C Debugger Work?](https://blog.0x972.info/?d=2014/11/13/10/40/50-how-does-a-debugger-work)

* [The Lost Art of Structure Packing](http://www.catb.org/esr/structure-packing) by *Eric S. Raymond*

* [Unicode programming, with examples](https://begriffs.com/posts/2019-05-23-unicode-icu.html) by *Joe Nelson*

### C++ <span id="cpp">

* [Awesome Modern C++](https://awesomecpp.com/)

* [Beginner's Guide to Linkers](https://www.lurklurk.org/linkers/linkers.html) by *David Drysdale*

* [Hacking C++](https://hackingcpp.com)

* [C++20 Coroutines: sketching a minimal async framework](https://www.jeremyong.com/cpp/2021/01/04/cpp20-coroutines-a-minimal-async-framework) by *Jeremy Ong*

* [C++20 Concepts: The Definitive Guide](https://thecodepad.com/cpp/c20-concepts-the-definitive-guide) by *Rajat Jain*

* [C++ exceptions under the hood](https://monkeywritescode.blogspot.com/p/c-exceptions-under-hood.html) by *Nicolás Brailovsky*

* [Microsoft C++ language documentation](https://docs.microsoft.com/en-us/cpp/cpp)

* [Performance Analysis and Tunning on Modern CPUs](https://book.easyperf.net/perf_book) by *Denis Bakhvalov*

### Clojure

* [Clojure Concurrency Tutorial](https://purelyfunctional.tv/guide/clojure-concurrency) by *Eric Normand*

* [Clojure for the Brave and True](https://www.braveclojure.com/) by *Daniel Higginbotham*

### Common Lisp

* [Practical Common Lisp](https://gigamonkeys.com/book) by *Peter Seibel*

* [The Common Lisp Cookbook](https://lispcookbook.github.io/cl-cookbook)

### D

* [Programming in D](http://ddili.org/ders/d.en/index.html) by *Ali Çehreli*

### Erlang

* [Learn You Some Erlang for great good!](https://learnyousomeerlang.com) by *Fred Hebert*

### Go

* [Network Programming with Go](https://ipfs.io/ipfs/QmfYeDhGH9bZzihBUDEQbCbTc5k5FZKURMUoUvfmc27BwL/index.html) by *Jan Newmarch*

* [Practical Go Lessons](https://www.practical-go-lessons.com) by *Maximilien Andile*

### Haskell

* [Learn Haskell by building a blog generator](https://lhbg-book.link/) *Gil Mizrahi*

* [Learn You a Haskell for Great Good!](http://learnyouahaskell.com) by *Miran Lipovača*

* [Monday Morning Haskell](https://mmhaskell.com)

* [Real World Haskell](http://book.realworldhaskell.org) by *Bryan O'Sullivan, Don Stewart, and John Goerzen*

### JavaScript

* [Eloquent JavaScript](https://eloquentjavascript.net) by *Marijn Haverbeke*

* [The Modern JavaScript Tutorial](https://javascript.info) by *Ilya Kantor*

### Nim

* [Computer Programming with the Nim Programming Language](https://ssalewski.de/nimprogramming.html) by *Dr. Stefan Salewski*

### OCaml

* [Real World OCaml](https://dev.realworldocaml.org) by *Yaron Minsky*, *Anil Madhavapeddy* and *Jason Hickey*

### Pascal

* [Modern Object Pascal Introduction for Programmers](https://castle-engine.io/modern_pascal_introduction.html) by *Michalis Kamburelis*

### Prolog

* [The Power of Prolog](https://www.metalevel.at/prolog) by *Markus Triska*

### Pyret

* [Programming and Programming Languages](https://papl.cs.brown.edu/2020)

### Python

* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com/2e) by *Al Sweigart*

* [Composing Programs](http://composingprograms.com) by *John DeNero*

* [From Python to Numpy](https://www.labri.fr/perso/nrougier/from-python-to-numpy) by *Nicolas P. Rougier*

* [Learn Python the Right Way](https://learnpythontherightway.com)

* [Python Design Patterns](https://python-patterns.guide) by *Brandon Rhodes*

* [Python for Data Analysis, 3rd edition](https://wesmckinney.com/book) by *Wes McKinney*

* [Scientific Visualization: Python + Matplotlib](https://github.com/rougier/scientific-visualization-book) by *Nicolas Rougier*

### Racket

* [Beautiful Racket](https://beautifulracket.com/) by *Matthew Butterick*

* [How to Design Programs](https://htdp.org/), Second Edition by *Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi*

### Regular expressions

* [Implementing Regular Expressions](https://swtch.com/~rsc/regexp) by *Russ Cox*

* [Learn RegEx step by step, from zero to advanced](https://regexlearn.com/)

* [RegexOne](https://regexone.com)

* [Regular-Expressions.info](https://www.regular-expressions.info) by *Jan Goyvaerts*

* [Rex Eats Regular Expressions for Breakfast](https://www.rexegg.com)

### Rust

* [A Gentle Introduction to Rust](https://stevedonovan.github.io/rust-gentle-intro/readme.html) by *Steve Donovan*

* [Beginner's guide to Error Handling in Rust](https://www.sheshbabu.com/posts/rust-error-handling) by *Shesh Babu*

* [Clear explanation of Rust’s module system](https://www.sheshbabu.com/posts/rust-module-system) by *Shesh Babu*

* [Exploring ways to make async Rust easier](https://carllerche.com/2021/06/17/six-ways-to-make-async-rust-easier) by *Carl Lerche*

* [Rust Language Cheat Sheet](https://cheats.rs)

* [Things you can’t do in Rust (and what to do instead)](https://blog.logrocket.com/what-you-cant-do-in-rust-and-what-to-do-instead)

### Scheme

* [Structure and Interpretation of Computer Programs](https://xuanji.appspot.com/isicp/index.html) by *Harold Abelson and Gerald Jay Sussman with Julie Sussman*

## Retrocomputing

* [An Afterlife User's Guide to the C64](http://www.c64os.com/c64os/afterlifeguide) by *Gregorio Naçu*

* [Apple II Documentation Project](http://mirrors.apple2.org.za/Apple%20II%20Documentation%20Project)

* [Famicom Party: Making NES Games in Assembly](https://famicom.party/book) by *Kevin Zurawel*

* [First Steps in Z80 Assembly Language](http://ped.7gods.org/z80.pdf) by *Darryl Sloan*

* [How to Write ZX Spectrum Games](https://spectrumcomputing.co.uk/zxdb/sinclair/entries/2001501/HowToWriteSpectrumGames%28v1.0%29.pdf) by *Jonathan Cauldwell*

* [Learn Multiplatform Assembly Programming](https://www.chibiakumas.com) by *ChibiAkumas*

* [MEGA65 Welcome Guide](https://dansanderson.com/mega65/welcome/index.html) by *Dan Sanderson*

* [Multiplying and Dividing on the 6502](https://llx.com/Neil/a2/mult.html)

* [The Lost Ways of Programming: Commodore 64 BASIC](http://tomasp.net/commodore64) by *Tomas Petricek*

* [Z80 User's Manual](https://zany80.github.io/documentation/Z80/UserManual.html)

* [ZX Spectrum Next: Assembly Developer Guide](https://github.com/tomaz/zx-next-dev-guide) by *Tomaz Kragelj*

## Reverse engineering

* [Reverse Engineering for Beginners](https://beginners.re) by *Dennis Yurichev*

* [Reversing for dummies - x86 assembly and C code](https://0x41.cf/reversing/2021/07/21/reversing-x86-and-c-code-for-beginners.html) by *Sami Alaoui*

* [Linux Reverse Engineering CTFs for Beginners](https://osandamalith.com/2019/02/11/linux-reverse-engineering-ctfs-for-beginners)

## Robotics

* [Modern Robotics: Mechanics, Planning, and Control](http://hades.mech.northwestern.edu/index.php/Modern_Robotics) by *Kevin M. Lynch* and *Frank C. Park*

* [Underactuated Robotics](https://underactuated.mit.edu/) by *Russ Tedrake*

## Text editors

* [Build Your Own Text Editor](https://viewsourcecode.org/snaptoken/kilo)

* [Learn Vim (the Smart Way)](https://github.com/iggredible/Learn-Vim) by *Igor Irianto*

* [The Vi/Ex Editor](https://www.ele.uri.edu/faculty/vetter/Other-stuff/vi/009-index.html) by *Walter Alan Zintz*

* [Vim Reference Guide](https://learnbyexample.github.io/vim_reference) by *Sundeep Agarwal*

## Version control tools

* [Git from the Bottom Up](https://jwiegley.github.io/git-from-the-bottom-up) by *John Wiegley*

* [Learn the workings of Git, not just the commands](https://developer.ibm.com/tutorials/d-learn-workings-git) by *Andre Fachat*

## Emulators and Virtual Machines

* [GameBoy Emulation in JavaScript](http://imrannazar.com/GameBoy-Emulation-in-JavaScript:-The-CPU) by *Imran Nazar*

* [Write your Own Virtual Machine](https://justinmeiners.github.io/lc3-vm)

* [Writing NES emulator in Rust](https://bugzmanov.github.io/nes_ebook) by *Rafael Bagmanov*

## Web programming

* [FastCGI — The Forgotten Treasure](http://www.nongnu.org/fastcgi) by *Peter Simons and Ralph Babel*

* [Intro to Web Dev](https://btholt.github.io/intro-to-web-dev-v2)

* [The Flask Mega-Tutorial](https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world) by *Miguel Grinberg*

## Other

* [Beej's Guides](http://beej.us/guide)

* [Computer Science from the Bottom Up](https://www.bottomupcs.com/) by *Ian Wienand*

* [How These Things Work](https://reasonablypolymorphic.com/book/preface.html) - a book about abstraction

* [Memory Management Reference](https://www.memorymanagement.org)

* [Teach Yourself Computer Science](https://teachyourselfcs.com/)

* [The Nature of Code](https://natureofcode.com) a book about how can we capture the unpredictable evolutionary and emergent properties of nature in software by *Daniel Shiffman*

* [The Scientist and Engineer's Guide to Digital Signal Processing](http://www.dspguide.com) by *Steven W. Smith, Ph.D.*

## Other lists

* [Build Your Own X](https://github.com/danistefanovic/build-your-own-x/blob/master/README.md)

* [Electronic References](https://csgordon.github.io/books.html) by *Colin S. Gordon* - a loosely-categorized collection of links to CS textbooks in a variety of areas that are freely available online.

* [Project Based Learning](https://github.com/practical-tutorials/project-based-learning/blob/master/README.md)