Translated everything to line 1530

translations/README-bg.md

@@ -1267,3 +1267,723 @@ Mock интервюта:
     *****************************************************************************************************
 
 ---
+
+## Допълнителни книги
+
+    Книгите тук ще ви позволят да се гмурнете в теми, които са интересни за вас.
+
+-   [The Unix Programming Environment](https://www.amazon.com/dp/013937681X)
+    -   An oldie but a goodie
+-   [The Linux Command Line: A Complete Introduction](https://www.amazon.com/dp/1593273894/)
+    -   A modern option
+-   [TCP/IP Illustrated Series](https://en.wikipedia.org/wiki/TCP/IP_Illustrated)
+-   [Head First Design Patterns](https://www.amazon.com/gp/product/0596007124/)
+    -   A gentle introduction to design patterns
+-   [Design Patterns: Elements of Reusable Object-Oriente​d Software](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612)
+    -   AKA the "Gang Of Four" book, or GOF
+    -   The canonical design patterns book
+-   [Algorithm Design Manual](http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202) (Skiena)
+    -   As a review and problem recognition
+    -   The algorithm catalog portion is well beyond the scope of difficulty you'll get in an interview
+    -   This book has 2 parts:
+        -   Class textbook on data structures and algorithms
+            -   Pros:
+                -   Is a good review as any algorithms textbook would be
+                -   Nice stories from his experiences solving problems in industry and academia
+                -   Code examples in C
+            -   Cons:
+                -   Can be as dense or impenetrable as CLRS, and in some cases, CLRS may be a better alternative for some subjects
+                -   Chapters 7, 8, 9 can be painful to try to follow, as some items are not explained well or require more brain than I have
+                -   Don't get me wrong: I like Skiena, his teaching style, and mannerisms, but I may not be Stony Brook material
+        -   Algorithm catalog:
+            -   This is the real reason you buy this book.
+            -   This book is better as an algorithm reference, and not something you read cover to cover.
+    -   Can rent it on Kindle
+    -   Answers:
+        -   [Solutions](<http://www.algorithm.cs.sunysb.edu/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition)>)
+        -   [Solutions](http://blog.panictank.net/category/algorithmndesignmanualsolutions/page/2/)
+    -   [Errata](http://www3.cs.stonybrook.edu/~skiena/algorist/book/errata)
+-   [Write Great Code: Volume 1: Understanding the Machine](https://www.amazon.com/Write-Great-Code-Understanding-Machine/dp/1593270038)
+    -   The book was published in 2004, and is somewhat outdated, but it's a terrific resource for understanding a computer in brief
+    -   The author invented [HLA](https://en.wikipedia.org/wiki/High_Level_Assembly), so take mentions and examples in HLA with a grain of salt. Not widely used, but decent examples of what assembly looks like
+    -   These chapters are worth the read to give you a nice foundation:
+        -   Chapter 2 - Numeric Representation
+        -   Chapter 3 - Binary Arithmetic and Bit Operations
+        -   Chapter 4 - Floating-Point Representation
+        -   Chapter 5 - Character Representation
+        -   Chapter 6 - Memory Organization and Access
+        -   Chapter 7 - Composite Data Types and Memory Objects
+        -   Chapter 9 - CPU Architecture
+        -   Chapter 10 - Instruction Set Architecture
+        -   Chapter 11 - Memory Architecture and Organization
+-   [Introduction to Algorithms](https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844)
+    -   **Important:** Reading this book will only have limited value. This book is a great review of algorithms and data structures, but won't teach you how to write good code. You have to be able to code a decent solution efficiently
+    -   AKA CLR, sometimes CLRS, because Stein was late to the game
+-   [Computer Architecture, Sixth Edition: A Quantitative Approach](https://www.amazon.com/dp/0128119055)
+    -   For a richer, more up-to-date (2017), but longer treatment
+
+## System Design, Scalability, Data Handling
+
+**You can expect system design questions if you have 4+ years of experience.**
+
+-   Scalability and System Design are very large topics with many topics and resources, since
+    there is a lot to consider when designing a software/hardware system that can scale.
+    Expect to spend quite a bit of time on this
+-   Considerations:
+    -   Scalability
+        -   Distill large data sets to single values
+        -   Transform one data set to another
+        -   Handling obscenely large amounts of data
+    -   System design
+        -   features sets
+        -   interfaces
+        -   class hierarchies
+        -   designing a system under certain constraints
+        -   simplicity and robustness
+        -   tradeoffs
+        -   performance analysis and optimization
+-   [ ] **START HERE**: [The System Design Primer](https://github.com/donnemartin/system-design-primer)
+-   [ ] [System Design from HiredInTech](http://www.hiredintech.com/system-design/)
+-   [ ] [How Do I Prepare To Answer Design Questions In A Technical Interview?](https://www.quora.com/How-do-I-prepare-to-answer-design-questions-in-a-technical-interview?redirected_qid=1500023)
+-   [ ] [8 Things You Need to Know Before a System Design Interview](http://blog.gainlo.co/index.php/2015/10/22/8-things-you-need-to-know-before-system-design-interviews/)
+-   [ ] [Database Normalization - 1NF, 2NF, 3NF and 4NF (video)](https://www.youtube.com/watch?v=UrYLYV7WSHM)
+-   [ ] [System Design Interview](https://github.com/checkcheckzz/system-design-interview) - There are a lot of resources in this one. Look through the articles and examples. I put some of them below
+-   [ ] [How to ace a systems design interview](http://www.palantir.com/2011/10/how-to-rock-a-systems-design-interview/)
+-   [ ] [Numbers Everyone Should Know](http://everythingisdata.wordpress.com/2009/10/17/numbers-everyone-should-know/)
+-   [ ] [How long does it take to make a context switch?](http://blog.tsunanet.net/2010/11/how-long-does-it-take-to-make-context.html)
+-   [ ] [Transactions Across Datacenters (video)](https://www.youtube.com/watch?v=srOgpXECblk)
+-   [ ] [A plain English introduction to CAP Theorem](http://ksat.me/a-plain-english-introduction-to-cap-theorem)
+-   [ ] [MIT 6.824: Distributed Systems, Spring 2020 (20 videos)](https://www.youtube.com/watch?v=cQP8WApzIQQ&list=PLrw6a1wE39_tb2fErI4-WkMbsvGQk9_UB)
+-   [ ] Consensus Algorithms:
+    -   [ ] Paxos - [Paxos Agreement - Computerphile (video)](https://www.youtube.com/watch?v=s8JqcZtvnsM)
+    -   [ ] Raft - [An Introduction to the Raft Distributed Consensus Algorithm (video)](https://www.youtube.com/watch?v=P9Ydif5_qvE)
+        -   [ ] [Easy-to-read paper](https://raft.github.io/)
+        -   [ ] [Infographic](http://thesecretlivesofdata.com/raft/)
+-   [ ] [Consistent Hashing](http://www.tom-e-white.com/2007/11/consistent-hashing.html)
+-   [ ] [NoSQL Patterns](http://horicky.blogspot.com/2009/11/nosql-patterns.html)
+-   [ ] Scalability:
+    -   You don't need all of these. Just pick a few that interest you.
+    -   [ ] [Great overview (video)](https://www.youtube.com/watch?v=-W9F__D3oY4)
+    -   [ ] Short series:
+        -   [Clones](http://www.lecloud.net/post/7295452622/scalability-for-dummies-part-1-clones)
+        -   [Database](http://www.lecloud.net/post/7994751381/scalability-for-dummies-part-2-database)
+        -   [Cache](http://www.lecloud.net/post/9246290032/scalability-for-dummies-part-3-cache)
+        -   [Asynchronism](http://www.lecloud.net/post/9699762917/scalability-for-dummies-part-4-asynchronism)
+    -   [ ] [Scalable Web Architecture and Distributed Systems](http://www.aosabook.org/en/distsys.html)
+    -   [ ] [Fallacies of Distributed Computing Explained](https://pages.cs.wisc.edu/~zuyu/files/fallacies.pdf)
+    -   [ ] [Jeff Dean - Building Software Systems At Google and Lessons Learned (video)](https://www.youtube.com/watch?v=modXC5IWTJI)
+    -   [ ] [Introduction to Architecting Systems for Scale](http://lethain.com/introduction-to-architecting-systems-for-scale/)
+    -   [ ] [Scaling mobile games to a global audience using App Engine and Cloud Datastore (video)](https://www.youtube.com/watch?v=9nWyWwY2Onc)
+    -   [ ] [How Google Does Planet-Scale Engineering for Planet-Scale Infra (video)](https://www.youtube.com/watch?v=H4vMcD7zKM0)
+    -   [ ] [The Importance of Algorithms](https://www.topcoder.com/community/competitive-programming/tutorials/the-importance-of-algorithms/)
+    -   [ ] [Sharding](http://highscalability.com/blog/2009/8/6/an-unorthodox-approach-to-database-design-the-coming-of-the.html)
+    -   [ ] [Engineering for the Long Game - Astrid Atkinson Keynote(video)](https://www.youtube.com/watch?v=p0jGmgIrf_M&list=PLRXxvay_m8gqVlExPC5DG3TGWJTaBgqSA&index=4)
+    -   [ ] [7 Years Of YouTube Scalability Lessons In 30 Minutes](http://highscalability.com/blog/2012/3/26/7-years-of-youtube-scalability-lessons-in-30-minutes.html)
+        -   [video](https://www.youtube.com/watch?v=G-lGCC4KKok)
+    -   [ ] [How PayPal Scaled To Billions Of Transactions Daily Using Just 8VMs](http://highscalability.com/blog/2016/8/15/how-paypal-scaled-to-billions-of-transactions-daily-using-ju.html)
+    -   [ ] [How to Remove Duplicates in Large Datasets](https://blog.clevertap.com/how-to-remove-duplicates-in-large-datasets/)
+    -   [ ] [A look inside Etsy's scale and engineering culture with Jon Cowie (video)](https://www.youtube.com/watch?v=3vV4YiqKm1o)
+    -   [ ] [What Led Amazon to its Own Microservices Architecture](http://thenewstack.io/led-amazon-microservices-architecture/)
+    -   [ ] [To Compress Or Not To Compress, That Was Uber's Question](https://eng.uber.com/trip-data-squeeze/)
+    -   [ ] [When Should Approximate Query Processing Be Used?](http://highscalability.com/blog/2016/2/25/when-should-approximate-query-processing-be-used.html)
+    -   [ ] [Google's Transition From Single Datacenter, To Failover, To A Native Multihomed Architecture](http://highscalability.com/blog/2016/2/23/googles-transition-from-single-datacenter-to-failover-to-a-n.html)
+    -   [ ] [The Image Optimization Technology That Serves Millions Of Requests Per Day](http://highscalability.com/blog/2016/6/15/the-image-optimization-technology-that-serves-millions-of-re.html)
+    -   [ ] [A Patreon Architecture Short](http://highscalability.com/blog/2016/2/1/a-patreon-architecture-short.html)
+    -   [ ] [Tinder: How Does One Of The Largest Recommendation Engines Decide Who You'll See Next?](http://highscalability.com/blog/2016/1/27/tinder-how-does-one-of-the-largest-recommendation-engines-de.html)
+    -   [ ] [Design Of A Modern Cache](http://highscalability.com/blog/2016/1/25/design-of-a-modern-cache.html)
+    -   [ ] [Live Video Streaming At Facebook Scale](http://highscalability.com/blog/2016/1/13/live-video-streaming-at-facebook-scale.html)
+    -   [ ] [A Beginner's Guide To Scaling To 11 Million+ Users On Amazon's AWS](http://highscalability.com/blog/2016/1/11/a-beginners-guide-to-scaling-to-11-million-users-on-amazons.html)
+    -   [ ] [A 360 Degree View Of The Entire Netflix Stack](http://highscalability.com/blog/2015/11/9/a-360-degree-view-of-the-entire-netflix-stack.html)
+    -   [ ] [Latency Is Everywhere And It Costs You Sales - How To Crush It](http://highscalability.com/latency-everywhere-and-it-costs-you-sales-how-crush-it)
+    -   [ ] [What Powers Instagram: Hundreds of Instances, Dozens of Technologies](http://instagram-engineering.tumblr.com/post/13649370142/what-powers-instagram-hundreds-of-instances)
+    -   [ ] [Salesforce Architecture - How They Handle 1.3 Billion Transactions A Day](http://highscalability.com/blog/2013/9/23/salesforce-architecture-how-they-handle-13-billion-transacti.html)
+    -   [ ] [ESPN's Architecture At Scale - Operating At 100,000 Duh Nuh Nuhs Per Second](http://highscalability.com/blog/2013/11/4/espns-architecture-at-scale-operating-at-100000-duh-nuh-nuhs.html)
+    -   [ ] See "Messaging, Serialization, and Queueing Systems" way below for info on some of the technologies that can glue services together
+    -   [ ] Twitter:
+        -   [O'Reilly MySQL CE 2011: Jeremy Cole, "Big and Small Data at @Twitter" (video)](https://www.youtube.com/watch?v=5cKTP36HVgI)
+        -   [Timelines at Scale](https://www.infoq.com/presentations/Twitter-Timeline-Scalability)
+    -   For even more, see "Mining Massive Datasets" video series in the [Video Series](#video-series) section
+-   [ ] Practicing the system design process: Here are some ideas to try working through on paper, each with some documentation on how it was handled in the real world:
+    -   review: [The System Design Primer](https://github.com/donnemartin/system-design-primer)
+    -   [System Design from HiredInTech](http://www.hiredintech.com/system-design/)
+    -   [cheat sheet](https://github.com/jwasham/coding-interview-university/blob/main/extras/cheat%20sheets/system-design.pdf)
+    -   flow:
+        1. Understand the problem and scope:
+            - Define the use cases, with interviewer's help
+            - Suggest additional features
+            - Remove items that interviewer deems out of scope
+            - Assume high availability is required, add as a use case
+        2. Think about constraints:
+            - Ask how many requests per month
+            - Ask how many requests per second (they may volunteer it or make you do the math)
+            - Estimate reads vs. writes percentage
+            - Keep 80/20 rule in mind when estimating
+            - How much data written per second
+            - Total storage required over 5 years
+            - How much data read per second
+        3. Abstract design:
+            - Layers (service, data, caching)
+            - Infrastructure: load balancing, messaging
+            - Rough overview of any key algorithm that drives the service
+            - Consider bottlenecks and determine solutions
+    -   Exercises:
+        -   [Design a random unique ID generation system](https://blog.twitter.com/2010/announcing-snowflake)
+        -   [Design a key-value database](http://www.slideshare.net/dvirsky/introduction-to-redis)
+        -   [Design a picture sharing system](http://highscalability.com/blog/2011/12/6/instagram-architecture-14-million-users-terabytes-of-photos.html)
+        -   [Design a recommendation system](http://ijcai13.org/files/tutorial_slides/td3.pdf)
+        -   [Design a URL-shortener system: copied from above](http://www.hiredintech.com/system-design/the-system-design-process/)
+        -   [Design a cache system](https://www.adayinthelifeof.nl/2011/02/06/memcache-internals/)
+
+## Additional Learning
+
+    Добавих тези теми, за да Ви помогна да бъдете по-добри софтуерни инженери и да сте наясно с определени технологии и алгоритми, което ще разшири "инструментите", с които можете да работите
+
+-   ### Компилатори
+
+    -   [Как работи един компилатор в ~1 минута (клип)](https://www.youtube.com/watch?v=IhC7sdYe-Jg)
+    -   [Harvard CS50 - Компилатори (клип)](https://www.youtube.com/watch?v=CSZLNYF4Klo)
+    -   [C++ (клип)](https://www.youtube.com/watch?v=twodd1KFfGk)
+    -   [Да разберем оптимизирането на компилатори (C++) (клип)](https://www.youtube.com/watch?v=FnGCDLhaxKU)
+
+-   ### Emacs and vi(m)
+
+    -   Запознайте се с някой unix-базиран кодов редактор
+    -   vi(m):
+        -   [Редактиране с vim 01 - Инсталация, настройване и различните режими (клип)](https://www.youtube.com/watch?v=5givLEMcINQ&index=1&list=PL13bz4SHGmRxlZVmWQ9DvXo1fEg4UdGkr)
+        -   [VIM приключения](http://vim-adventures.com/)
+        -   4 клипа:
+            -   [The vi/vim editor - Урок 1](https://www.youtube.com/watch?v=SI8TeVMX8pk)
+            -   [The vi/vim editor - Урок 2](https://www.youtube.com/watch?v=F3OO7ZIOaJE)
+            -   [The vi/vim editor - Урок 3](https://www.youtube.com/watch?v=ZYEccA_nMaI)
+            -   [The vi/vim editor - Урок 4](https://www.youtube.com/watch?v=1lYD5gwgZIA)
+        -   [Използване на Vi вместо Emacs](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Using_Vi_instead_of_Emacs)
+    -   emacs:
+        -   [Основите на Emacs (клип)](https://www.youtube.com/watch?v=hbmV1bnQ-i0)
+        -   3 клипа:
+            -   [Emacs ръководство (За начинаещи) -Част 1- файлови команди, cut/copy/paste, cursor команди](https://www.youtube.com/watch?v=ujODL7MD04Q)
+            -   [Emacs ръководство (За начинаещи) -Част 2- Управление на буфера, търсене, M-x grep и rgrep режими](https://www.youtube.com/watch?v=XWpsRupJ4II)
+            -   [Emacs въководство (За начинаещи) -Част 3- Изрази, Твърдения, ~/.emacs файлове и пакети](https://www.youtube.com/watch?v=paSgzPso-yc)
+        -   [Зъл режиим: Или как се научих да спра да се тревожа и да заобичам Emacs (клип)](https://www.youtube.com/watch?v=JWD1Fpdd4Pc)
+        -   [Писане на C програми с Emacs](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Writing_C_programs_with_Emacs)
+        -   [(по желание) Org режима в подробности: Управление на структурата (клип)](https://www.youtube.com/watch?v=nsGYet02bEk)
+
+-   ### Unix command line tools
+
+    -   bash
+    -   cat
+    -   grep
+    -   sed
+    -   awk
+    -   curl or wget
+    -   sort
+    -   tr
+    -   uniq
+    -   [strace](https://en.wikipedia.org/wiki/Strace)
+    -   [tcpdump](https://danielmiessler.com/study/tcpdump/)
+
+-   ### Information theory (videos)
+
+    -   [Khan Academy](https://www.khanacademy.org/computing/computer-science/informationtheory)
+    -   Повече за Марковските процеси:
+        -   [Основите на Марковския текст](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/waxgx/core-markov-text-generation)
+        -   [Основите на имплементацията на Марковския текст](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/gZhiC/core-implementing-markov-text-generation)
+        -   [Проект = Ръководство за Марковския текст](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/EUjrq/project-markov-text-generation-walk-through)
+    -   Вижте повече в серията Information and Entropy MIT 6.050J надолу
+
+-   ### Паритет & код на Хаминг (клипове)
+
+    -   [Въведение](https://www.youtube.com/watch?v=q-3BctoUpHE)
+    -   [Паритет](https://www.youtube.com/watch?v=DdMcAUlxh1M)
+    -   Код на Хаминг:
+        -   [Откриване на грешки](https://www.youtube.com/watch?v=1A_NcXxdoCc)
+        -   [Поправяне на грешки](https://www.youtube.com/watch?v=JAMLuxdHH8o)
+    -   [Проверка за грешко](https://www.youtube.com/watch?v=wbH2VxzmoZk)
+
+-   ### Ентропия
+
+    -   Вижте също клиповете надолу
+    -   Първо изгледайте клиповете за information theory
+    -   [Information Theory, Клод Шанън, Ентропия, Redundancy, Компресия на данни & Битове (клип)](https://youtu.be/JnJq3Py0dyM?t=176)
+
+-   ### Криптография
+
+    -   Вижте също клиповете надолу
+    -   Първо изгледайте клиповете за information theory
+    -   [Khan Academy](https://www.khanacademy.org/computing/computer-science/cryptography)
+    -   [Криптография: Функции за хеширане](https://www.youtube.com/watch?v=KqqOXndnvic&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=30)
+    -   [Криптография: Криптиране](https://www.youtube.com/watch?v=9TNI2wHmaeI&index=31&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
+
+-   ### Компресия
+
+    -   Първо изгледайте клиповете за information theory
+    -   Computerphile (клипове):
+        -   [Компресия](https://www.youtube.com/watch?v=Lto-ajuqW3w)
+        -   [Ентропия в компресията](https://www.youtube.com/watch?v=M5c_RFKVkko)
+        -   [Upside Down Trees (Дървета на Хъфман)](https://www.youtube.com/watch?v=umTbivyJoiI)
+        -   [EXTRA BITS/TRITS - Дървета на Хъфман](https://www.youtube.com/watch?v=DV8efuB3h2g)
+        -   [Елегантна компресия на текст (LZ 77 методът)](https://www.youtube.com/watch?v=goOa3DGezUA)
+        -   [Компресията на текст среща вероятностите](https://www.youtube.com/watch?v=cCDCfoHTsaU)
+    -   [Compressor Head клипове](https://www.youtube.com/playlist?list=PLOU2XLYxmsIJGErt5rrCqaSGTMyyqNt2H)
+    -   [(по желание) Google Developers Live: GZIP не е достатъчен!](https://www.youtube.com/watch?v=whGwm0Lky2s)
+
+-   ### Компютърна сигурност
+
+    -   [MIT (23 клипа)](https://www.youtube.com/playlist?list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+        -   [Introduction, Threat Models](https://www.youtube.com/watch?v=GqmQg-cszw4&index=1&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+        -   [Control Hijacking Attacks](https://www.youtube.com/watch?v=6bwzNg5qQ0o&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh&index=2)
+        -   [Buffer Overflow Exploits and Defenses](https://www.youtube.com/watch?v=drQyrzRoRiA&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh&index=3)
+        -   [Privilege Separation](https://www.youtube.com/watch?v=6SIJmoE9L9g&index=4&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+        -   [Capabilities](https://www.youtube.com/watch?v=8VqTSY-11F4&index=5&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+        -   [Sandboxing Native Code](https://www.youtube.com/watch?v=VEV74hwASeU&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh&index=6)
+        -   [Web Security Model](https://www.youtube.com/watch?v=chkFBigodIw&index=7&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+        -   [Securing Web Applications](https://www.youtube.com/watch?v=EBQIGy1ROLY&index=8&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+        -   [Symbolic Execution](https://www.youtube.com/watch?v=yRVZPvHYHzw&index=9&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+        -   [Network Security](https://www.youtube.com/watch?v=SIEVvk3NVuk&index=11&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+        -   [Network Protocols](https://www.youtube.com/watch?v=QOtA76ga_fY&index=12&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+        -   [Side-Channel Attacks](https://www.youtube.com/watch?v=PuVMkSEcPiI&index=15&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+
+-   ### Garbage collection
+
+    -   [GC in Python (video)](https://www.youtube.com/watch?v=iHVs_HkjdmI)
+    -   [Deep Dive Java: Garbage Collection is Good!](https://www.infoq.com/presentations/garbage-collection-benefits)
+    -   [Deep Dive Python: Garbage Collection in CPython (video)](https://www.youtube.com/watch?v=P-8Z0-MhdQs&list=PLdzf4Clw0VbOEWOS_sLhT_9zaiQDrS5AR&index=3)
+
+-   ### Parallel Programming
+
+    -   [Coursera (Scala)](https://www.coursera.org/learn/parprog1/home/week/1)
+    -   [Efficient Python for High Performance Parallel Computing (video)](https://www.youtube.com/watch?v=uY85GkaYzBk)
+
+-   ### Messaging, Serialization, and Queueing Systems
+
+    -   [Thrift](https://thrift.apache.org/)
+        -   [Tutorial](http://thrift-tutorial.readthedocs.io/en/latest/intro.html)
+    -   [Protocol Buffers](https://developers.google.com/protocol-buffers/)
+        -   [Tutorials](https://developers.google.com/protocol-buffers/docs/tutorials)
+    -   [gRPC](http://www.grpc.io/)
+        -   [gRPC 101 for Java Developers (video)](https://www.youtube.com/watch?v=5tmPvSe7xXQ&list=PLcTqM9n_dieN0k1nSeN36Z_ppKnvMJoly&index=1)
+    -   [Redis](http://redis.io/)
+        -   [Tutorial](http://try.redis.io/)
+    -   [Amazon SQS (queue)](https://aws.amazon.com/sqs/)
+    -   [Amazon SNS (pub-sub)](https://aws.amazon.com/sns/)
+    -   [RabbitMQ](https://www.rabbitmq.com/)
+        -   [Get Started](https://www.rabbitmq.com/getstarted.html)
+    -   [Celery](http://www.celeryproject.org/)
+        -   [First Steps With Celery](http://docs.celeryproject.org/en/latest/getting-started/first-steps-with-celery.html)
+    -   [ZeroMQ](http://zeromq.org/)
+        -   [Intro - Read The Manual](http://zeromq.org/intro:read-the-manual)
+    -   [ActiveMQ](http://activemq.apache.org/)
+    -   [Kafka](http://kafka.apache.org/documentation.html#introduction)
+    -   [MessagePack](http://msgpack.org/index.html)
+    -   [Avro](https://avro.apache.org/)
+
+-   ### A\*
+
+    -   [A Search Algorithm](https://en.wikipedia.org/wiki/A*_search_algorithm)
+    -   [A\* Pathfinding Tutorial (video)](https://www.youtube.com/watch?v=KNXfSOx4eEE)
+    -   [A\* Pathfinding (E01: algorithm explanation) (video)](https://www.youtube.com/watch?v=-L-WgKMFuhE)
+
+-   ### Fast Fourier Transform
+
+    -   [An Interactive Guide To The Fourier Transform](https://betterexplained.com/articles/an-interactive-guide-to-the-fourier-transform/)
+    -   [What is a Fourier transform? What is it used for?](http://www.askamathematician.com/2012/09/q-what-is-a-fourier-transform-what-is-it-used-for/)
+    -   [What is the Fourier Transform? (video)](https://www.youtube.com/watch?v=Xxut2PN-V8Q)
+    -   [Divide & Conquer: FFT (video)](https://www.youtube.com/watch?v=iTMn0Kt18tg&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=4)
+    -   [Understanding The FFT](http://jakevdp.github.io/blog/2013/08/28/understanding-the-fft/)
+
+-   ### Bloom Filter
+
+    -   Given a Bloom filter with m bits and k hashing functions, both insertion and membership testing are O(k)
+    -   [Bloom Filters (video)](https://www.youtube.com/watch?v=-SuTGoFYjZs)
+    -   [Bloom Filters | Mining of Massive Datasets | Stanford University (video)](https://www.youtube.com/watch?v=qBTdukbzc78)
+    -   [Tutorial](http://billmill.org/bloomfilter-tutorial/)
+    -   [How To Write A Bloom Filter App](http://blog.michaelschmatz.com/2016/04/11/how-to-write-a-bloom-filter-cpp/)
+
+-   ### HyperLogLog
+
+    -   [How To Count A Billion Distinct Objects Using Only 1.5KB Of Memory](http://highscalability.com/blog/2012/4/5/big-data-counting-how-to-count-a-billion-distinct-objects-us.html)
+
+-   ### Locality-Sensitive Hashing
+
+    -   Used to determine the similarity of documents
+    -   The opposite of MD5 or SHA which are used to determine if 2 documents/strings are exactly the same
+    -   [Simhashing (hopefully) made simple](http://ferd.ca/simhashing-hopefully-made-simple.html)
+
+-   ### van Emde Boas Trees
+
+    -   [Divide & Conquer: van Emde Boas Trees (video)](https://www.youtube.com/watch?v=hmReJCupbNU&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=6)
+    -   [MIT Lecture Notes](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-046j-design-and-analysis-of-algorithms-spring-2012/lecture-notes/MIT6_046JS12_lec15.pdf)
+
+-   ### Augmented Data Structures
+
+    -   [CS 61B Lecture 39: Augmenting Data Structures](https://archive.org/details/ucberkeley_webcast_zksIj9O8_jc)
+
+-   ### Balanced search trees
+
+    -   Know at least one type of balanced binary tree (and know how it's implemented):
+    -   "Among balanced search trees, AVL and 2/3 trees are now passé, and red-black trees seem to be more popular.
+        A particularly interesting self-organizing data structure is the splay tree, which uses rotations
+        to move any accessed key to the root." - Skiena
+    -   Of these, I chose to implement a splay tree. From what I've read, you won't implement a
+        balanced search tree in your interview. But I wanted exposure to coding one up
+        and let's face it, splay trees are the bee's knees. I did read a lot of red-black tree code
+        -   Splay tree: insert, search, delete functions
+            If you end up implementing red/black tree try just these:
+        -   Search and insertion functions, skipping delete
+    -   I want to learn more about B-Tree since it's used so widely with very large data sets
+    -   [Self-balancing binary search tree](https://en.wikipedia.org/wiki/Self-balancing_binary_search_tree)
+
+    -   **AVL trees**
+
+        -   In practice:
+            From what I can tell, these aren't used much in practice, but I could see where they would be:
+            The AVL tree is another structure supporting O(log n) search, insertion, and removal. It is more rigidly
+            balanced than red–black trees, leading to slower insertion and removal but faster retrieval. This makes it
+            attractive for data structures that may be built once and loaded without reconstruction, such as language
+            dictionaries (or program dictionaries, such as the opcodes of an assembler or interpreter)
+        -   [MIT AVL Trees / AVL Sort (video)](https://www.youtube.com/watch?v=FNeL18KsWPc&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=6)
+        -   [AVL Trees (video)](https://www.coursera.org/learn/data-structures/lecture/Qq5E0/avl-trees)
+        -   [AVL Tree Implementation (video)](https://www.coursera.org/learn/data-structures/lecture/PKEBC/avl-tree-implementation)
+        -   [Split And Merge](https://www.coursera.org/learn/data-structures/lecture/22BgE/split-and-merge)
+
+    -   **Splay trees**
+
+        -   In practice:
+            Splay trees are typically used in the implementation of caches, memory allocators, routers, garbage collectors,
+            data compression, ropes (replacement of string used for long text strings), in Windows NT (in the virtual memory,
+            networking and file system code) etc
+        -   [CS 61B: Splay Trees (video)](https://archive.org/details/ucberkeley_webcast_G5QIXywcJlY)
+        -   MIT Lecture: Splay Trees:
+            -   Gets very mathy, but watch the last 10 minutes for sure.
+            -   [Video](https://www.youtube.com/watch?v=QnPl_Y6EqMo)
+
+    -   **Red/black trees**
+
+        -   These are a translation of a 2-3 tree (see below).
+        -   In practice:
+            Red–black trees offer worst-case guarantees for insertion time, deletion time, and search time.
+            Not only does this make them valuable in time-sensitive applications such as real-time applications,
+            but it makes them valuable building blocks in other data structures which provide worst-case guarantees;
+            for example, many data structures used in computational geometry can be based on red–black trees, and
+            the Completely Fair Scheduler used in current Linux kernels uses red–black trees. In the version 8 of Java,
+            the Collection HashMap has been modified such that instead of using a LinkedList to store identical elements with poor
+            hashcodes, a Red-Black tree is used
+        -   [Aduni - Algorithms - Lecture 4 (link jumps to starting point) (video)](https://youtu.be/1W3x0f_RmUo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=3871)
+        -   [Aduni - Algorithms - Lecture 5 (video)](https://www.youtube.com/watch?v=hm2GHwyKF1o&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=5)
+        -   [Red-Black Tree](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree)
+        -   [An Introduction To Binary Search And Red Black Tree](https://www.topcoder.com/community/competitive-programming/tutorials/an-introduction-to-binary-search-and-red-black-trees/)
+
+    -   **2-3 search trees**
+
+        -   In practice:
+            2-3 trees have faster inserts at the expense of slower searches (since height is more compared to AVL trees).
+        -   You would use 2-3 tree very rarely because its implementation involves different types of nodes. Instead, people use Red Black trees.
+        -   [23-Tree Intuition and Definition (video)](https://www.youtube.com/watch?v=C3SsdUqasD4&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6&index=2)
+        -   [Binary View of 23-Tree](https://www.youtube.com/watch?v=iYvBtGKsqSg&index=3&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
+        -   [2-3 Trees (student recitation) (video)](https://www.youtube.com/watch?v=TOb1tuEZ2X4&index=5&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
+
+    -   **2-3-4 Trees (aka 2-4 trees)**
+
+        -   In practice:
+            For every 2-4 tree, there are corresponding red–black trees with data elements in the same order. The insertion and deletion
+            operations on 2-4 trees are also equivalent to color-flipping and rotations in red–black trees. This makes 2-4 trees an
+            important tool for understanding the logic behind red–black trees, and this is why many introductory algorithm texts introduce
+            2-4 trees just before red–black trees, even though **2-4 trees are not often used in practice**.
+        -   [CS 61B Lecture 26: Balanced Search Trees (video)](https://archive.org/details/ucberkeley_webcast_zqrqYXkth6Q)
+        -   [Bottom Up 234-Trees (video)](https://www.youtube.com/watch?v=DQdMYevEyE4&index=4&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
+        -   [Top Down 234-Trees (video)](https://www.youtube.com/watch?v=2679VQ26Fp4&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6&index=5)
+
+    -   **N-ary (K-ary, M-ary) trees**
+
+        -   note: the N or K is the branching factor (max branches)
+        -   binary trees are a 2-ary tree, with branching factor = 2
+        -   2-3 trees are 3-ary
+        -   [K-Ary Tree](https://en.wikipedia.org/wiki/K-ary_tree)
+
+    -   **B-Trees**
+        -   Fun fact: it's a mystery, but the B could stand for Boeing, Balanced, or Bayer (co-inventor).
+        -   In Practice:
+            B-Trees are widely used in databases. Most modern filesystems use B-trees (or Variants). In addition to
+            its use in databases, the B-tree is also used in filesystems to allow quick random access to an arbitrary
+            block in a particular file. The basic problem is turning the file block i address into a disk block
+            (or perhaps to a cylinder-head-sector) address
+        -   [B-Tree](https://en.wikipedia.org/wiki/B-tree)
+        -   [B-Tree Datastructure](http://btechsmartclass.com/data_structures/b-trees.html)
+        -   [Introduction to B-Trees (video)](https://www.youtube.com/watch?v=I22wEC1tTGo&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6&index=6)
+        -   [B-Tree Definition and Insertion (video)](https://www.youtube.com/watch?v=s3bCdZGrgpA&index=7&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
+        -   [B-Tree Deletion (video)](https://www.youtube.com/watch?v=svfnVhJOfMc&index=8&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
+        -   [MIT 6.851 - Memory Hierarchy Models (video)](https://www.youtube.com/watch?v=V3omVLzI0WE&index=7&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf) - covers cache-oblivious B-Trees, very interesting data structures - the first 37 minutes are very technical, may be skipped (B is block size, cache line size)
+
+-   ### k-D Trees
+
+    -   Great for finding number of points in a rectangle or higher dimension object
+    -   A good fit for k-nearest neighbors
+    -   [Kd Trees (video)](https://www.youtube.com/watch?v=W94M9D_yXKk)
+    -   [kNN K-d tree algorithm (video)](https://www.youtube.com/watch?v=Y4ZgLlDfKDg)
+
+-   ### Skip lists
+
+    -   "These are somewhat of a cult data structure" - Skiena
+    -   [Randomization: Skip Lists (video)](https://www.youtube.com/watch?v=2g9OSRKJuzM&index=10&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
+    -   [For animations and a little more detail](https://en.wikipedia.org/wiki/Skip_list)
+
+-   ### Network Flows
+
+    -   [Ford-Fulkerson in 5 minutes — Step by step example (video)](https://www.youtube.com/watch?v=Tl90tNtKvxs)
+    -   [Ford-Fulkerson Algorithm (video)](https://www.youtube.com/watch?v=v1VgJmkEJW0)
+    -   [Network Flows (video)](https://www.youtube.com/watch?v=2vhN4Ice5jI)
+
+-   ### Disjoint Sets & Union Find
+
+    -   [UCB 61B - Disjoint Sets; Sorting & selection (video)](https://archive.org/details/ucberkeley_webcast_MAEGXTwmUsI)
+    -   [Sedgewick Algorithms - Union-Find (6 videos)](https://www.coursera.org/learn/algorithms-part1/home/week/1)
+
+-   ### Math for Fast Processing
+
+    -   [Integer Arithmetic, Karatsuba Multiplication (video)](https://www.youtube.com/watch?v=eCaXlAaN2uE&index=11&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
+    -   [The Chinese Remainder Theorem (used in cryptography) (video)](https://www.youtube.com/watch?v=ru7mWZJlRQg)
+
+-   ### Treap
+
+    -   Combination of a binary search tree and a heap
+    -   [Treap](https://en.wikipedia.org/wiki/Treap)
+    -   [Data Structures: Treaps explained (video)](https://www.youtube.com/watch?v=6podLUYinH8)
+    -   [Applications in set operations](https://www.cs.cmu.edu/~scandal/papers/treaps-spaa98.pdf)
+
+-   ### Linear Programming (videos)
+
+    -   [Linear Programming](https://www.youtube.com/watch?v=M4K6HYLHREQ)
+    -   [Finding minimum cost](https://www.youtube.com/watch?v=2ACJ9ewUC6U)
+    -   [Finding maximum value](https://www.youtube.com/watch?v=8AA_81xI3ik)
+    -   [Solve Linear Equations with Python - Simplex Algorithm](https://www.youtube.com/watch?v=44pAWI7v5Zk)
+
+-   ### Geometry, Convex hull (videos)
+
+    -   [Graph Alg. IV: Intro to geometric algorithms - Lecture 9](https://youtu.be/XIAQRlNkJAw?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=3164)
+    -   [Geometric Algorithms: Graham & Jarvis - Lecture 10](https://www.youtube.com/watch?v=J5aJEcOr6Eo&index=10&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
+    -   [Divide & Conquer: Convex Hull, Median Finding](https://www.youtube.com/watch?v=EzeYI7p9MjU&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=2)
+
+-   ### Discrete math
+
+    -   [Computer Science 70, 001 - Spring 2015 - Discrete Mathematics and Probability Theory](http://www.infocobuild.com/education/audio-video-courses/computer-science/cs70-spring2015-berkeley.html)
+    -   [Discrete Mathematics by Shai Simonson (19 videos)](https://www.youtube.com/playlist?list=PLWX710qNZo_sNlSWRMVIh6kfTjolNaZ8t)
+    -   [Discrete Mathematics By IIT Ropar NPTEL](https://nptel.ac.in/courses/106/106/106106183/)
+
+-   ### Machine Learning
+    -   Why ML?
+        -   [How Google Is Remaking Itself As A Machine Learning First Company](https://backchannel.com/how-google-is-remaking-itself-as-a-machine-learning-first-company-ada63defcb70)
+        -   [Large-Scale Deep Learning for Intelligent Computer Systems (video)](https://www.youtube.com/watch?v=QSaZGT4-6EY)
+        -   [Deep Learning and Understandability versus Software Engineering and Verification by Peter Norvig](https://www.youtube.com/watch?v=X769cyzBNVw)
+    -   [Google's Cloud Machine learning tools (video)](https://www.youtube.com/watch?v=Ja2hxBAwG_0)
+    -   [Google Developers' Machine Learning Recipes (Scikit Learn & Tensorflow) (video)](https://www.youtube.com/playlist?list=PLOU2XLYxmsIIuiBfYad6rFYQU_jL2ryal)
+    -   [Tensorflow (video)](https://www.youtube.com/watch?v=oZikw5k_2FM)
+    -   [Tensorflow Tutorials](https://www.tensorflow.org/versions/r0.11/tutorials/index.html)
+    -   [Practical Guide to implementing Neural Networks in Python (using Theano)](http://www.analyticsvidhya.com/blog/2016/04/neural-networks-python-theano/)
+    -   Courses:
+        -   [Great starter course: Machine Learning](https://www.coursera.org/learn/machine-learning) - [videos only](https://www.youtube.com/playlist?list=PLZ9qNFMHZ-A4rycgrgOYma6zxF4BZGGPW) - see videos 12-18 for a review of linear algebra (14 and 15 are duplicates)
+        -   [Neural Networks for Machine Learning](https://www.coursera.org/learn/neural-networks)
+        -   [Google's Deep Learning Nanodegree](https://www.udacity.com/course/deep-learning--ud730)
+        -   [Google/Kaggle Machine Learning Engineer Nanodegree](https://www.udacity.com/course/machine-learning-engineer-nanodegree-by-google--nd009)
+        -   [Self-Driving Car Engineer Nanodegree](https://www.udacity.com/drive)
+        -   [Metis Online Course ($99 for 2 months)](http://www.thisismetis.com/explore-data-science)
+    -   Resources:
+        -   Books:
+            -   [Python Machine Learning](https://www.amazon.com/Python-Machine-Learning-Sebastian-Raschka/dp/1783555130/)
+            -   [Data Science from Scratch: First Principles with Python](https://www.amazon.com/Data-Science-Scratch-Principles-Python/dp/149190142X)
+            -   [Introduction to Machine Learning with Python](https://www.amazon.com/Introduction-Machine-Learning-Python-Scientists/dp/1449369413/)
+        -   [Machine Learning for Software Engineers](https://github.com/ZuzooVn/machine-learning-for-software-engineers)
+        -   Data School: http://www.dataschool.io/
+
+---
+
+## Additional Detail on Some Subjects
+
+    I added these to reinforce some ideas already presented above, but didn't want to include them
+    above because it's just too much. It's easy to overdo it on a subject.
+    You want to get hired in this century, right?
+
+-   **SOLID**
+
+    -   [ ] [Bob Martin SOLID Principles of Object Oriented and Agile Design (video)](https://www.youtube.com/watch?v=TMuno5RZNeE)
+    -   [ ] S - [Single Responsibility Principle](http://www.oodesign.com/single-responsibility-principle.html) | [Single responsibility to each Object](http://www.javacodegeeks.com/2011/11/solid-single-responsibility-principle.html)
+        -   [more flavor](https://docs.google.com/open?id=0ByOwmqah_nuGNHEtcU5OekdDMkk)
+    -   [ ] O - [Open/Closed Principle](http://www.oodesign.com/open-close-principle.html) | [On production level Objects are ready for extension but not for modification](https://en.wikipedia.org/wiki/Open/closed_principle)
+        -   [more flavor](http://docs.google.com/a/cleancoder.com/viewer?a=v&pid=explorer&chrome=true&srcid=0BwhCYaYDn8EgN2M5MTkwM2EtNWFkZC00ZTI3LWFjZTUtNTFhZGZiYmUzODc1&hl=en)
+    -   [ ] L - [Liskov Substitution Principle](http://www.oodesign.com/liskov-s-substitution-principle.html) | [Base Class and Derived class follow ‘IS A’ Principle](http://stackoverflow.com/questions/56860/what-is-the-liskov-substitution-principle)
+        -   [more flavor](http://docs.google.com/a/cleancoder.com/viewer?a=v&pid=explorer&chrome=true&srcid=0BwhCYaYDn8EgNzAzZjA5ZmItNjU3NS00MzQ5LTkwYjMtMDJhNDU5ZTM0MTlh&hl=en)
+    -   [ ] I - [Interface segregation principle](http://www.oodesign.com/interface-segregation-principle.html) | clients should not be forced to implement interfaces they don't use
+        -   [Interface Segregation Principle in 5 minutes (video)](https://www.youtube.com/watch?v=3CtAfl7aXAQ)
+        -   [more flavor](http://docs.google.com/a/cleancoder.com/viewer?a=v&pid=explorer&chrome=true&srcid=0BwhCYaYDn8EgOTViYjJhYzMtMzYxMC00MzFjLWJjMzYtOGJiMDc5N2JkYmJi&hl=en)
+    -   [ ] D -[Dependency Inversion principle](http://www.oodesign.com/dependency-inversion-principle.html) | Reduce the dependency In composition of objects.
+        -   [Why Is The Dependency Inversion Principle And Why Is It Important](http://stackoverflow.com/questions/62539/what-is-the-dependency-inversion-principle-and-why-is-it-important)
+        -   [more flavor](http://docs.google.com/a/cleancoder.com/viewer?a=v&pid=explorer&chrome=true&srcid=0BwhCYaYDn8EgMjdlMWIzNGUtZTQ0NC00ZjQ5LTkwYzQtZjRhMDRlNTQ3ZGMz&hl=en)
+
+-   **Union-Find**
+
+    -   [Overview](https://www.coursera.org/learn/data-structures/lecture/JssSY/overview)
+    -   [Naive Implementation](https://www.coursera.org/learn/data-structures/lecture/EM5D0/naive-implementations)
+    -   [Trees](https://www.coursera.org/learn/data-structures/lecture/Mxu0w/trees)
+    -   [Union By Rank](https://www.coursera.org/learn/data-structures/lecture/qb4c2/union-by-rank)
+    -   [Path Compression](https://www.coursera.org/learn/data-structures/lecture/Q9CVI/path-compression)
+    -   [Analysis Options](https://www.coursera.org/learn/data-structures/lecture/GQQLN/analysis-optional)
+
+-   **More Dynamic Programming** (videos)
+
+    -   [6.006: Dynamic Programming I: Fibonacci, Shortest Paths](https://www.youtube.com/watch?v=OQ5jsbhAv_M&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=19)
+    -   [6.006: Dynamic Programming II: Text Justification, Blackjack](https://www.youtube.com/watch?v=ENyox7kNKeY&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=20)
+    -   [6.006: DP III: Parenthesization, Edit Distance, Knapsack](https://www.youtube.com/watch?v=ocZMDMZwhCY&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=21)
+    -   [6.006: DP IV: Guitar Fingering, Tetris, Super Mario Bros.](https://www.youtube.com/watch?v=tp4_UXaVyx8&index=22&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
+    -   [6.046: Dynamic Programming & Advanced DP](https://www.youtube.com/watch?v=Tw1k46ywN6E&index=14&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
+    -   [6.046: Dynamic Programming: All-Pairs Shortest Paths](https://www.youtube.com/watch?v=NzgFUwOaoIw&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=15)
+    -   [6.046: Dynamic Programming (student recitation)](https://www.youtube.com/watch?v=krZI60lKPek&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=12)
+
+-   **Advanced Graph Processing** (videos)
+
+    -   [Synchronous Distributed Algorithms: Symmetry-Breaking. Shortest-Paths Spanning Trees](https://www.youtube.com/watch?v=mUBmcbbJNf4&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=27)
+    -   [Asynchronous Distributed Algorithms: Shortest-Paths Spanning Trees](https://www.youtube.com/watch?v=kQ-UQAzcnzA&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=28)
+
+-   MIT **Probability** (mathy, and go slowly, which is good for mathy things) (videos):
+
+    -   [MIT 6.042J - Probability Introduction](https://www.youtube.com/watch?v=SmFwFdESMHI&index=18&list=PLB7540DEDD482705B)
+    -   [MIT 6.042J - Conditional Probability](https://www.youtube.com/watch?v=E6FbvM-FGZ8&index=19&list=PLB7540DEDD482705B)
+    -   [MIT 6.042J - Independence](https://www.youtube.com/watch?v=l1BCv3qqW4A&index=20&list=PLB7540DEDD482705B)
+    -   [MIT 6.042J - Random Variables](https://www.youtube.com/watch?v=MOfhhFaQdjw&list=PLB7540DEDD482705B&index=21)
+    -   [MIT 6.042J - Expectation I](https://www.youtube.com/watch?v=gGlMSe7uEkA&index=22&list=PLB7540DEDD482705B)
+    -   [MIT 6.042J - Expectation II](https://www.youtube.com/watch?v=oI9fMUqgfxY&index=23&list=PLB7540DEDD482705B)
+    -   [MIT 6.042J - Large Deviations](https://www.youtube.com/watch?v=q4mwO2qS2z4&index=24&list=PLB7540DEDD482705B)
+    -   [MIT 6.042J - Random Walks](https://www.youtube.com/watch?v=56iFMY8QW2k&list=PLB7540DEDD482705B&index=25)
+
+-   [Simonson: Approximation Algorithms (video)](https://www.youtube.com/watch?v=oDniZCmNmNw&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=19)
+
+-   **String Matching**
+
+    -   Rabin-Karp (videos):
+        -   [Rabin Karps Algorithm](https://www.coursera.org/learn/data-structures/lecture/c0Qkw/rabin-karps-algorithm)
+        -   [Precomputing](https://www.coursera.org/learn/data-structures/lecture/nYrc8/optimization-precomputation)
+        -   [Optimization: Implementation and Analysis](https://www.coursera.org/learn/data-structures/lecture/h4ZLc/optimization-implementation-and-analysis)
+        -   [Table Doubling, Karp-Rabin](https://www.youtube.com/watch?v=BRO7mVIFt08&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=9)
+        -   [Rolling Hashes, Amortized Analysis](https://www.youtube.com/watch?v=w6nuXg0BISo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=32)
+    -   Knuth-Morris-Pratt (KMP):
+        -   [TThe Knuth-Morris-Pratt (KMP) String Matching Algorithm](https://www.youtube.com/watch?v=5i7oKodCRJo)
+    -   Boyer–Moore string search algorithm
+        -   [Boyer-Moore String Search Algorithm](https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm)
+        -   [Advanced String Searching Boyer-Moore-Horspool Algorithms (video)](https://www.youtube.com/watch?v=QDZpzctPf10)
+    -   [Coursera: Algorithms on Strings](https://www.coursera.org/learn/algorithms-on-strings/home/week/1)
+        -   starts off great, but by the time it gets past KMP it gets more complicated than it needs to be
+        -   nice explanation of tries
+        -   can be skipped
+
+-   **Sorting**
+
+    -   Stanford lectures on sorting:
+        -   [Lecture 15 | Programming Abstractions (video)](https://www.youtube.com/watch?v=ENp00xylP7c&index=15&list=PLFE6E58F856038C69)
+        -   [Lecture 16 | Programming Abstractions (video)](https://www.youtube.com/watch?v=y4M9IVgrVKo&index=16&list=PLFE6E58F856038C69)
+    -   Shai Simonson, [Aduni.org](http://www.aduni.org/):
+        -   [Algorithms - Sorting - Lecture 2 (video)](https://www.youtube.com/watch?v=odNJmw5TOEE&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=2)
+        -   [Algorithms - Sorting II - Lecture 3 (video)](https://www.youtube.com/watch?v=hj8YKFTFKEE&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=3)
+    -   Steven Skiena lectures on sorting:
+        -   [lecture begins at 26:46 (video)](https://youtu.be/ute-pmMkyuk?list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&t=1600)
+        -   [lecture begins at 27:40 (video)](https://www.youtube.com/watch?v=yLvp-pB8mak&index=8&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b)
+        -   [lecture begins at 35:00 (video)](https://www.youtube.com/watch?v=q7K9otnzlfE&index=9&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b)
+        -   [lecture begins at 23:50 (video)](https://www.youtube.com/watch?v=TvqIGu9Iupw&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=10)
+
+## Video Series
+
+Sit back and enjoy.
+
+-   [List of individual Dynamic Programming problems (each is short)](https://www.youtube.com/playlist?list=PLrmLmBdmIlpsHaNTPP_jHHDx_os9ItYXr)
+
+-   [x86 Architecture, Assembly, Applications (11 videos)](https://www.youtube.com/playlist?list=PL038BE01D3BAEFDB0)
+
+-   [MIT 18.06 Linear Algebra, Spring 2005 (35 videos)](https://www.youtube.com/playlist?list=PLE7DDD91010BC51F8)
+
+-   [Excellent - MIT Calculus Revisited: Single Variable Calculus](https://www.youtube.com/playlist?list=PL3B08AE665AB9002A)
+
+-   CSE373 - Analysis of Algorithms (25 videos)
+
+    -   [Skiena lectures from Algorithm Design Manual](https://www.youtube.com/watch?v=ZFjhkohHdAA&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=1)
+
+-   [UC Berkeley 61B (Spring 2014): Data Structures (25 videos)](https://archive.org/details/ucberkeley-webcast-PL-XXv-cvA_iAlnI-BQr9hjqADPBtujFJd)
+
+-   [UC Berkeley 61B (Fall 2006): Data Structures (39 videos)](https://archive.org/details/ucberkeley-webcast-PL4BBB74C7D2A1049C)
+
+-   [UC Berkeley 61C: Machine Structures (26 videos)](https://archive.org/details/ucberkeley-webcast-PL-XXv-cvA_iCl2-D-FS5mk0jFF6cYSJs_)
+
+-   [OOSE: Software Dev Using UML and Java (21 videos)](https://www.youtube.com/playlist?list=PLJ9pm_Rc9HesnkwKlal_buSIHA-jTZMpO)
+
+-   ~~[UC Berkeley CS 152: Computer Architecture and Engineering (20 videos)](https://www.youtube.com/watch?v=UH0QYvtP7Rk&index=20&list=PLkFD6_40KJIwEiwQx1dACXwh-2Fuo32qr)~~
+
+-   [MIT 6.004: Computation Structures (49 videos)](https://www.youtube.com/playlist?list=PLDSlqjcPpoL64CJdF0Qee5oWqGS6we_Yu)
+
+-   [Carnegie Mellon - Computer Architecture Lectures (39 videos)](https://www.youtube.com/playlist?list=PL5PHm2jkkXmi5CxxI7b3JCL1TWybTDtKq)
+
+-   [MIT 6.006: Intro to Algorithms (47 videos)](https://www.youtube.com/watch?v=HtSuA80QTyo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&nohtml5=False)
+
+-   [MIT 6.033: Computer System Engineering (22 videos)](https://www.youtube.com/watch?v=zm2VP0kHl1M&list=PL6535748F59DCA484)
+
+-   [MIT 6.034 Artificial Intelligence, Fall 2010 (30 videos)](https://www.youtube.com/playlist?list=PLUl4u3cNGP63gFHB6xb-kVBiQHYe_4hSi)
+
+-   [MIT 6.042J: Mathematics for Computer Science, Fall 2010 (25 videos)](https://www.youtube.com/watch?v=L3LMbpZIKhQ&list=PLB7540DEDD482705B)
+
+-   [MIT 6.046: Design and Analysis of Algorithms (34 videos)](https://www.youtube.com/watch?v=2P-yW7LQr08&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
+
+-   [MIT 6.050J: Information and Entropy, Spring 2008 (19 videos)](https://www.youtube.com/watch?v=phxsQrZQupo&list=PL_2Bwul6T-A7OldmhGODImZL8KEVE38X7)
+
+-   [MIT 6.824: Distributed Systems, Spring 2020 (20 videos)](https://www.youtube.com/watch?v=cQP8WApzIQQ&list=PLrw6a1wE39_tb2fErI4-WkMbsvGQk9_UB)
+
+-   [MIT 6.851: Advanced Data Structures (22 videos)](https://www.youtube.com/watch?v=T0yzrZL1py0&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf&index=1)
+
+-   [MIT 6.854: Advanced Algorithms, Spring 2016 (24 videos)](https://www.youtube.com/playlist?list=PL6ogFv-ieghdoGKGg2Bik3Gl1glBTEu8c)
+
+-   [Harvard COMPSCI 224: Advanced Algorithms (25 videos)](https://www.youtube.com/playlist?list=PL2SOU6wwxB0uP4rJgf5ayhHWgw7akUWSf)
+
+-   [MIT 6.858 Computer Systems Security, Fall 2014](https://www.youtube.com/watch?v=GqmQg-cszw4&index=1&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
+
+-   [Stanford: Programming Paradigms (27 videos)](https://www.youtube.com/playlist?list=PL9D558D49CA734A02)
+
+-   [Introduction to Cryptography by Christof Paar](https://www.youtube.com/playlist?list=PL6N5qY2nvvJE8X75VkXglSrVhLv1tVcfy)
+
+    -   [Course Website along with Slides and Problem Sets](http://www.crypto-textbook.com/)
+
+-   [Mining Massive Datasets - Stanford University (94 videos)](https://www.youtube.com/playlist?list=PLLssT5z_DsK9JDLcT8T62VtzwyW9LNepV)
+
+-   [Graph Theory by Sarada Herke (67 videos)](https://www.youtube.com/user/DrSaradaHerke/playlists?shelf_id=5&view=50&sort=dd)
+
+## Computer Science Courses
+
+-   [Directory of Online CS Courses](https://github.com/open-source-society/computer-science)
+-   [Directory of CS Courses (many with online lectures)](https://github.com/prakhar1989/awesome-courses)
+
+## Algorithms implementation
+
+-   [Multiple Algorithms implementation by Princeton University](https://algs4.cs.princeton.edu/code)
+
+## Papers
+
+-   [Love classic papers?](https://www.cs.cmu.edu/~crary/819-f09/)
+-   [1978: Communicating Sequential Processes](http://spinroot.com/courses/summer/Papers/hoare_1978.pdf)
+    -   [implemented in Go](https://godoc.org/github.com/thomas11/csp)
+-   [2003: The Google File System](http://static.googleusercontent.com/media/research.google.com/en//archive/gfs-sosp2003.pdf)
+    -   replaced by Colossus in 2012
+-   [2004: MapReduce: Simplified Data Processing on Large Clusters](http://static.googleusercontent.com/media/research.google.com/en//archive/mapreduce-osdi04.pdf)
+    -   mostly replaced by Cloud Dataflow?
+-   [2006: Bigtable: A Distributed Storage System for Structured Data](https://static.googleusercontent.com/media/research.google.com/en//archive/bigtable-osdi06.pdf)
+-   [2006: The Chubby Lock Service for Loosely-Coupled Distributed Systems](https://research.google.com/archive/chubby-osdi06.pdf)
+-   [2007: Dynamo: Amazon’s Highly Available Key-value Store](http://s3.amazonaws.com/AllThingsDistributed/sosp/amazon-dynamo-sosp2007.pdf)
+    -   The Dynamo paper kicked off the NoSQL revolution
+-   [2007: What Every Programmer Should Know About Memory (very long, and the author encourages skipping of some sections)](https://www.akkadia.org/drepper/cpumemory.pdf)
+-   2012: AddressSanitizer: A Fast Address Sanity Checker:
+    -   [paper](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/37752.pdf)
+    -   [video](https://www.usenix.org/conference/atc12/technical-sessions/presentation/serebryany)
+-   2013: Spanner: Google’s Globally-Distributed Database:
+    -   [paper](http://static.googleusercontent.com/media/research.google.com/en//archive/spanner-osdi2012.pdf)
+    -   [video](https://www.usenix.org/node/170855)
+-   [2014: Machine Learning: The High-Interest Credit Card of Technical Debt](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43146.pdf)
+-   [2015: Continuous Pipelines at Google](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43790.pdf)
+-   [2015: High-Availability at Massive Scale: Building Google’s Data Infrastructure for Ads](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44686.pdf)
+-   [2015: TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems](http://download.tensorflow.org/paper/whitepaper2015.pdf)
+-   [2015: How Developers Search for Code: A Case Study](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43835.pdf)
+-   More papers: [1,000 papers](https://github.com/0voice/computer_expert_paper)
+
+## LICENSE
+
+[CC-BY-SA-4.0](./LICENSE.txt)