All my notes for technical book reading. Most of these notes are only outlines -- too many things need to learn, and some of them are low priority.
183 directories, 574 files:
.
├── 00.Algorithm
│ ├── 00.Methodology
│ │ └── How-to-Solve-It.org
│ ├── Algorithmic-Puzzles.org
│ ├── Algorithms-4th.org
│ ├── Algorithms.org
│ ├── Data-Structures-and-Algorithm-Analysis-in-C.org
│ ├── Data-Structures-and-Algorithms.org
│ ├── Functional-Algorithm-and-Data-Structures
│ │ ├── Pearls-of-Functional-Algorithm-Design.org
│ │ ├── Purely-Functional-Data-Structures.org
│ │ └── Structuring_Depth-First_Search_Algorithms_in_Haskell.org
│ ├── Graph-Theory
│ │ └── Graph-Theory.org
│ ├── Introduction-to-Algorithms-3rd.org
│ ├── Quicksort.org
│ ├── The-Algorithm-Design-Manual-2nd.org
│ └── Think-Data-Structures.org
├── 00.Understand_Computers
│ └── The-Secret-Life-of-Programs.org
├── 01.Theory
│ ├── Algebra-Driven_Design.org
│ ├── CSAPP3rd.org
│ ├── Category_Theory
│ │ ├── Category-Theory-for-Programmers-Scala-Edition.org
│ │ ├── Category-Theory-in-Context.tm
│ │ └── Conceptual-Mathematics.tm
│ ├── Code.org
│ ├── DSL
│ │ └── DSLs-in-Action.org
│ ├── Extended_BNF.org
│ ├── Introduction-to-Automata-Theory,Languages,and-Computation_3rd.org
│ ├── Lambda_Calculus
│ │ ├── A-Tutorial-Introduction-to-the-Lambda-Calculus_by_Raul-Rojas.tm
│ │ ├── Programming-Language-and-Lambda-Calculi_by_Matthias-Felleisen_Matthew-Flatt.tm
│ │ └── The-Calculi-Of-Lambda-Conversion.org
│ ├── Mathematical-Logic-Part-I.tm
│ ├── Optics-by-Example.org
│ ├── Paradigms-of-Artificial-Intelligence-Programming.org
│ ├── Parsing-Techniques-2nd.tm
│ ├── Pre_Category
│ │ └── A-Book-of-Abstract-Algebra.tm
│ ├── Program-Construction.org
│ ├── Programming-Language-Pragmatics_4th.org
│ ├── Programming-Languages_Application-and-Interpretation_2nd.org
│ ├── Programming-Languages_Application-and-Interpretation_3rd.org
│ ├── Semantics
│ │ ├── [1992 - Semantics of Programming Languages].Carl A. Gunter.tm
│ │ ├── [1993 - The Formal Semantics of Programming Languages - An Introduction].Glynn Winskel.tm
│ │ ├── [1995 - Formal Syntax and Semantics of Programming Languages].Kenneth Slonneger, Barry L. Kurtz.tm
│ │ ├── [2007 - Semantics with Applications - An Appetizer].Hanne Riis Nielson, Flemming Nielson.tm
│ │ └── [2009 - Semantics engineering with PLT Redex].Matthias Felleisen, Robert Bruce Findler, Matthew Flatt.tm
│ ├── Software-Design-for-Flexibility.org
│ ├── The-Little-Typer.org
│ ├── Type-Systems.tm
│ ├── Types-and-Programming-Languages.org
│ ├── Understanding-Computation.org
│ └── UniMath
│ └── Symmetry.tm
├── 02.Ruminations
│ ├── 97-Things-Every-Programmer-Should-Know.org
│ ├── A-Philosophy-of-Software-Design.org
│ ├── Elements-of-Information-Theory-2nd.org
│ └── Working-Effectively-with-Legacy-Code.org
├── 03.DevOps
│ ├── Arch_Linux
│ │ └── package-management.org
│ ├── Configuration_File_Formats
│ │ ├── HOCON
│ │ │ ├── Config.org
│ │ │ └── HOCON.org
│ │ ├── Markdown
│ │ │ └── GitHub-Flavored-Markdown-Spec.org
│ │ ├── TOML
│ │ │ └── TOML.org
│ │ └── YAML
│ ├── Postman
│ │ └── Postman-Official-Document.org
│ ├── Programming_Etiquette
│ │ └── Conventional-Commits.org
│ ├── System_Management
│ │ ├── Learn-Powershell-Core-6.0.org
│ │ ├── Learn-Windows-Powershell-in-A-Month-of-Lunches-3rd.org
│ │ ├── PowerShell-for-SYSADMINS.org
│ │ ├── The-Unix-Person's-Guide-to-Powershell.org
│ │ ├── Unix-and-Linux-System-AdminHandbook-4th.org
│ │ └── Windows-PowerShell-in-Action-3rd.org
│ ├── Version_Control
│ │ └── Git
│ │ ├── Got-Git_CN.org
│ │ ├── Pragmatic-Guide-to-Git.org
│ │ ├── Pro-Git-2.1.308.org
│ │ ├── Rys-Git-Tutorial.org
│ │ ├── Version-Control-with-Git-3rd.org
│ │ └── Writing-on-GitHub.org
│ ├── Virtualization_and_Container
│ │ ├── Docker-Crash-Course-for-busy-DevOps-and-Developers.org
│ │ ├── Docker-and-Kubernetes_The-Practical-Guide_2024-Edition.org
│ │ ├── Kubernetes-Up_and_Running-3rd.org
│ │ ├── Learning-Helm.org
│ │ ├── Podman-in-Action.org
│ │ └── the-Docker-Book-18.03.org
│ └── curl-Official-Document.org
├── 04.Architecture_and_OS
│ ├── Computer-Architecture-6th.org
│ ├── Computer-Organization-and-Design-5th.org
│ ├── The-Elements-of-Computing-Systems.org
│ └── xv6.org
├── 05.Compiler_and_Static_Analysis
│ ├── Abstract_Interpretation
│ │ └── Introduction-to-Abstract-Interpretation.tm
│ ├── Engineering-a-Compiler-2nd.org
│ ├── LLVM
│ │ ├── LLVM-Language-Reference-Manual.org
│ │ └── LLVM-Tutorial.org
│ ├── Language_Server_Protocol
│ │ └── Language-Server-Protocol-Specification.org
│ ├── Modern-Compiler-Implementation-in-ML.org
│ ├── Program-Analysis_An-Appetizer.org
│ └── Static-Single-Assignment-Book.org
├── 06.Language_Virtual_Machine
│ ├── CLR
│ │ ├── Standard-ECMA-335-6th.org
│ │ ├── dotNET-Core-in-Action.org
│ │ └── dotNET-IL-Assembler.org
│ ├── JVM
│ │ ├── ASM-4-Guide.org
│ │ ├── Decompiling-Java.org
│ │ ├── JMH-Samples.org
│ │ ├── The-JVM-Spec-SE13.org
│ │ ├── Understanding-the-JVM_3rd.org
│ │ ├── Virtual-Machines.org
│ │ └── VisualVM-Documentation.org
│ └── Principles-of-Computer-Organization-and-Assembly-Language.org
├── 07.Concurrency_and_Parallel_and_Distributed
│ ├── Actors_a-Model-of-Concurrent-Computation-in-Distributed-Systems.org
│ ├── Java-Concurrency-in-Practice.org
│ ├── Learning-Concurrent-Programming-in-Scala-2nd.org
│ ├── Parallel-and-Concurrent-Programming-in-Haskell.org
│ ├── Programming-with-POSIX-Threads.org
│ ├── Seven-Concurrency-Models-in-Seven-Weeks.org
│ ├── The-Art-of-Multiprocessor-Programming-Revised.org
│ └── pthreads-Programming.org
├── 08.Web
│ ├── HTTP
│ │ ├── HTTP-the-Definitive-Guide.org
│ │ ├── Learning-HTTP2.org
│ │ └── RFC7230-HTTP1.1.org
│ ├── Monadic-Design-Patterns-for-the-Web.org
│ ├── RESTful
│ │ ├── Architectural-Styles-and-the-Design-of-Network-based-Software-Architectures.org
│ │ ├── Learn-API-Doc.org
│ │ ├── OpenAPI-Sepcification.org
│ │ ├── REST-API-Design-Rulebook.org
│ │ ├── RESTful-Web-APIs.org
│ │ ├── RESTful-Web-Services-with-Scala.org
│ │ └── Web-Design_the-Missing-Link-Ebook.org
│ ├── Reactive-Web-Applications.org
│ ├── Spring-in-Action-5th.org
│ └── Webassembly
│ └── WebAssembly-Specification-Release1.0.org
├── 09.Languages
│ ├── Assembly_and_C
│ │ ├── Assembly-Language-Step-by-Step3rd.org
│ │ ├── Managing-Projects-with-GNU-Make.org
│ │ ├── Modern-C.org
│ │ └── The-Art-of-64bit-Assembly-Language.org
│ ├── C#
│ │ ├── CSharp-10-in-a-Nutshell.org
│ │ ├── CSharp-6-in-a-Nutshell.org
│ │ └── Real-World-Functional-Programming-with-Examples-in-Fsharp-and-Csharp.org
│ ├── C++
│ │ └── C++-Primer-5th.org
│ ├── Common_Lisp
│ │ ├── Common-Lisp-Recipes.org
│ │ ├── Practical-Common-Lisp.org
│ │ └── The-Art-of-the-Metaobject-Protocol.org
│ ├── Elixir_and_Erlang
│ │ ├── Elixir-Official-Guides.org
│ │ ├── Elixir-in-Action-2nd.org
│ │ ├── Erlang_Official_Documentation
│ │ │ └── Getting-Started-with-Erlang.org
│ │ ├── Learn-You-Some-Erlang-for-Great-Good.org
│ │ ├── Programming-Elixir-greaterThan-1dot6.org
│ │ ├── Programming-Erlang-2nd.org
│ │ └── rebar3.org
│ ├── Emacs_Lisp
│ │ ├── An-Introduction-to-Programming-in-Emacs-Lisp.org
│ │ ├── Learn-Elisp.org
│ │ └── Practical-Emacs.org
│ ├── Go
│ │ ├── A-Tour-of-Go.org
│ │ ├── Concurrency-in-Go.org
│ │ ├── Effective-Go.org
│ │ └── the-Go-Programming-Language.org
│ ├── Groovy
│ │ └── Groovy-in-Action-2nd.org
│ ├── Haskell
│ │ ├── 24-Days-of-GHC-Extensions.org
│ │ ├── Developing-Web-Apps-with-Haskell-and-Yesod-2nd.org
│ │ ├── GHC-8.01-Users-Guide.org
│ │ ├── Haskell-Programming-from-First-Principles.org
│ │ ├── Haskell-wiki.org
│ │ ├── Introduction-to-Functional-Programming-in-Haskell_CN.org
│ │ ├── Learn-You-a-Haskell-for-Great-Good.org
│ │ ├── Real-World-Haskell.org
│ │ └── The-Haskell-School-of-Expression.org
│ ├── Idris
│ │ └── Type-Driven-Development-with-Idris.org
│ ├── Java
│ │ ├── A-Little-Java-a-Few-Patterns.org
│ │ ├── Best_Practice
│ │ │ ├── Alibaba-Java-Coding-Guidelines.org
│ │ │ ├── Effective-Java-3rd.org
│ │ │ ├── Google-Java-Style-Guide.org
│ │ │ ├── Java-Cookbook_3rd.org
│ │ │ ├── Java9-Recipes.org
│ │ │ └── Modern-Java-Recipes.org
│ │ ├── Core_Java
│ │ │ ├── Core-Java-SE-9-for-The-Impatient.org
│ │ │ └── Core-Java_Volume_1_and_2-11th.org
│ │ ├── Functional-Programing-in-Java.org
│ │ ├── JUnit-in-Action_3rd.org
│ │ ├── Java-13-Revealed-2nd.org
│ │ ├── Java-Network-Programming-4th.org
│ │ ├── Java-Puzzlers.org
│ │ ├── Java-Threads-3rd.org
│ │ ├── Java-by-Comparison.org
│ │ ├── Java-the-Legend.org
│ │ ├── Java8-Lambdas.org
│ │ ├── Java_in_Action
│ │ │ ├── Java8-in-Action.org
│ │ │ └── Modern-Java-in-Action.org
│ │ ├── Libraries
│ │ │ ├── Java-Generics-and-Collections.org
│ │ │ ├── Java-IO-NIO-and-NIO2.org
│ │ │ └── Java-Threads_3rd.org
│ │ ├── Logging
│ │ │ ├── SLF4J.org
│ │ │ └── sematext-BLOG-logging
│ │ │ ├── Java-Logging-Frameworks-Comparison_Log4j_vs_Logback_vs_Log4j2_vs_SLF4j_Differences.org
│ │ │ ├── Java-Logging-Tutorial_Basic-Concepts-to-Help-You-Get-Started.org
│ │ │ └── SLF4J-Tutorial_Example-of-How-to-Configure-it-for-Logging-Java-Applications.org
│ │ ├── MetaProgramming
│ │ │ ├── Java-Reflection-in-Action.org
│ │ │ └── Trail_The-Reflection-API.org
│ │ ├── Module_System
│ │ │ ├── Java9-Modularity.org
│ │ │ └── The-Java-Module-System.org
│ │ ├── Official_Documents_and_Standards
│ │ │ ├── Java-Shell-Users-Guide_JDK10.org
│ │ │ ├── Java9-with-JShell.org
│ │ │ ├── Mastering-Lambdas_Java-Programming-in-a-Multicore-World.org
│ │ │ ├── The-Java-Language-Specification-SE15.tm
│ │ │ ├── The-Java-Language-Specification-SE9.org
│ │ │ ├── The-Java-Language-Specification-SE9.tm
│ │ │ └── The-Java-Virtual-Machine-Specification-SE15.tm
│ │ └── Thinking-in-Java-4th.org
│ ├── JavaScript
│ │ ├── Eloquent-JavaScript-2nd.org
│ │ ├── Eloquent-JavaScript-3nd.org
│ │ ├── JavaScript-with-Promises.org
│ │ ├── Understanding-ECMAScript6.org
│ │ └── the-Road-to-Learn-React.org
│ ├── Kotlin
│ │ └── Kotlin-in-Action.org
│ ├── Lua
│ │ └── Lua-5.4-Reference-Manual.org
│ ├── MoonBit
│ │ └── MoonBit.org
│ ├── OCaml
│ │ ├── Real-World-OCaml-2nd.org
│ │ └── opam-2.0-documentation.org
│ ├── Prolog
│ │ ├── Learn-Prolog-Now.org
│ │ └── The-Art-of-Prolog-2nd.org
│ ├── Python
│ │ ├── Concurrency
│ │ │ ├── Learning-Concurrency-in-Python.org
│ │ │ ├── Mastering-Concurrency-in-Python.org
│ │ │ └── Using-Asyncio-in-Python.org
│ │ ├── Effective-Python-2nd.org
│ │ ├── Environment_Management
│ │ │ └── Conda-docs.org
│ │ ├── Fluent-Python-2nd.org
│ │ ├── Fluent-Python.org
│ │ ├── High-Performance-Python-2nd.org
│ │ ├── Learning-Python-5th.org
│ │ ├── Libraries
│ │ │ └── Requests_HTTP-for-Humans.org
│ │ ├── Linters
│ │ │ └── Flake8.org
│ │ ├── Official_Documentation
│ │ │ ├── Debugging-and-Profiling.org
│ │ │ ├── Python-HOWTOs.org
│ │ │ ├── Python_Enhancement_Proposals
│ │ │ │ ├── Packaging_PEPs
│ │ │ │ └── Typing_PEPs
│ │ │ ├── The-Python-Language-Reference.org
│ │ │ ├── The-Python-Tutorial.org
│ │ │ └── The_Python_Standard_Library
│ │ │ ├── Development_Tools
│ │ │ │ ├── typing.org
│ │ │ │ └── unittest.org
│ │ │ ├── File_and_Directory_Access
│ │ │ │ └── pathlib.org
│ │ │ └── Networking_and_Interprocess_Communication
│ │ │ └── asyncio-Asynchronous-IO.org
│ │ ├── Programming-Python-4th.org
│ │ ├── Python-Cookbook.org
│ │ ├── Python-Testing-with-pytest.org
│ │ ├── Real_Python
│ │ │ └── Speed-Up-Your-Python-Program-with-Concurrency.org
│ │ ├── Robust-Python.org
│ │ ├── Standard_Library_third_party_documents
│ │ │ ├── Python-Standard-Library.org
│ │ │ └── The-Python-3-Standard-Library-by-Example.org
│ │ ├── Violent-Python.org
│ │ ├── Web-Scraping-with-Python-2nd.org
│ │ └── packaging
│ │ ├── Publishing-Python-Packages.org
│ │ ├── Python-Packaging-Authority.org
│ │ ├── Setuptools.org
│ │ └── pip-documentation.org
│ ├── R
│ │ ├── Advanced-R_2nd.org
│ │ ├── An-Introduction-to-R.org
│ │ ├── Hands-On-Programming-with-R.org
│ │ ├── R-Cookbook_2nd.org
│ │ ├── R-Markdown.org
│ │ ├── The-Art-of-R-Programming.org
│ │ ├── The-Book-of-R.org
│ │ └── The-tidyverse-Style-Guide.org
│ ├── Racket
│ │ ├── Guile-Reference-Manual.org
│ │ ├── Plait-Language.org
│ │ ├── Plot_Graph-Plotting.org
│ │ ├── Structure-and-Interpretation-of-Computer-Programs-2nd.org
│ │ ├── The-Racket-Guide.org
│ │ ├── The-Racket-Reference.org
│ │ ├── The-Scheme-Programming-Language-4th.org
│ │ └── The-Typed-Racket-Guide.org
│ ├── ReScript
│ │ └── Official_Documents
│ │ └── Language-Manual.org
│ ├── Rust
│ │ ├── Command-Line_Rust.org
│ │ ├── Command-line-apps-in-Rust.org
│ │ ├── Easy-Rust.org
│ │ ├── Libraries
│ │ │ ├── A-Thoughtful-Introduction-to-The-Pest-Parser.org
│ │ │ ├── The-Nominomicon.org
│ │ │ └── nom.org
│ │ ├── Official_Documentation
│ │ │ ├── Clippy-Documentation.org
│ │ │ ├── Rust-by-Example.org
│ │ │ ├── The-Cargo-Book.org
│ │ │ ├── The-Edition-Guide.org
│ │ │ ├── The-Rust-Style-Guide.org
│ │ │ ├── The-rustc-book.org
│ │ │ └── The-rustdoc-book.org
│ │ ├── Practical-Rust-1.x-Cookbook.org
│ │ ├── Programming-Rust-2nd.org
│ │ ├── Programming-Rust.org
│ │ ├── Programming-WebAssembly-with-Rust.org
│ │ ├── Rust-Atomics-and-Locks.org
│ │ ├── Rust-Cookbook.org
│ │ ├── Rust-Standard-Library-Cookbook.org
│ │ ├── Rust-Style-Guidelines.org
│ │ ├── Rust-and-WebAssembly.org
│ │ ├── Rust-for-Rustaceans.org
│ │ ├── Serde
│ │ │ ├── Serde-JSON.org
│ │ │ └── Serde.org
│ │ ├── The-Embedded-Rust-Book.org
│ │ ├── The-Little-Book-of-Rust-Macros.org
│ │ ├── The-Rust-Programming-Language-2nd.org
│ │ ├── The-Rust-Reference.org
│ │ ├── The-Rustonomicon.org
│ │ ├── The-Tao-of-Rust.org
│ │ ├── Tour-of-Rust.org
│ │ ├── Zero-to-Production-in-Rust.org
│ │ ├── rust-analyzer-user-manual.org
│ │ └── rust-unofficial
│ │ ├── Learning-Rust-with-Entirely-Too-Many-Linked-Lists.org
│ │ └── Rust-Design-Patterns.org
│ ├── SML
│ │ ├── ML-for-Working-Programmer-2nd.org
│ │ └── Programming-in-Standard-ML.org
│ ├── Scala_2
│ │ ├── Akka
│ │ │ ├── Akka-Concurrency.org
│ │ │ ├── Akka-Cookbook.org
│ │ │ ├── Akka-in-Action-2nd.org
│ │ │ ├── Akka-in-Action.org
│ │ │ ├── Akka_Official_Documentation
│ │ │ │ ├── Actors.org
│ │ │ │ ├── Akka-Classic.org
│ │ │ │ ├── Cluster.org
│ │ │ │ ├── Clustering.org
│ │ │ │ ├── Discovery.org
│ │ │ │ ├── General-Concepts.org
│ │ │ │ ├── Getting-Started-Guide.org
│ │ │ │ ├── Other-Akka-modules.org
│ │ │ │ ├── Package-Deploy-and-Run.org
│ │ │ │ ├── Persistence-(Durable-State).org
│ │ │ │ ├── Persistence-(Event-Sourcing).org
│ │ │ │ ├── Project-Information.org
│ │ │ │ ├── Security-Announcements.org
│ │ │ │ ├── Streams.org
│ │ │ │ └── Utilities.org
│ │ │ ├── Alpakka-Documentation.org
│ │ │ ├── Effective-Akka.org
│ │ │ ├── Learning-Akka.org
│ │ │ └── rockthejvm-The-Akka-Bundle
│ │ │ ├── Akka-Classic-Essentials.org
│ │ │ ├── Akka-Classic-Persistence.org
│ │ │ └── Akka-Streams-with-Scala.org
│ │ ├── Ammonite.org
│ │ ├── Creative-Scala.org
│ │ ├── Effective-Scala-by-Twitter.org
│ │ ├── Essential-Scala.org
│ │ ├── Functional-Programming-Simplified.org
│ │ ├── Functional-Programming-in-Scala.org
│ │ ├── Hands-on_Scala.org
│ │ ├── Libraries
│ │ │ ├── Database
│ │ │ │ ├── Essential-Slick.org
│ │ │ │ ├── Scredis.org
│ │ │ │ ├── Slick.org
│ │ │ │ └── quill.org
│ │ │ ├── HOCON
│ │ │ │ └── PureConfig.org
│ │ │ ├── Scalafix.org
│ │ │ ├── Scalafmt.org
│ │ │ └── Shapeless
│ │ │ ├── Shapeless-API.org
│ │ │ └── The-Type-Astronauts-Guide-to-Shapeless.org
│ │ ├── Metaprogramming
│ │ │ ├── Scalameta.org
│ │ │ └── Separately_Shipped_Standard_Libraries
│ │ │ └── scala-reflection-library.org
│ │ ├── Notes4Talks
│ │ │ ├── How-to-Totally-Fix-PartialFunction_by_Dale-Wijnand.org
│ │ │ ├── Talks_No-Plan-for-Taking-Note.org
│ │ │ ├── The-Last-Hope-for-Scala's-Infinity-War_John-A.-De-Goes.org
│ │ │ └── Think-Less-with-Scala_Daniel-Sivan.org
│ │ ├── Official_Documents
│ │ │ ├── Guides_and_Overviews
│ │ │ │ ├── Authoring_Libraries
│ │ │ │ │ └── Library-Author-Guide.org
│ │ │ │ ├── Compatibility
│ │ │ │ │ ├── Binary-Compatibility-for-Library-Authors.org
│ │ │ │ │ ├── Binary-Compatibility-of-Scala-Releases.org
│ │ │ │ │ └── JDK-Version-Compatibility.org
│ │ │ │ ├── Compiler
│ │ │ │ │ ├── Error-Formatting.org
│ │ │ │ │ ├── Optimizer.org
│ │ │ │ │ ├── Quasiquotes-in-Scala-2.org
│ │ │ │ │ ├── Scala-2-Compiler-Options.org
│ │ │ │ │ ├── Scala-2-Compiler-Plugins.org
│ │ │ │ │ ├── Scala-2-Macros.org
│ │ │ │ │ └── Scala-2-Reflection.org
│ │ │ │ ├── Language
│ │ │ │ │ ├── An-Overview-of-TASTy.org
│ │ │ │ │ ├── Implicit-Classes.org
│ │ │ │ │ ├── Migration-from-Scala-2-to-Scala-3.org
│ │ │ │ │ ├── Scala-3-Macros.org
│ │ │ │ │ ├── String-Interpolation.org
│ │ │ │ │ ├── The-Scala-Book.org
│ │ │ │ │ └── Value-Classes-and-Universal-Traits.org
│ │ │ │ ├── Legacy
│ │ │ │ │ ├── Scala-2.8-to-2.12s-Collections.org
│ │ │ │ │ └── The-Architecture-of-Scala-2.8-to-2.12s-Collections.org
│ │ │ │ ├── Parallel_and_Concurrent_Programming
│ │ │ │ │ ├── Futures-and-Promises.org
│ │ │ │ │ └── Parallel-Collections.org
│ │ │ │ ├── Standard_Library
│ │ │ │ │ ├── Adding-Custom-Collection-Operations.org
│ │ │ │ │ ├── Implementing-Custom-Collections.org
│ │ │ │ │ ├── Migrating-a-Project-to-Scala-2.13s-Collections.org
│ │ │ │ │ ├── Scala-Collections.org
│ │ │ │ │ └── The-Architecture-of-Scala-2.13s-Collections.org
│ │ │ │ └── Tools
│ │ │ │ ├── Scala-2-REPL.org
│ │ │ │ ├── Scaladoc-For-Scala-3.org
│ │ │ │ └── Scaladoc.org
│ │ │ ├── SIPs
│ │ │ │ ├── SIP-11_String_Interpolation.org
│ │ │ │ ├── SIP-13_Implicit_Classes.org
│ │ │ │ └── SIP-15_Value_Classes.org
│ │ │ └── Scala-API.org
│ │ ├── Personal_Notes
│ │ │ ├── Scala-Refactor-Recipies.org
│ │ │ └── Scala-Traps-and-Pitfalls_Personal-Note.org
│ │ ├── Play_Framework
│ │ │ ├── Essential-Play.org
│ │ │ ├── Play-Documentation.org
│ │ │ ├── Play-Framework-Essentials.org
│ │ │ └── Play-for-Scala.org
│ │ ├── Practical-FP-in-Scala-2nd.org
│ │ ├── Practical-FP-in-Scala.org
│ │ ├── Practice
│ │ │ └── tetrix-in-Scala.org
│ │ ├── Programming-in-Scala-3rd.org
│ │ ├── Programming-in-Scala-4th.org
│ │ ├── Scala-Collection-Technique-Manual_2.8to2.12.org
│ │ ├── Scala-Cookbook.org
│ │ ├── Scala-Design-Patterns-2nd.org
│ │ ├── Scala-High-Performance-Programming.org
│ │ ├── Scala-Puzzlers-from-Me.org
│ │ ├── Scala-Puzzlers.org
│ │ ├── Scala-for-the-Impatient.org
│ │ ├── Scala-in-Depth.org
│ │ ├── Scala.js
│ │ │ ├── Documentation.org
│ │ │ └── Hands-on-Scala.js.org
│ │ ├── Specification_and_Enhancement
│ │ │ ├── Scala-Language-Specification.org
│ │ │ └── Scala-Style-Guide.org
│ │ ├── Talks-Note.org
│ │ └── Things-you-need-to-know-about-JVM_that-matter-in-Scala.org
│ ├── Scala_3
│ │ ├── Advanced-Programming-in-Scala-5th.org
│ │ ├── DevInsideYou
│ │ │ └── JSON-and-Circe.org
│ │ ├── Effect_Systems
│ │ │ ├── Cats-Effect
│ │ │ │ ├── Essential-Effects.org
│ │ │ │ └── cats-effect-3.org
│ │ │ └── ZIO
│ │ │ ├── ZIO.org
│ │ │ ├── ZIO2.org
│ │ │ └── Zionomicon.org
│ │ ├── Functional-Programming-Strategies-in-Scala-with-Cats.org
│ │ ├── Functional-Programming-in-Scala-2nd.org
│ │ ├── Functional-event-driven-architecture.org
│ │ ├── Get-Programming-with-Scala.org
│ │ ├── Guides
│ │ │ ├── An-Overview-of-TASTy.org
│ │ │ └── Migration-from-Scala-2-to-Scala3.org
│ │ ├── Libraries
│ │ │ ├── Cats
│ │ │ │ ├── Functional-effect-handling-in-Scala-with-cats-effect.org
│ │ │ │ ├── Typelevel-Cats-Document.org
│ │ │ │ ├── Udemy-Course_FP-with-Scala-Cats.org
│ │ │ │ ├── Udemy-Functional-effect-handling-in-Scala-with-Cats-Effect.org
│ │ │ │ ├── cats-API.org
│ │ │ │ ├── cats-effect-2.org
│ │ │ │ ├── cats-mtl.org
│ │ │ │ ├── cats-retry.org
│ │ │ │ └── herding-cats.org
│ │ │ ├── Database
│ │ │ │ ├── Doobie.org
│ │ │ │ ├── Redis4Cats.org
│ │ │ │ ├── ScalikeJDBC.org
│ │ │ │ └── Skunk.org
│ │ │ ├── Enumeratum.org
│ │ │ ├── FS2
│ │ │ │ ├── FS2.org
│ │ │ │ ├── Functional-Streams-for-Scala-with-FS2.org
│ │ │ │ └── Udemy_Functional-Streams-for-Scala-with-FS2.org
│ │ │ ├── HOCON
│ │ │ │ └── Ciris.org
│ │ │ ├── Izumi_Project
│ │ │ │ └── distage.org
│ │ │ ├── JSON
│ │ │ │ ├── Circe.org
│ │ │ │ └── Json4s.org
│ │ │ ├── Monocle-Official.org
│ │ │ ├── Scala-with-Cats_me.org
│ │ │ ├── ScalaPB_Scala-Protocol-Buffer-Compiler.org
│ │ │ ├── Spire.org
│ │ │ ├── Squants.org
│ │ │ ├── TSec.org
│ │ │ ├── com-lihaoyi
│ │ │ │ ├── FastParse2.org
│ │ │ │ ├── OS-Lib.org
│ │ │ │ └── upickle.org
│ │ │ ├── http4s
│ │ │ │ ├── http4s-0.2x.org
│ │ │ │ └── http4s-1.org
│ │ │ ├── parboiled2.org
│ │ │ ├── refined.org
│ │ │ ├── scodec.org
│ │ │ └── sttp.org
│ │ ├── Macro
│ │ │ └── A-Macro-Almanac.org
│ │ ├── Notes4Talks
│ │ │ ├── Preparing-Apache-Kafka-for-Scala3.org
│ │ │ └── Scala-3-Macros_by-Nicolas-Stucki.org
│ │ ├── Official_Documents
│ │ │ ├── 0.New-in-Scala-3.org
│ │ │ ├── 1.Getting-Started.org
│ │ │ ├── 2.Scala-3-Book.org
│ │ │ ├── 3.Migration-Guide.org
│ │ │ ├── 4.Guides
│ │ │ │ └── Macros.org
│ │ │ ├── 5.API.org
│ │ │ ├── 6.Language-Reference.org
│ │ │ ├── 7.All-New-Scaladoc-for-Scala-3.org
│ │ │ ├── Scala-3-Contributing-Guide.org
│ │ │ ├── The-Scala-Toolkit.org
│ │ │ └── from-old-reference.org
│ │ ├── Programming-Scala-3rd.org
│ │ ├── Programming-in-Scala-5th.org
│ │ ├── Scala-Cookbook_2nd.org
│ │ ├── Test_Frameworks
│ │ │ ├── MUnit.org
│ │ │ ├── Scala-Test-Driven-Development.org
│ │ │ ├── ScalaCheck
│ │ │ │ ├── ScalaCheck-Cookbook.org
│ │ │ │ ├── ScalaCheck-User-Guide.org
│ │ │ │ └── ScalaCheck_The-Definitive-Guide.org
│ │ │ ├── ScalaMock.org
│ │ │ ├── ScalaTest-User-Guide.org
│ │ │ ├── Testing-in-Scala.org
│ │ │ ├── Weaver-Test.org
│ │ │ └── uTest.org
│ │ ├── Tools
│ │ │ ├── Coursier.org
│ │ │ ├── Giter8.org
│ │ │ └── Scala-CLI.org
│ │ └── rockthejvm
│ │ └── Typelevel-Rite-of-Passage.org
│ ├── Scala_Native
│ │ └── Official-Documentation.org
│ ├── Seven-Languages-in-Seven-Weeks.org
│ ├── Seven-More-Languages-in-Seven-Weeks.org
│ ├── SmallTalk
│ │ ├── A-Little-Smalltalk.org
│ │ ├── A-Taste-of-SmallTalk.org
│ │ └── Pharo-by-Example.org
│ └── TypeScript
│ ├── Official-Documentation.org
│ └── Programming-TypeScript.org
├── 10.Typesetting
│ ├── Fonts-and-Encodings.org
│ └── Unicode-Explained.org
├── 11.Programming_Paradigms
│ ├── Mastering-Functional-Programming.org
│ ├── Object_Oriented
│ │ └── The-Object-Oriented-Thought-Process.org
│ ├── Reactive
│ │ ├── Functional-Reactive-Programming.org
│ │ └── Reactive-Programming-with-Rxjava.org
│ └── Why-Functional-Programming-Matters.org
├── 12.Data_Science
│ ├── An-Introduction-to-Statistical-Learning.org
│ ├── Apache-Hadoop-Official-Document.org
│ ├── Database
│ │ ├── DBeaver.org
│ │ ├── Database-Management-Systems-3rd.org
│ │ ├── MySQL
│ │ │ ├── High-Performance-MySQL-3rd.org
│ │ │ └── Jump-Start-MySQL.org
│ │ ├── PostgreSQL
│ │ │ ├── Official-PostgreSQL-Documentation.org
│ │ │ ├── PostgreSQL-Bootcamp_Udemy.org
│ │ │ └── PostgreSQL-Up-and-Running-3rd.org
│ │ ├── Redis
│ │ │ ├── Redis-Official-Documentation.org
│ │ │ └── Redis-The-Complete-Developer's-Guide.org
│ │ ├── SQL
│ │ │ ├── Learning-SQL-2nd.org
│ │ │ ├── SQL-Cookbook.org
│ │ │ └── SQL-in-10Min-4th.org
│ │ └── Seven-Databases-in-Seven-Weeks.org
│ ├── Designing_Data-Intensive_Applicaitons.org
│ ├── Jupyter
│ │ └── Programming-in-Scala-5th.org
│ ├── Message_Queue
│ │ └── Kafka
│ │ ├── Kafka-Streams-in-Action.org
│ │ ├── Kafka-in-Action.org
│ │ ├── Kafka_The-Definitive-Guide_2nd.org
│ │ ├── Udemy_Apache-Kafka-Series
│ │ │ ├── Kafka-Streams-for-Data-Processing.org
│ │ │ └── Kafka_Connect_Hands-on_Learning.org
│ │ └── Udemy_Apache-Kafka-Series_Learn-Apache-Kafka-for-Beginners-v3.org
│ ├── Next-Generation-Databases.org
│ ├── Spark
│ │ ├── Advanced-Analytics-with-Spark-2nd.org
│ │ ├── Data-Algorithms-with-Spark.org
│ │ ├── High-Performance-Spark.org
│ │ ├── Learning-Spark-SQL.org
│ │ ├── Learning-Spark.org
│ │ ├── Learning-Spark_2nd.org
│ │ ├── Spark-2.4.x-Documentation.org
│ │ ├── Spark-3.x.x-Documentation.org
│ │ ├── Spark-The-Definitive-Guide.org
│ │ ├── Spark-in-Action.org
│ │ ├── Spark-in-Action_2nd.org
│ │ └── allaboutscala-Learn-Apache-Spark-2.org
│ ├── Streaming
│ │ ├── Streaming-Systems.org
│ │ └── grokking-Streaming-Systems.org
│ └── pandas
│ └── User-Guide.org
├── 13.Building_System
│ ├── Apache-Ant-1.10.x-Manual.org
│ ├── Maven
│ │ ├── Apache-Maven-Project-Documents.org
│ │ └── Maven-Essentials.org
│ ├── Scala_Build_Tools
│ │ ├── Bloop.org
│ │ ├── mill-manual.org
│ │ └── sbt
│ │ ├── sbt-Reference-Manual.org
│ │ ├── sbt-assembly.org
│ │ ├── sbt-in-Action.org
│ │ └── sbt-native-packager.org
│ ├── Software-Build-Systems.org
│ └── make
│ ├── GNU-make.org
│ └── Write-Makefile-with-Me.org
├── 14.Blogs
│ └── Matthew_Might
│ └── The-Language-of-Languages.org
├── 15.System_Programming
│ └── The-Linux-Programming-Interface.org
├── 16.Music
│ ├── Music-Theory-Comprehensive.org
│ └── The-Haskell-School-of-Music.org
├── Editors
│ ├── Spacemacs
│ │ ├── Important-Layers.org
│ │ └── Spacemacs-Documentation.org
│ ├── The-compact-Org-mode-Guide.org
│ ├── Vim
│ │ ├── Learning-the-vi&Vim-Editors.org
│ │ └── Modern-Vim.org
│ ├── Visual_Studio_Code
│ │ └── Learning-the-vi&Vim-Editors.org
│ └── code.md
├── MISC
│ ├── Bit_Operations
│ │ ├── Bit-Twiddling-Hacks.org
│ │ └── Hackers-Delight-2nd.org
│ ├── Calendrical-Calculations_The-Ultimate-Edition.org
│ ├── IntelliJ-IDEA
│ │ ├── IntelliJ-IDEA-Essentials.org
│ │ ├── Intellij-IDEA-Help.org
│ │ └── Udemy_Java-Debugging-With-IntelliJ-IDEA.org
│ ├── Low_Priority
│ │ └── Tool_MATLAB
│ │ ├── Matlab-Primer-2017b.org
│ │ └── Matlab-a-Practical-Introduction-to-Programming-and-Problem-Solving.org
│ ├── Mastering-Regular-Expressions-3rd.org
│ ├── Real-World_Cryptography.org
│ ├── Serialization
│ │ └── Programmers-Guide-to-Apache-Thrift.org
│ ├── Visualization-Analysis-and-Design.org
│ └── i3-User's-Guide.org
├── README.md