From bd0a82c3c8375c0d2d893148c3a17216250bce45 Mon Sep 17 00:00:00 2001 From: Vortana Say Date: Tue, 3 Nov 2020 06:02:41 -0600 Subject: [PATCH] Update README-kh.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Translated ពត៌មានលំអិតបន្ថែមលើមុខវិជ្ជាមួយចំនួន --- translations/README-kh.md | 1074 +++++++++++++++++++++++++++++++++++++ 1 file changed, 1074 insertions(+) diff --git a/translations/README-kh.md b/translations/README-kh.md index dcbee57472..f5146000d6 100644 --- a/translations/README-kh.md +++ b/translations/README-kh.md @@ -928,3 +928,1077 @@ Graphs អាចត្រូវបានប្រើដើម្បីបង្ - [ ] [DP vs. recursive implementation (វីដេអូ)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/M999a/dp-vs-recursive-implementation) - [ ] [Global pairwise sequence alignment (វីដេអូ)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/UZ7o6/global-pairwise-sequence-alignment) - [ ] [Local pairwise sequence alignment (វីដេអូ)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/WnNau/local-pairwise-sequence-alignment) + +- ### Object-Oriented Programming + - [ ] [Optional: UML 2.0 Series (វីដេអូ)](https://www.youtube.com/watch?v=OkC7HKtiZC0&list=PLGLfVvz_LVvQ5G-LdJ8RLqe-ndo7QITYc) + - [ ] គោលការណ៍ SOLID OOP: [គោលការណ៍ SOLID (វីដេអូ)](https://www.youtube.com/playlist?list=PL4CE9F710017EA77A) + +- ### Design patterns + - [ ] [ការពិនិត្យ Quick UML (វីដេអូ)](https://www.youtube.com/watch?v=3cmzqZzwNDM&list=PLGLfVvz_LVvQ5G-LdJ8RLqe-ndo7QITYc&index=3) + - [ ] រៀនគំរូទាំងនេះ: + - [ ] strategy + - [ ] singleton + - [ ] adapter + - [ ] prototype + - [ ] decorator + - [ ] visitor + - [ ] factory, abstract factory + - [ ] facade + - [ ] observer + - [ ] proxy + - [ ] delegate + - [ ] command + - [ ] state + - [ ] memento + - [ ] iterator + - [ ] composite + - [ ] flyweight + - [ ] [ជំពូកទី ៦ (ភាគ ១) - Patterns (វីដេអូ)](https://youtu.be/LAP2A80Ajrg?list=PLJ9pm_Rc9HesnkwKlal_buSIHA-jTZMpO&t=3344) + - [ ] [ជំពូកទី ៦ (ភាគ ២) - Abstraction-Occurrence, General Hierarchy, Player-Role, Singleton, Observer, Delegation (វីដេអូ)](https://www.youtube.com/watch?v=U8-PGsjvZc4&index=12&list=PLJ9pm_Rc9HesnkwKlal_buSIHA-jTZMpO) + - [ ] [ជំពូកទី ៦ (ភាគ ៣) - Adapter, Facade, Immutable, Read-Only Interface, Proxy (video)](https://www.youtube.com/watch?v=7sduBHuex4c&index=13&list=PLJ9pm_Rc9HesnkwKlal_buSIHA-jTZMpO) + - [ ] [ស៊េរីវីដេអូ (២៧ វីដេអូ)](https://www.youtube.com/playlist?list=PLF206E906175C7E07) + - [ ] [Head First Design Patterns](https://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124) + - ខ្ញុំដឹងថាសៀវភៅបទបញ្ញត្តិគឺ“ លំនាំរចនា៖ ធាតុផ្សំនៃកម្មវិធីដែលអាចប្រើឡើងវិញបាន” ប៉ុន្តែក្បាលទីមួយគឺល្អសម្រាប់អ្នកចាប់ផ្តើមដំបូង Object-Oriented ។ + - [ ] [Handy reference: 101 Design Patterns & Tips for Developers](https://sourcemaking.com/design-patterns-and-tips) + - [ ] [Design patterns សម្រាប់មនុស្ស](https://github.com/kamranahmedse/design-patterns-for-humans#structural-design-patterns) + +- ### Combinatorics (n choose k) & Probability + - [ ] [ជំនាញគណិតវិទ្យា៖ វិធីស្វែងរក Factorial, Permutation និង Combination (ជ្រើសរើស) (វីដេអូ)](https://www.youtube.com/watch?v=8RRo6Ti9d0U) + - [ ] [Make School: Probability (វីដេអូ)](https://www.youtube.com/watch?v=sZkAAk9Wwa4) + - [ ] [Make School: បន្ថែមលេី Probability និង Markov Chains (វីដេអូ)](https://www.youtube.com/watch?v=dNaJg-mLobQ) + - [ ] Khan Academy: + - ប្លង់វគ្គសិក្សា: + - [ ] [ទ្រឹស្តីប្រូបាបដំបូង](https://www.khanacademy.org/math/probability/probability-and-combinatorics-topic) + - គ្រាន់តែវីដេអូ - ៤១ (វីដេអូនីមួយៗមានលក្ខណៈសាមញ្ញហើយវីដេអូនីមួយៗខ្លី)៖ + - [ ] [ពន្យល់អំពីប្រូបាប (វីដេអូ)](https://www.youtube.com/watch?v=uzkc-qNVoOk&list=PLC58778F28211FA19) + +- ### NP, NP-Complete and Approximation Algorithms + - Know about the most famous classes of NP-complete problems, such as traveling salesman and the knapsack problem, + and be able to recognize them when an interviewer asks you them in disguise. + - Know what NP-complete means. + - [ ] [Computational Complexity (video)](https://www.youtube.com/watch?v=moPtwq_cVH8&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=23) + - [ ] Simonson: + - [ ] [Greedy Algs. II & Intro to NP Completeness (video)](https://youtu.be/qcGnJ47Smlo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=2939) + - [ ] [NP Completeness II & Reductions (video)](https://www.youtube.com/watch?v=e0tGC6ZQdQE&index=16&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm) + - [ ] [NP Completeness III (Video)](https://www.youtube.com/watch?v=fCX1BGT3wjE&index=17&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm) + - [ ] [NP Completeness IV (video)](https://www.youtube.com/watch?v=NKLDp3Rch3M&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=18) + - [ ] Skiena: + - [ ] [CSE373 2012 - Lecture 23 - Introduction to NP-Completeness (video)](https://youtu.be/KiK5TVgXbFg?list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&t=1508) + - [ ] [CSE373 2012 - Lecture 24 - NP-Completeness Proofs (video)](https://www.youtube.com/watch?v=27Al52X3hd4&index=24&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b) + - [ ] [CSE373 2012 - Lecture 25 - NP-Completeness Challenge (video)](https://www.youtube.com/watch?v=xCPH4gwIIXM&index=25&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b) + - [ ] [Complexity: P, NP, NP-completeness, Reductions (video)](https://www.youtube.com/watch?v=eHZifpgyH_4&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=22) + - [ ] [Complexity: Approximation Algorithms (video)](https://www.youtube.com/watch?v=MEz1J9wY2iM&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=24) + - [ ] [Complexity: Fixed-Parameter Algorithms (video)](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp) + - Peter Norvig discusses near-optimal solutions to traveling salesman problem: + - [Jupyter Notebook](http://nbviewer.jupyter.org/url/norvig.com/ipython/TSP.ipynb) + - Pages 1048 - 1140 in CLRS if you have it. + +- ### Caches + - [ ] LRU cache: + - [ ] [The Magic of LRU Cache (100 Days of Google Dev) (video)](https://www.youtube.com/watch?v=R5ON3iwx78M) + - [ ] [Implementing LRU (video)](https://www.youtube.com/watch?v=bq6N7Ym81iI) + - [ ] [LeetCode - 146 LRU Cache (C++) (video)](https://www.youtube.com/watch?v=8-FZRAjR7qU) + - [ ] CPU cache: + - [ ] [MIT 6.004 L15: The Memory Hierarchy (video)](https://www.youtube.com/watch?v=vjYF_fAZI5E&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-&index=24) + - [ ] [MIT 6.004 L16: Cache Issues (video)](https://www.youtube.com/watch?v=ajgC3-pyGlk&index=25&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-) + +- ### Processes and Threads + - [ ] Computer Science 162 - Operating Systems (25 videos): + - for processes and threads see videos 1-11 + - [Operating Systems and System Programming (video)](https://archive.org/details/ucberkeley-webcast-PL-XXv-cvA_iBDyz-ba4yDskqMDY6A1w_c) + - [What Is The Difference Between A Process And A Thread?](https://www.quora.com/What-is-the-difference-between-a-process-and-a-thread) + - Covers: + - Processes, Threads, Concurrency issues + - Difference between processes and threads + - Processes + - Threads + - Locks + - Mutexes + - Semaphores + - Monitors + - How they work? + - Deadlock + - Livelock + - CPU activity, interrupts, context switching + - Modern concurrency constructs with multicore processors + - [Paging, segmentation and virtual memory (video)](https://www.youtube.com/watch?v=LKe7xK0bF7o&list=PLCiOXwirraUCBE9i_ukL8_Kfg6XNv7Se8&index=2) + - [Interrupts (video)](https://www.youtube.com/watch?v=uFKi2-J-6II&list=PLCiOXwirraUCBE9i_ukL8_Kfg6XNv7Se8&index=3) + - Process resource needs (memory: code, static storage, stack, heap, and also file descriptors, i/o) + - Thread resource needs (shares above (minus stack) with other threads in the same process but each has its own pc, stack counter, registers, and stack) + - Forking is really copy on write (read-only) until the new process writes to memory, then it does a full copy. + - Context switching + - How context switching is initiated by the operating system and underlying hardware? + - [ ] [threads in C++ (series - 10 videos)](https://www.youtube.com/playlist?list=PL5jc9xFGsL8E12so1wlMS0r0hTQoJL74M) + - [ ] concurrency in Python (videos): + - [ ] [Short series on threads](https://www.youtube.com/playlist?list=PL1H1sBF1VAKVMONJWJkmUh6_p8g4F2oy1) + - [ ] [Python Threads](https://www.youtube.com/watch?v=Bs7vPNbB9JM) + - [ ] [Understanding the Python GIL (2010)](https://www.youtube.com/watch?v=Obt-vMVdM8s) + - [reference](http://www.dabeaz.com/GIL) + - [ ] [David Beazley - Python Concurrency From the Ground Up: LIVE! - PyCon 2015](https://www.youtube.com/watch?v=MCs5OvhV9S4) + - [ ] [Keynote David Beazley - Topics of Interest (Python Asyncio)](https://www.youtube.com/watch?v=ZzfHjytDceU) + - [ ] [Mutex in Python](https://www.youtube.com/watch?v=0zaPs8OtyKY) + +- ### Testing + - To cover: + - how unit testing works + - what are mock objects + - what is integration testing + - what is dependency injection + - [ ] [Agile Software Testing with James Bach (video)](https://www.youtube.com/watch?v=SAhJf36_u5U) + - [ ] [Open Lecture by James Bach on Software Testing (video)](https://www.youtube.com/watch?v=ILkT_HV9DVU) + - [ ] [Steve Freeman - Test-Driven Development (that’s not what we meant) (video)](https://vimeo.com/83960706) + - [slides](http://gotocon.com/dl/goto-berlin-2013/slides/SteveFreeman_TestDrivenDevelopmentThatsNotWhatWeMeant.pdf) + - [ ] Dependency injection: + - [ ] [video](https://www.youtube.com/watch?v=IKD2-MAkXyQ) + - [ ] [Tao Of Testing](http://jasonpolites.github.io/tao-of-testing/ch3-1.1.html) + - [ ] [How to write tests](http://jasonpolites.github.io/tao-of-testing/ch4-1.1.html) + +- ### Scheduling + - In an OS, how it works? + - Can be gleaned from Operating System videos + +- ### String searching & manipulations + - [ ] [Sedgewick - Suffix Arrays (video)](https://www.coursera.org/learn/algorithms-part2/lecture/TH18W/suffix-arrays) + - [ ] [Sedgewick - Substring Search (videos)](https://www.coursera.org/learn/algorithms-part2/home/week/4) + - [ ] [1. Introduction to Substring Search](https://www.coursera.org/learn/algorithms-part2/lecture/n3ZpG/introduction-to-substring-search) + - [ ] [2. Brute-Force Substring Search](https://www.coursera.org/learn/algorithms-part2/lecture/2Kn5i/brute-force-substring-search) + - [ ] [3. Knuth-Morris Pratt](https://www.coursera.org/learn/algorithms-part2/lecture/TAtDr/knuth-morris-pratt) + - [ ] [4. Boyer-Moore](https://www.coursera.org/learn/algorithms-part2/lecture/CYxOT/boyer-moore) + - [ ] [5. Rabin-Karp](https://www.coursera.org/learn/algorithms-part2/lecture/3KiqT/rabin-karp) + - [ ] [Search pattern in text (video)](https://www.coursera.org/learn/data-structures/lecture/tAfHI/search-pattern-in-text) + + If you need more detail on this subject, see "String Matching" section in [Additional Detail on Some Subjects](#additional-detail-on-some-subjects). + +- ### Tries + - Note there are different kinds of tries. Some have prefixes, some don't, and some use string instead of bits + to track the path + - I read through code, but will not implement + - [ ] [Sedgewick - Tries (3 videos)](https://www.coursera.org/learn/algorithms-part2/home/week/4) + - [ ] [1. R Way Tries](https://www.coursera.org/learn/algorithms-part2/lecture/CPVdr/r-way-tries) + - [ ] [2. Ternary Search Tries](https://www.coursera.org/learn/algorithms-part2/lecture/yQM8K/ternary-search-tries) + - [ ] [3. Character Based Operations](https://www.coursera.org/learn/algorithms-part2/lecture/jwNmV/character-based-operations) + - [ ] [Notes on Data Structures and Programming Techniques](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Tries) + - [ ] Short course videos: + - [ ] [Introduction To Tries (video)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/08Xyf/core-introduction-to-tries) + - [ ] [Performance Of Tries (video)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/PvlZW/core-performance-of-tries) + - [ ] [Implementing A Trie (video)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/DFvd3/core-implementing-a-trie) + - [ ] [The Trie: A Neglected Data Structure](https://www.toptal.com/java/the-trie-a-neglected-data-structure) + - [ ] [TopCoder - Using Tries](https://www.topcoder.com/community/competitive-programming/tutorials/using-tries/) + - [ ] [Stanford Lecture (real world use case) (video)](https://www.youtube.com/watch?v=TJ8SkcUSdbU) + - [ ] [MIT, Advanced Data Structures, Strings (can get pretty obscure about halfway through) (video)](https://www.youtube.com/watch?v=NinWEPPrkDQ&index=16&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf) + +- ### Floating Point Numbers + - [ ] simple 8-bit: [Representation of Floating Point Numbers - 1 (video - there is an error in calculations - see video description)](https://www.youtube.com/watch?v=ji3SfClm8TU) + - [ ] 32 bit: [IEEE754 32-bit floating point binary (video)](https://www.youtube.com/watch?v=50ZYcZebIec) + +- ### Unicode + - [ ] [The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets]( http://www.joelonsoftware.com/articles/Unicode.html) + - [ ] [What Every Programmer Absolutely, Positively Needs To Know About Encodings And Character Sets To Work With Text](http://kunststube.net/encoding/) + +- ### Endianness + - [ ] [Big And Little Endian](https://web.archive.org/web/20180107141940/http://www.cs.umd.edu:80/class/sum2003/cmsc311/Notes/Data/endian.html) + - [ ] [Big Endian Vs Little Endian (video)](https://www.youtube.com/watch?v=JrNF0KRAlyo) + - [ ] [Big And Little Endian Inside/Out (video)](https://www.youtube.com/watch?v=oBSuXP-1Tc0) + - Very technical talk for kernel devs. Don't worry if most is over your head. + - The first half is enough. + +- ### Networking + - **if you have networking experience or want to be a reliability engineer or operations engineer, expect questions** + - Otherwise, this is just good to know + - [ ] [Khan Academy](https://www.khanacademy.org/computing/computer-science/computers-and-internet-code-org) + - [ ] [UDP and TCP: Comparison of Transport Protocols (video)](https://www.youtube.com/watch?v=Vdc8TCESIg8) + - [ ] [TCP/IP and the OSI Model Explained! (video)](https://www.youtube.com/watch?v=e5DEVa9eSN0) + - [ ] [Packet Transmission across the Internet. Networking & TCP/IP tutorial. (video)](https://www.youtube.com/watch?v=nomyRJehhnM) + - [ ] [HTTP (video)](https://www.youtube.com/watch?v=WGJrLqtX7As) + - [ ] [SSL and HTTPS (video)](https://www.youtube.com/watch?v=S2iBR2ZlZf0) + - [ ] [SSL/TLS (video)](https://www.youtube.com/watch?v=Rp3iZUvXWlM) + - [ ] [HTTP 2.0 (video)](https://www.youtube.com/watch?v=E9FxNzv1Tr8) + - [ ] [Video Series (21 videos) (video)](https://www.youtube.com/playlist?list=PLEbnTDJUr_IegfoqO4iPnPYQui46QqT0j) + - [ ] [Subnetting Demystified - Part 5 CIDR Notation (video)](https://www.youtube.com/watch?v=t5xYI0jzOf4) + - [ ] Sockets: + - [ ] [Java - Sockets - Introduction (video)](https://www.youtube.com/watch?v=6G_W54zuadg&t=6s) + - [ ] [Socket Programming (video)](https://www.youtube.com/watch?v=G75vN2mnJeQ) + +## 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 Inverview?](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/) +- [ ] [Algorithm design](http://www.hiredintech.com/algorithm-design/) +- [ ] [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/) +- [ ] 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) + - [ ] [Pragmatic Programming Techniques](http://horicky.blogspot.com/2010/10/scalable-system-design-patterns.html) + - [extra: Google Pregel Graph Processing](http://horicky.blogspot.com/2010/07/google-pregel-graph-processing.html) + - [ ] [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) + - [ ] [Scale at Facebook (2012), "Building for a Billion Users" (video)](https://www.youtube.com/watch?v=oodS71YtkGU) + - [ ] [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/) + - [ ] [Asyncio Tarantool Queue, Get In The Queue](http://highscalability.com/blog/2016/3/3/asyncio-tarantool-queue-get-in-the-queue.html) + - [ ] [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) + - [ ] [Spanner](http://highscalability.com/blog/2012/9/24/google-spanners-most-surprising-revelation-nosql-is-out-and.html) + - [ ] [Machine Learning Driven Programming: A New Programming For A New World](http://highscalability.com/blog/2016/7/6/machine-learning-driven-programming-a-new-programming-for-a.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) + - [ ] [How Does The Use Of Docker Effect Latency?](http://highscalability.com/blog/2015/12/16/how-does-the-use-of-docker-effect-latency.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) + - [ ] [Serverless (very long, just need the gist)](http://martinfowler.com/articles/serverless.html) + - [ ] [What Powers Instagram: Hundreds of Instances, Dozens of Technologies](http://instagram-engineering.tumblr.com/post/13649370142/what-powers-instagram-hundreds-of-instances) + - [ ] [Cinchcast Architecture - Producing 1,500 Hours Of Audio Every Day](http://highscalability.com/blog/2012/7/16/cinchcast-architecture-producing-1500-hours-of-audio-every-d.html) + - [ ] [Justin.Tv's Live Video Broadcasting Architecture](http://highscalability.com/blog/2010/3/16/justintvs-live-video-broadcasting-architecture.html) + - [ ] [Playfish's Social Gaming Architecture - 50 Million Monthly Users And Growing](http://highscalability.com/blog/2010/9/21/playfishs-social-gaming-architecture-50-million-monthly-user.html) + - [ ] [TripAdvisor Architecture - 40M Visitors, 200M Dynamic Page Views, 30TB Data](http://highscalability.com/blog/2011/6/27/tripadvisor-architecture-40m-visitors-200m-dynamic-page-view.html) + - [ ] [PlentyOfFish Architecture](http://highscalability.com/plentyoffish-architecture) + - [ ] [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/master/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 CDN network: old article](https://kilthub.cmu.edu/articles/Globally_distributed_content_delivery/6605972) + - [Design a random unique ID generation system](https://blog.twitter.com/2010/announcing-snowflake) + - [Design an online multiplayer card game](http://www.indieflashblog.com/how-to-create-an-asynchronous-multiplayer-game.html) + - [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/) + +--- + +## Final Review + + This section will have shorter videos that you can watch pretty quickly to review most of the important concepts. + It's nice if you want a refresher often. + +- [ ] Series of 2-3 minutes short subject videos (23 videos) + - [Videos](https://www.youtube.com/watch?v=r4r1DZcx1cM&list=PLmVb1OknmNJuC5POdcDv5oCS7_OUkDgpj&index=22) +- [ ] Series of 2-5 minutes short subject videos - Michael Sambol (18 videos): + - [Videos](https://www.youtube.com/channel/UCzDJwLWoYCUQowF_nG3m5OQ) +- [ ] [Sedgewick Videos - Algorithms I](https://www.coursera.org/learn/algorithms-part1) +- [ ] [Sedgewick Videos - Algorithms II](https://www.coursera.org/learn/algorithms-part2) + +--- + +## Coding Question Practice + +Now that you know all the computer science topics above, it's time to practice answering coding problems. + +**Coding question practice is not about memorizing answers to programming problems.** + +Why you need to practice doing programming problems: +- Problem recognition, and where the right data structures and algorithms fit in +- Gathering requirements for the problem +- Talking your way through the problem like you will in the interview +- Coding on a whiteboard or paper, not a computer +- Coming up with time and space complexity for your solutions +- Testing your solutions + +There is a great intro for methodical, communicative problem solving in an interview. You'll get this from the programming +interview books, too, but I found this outstanding: +[Algorithm design canvas](http://www.hiredintech.com/algorithm-design/) + +No whiteboard at home? That makes sense. I'm a weirdo and have a big whiteboard. Instead of a whiteboard, pick up a +large drawing pad from an art store. You can sit on the couch and practice. This is my "sofa whiteboard". +I added the pen in the photo for scale. If you use a pen, you'll wish you could erase. Gets messy quick. I use a pencil +and eraser. + +![my sofa whiteboard](https://d3j2pkmjtin6ou.cloudfront.net/art_board_sm_2.jpg) + +Supplemental: + +- [Mathematics for Topcoders](https://www.topcoder.com/community/competitive-programming/tutorials/mathematics-for-topcoders/) +- [Dynamic Programming – From Novice to Advanced](https://www.topcoder.com/community/competitive-programming/tutorials/dynamic-programming-from-novice-to-advanced/) +- [MIT Interview Materials](https://web.archive.org/web/20160906124824/http://courses.csail.mit.edu/iap/interview/materials.php) +- [Exercises for getting better at a given language](http://exercism.io/languages) + +**Read and Do Programming Problems (in this order):** + +- [ ] [Programming Interviews Exposed: Secrets to Landing Your Next Job, 2nd Edition](http://www.wiley.com/WileyCDA/WileyTitle/productCd-047012167X.html) + - answers in C, C++ and Java +- [ ] [Cracking the Coding Interview, 6th Edition](http://www.amazon.com/Cracking-Coding-Interview-6th-Programming/dp/0984782850/) + - answers in Java + +See [Book List above](#book-list) + + +## Coding exercises/challenges + +Once you've learned your brains out, put those brains to work. +Take coding challenges every day, as many as you can. + +- [How to Find a Solution](https://www.topcoder.com/community/competitive-programming/tutorials/how-to-find-a-solution/) +- [How to Dissect a Topcoder Problem Statement](https://www.topcoder.com/community/competitive-programming/tutorials/how-to-dissect-a-topcoder-problem-statement/) + +Coding Interview Question Videos: +- [IDeserve (88 videos)](https://www.youtube.com/watch?v=NBcqBddFbZw&list=PLamzFoFxwoNjPfxzaWqs7cZGsPYy0x_gI) +- [Tushar Roy (5 playlists)](https://www.youtube.com/user/tusharroy2525/playlists?shelf_id=2&view=50&sort=dd) + - Super for walkthroughs of problem solutions +- [Nick White - LeetCode Solutions (187 Videos)](https://www.youtube.com/playlist?list=PLU_sdQYzUj2keVENTP0a5rdykRSgg9Wp-) + - Good explanations of solution and the code + - You can watch several in a short time +- [FisherCoder - LeetCode Solutions](https://youtube.com/FisherCoder) + +Challenge sites: +- [LeetCode](https://leetcode.com/) + - My favorite coding problem site. It's worth the subscription money for the 1-2 months you'll likely be preparing + - [LeetCode solutions from FisherCoder](https://github.com/fishercoder1534/Leetcode) + - See Nick White Videos above for short code-throughs +- [HackerRank](https://www.hackerrank.com/) +- [TopCoder](https://www.topcoder.com/) +- [InterviewCake](https://www.interviewcake.com/) +- [Geeks for Geeks](http://www.geeksforgeeks.org/) +- [InterviewBit](https://www.interviewbit.com/invite/icjf) +- [Project Euler (math-focused)](https://projecteuler.net/index.php?section=problems) +- [Code Exercises](https://code-exercises.com) + +Language-learning sites, with challenges: +- [Codewars](http://www.codewars.com) +- [Codility](https://codility.com/programmers/) +- [HackerEarth](https://www.hackerearth.com/) +- [Sphere Online Judge (spoj)](http://www.spoj.com/) +- [Codechef](https://www.codechef.com/) + +Challenge repos: +- [Interactive Coding Interview Challenges in Python](https://github.com/donnemartin/interactive-coding-challenges) + +Mock Interviews: +- [Gainlo.co: Mock interviewers from big companies](http://www.gainlo.co/) - I used this and it helped me relax for the phone screen and on-site interview +- [Pramp: Mock interviews from/with peers](https://www.pramp.com/) - peer-to-peer model of practice interviews +- [Refdash: Mock interviews and expedited interviews](https://refdash.com/) - also help candidates fast track by skipping multiple interviews with tech companies +- [interviewing.io: Practice mock interview with senior engineers](https://interviewing.io) - anonymous algorithmic/systems design interviews with senior engineers from FAANG anonymously. + + +## Once you're closer to the interview + +- Cracking The Coding Interview Set 2 (videos): + - [Cracking The Code Interview](https://www.youtube.com/watch?v=4NIb9l3imAo) + - [Cracking the Coding Interview - Fullstack Speaker Series](https://www.youtube.com/watch?v=Eg5-tdAwclo) + +## Your Resume + +- See Resume prep items in Cracking The Coding Interview and back of Programming Interviews Exposed + + +## Be thinking of for when the interview comes + +Think of about 20 interview questions you'll get, along with the lines of the items below. Have 2-3 answers for each. +Have a story, not just data, about something you accomplished. + +- Why do you want this job? +- What's a tough problem you've solved? +- Biggest challenges faced? +- Best/worst designs seen? +- Ideas for improving an existing product +- How do you work best, as an individual and as part of a team? +- Which of your skills or experiences would be assets in the role and why? +- What did you most enjoy at [job x / project y]? +- What was the biggest challenge you faced at [job x / project y]? +- What was the hardest bug you faced at [job x / project y]? +- What did you learn at [job x / project y]? +- What would you have done better at [job x / project y]? + +## Have questions for the interviewer + + Some of mine (I already may know answer to but want their opinion or team perspective): + +- How large is your team? +- What does your dev cycle look like? Do you do waterfall/sprints/agile? +- Are rushes to deadlines common? Or is there flexibility? +- How are decisions made in your team? +- How many meetings do you have per week? +- Do you feel your work environment helps you concentrate? +- What are you working on? +- What do you like about it? +- What is the work life like? +- How is work/life balance? + +## Once You've Got The Job + +Congratulations! + +Keep learning. + +You're never really done. + +--- + + ***************************************************************************************************** + ***************************************************************************************************** + + Everything below this point is optional. + By studying these, you'll get greater exposure to more CS concepts, and will be better prepared for + any software engineering job. You'll be a much more well-rounded software engineer. + + ***************************************************************************************************** + ***************************************************************************************************** + +--- + +## Additional Books + + These are here so you can dive into a topic you find interesting. + +- [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 +- [UNIX and Linux System Administration Handbook, 5th Edition](https://www.amazon.com/UNIX-Linux-System-Administration-Handbook/dp/0134277554/) +- [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 + - About to get to this part. Will update here once I've made my way through it + - 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 + +- [Programming Pearls](http://www.amazon.com/Programming-Pearls-2nd-Jon-Bentley/dp/0201657880) + - The first couple of chapters present clever solutions to programming problems (some very old using data tape) but + that is just an intro. This a guidebook on program design and architecture + +## Additional Learning + + I added them to help you become a well-rounded software engineer, and to be aware of certain + technologies and algorithms, so you'll have a bigger toolbox. + +- ### Compilers + - [How a Compiler Works in ~1 minute (video)](https://www.youtube.com/watch?v=IhC7sdYe-Jg) + - [Harvard CS50 - Compilers (video)](https://www.youtube.com/watch?v=CSZLNYF4Klo) + - [C++ (video)](https://www.youtube.com/watch?v=twodd1KFfGk) + - [Understanding Compiler Optimization (C++) (video)](https://www.youtube.com/watch?v=FnGCDLhaxKU) + +- ### Emacs and vi(m) + - Familiarize yourself with a unix-based code editor + - vi(m): + - [Editing With vim 01 - Installation, Setup, and The Modes (video)](https://www.youtube.com/watch?v=5givLEMcINQ&index=1&list=PL13bz4SHGmRxlZVmWQ9DvXo1fEg4UdGkr) + - [VIM Adventures](http://vim-adventures.com/) + - set of 4 videos: + - [The vi/vim editor - Lesson 1](https://www.youtube.com/watch?v=SI8TeVMX8pk) + - [The vi/vim editor - Lesson 2](https://www.youtube.com/watch?v=F3OO7ZIOaJE) + - [The vi/vim editor - Lesson 3](https://www.youtube.com/watch?v=ZYEccA_nMaI) + - [The vi/vim editor - Lesson 4](https://www.youtube.com/watch?v=1lYD5gwgZIA) + - [Using Vi Instead of Emacs](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Using_Vi_instead_of_Emacs) + - emacs: + - [Basics Emacs Tutorial (video)](https://www.youtube.com/watch?v=hbmV1bnQ-i0) + - set of 3 (videos): + - [Emacs Tutorial (Beginners) -Part 1- File commands, cut/copy/paste, cursor commands](https://www.youtube.com/watch?v=ujODL7MD04Q) + - [Emacs Tutorial (Beginners) -Part 2- Buffer management, search, M-x grep and rgrep modes](https://www.youtube.com/watch?v=XWpsRupJ4II) + - [Emacs Tutorial (Beginners) -Part 3- Expressions, Statements, ~/.emacs file and packages](https://www.youtube.com/watch?v=paSgzPso-yc) + - [Evil Mode: Or, How I Learned to Stop Worrying and Love Emacs (video)](https://www.youtube.com/watch?v=JWD1Fpdd4Pc) + - [Writing C Programs With Emacs](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Writing_C_programs_with_Emacs) + - [(maybe) Org Mode In Depth: Managing Structure (video)](https://www.youtube.com/watch?v=nsGYet02bEk) + +- ### Unix command line tools + - I filled in the list below from good 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) + - More about Markov processes: + - [Core Markov Text Generation](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/waxgx/core-markov-text-generation) + - [Core Implementing Markov Text Generation](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/gZhiC/core-implementing-markov-text-generation) + - [Project = Markov Text Generation Walk Through](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/EUjrq/project-markov-text-generation-walk-through) + - See more in MIT 6.050J Information and Entropy series below + +- ### Parity & Hamming Code (videos) + - [Intro](https://www.youtube.com/watch?v=q-3BctoUpHE) + - [Parity](https://www.youtube.com/watch?v=DdMcAUlxh1M) + - Hamming Code: + - [Error detection](https://www.youtube.com/watch?v=1A_NcXxdoCc) + - [Error correction](https://www.youtube.com/watch?v=JAMLuxdHH8o) + - [Error Checking](https://www.youtube.com/watch?v=wbH2VxzmoZk) + +- ### Entropy + - Also see videos below + - Make sure to watch information theory videos first + - [Information Theory, Claude Shannon, Entropy, Redundancy, Data Compression & Bits (video)](https://youtu.be/JnJq3Py0dyM?t=176) + +- ### Cryptography + - Also see videos below + - Make sure to watch information theory videos first + - [Khan Academy Series](https://www.khanacademy.org/computing/computer-science/cryptography) + - [Cryptography: Hash Functions](https://www.youtube.com/watch?v=KqqOXndnvic&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=30) + - [Cryptography: Encryption](https://www.youtube.com/watch?v=9TNI2wHmaeI&index=31&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp) + +- ### Compression + - Make sure to watch information theory videos first + - Computerphile (videos): + - [Compression](https://www.youtube.com/watch?v=Lto-ajuqW3w) + - [Entropy in Compression](https://www.youtube.com/watch?v=M5c_RFKVkko) + - [Upside Down Trees (Huffman Trees)](https://www.youtube.com/watch?v=umTbivyJoiI) + - [EXTRA BITS/TRITS - Huffman Trees](https://www.youtube.com/watch?v=DV8efuB3h2g) + - [Elegant Compression in Text (The LZ 77 Method)](https://www.youtube.com/watch?v=goOa3DGezUA) + - [Text Compression Meets Probabilities](https://www.youtube.com/watch?v=cCDCfoHTsaU) + - [Compressor Head videos](https://www.youtube.com/playlist?list=PLOU2XLYxmsIJGErt5rrCqaSGTMyyqNt2H) + - [(optional) Google Developers Live: GZIP is not enough!](https://www.youtube.com/watch?v=whGwm0Lky2s) + +- ### Computer Security + - [MIT (23 videos)](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 + - See videos below + +- ### 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 +## ពត៌មានលំអិតបន្ថែមលើមុខវិជ្ជាមួយចំនួន + + ខ្ញុំបានបន្ថែមគំនិតទាំងនេះដើម្បីពង្រឹងគំនិតមួយចំនួនដែលបានបង្ហាញខាងលើប៉ុន្តែខ្ញុំមិនចង់បញ្ចូលវាខាងលើព្រោះវាច្រើនពេក។ វាងាយស្រួលក្នុងការធ្វើឱ្យវាហួសប្រមាណលើប្រធានបទ។ + អ្នកចង់ទទួលបានការងារនៅសតវត្សនេះមែនទេ? + +- **SOLID** + - [ ] [Bob Martin SOLID Principles of Object Oriented and Agile Design (វីដេអូ)](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) + - [ប្រភេទផ្សេងទៀត](https://docs.google.com/open?id=0ByOwmqah_nuGNHEtcU5OekdDMkk) + - [ ] O - [Open/Closed Principal](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) + - [ប្រភេទផ្សេងទៀត](http://docs.google.com/a/cleancoder.com/viewer?a=v&pid=explorer&chrome=true&srcid=0BwhCYaYDn8EgN2M5MTkwM2EtNWFkZC00ZTI3LWFjZTUtNTFhZGZiYmUzODc1&hl=en) + - [ ] L - [Liskov Substitution Principal](http://www.oodesign.com/liskov-s-substitution-principle.html) | [Base Class and Derived class follow ‘IS A’ principal](http://stackoverflow.com/questions/56860/what-is-the-liskov-substitution-principle) + - [ប្រភេទផ្សេងទៀត](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 ក្នុងរយៈពេល 5 នាទី (វីដេអូ)](https://www.youtube.com/watch?v=3CtAfl7aXAQ) + - [ប្រភេទផ្សេងទៀត](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. + - [ហេតុអ្វីបានជា The Dependency Inversion Principle និងហេតុអ្វីវាសំខាន់](http://stackoverflow.com/questions/62539/what-is-the-dependency-inversion-principle-and-why-is-it-important) + - [ប្រភេទផ្សេងទៀត](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** (វីដេអូ) + - [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** (វីដេអូ) + - [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** ប្រូបាប (គណិតវិទ្យា បងៀនយឹតល្អ) (វីដេអូ): + - [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 (វីដេអូ): + - [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 (វីដេអូ)](https://www.youtube.com/watch?v=QDZpzctPf10) + - [Coursera: Algorithms អំពី Strings](https://www.coursera.org/learn/algorithms-on-strings/home/week/1) + - ចាប់ផ្តើមល្អ ប៉ុន្តែដល់ពេលហួស KMP វាកាន់តែស្មុគស្មាញ + - ការពន្យល់ដ៏ល្អនៃការព្យាយាម + - អាចរំលងបាន + +- **Sorting** + + - Stanford lectures on sorting: + - [មេរៀនទី 15 | Programming Abstractions (វីដេអូ)](https://www.youtube.com/watch?v=ENp00xylP7c&index=15&list=PLFE6E58F856038C69) + - [មេរៀនទី 16 | Programming Abstractions (វីដេអូ)](https://www.youtube.com/watch?v=y4M9IVgrVKo&index=16&list=PLFE6E58F856038C69) + - Shai Simonson, [Aduni.org](http://www.aduni.org/): + - [Algorithms - Sorting - មេរៀនទី 2 (វីដេអូ)](https://www.youtube.com/watch?v=odNJmw5TOEE&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=2) + - [Algorithms - Sorting II - មេរៀនទី 3 (វីដេអូ)](https://www.youtube.com/watch?v=hj8YKFTFKEE&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=3) + - ការបង្រៀនរបស់ Steven Skiena អំពី sorting: + - [មេរៀនចាប់ផ្តេីមពី 26:46 (វីដេអូ)](https://youtu.be/ute-pmMkyuk?list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&t=1600) + - [មេរៀនចាប់ផ្តេីមពី 27:40 (វីដេអូ)](https://www.youtube.com/watch?v=yLvp-pB8mak&index=8&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b) + - [មេរៀនចាប់ផ្តេីមពី 35:00 (វីដេអូ)](https://www.youtube.com/watch?v=q7K9otnzlfE&index=9&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b) + - [មេរៀនចាប់ផ្តេីមពី 23:50 (វីដេអូ)](https://www.youtube.com/watch?v=TvqIGu9Iupw&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=10) + +## Video Series +## ស៊េរីវីដេអូ + +រីករាយជាមួយវិដេអូរខាងក្រោម + +- [List of individual Dynamic Programming problems (each is short)](https://www.youtube.com/playlist?list=PLrmLmBdmIlpsHaNTPP_jHHDx_os9ItYXr) + +- [x86 Architecture, Assembly, Applications (11 វីដេអូ)](https://www.youtube.com/playlist?list=PL038BE01D3BAEFDB0) + +- [MIT 18.06 Linear Algebra, Spring 2005 (35 វីដេអូ)](https://www.youtube.com/playlist?list=PLE7DDD91010BC51F8) + +- [Excellent - MIT Calculus Revisited: Single Variable Calculus](https://www.youtube.com/playlist?list=PL3B08AE665AB9002A) + +- [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 ដោយ Shai Simonson (19 វីដេអូ)](https://www.youtube.com/playlist?list=PL3o9D4Dl2FJ9q0_gtFXPh_H4POI5dK0yG) + +- [Discrete Mathematics Part 1 by Sarada Herke (5 វីដេអូ)](https://www.youtube.com/playlist?list=PLGxuz-nmYlQPOc4w1Kp2MZrdqOOm4Jxeo) + +- CSE373 - Analysis of Algorithms (25 វីដេអូ) + - [ការបង្រៀនរបស់ Skiena ពី Algorithm Design Manual](https://www.youtube.com/watch?v=ZFjhkohHdAA&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=1) + +- [UC Berkeley 61B (Spring 2014): Data Structures (25 វីដេអូ)](https://archive.org/details/ucberkeley-webcast-PL-XXv-cvA_iAlnI-BQr9hjqADPBtujFJd) + +- [UC Berkeley 61B (Fall 2006): Data Structures (39 វីដេអូ)](https://archive.org/details/ucberkeley-webcast-PL4BBB74C7D2A1049C) + +- [UC Berkeley 61C: Machine Structures (26 វីដេអូ)](https://archive.org/details/ucberkeley-webcast-PL-XXv-cvA_iCl2-D-FS5mk0jFF6cYSJs_) + +- [OOSE: Software Dev Using UML and Java (21 វីដេអូ)](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 វីដេអូ)](https://www.youtube.com/playlist?list=PLDSlqjcPpoL64CJdF0Qee5oWqGS6we_Yu) + +- [Carnegie Mellon - Computer Architecture Lectures (39 វីដេអូ)](https://www.youtube.com/playlist?list=PL5PHm2jkkXmi5CxxI7b3JCL1TWybTDtKq) + +- [MIT 6.006: Intro to Algorithms (47 វីដេអូ)](https://www.youtube.com/watch?v=HtSuA80QTyo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&nohtml5=False) + +- [MIT 6.033: Computer System Engineering (22 វីដេអូ)](https://www.youtube.com/watch?v=zm2VP0kHl1M&list=PL6535748F59DCA484) + +- [MIT 6.034 Artificial Intelligence, Fall 2010 (30 វីដេអូ)](https://www.youtube.com/playlist?list=PLUl4u3cNGP63gFHB6xb-kVBiQHYe_4hSi) + +- [MIT 6.042J: Mathematics for Computer Science, Fall 2010 (25 វីដេអូ)](https://www.youtube.com/watch?v=L3LMbpZIKhQ&list=PLB7540DEDD482705B) + +- [MIT 6.046: Design and Analysis of Algorithms (34 វីដេអូ)](https://www.youtube.com/watch?v=2P-yW7LQr08&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp) + +- [MIT 6.050J: Information and Entropy, Spring 2008 (19 វីដេអូ)](https://www.youtube.com/watch?v=phxsQrZQupo&list=PL_2Bwul6T-A7OldmhGODImZL8KEVE38X7) + +- [MIT 6.851: Advanced Data Structures (22 វីដេអូ)](https://www.youtube.com/watch?v=T0yzrZL1py0&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf&index=1) + +- [MIT 6.854: Advanced Algorithms, Spring 2016 (24 វីដេអូ)](https://www.youtube.com/playlist?list=PL6ogFv-ieghdoGKGg2Bik3Gl1glBTEu8c) + +- [Harvard COMPSCI 224: Advanced Algorithms (25 វីដេអូ)](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 វីដេអូ)](https://www.youtube.com/view_play_list?p=9D558D49CA734A02) + +- [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 វីដេអូ)](https://www.youtube.com/playlist?list=PLLssT5z_DsK9JDLcT8T62VtzwyW9LNepV) + +- [Graph Theory by Sarada Herke (67 វីដេអូ)](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 (ភាគច្រើនជាមួយការបង្រៀនតាមអ៊ិនធរណេត)](https://github.com/prakhar1989/awesome-courses) + +## 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) + - ជំនួសដោយ Colossus ក្នុងឆ្នាំ 2012 +- [2004: MapReduce: Simplified Data Processing on Large Clusters]( http://static.googleusercontent.com/media/research.google.com/en//archive/mapreduce-osdi04.pdf) + - ជំនួសដោយ Cloud Dataflow? +- [2006: Bigtable: A Distributed Storage System for Structured Data](https://static.googleusercontent.com/media/research.google.com/en//archive/bigtable-osdi06.pdf) + - [An Inside Look at Google BigQuery](https://cloud.google.com/files/BigQueryTechnicalWP.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) + - អត្ថបទ Dynamo ចាប់ផ្តេីមអោយមាន NoSQL +- [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) +- [2010: Dapper, a Large-Scale Distributed Systems Tracing Infrastructure](https://research.google.com/pubs/archive/36356.pdf) +- [2010: Dremel: Interactive Analysis of Web-Scale Datasets](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/36632.pdf) +- [2012: Google's Colossus](https://www.wired.com/2012/07/google-colossus/) + - មិនមាន អត្ថបទ +- 2012: AddressSanitizer: A Fast Address Sanity Checker: + - [អត្ថបទ](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/37752.pdf) + - [វីដេអូ](https://www.usenix.org/conference/atc12/technical-sessions/presentation/serebryany) +- 2013: Spanner: Google’s Globally-Distributed Database: + - [អត្ថបទ](http://static.googleusercontent.com/media/research.google.com/en//archive/spanner-osdi2012.pdf) + - [វីដេអូ](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) +- [2016: Borg, Omega, and Kubernetes](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44843.pdf) + + +## LICENSE +## សាលាកប័រត + +[CC-BY-SA-4.0](./LICENSE.txt)