# Kodering Onderhoud Universiteit

> Ek het oorspronklik dié as 'n kort om-te-doen lys van studie onderwerpe om 'n sagteware ingenieur te word gemaak,
> maar dit het gegroei tot die groot lys wat jy vandag sien. Nadat ek dié studieplan gevolg het, [het Amazon my
> aangestel](https://startupnextdoor.com/ive-been-acquired-by-amazon/?src=ciu)!
> Jy hoef heel waarskynlik nie soveel soos ek te studeer nie. Maar alles wat jy nodig het is hier.
> 
> Ek het ongeveer 8-12 gestudeer elke dag, vir maande. Hier is my storie: [Hoekom ek vol-tyd gestudeer het, vir 8 maande, vir 'n Google onderhoud](https://medium.freecodecamp.org/why-i-studied-full-time-for-8-months-for-a-google-interview-cc662ce9bb13)
> 
> **Let asseblief op:** Jy sal nie soveel soos ek hoef te studeer nie. Ek het baie tyd gemors op goed wat ek nie benodig het nie. Meer inligting daaroor onder. Ek sal jou help leer sonder om jou kosbare tyd te mors.
>
> Die items wat hier gelys is sal jou goed voorberei vir tegniese onderhoude by omtrent enige sagteware maatskappy,
> insluitend die reuse: Amazon, Facebook, Google, en Microsoft.
> 
> *Sterkte!*

<details>
<summary>Vertalings:</summary>

- [中文版本](translations/README-cn.md)
- [Tiếng Việt - Vietnamese](translations/README-vi.md)
- [Español](translations/README-es.md)
- [Português Brasileiro](translations/README-ptbr.md)
- [Polish](translations/README-pl.md)
- [繁體中文](translations/README-tw.md)
- [Japanese (日本語)](translations/README-ja.md)
- [Russian](translations/README-ru.md)
- [German](translations/README-de.md)
- [Bahasa Indonesia](translations/README-id.md)
- [ខ្មែរ - Khmer](translations/README-kh.md)
- [Uzbek](translations/README-uz.md)
- [Bulgarian](translations/README-bg.md)
- [বাংলা - Bangla](translations/README-bn.md)

</details>

<details>
<summary>Vertalings aan die gang:</summary>

- [हिन्दी](https://github.com/jwasham/coding-interview-university/issues/81)
- [עברית](https://github.com/jwasham/coding-interview-university/issues/82)
- [Arabic](https://github.com/jwasham/coding-interview-university/issues/98)
- [Turkish](https://github.com/jwasham/coding-interview-university/issues/90)
- [French](https://github.com/jwasham/coding-interview-university/issues/89)
- [Українська](https://github.com/jwasham/coding-interview-university/issues/106)
- [Korean(한국어)](https://github.com/jwasham/coding-interview-university/issues/118)
- [Telugu](https://github.com/jwasham/coding-interview-university/issues/117)
- [Urdu](https://github.com/jwasham/coding-interview-university/issues/519)
- [Thai](https://github.com/jwasham/coding-interview-university/issues/156)
- [Greek](https://github.com/jwasham/coding-interview-university/issues/166)
- [Malayalam](https://github.com/jwasham/coding-interview-university/issues/239)
- [Persian - Farsi](https://github.com/jwasham/coding-interview-university/issues/186)
- [Afrikaans](https://github.com/jwasham/coding-interview-university/issues/1164)

</details>

<div align="center">
    <hr />
    <p>
        <a href="https://github.com/sponsors/jwasham"><strong>Word 'n bydraër</strong> en borg Kodering Onderhoud Universiteit!</a>
    </p>
    <p>
        <strong>Spesiale dank aan:</strong>
    </p>
    <div>
        <a href="https://algo.monster/?utm_campaign=jwasham&utm_medium=referral&utm_content=coding-interview-university&utm_source=github">
            <div>
                <img src="https://d3j2pkmjtin6ou.cloudfront.net/sponsors/algo-monster.png" width="300" alt="AlgoMonster">
            </div>
            <div>
                <p>
                    <strong>Master the technical interview without endless grinding.</strong>
                </p>
            </div>
            <div>
                <sup>Created by ex-Google engineers, AlgoMonster will help you crush the technical interview in less time 
                and with fewer sleepless nights grinding away random problems. You will learn the key patterns necessary to solve 
                any interview question and gain the systematic knowledge you need to prove your expertise. Be more confident 
                as you walk into that interview!</sup>
            </div>
        </a>
    </div>
    <hr />
</div>

## Wat is dit?

![Kodering op die witbord - van HBO se Silicon Valley](https://d3j2pkmjtin6ou.cloudfront.net/coding-at-the-whiteboard-silicon-valley.png)

Dié is my multi-maand studie plan om 'n sagteware ingeneur te word vir 'n groot maatskappy.

**Benodighede:**
* 'n Bietjie ondervinding met kodrering (veranderlikes, lusse, metodes/funksies, ens)
* Geduld
* Tyd
  
Let wel dat die 'n studieplan vir 'n **sagteware ingeneur** pos is, nie 'n webontwikkeling pos nie. Groot maatskappeie soos Google, Amazon,
Facebook en Microsoft sien sagteware ingeneurs as verskilled van webontwikkeling ingeneurs. Byvoorbeeld, Amazon het
Frontend Ingeneurs (FEE) en Sagteware Ontwikkeling Ingeneurs (SDE). Die is 2 verskeie rolle en die onderhoude verskil,
omdat elkeen sy eie bevoegdhede het. Dié maatskappeie benodig rekenaar wetenskap kennis vir
sagteware ontwikkeling/ingeneur rolle.

---

## Inhoudsopgawe

### Die Studie Plan

- [Wat is dit?](#wat-is-dit)
- [Hoekom gebruik dit?](#hoekom-gebruik-dit)
- [Hoe om dit te gebruik](#hoe-om-dit-te-gebruik)
- [Moenie voel asof jy nie slim genoeg is nie](#moenie-voel-asof-jy-nie-slim-genoeg-is-nie)
- ['n Nota Oor Video Hulpbronne](#n-nota-oor-video-hulpbronne)
- [Kies 'n Programmeeringstaal](#kies-n-programmeeringstaal)
- [Boeke vir Datastrukture en Algoritmes](#boeke-vir-datastrukture-en-algoritmes)
- [Onderhoud Voorbereïngsboeke](#onderhoud-voorbereidingsboeke)
- [Moenie My Foute Maak Nie](#moenie-my-foute-maak-nie)
- [Wat Jy Nie Sal Sien Gedek Word Nie](#wat-jy-nie-sal-sien-gedek-word-nie)
- [Die Daaglikse Plan](#die-daaglikse-plan)
- [Kodering Vrae Beoefening](#kodering-vrae-beoefening)
- [Kodering Probleme](#kodering-probleme)

## Onderwerpe om te Studeer

- [Algoritmiese Kompleksiteit / Big-O / Asimptotiese analise](#algorithmic-complexity--big-o--asymptotic-analysis)
- [Datastrukture](#datastrukture)
    - [Skikkings](#skikkings)
    - [Linked Lists](#linked-lists)
    - [Stack](#stack)
    - [Queue](#queue)
    - [Hash table](#hash-table)
- [Meer Kennis](#meer-kennis)
    - [Binary search](#binary-search)
    - [Bitwise operations](#bitwise-operations)
- [Bome](#bome)
    - [Bome - Notas & Agtergrond](#bome---notas--agtergrond)
    - [Binary search trees: BSTs](#binary-search-trees-bsts)
    - [Heap / Priority Queue / Binary Heap](#heap--priority-queue--binary-heap)
    - balanced search trees (general concept, not details)
    - traversals: preorder, inorder, postorder, BFS, DFS
- [Sorting](#sorting)
    - selection
    - insertion
    - heapsort
    - quicksort
    - merge sort
- [Grafieke](#grafieke)
    - directed
    - undirected
    - adjacency matrix
    - adjacency list
    - traversals: BFS, DFS
- [Nog Meer Kennis](#nog-meer-kennis)
    - [Recursion](#recursion)
    - [Dinamiese Programering](#dinamiese-programering)
    - [Ontwerp Patrone](#ontwerp-patrone)
    - [Combinatorics (n choose k) & Probability](#combinatorics-n-choose-k--probability)
    - [NP, NP-Complete en Approximation Algorithms](#np-np-complete-en-approximation-algorithms)
    - [Hoe rekenare 'n program proseseer](#hoe-rekenare-n-program-proseseer)
    - [Caches](#caches)
    - [Prosesse en Threads](#prosesse-en-threads)
    - [Toets](#toets)
    - [String searching & manipulations](#string-searching--manipulations)
    - [Bome](#bome)
    - [Floating Point Numbers](#floating-point-numbers)
    - [Unicode](#unicode)
    - [Endianness](#endianness)
    - [Networking](#networking)
- [Finale revisie](#finale-revisie)

### Kry die Werk

- [Werk Jou CV By](#werk-jou-cv-by)
- [Kry 'n Werk](#kry-n-werk)
- [Onderhoudproses & Algemene Voorbereiding](#onderhoudproses--algemene-voorbereiding)
- [Dink aan vir wanneer die onderhoud kom](#dink-aan-vir-wanneer-die-onderhoud-kom)
- [Hê vrae vir die onderhoudvoerder](#he-vrae-vir-die-onderhoudvoerder)
- [Sodra Jy Die Werk Het](#sodra-jy-die-werk-het)

**---------------- Alles hieronder is opsioneel ----------------**

### Opsionele Ekstra Onderwerpe & Hulpbronne

- [Bykomende Boeke](#bykomende-boeke)
- [System Design, Scalability, Data Handling](#system-design-scalability-data-handling) (as jy 4+ jaar ondervinding het)
- [Bykomende Leer](#bykomende-leer)
    - [Compilers](#compilers)
    - [Emacs en vi(m)](#emacs-en-vim)
    - [Unix command line tools](#unix-command-line-tools)
    - [Inligtingsteorie](#inligtingsteorie-videos)
    - [Parity & Hamming Kode](#parity--hamming-kode-videos)
    - [Entropy](#entropy)
    - [Cryptography](#cryptography)
    - [Compression](#compression)
    - [Rekenaar Sekuriteit](#rekenaar-sekuriteit)
    - [Garbage collection](#garbage-collection)
    - [Parallel Programming](#parallel-programming)
    - [Messaging, Serialization, en Queueing Systems](#messaging-serialization-en-queueing-systems)
    - [A*](#a)
    - [Vinnige Fourier Transform](#vinnige-fourier-transform)
    - [Bloom Filter](#bloom-filter)
    - [HyperLogLog](#hyperloglog)
    - [Locality-Sensitive Hashing](#locality-sensitive-hashing)
    - [van Emde Boas Trees](#van-emde-boas-trees)
    - [Augmented Data Structures](#augmented-data-structures)
    - [Balanced search trees](#balanced-search-trees)
        - AVL trees
        - Splay trees
        - Red/black trees
        - 2-3 search trees
        - 2-3-4 Trees (aka 2-4 trees)
        - N-ary (K-ary, M-ary) trees
        - B-Trees
    - [k-D Bome](#k-d-bome)
    - [Skip lists](#skip-lists)
    - [Network Flows](#network-flows)
    - [Disjoint Sets & Union Find](#disjoint-sets--union-find)
    - [Wiskunde vir Vinnige Verwerking](#wiskunde-vir-vinnige-verwerking)
    - [Treap](#treap)
    - [Lineêre Programering](#lineêre-programering-videos)
    - [Geometry, Convex hull](#geometry-convex-hull-videos)
    - [Diskrete wiskunde](#diskrete-wiskunde)
    - [Masjienleer](#masjienleer)
- [Bykomende Detail op Sommige Vakke](#bykomende-detail-op-sommige-vakke)
- [Video Reeks](#video-reeks)
- [Rekenaar Wetenskap Kursusse](#rekenaar-wetenshap-kursusse)
- [Papiere](#papiere)

---

## Hoekom gebruik dit?

As jy wil werk as 'n sagteware ingeneur vir 'n groot maatskappy, hierdie is die goed wat jy moet ken.

As jy uitgemis het op 'n rekenaar wetenskap graad, soos ek het, sal hierdie jou laat opvang en vier jaar van jou lewe spaar.

Toe ek hierdie projek begin het, kon ek nie verskil tussen 'n stapel en 'n hoop nie, het niks van Big-O geweet nie, of enige iets van bome nie, of hoe om
'n grafiek te dwars nie. As ek 'n sorteer algoritme moes kode, kan ek jou verseker dit was verskriklik.
Elke datastruktuur wat ek ooit moes gebruik was ingebou in die taal, end ek het nie geweet hoe hulle werk
onder die kap nie. Ek het nooit nodig gehaad of geheue te bestuur nie, tensy 'n proses vir my 'n "te min
beskikbare geheue" fout gegee het, en dan moes ek 'n ander oplossing kry. Ek het 'n paar multidimensionele skikkings
in my lewe gebruik en duisende assosiatiewe skikkings, maar ek hoef nooit 'n datastruktuur van nuut af gebou het nie.

Dis 'n lang plan. Dit gaan maande vat. As jy klaar gemaklik met baie van dié is gaan dit jou baie minder tyd vat.

## Hoe om dit te gebruik?

Alles hieronder is 'n uitlyn, en jy moet elke item aan pak in orde van bo tot onder.

Ek gebruik Github se spisiale markdown flavor, insluitend taaklyste om vordering te volg.
  - [More about GitHub-flavored markdown](https://guides.github.com/features/mastering-markdown/#GitHub-flavored-markdown)

### As jy nie git wil gebruik nie

Op dié blad, kliek die Code knop naby die bookant, dan kliek "Download ZIP". Unzip die lêer en jy kan werk met die teks lêers.

As jy in 'n kode redakteur is wat markdown verstaan, sal jy sien alles is mooi geformateer.

![Hoe om die repo af te laai as 'n zip lêer](https://d3j2pkmjtin6ou.cloudfront.net/how-to-download-as-zip.png)

### As jy gemaklik met git is

Skep 'n nuwe tak sodat jy items soos dié kan merk, sit net 'n x in die hakies: [x]

    Virk 'n tak en vold die bevele hieronder

Virk die Github repo https://github.com/jwasham/coding-interview-university deur om die Fork knop to druk.

Kloon na jou plaaslike repo:

    git clone git@github.com:<your_github_username>/coding-interview-university.git
    git checkout -b progress
    git remote add jwasham https://github.com/jwasham/coding-interview-university
    git fetch --all

Merk al die bokse met X nadat jy jou veranderinge voltooi het:

    git add .
    git commit -m "Marked x"
    git rebase jwasham/main
    git push --set-upstream origin progress
    git push --force

## Moenie voel asof jy nie slim genoeg is nie

- Suksesvolle sagteware ingeneurs is slim, maar baie het onsekerhede dat hulle nie slim genoeg is nie.
- [Die mite van die Geniale Programeerder](https://www.youtube.com/watch?v=0SARbwvhupQ)
- [Dit is Gevaarlik om Alleen te Gaan: Struikel teen die Onsigbare Monsters in Tegnologie](https://www.youtube.com/watch?v=1i8ylq4j_EY)

## 'n Nota Oor Video Hulpbronne

Sekere videos is net beskikbaar as jy skryf vir 'n kurses in 'n Coursera of EdX klas. Dié is genoem MOOCs.
Soms is die klasse nie in sessie nie end jy sal moet wag vir 'n paar maande, so jy het nie toegang nie.

Dit sal wonderlik wees om die aanlyn klasse te vervang met gratis en altyd-beskikbare openbare bronne,
soos YouTube videos (verkieslik universiteitslesings), sodat julle daarvanaf enige tyd kan leer,
nie net wanneer 'n spesifieke aanlyn kursus in sessie is nie.

## Kies 'n Programmeeringstaal

Jy sal 'n programmeringstaal moet kies vir die kodering onderhoude wat jy gaan doen,
maar jy sal dan ook 'n taal moet kies waarmee jy rekenaar wetenskap konsepte kan leer.

Verkieslik is die taal dieselfde, sodat jy net vaardigheid in een hoef te bou.

### Vir die Studie Plan

Toe ek die studie plan gedoen het, het ek 2 tale gebruik vir meeste van dit: C en Python

* C: Baie lae vlak. Laat jou toe om met pointers en geheue allocation/deallocation te werk, sodat jy die datastrukture en
    algoritmes voel in jou bene. In hoër vlak tale soos Python en Java word die weggesteek van jou af. In daaglikse werk is dit wonderlik,
    maar wanneer jy leer hoe die lae-vlak datastrukture gebou is, voel dit lekker om naby die metaal te wees.
    - C is orals. Jy sal voorbeelde in boeke, lesings, vidoes, en *oral* sien wanner jy studeer.
    - [The C Programming Language, Vol 2](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628)
        - Dié is 'n kort boek, maar dit sal jou 'n goeie vat gee oor die C taal en as jy dit 'n bikie oefen sal jy vinnig
            vaardigheid bou. Deur om C te verstaan help dit jou om te verstaan hoe programme en geheue werk.
        - Jy hoef nie super diep in die boek te gaan nie (of eens dit klaar te maak nie). Gaan net tot die punt waar jy C gemaklik kan lees en skryf.
        - [Antwoorde vir vrae in die boek](https://github.com/lekkas/c-algorithms)
* Python: Modern en baie duur, ek het dit geleer want dis super nuttig en laat my toe om minder kode te skruf in 'n onderhoud.

Die is my voorkeur. Doen jy wat vir jou pas, natuurlik.

Jy mag dit dalk nie nodig kry nie, maar hier is 'n paar webwerwe om jou nuwe taal te leer:
- [Exercism](https://exercism.org/tracks)
- [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/)
- [Codeforces](https://codeforces.com/)

### Vir jou Kodering Onderhoud

Jy kan 'n taal gebruik waarmee jy gemaklik in is om die kodeering deel van die onderhoud te doen, maar vir groot maatskappye is die goeie besluite:

- C++
- Java
- Python

Jy kan ook dié gebruik, maar lees eers rond. Daar is baie caveats:

- JavaScript
- Ruby

Hier is 'n artikel wat ek geskryf het oor hoe om 'n taal te kies vir die onderhoud: 
[Pick One Language for the Coding Interview](https://startupnextdoor.com/important-pick-one-language-for-the-coding-interview/).
Hierdie is die oorspronklike artikel wat my pos op basseer was: [Choosing a Programming Language for Interviews](https://web.archive.org/web/20210516054124/http://blog.codingforinterviews.com/best-programming-language-jobs/)

Jy moet baie gemaklik in die taal wees en kundig.

Lees meer oor besluite:
- [Choose the Right Language for Your Coding Interview](http://www.byte-by-byte.com/choose-the-right-language-for-your-coding-interview/)

[Sien taal-spesifieke hulpbronne hier](programming-language-resources.md)

## Boeke vir Datastrukture en Algoritmes

Die boek sal jou fondasie vir rekenaar wetenskap vorm.

Kies net een, in die taal waarin jy gemaklik sal wees. Jy sal baie lees en kodeering doen.

### C

- [Algorithms in C, Parts 1-5 (Bundle), 3rd Edition](https://www.amazon.com/Algorithms-Parts-1-5-Bundle-Fundamentals/dp/0201756080)
    - Fondasie, Datastrukture, Sorteer, Soek, en Grafiek Algoritmes

### Python

- [Data Structures and Algorithms in Python](https://www.amazon.com/Structures-Algorithms-Python-Michael-Goodrich/dp/1118290275/)
    - deur Goodrich, Tamassia, Goldwasser
    - Ek lief die boek. Dit dek alles en meer.
    - Pythonic kode.
    - my gloeiende boekverslag: https://startupnextdoor.com/book-report-data-structures-and-algorithms-in-python/

### Java

Jou besluit:

- Goodrich, Tamassia, Goldwasser
    - [Data Structures and Algorithms in Java](https://www.amazon.com/Data-Structures-Algorithms-Michael-Goodrich/dp/1118771338/)
- Sedgewick and Wayne:
    - [Algorithms](https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/)
    - Free Coursera course that covers the book (taught by the authors!):
        - [Algorithms I](https://www.coursera.org/learn/algorithms-part1)
        - [Algorithms II](https://www.coursera.org/learn/algorithms-part2)

### C++

Jou besluit:

- Goodrich, Tamassia, and Mount
    - [Data Structures and Algorithms in C++, 2nd Edition](https://www.amazon.com/Data-Structures-Algorithms-Michael-Goodrich/dp/0470383275)
- Sedgewick and Wayne
    - [Algorithms in C++, Parts 1-4: Fundamentals, Data Structure, Sorting, Searching](https://www.amazon.com/Algorithms-Parts-1-4-Fundamentals-Structure/dp/0201350882/)
    - [Algorithms in C++ Part 5: Graph Algorithms](https://www.amazon.com/Algorithms-Part-Graph-3rd-Pt-5/dp/0201361183/)

## Onderhoud Voorbereïngsboeke

Jy hoef nie 'n klomp van die te koop nie. Eerlikwaar is "Craking the Coding Interview" heelwaarskynlik genoeg,
maar ek het meer gekoop om myself meer oefening te gee. Maar ek doen altyd te veel.

Ek het beide van die gekoop. Hulle het vir my genoeg oefening gegee.

- [Programming Interviews Exposed: Coding Your Way Through the Interview, 4th Edition](https://www.amazon.com/Programming-Interviews-Exposed-Through-Interview/dp/111941847X/)
    - Antwoorde in C++ en Java
    - Hierdie is 'n goeie opwarming vir Cracking the Coding Interview
    - Nie te moeilik nie. Meeste probleme mag dalk makliker wees as dié in die onderhoud (van wat ek gelees het)
- [Cracking the Coding Interview, 6th Edition](http://www.amazon.com/Cracking-Coding-Interview-6th-Programming/dp/0984782850/)
    - antwoorde in Java

### As jy tonne ekstra tyd het:

Kies een:

- [Elements of Programming Interviews (C++ version)](https://www.amazon.com/Elements-Programming-Interviews-Insiders-Guide/dp/1479274836)
- [Elements of Programming Interviews in Python](https://www.amazon.com/Elements-Programming-Interviews-Python-Insiders/dp/1537713949/)
- [Elements of Programming Interviews (Java version)](https://www.amazon.com/Elements-Programming-Interviews-Java-Insiders/dp/1517435803/)
        - [Companion Project - Method Stub and Test Cases for Every Problem in the Book](https://github.com/gardncl/elements-of-programming-interviews)

## Moenie My Foute Maak Nie

Hierdie lys het gegroei oor baie maande, en ja, dit het uit die hand geruk.

Hierdie is 'n paar foute wat ek gemaak het sodat jy 'n beter ervaaring het. En jy sal maande se tyd spaar.

### 1. Jy Sal Nie Alles Onthou Nie

Ek het ure lank videos gekyk en deeglike notas gevat, en maande later was daar baie wat ek nie meer onthou het nie. Ek het 3 dae spandeer
om deur my notas te gaan en flitskaarte te maak, sodat ek kon revisie. Ek het nie al daardie kennis nodig gehaad nie.

Asseblief, lees sodat jy nie my foute maak nie:

[Retaining Computer Science Knowledge](https://startupnextdoor.com/retaining-computer-science-knowledge/).

### 2. Gebruik flitskaarte

Om die probleem op te los, het ek a klein flitskaart webwerf gemaak waar ek 2 tipe flitskaarte kon byvoeg: algemeen en kode.
Elke kaart se formatering was verskillend. Ek het 'n mobiele-eerste webwerf gemaak, so ek kon revisie op my foon en tablet, waarookal ek is.

Maak jou eie verniet:

- [Flashcards site repo](https://github.com/jwasham/computer-science-flash-cards)

**Ek BEVEEL NIE AAN dat jy my flitskaarte gebruik nie.** Daar is te veel onnodige kaarte wat jy nie nodig het nie.

Maar as jy nie na my wil luister nie, hier is hulle:
- [My flash cards database (1200 cards)](https://github.com/jwasham/computer-science-flash-cards/blob/main/cards-jwasham.db):
- [My flash cards database (extreme - 1800 cards)](https://github.com/jwasham/computer-science-flash-cards/blob/main/cards-jwasham-extreme.db):

Hou in gedagte dat ek oorboord gegaan het en het kaarte wat alles van assembly taal en Python trivia na masjien leer en statistiek dek.
Dit te veel vir wat nodig is.

**Nota op flitskaarte:** Die eerste keer wat jy erken dat jy die anwoord ken, moenie dit as ken merk nie. Jy moet dieselfde
kaart sien en dit vele kere reg beantwoord voordat jy regtig dit ken. Herhaling sal die kennis diepier
in jou brein berê.

As 'n alternatief na my flitskaart webwerf is [Anki](http://ankisrs.net/), wat vir my voorgestel is talle kere.
Dit gebruik 'n herhalingssisteem om te help onthou. Dit gebruikers-vriendelik, beskikbaar op alle platforms en het 'n wolk sync sisteem.
Dit kos $25 op iOS maar is verniet op ander platforms.

My flitskaart databasis in Anki formaat: https://ankiweb.net/shared/info/25173560 (dankie [@xiewenya](https://github.com/xiewenya)).

Sommige studente het 'n kwessie na vore gebring dat daar wit spasie is in die formatering wat reg gemaak kan word met die volgende stappe: open deck, edit card, kliek cards, kies die "styling" radio knop, verg by die member "white-space: pre;" aan die einde van die card class.

### 3. Doen Kodering Onderhoud Vrae Terwyl Jy Leer

HIERDIE IS BAIE BELANGRIK.

Begin met die kodering onderhoud vrae terwyl jy datastrukture en algoritmes leer.

Jy moet toepas wat jy leer om probleme op te los, of jy sal vergeet. Ek het die fout gemaak.

Sodra jy 'n onderwerp geleer het, en voel sowat gemaklik met dit, byvoorbeeld, **linked lists**:
1. Maak een van die [Onderhoud Voorbereïngsboeke](#onderhoud-voorbereidingsboeke) (of kodering probleem webwerve, onder gelys) oop
2. Doen 2 of 3 vrae met betrekking tot linked lists.
3. Beweeg aan na die volgende onderwerp.
4. Later, gaan terug en doen nog 2 of 3 linked list probleme.
5. Doen hierdie met elke nuwe onderwerp wat jy leer.

**Hou aan probleme doen terwyl jy al hierdie goed leer, nie na die tyd nie.**

Jy word nie aangestel vir kennis nie, maar hoe jy die kennis toepas.

Daar is baie hulpbronne vir dié glys onder. Gaan voort.

### 4. Fokus

Daar is 'n klomp afleidings wat jou kosbare tyd kan opvat. Fokus en konsentreer is moelik. Sit musiek
aan sonder lirieke en jy sal in staat wees of goed te fokus.

## Wat Jy Nie Sal Sien Gedek Word Nie

Hierdie is algemene tegnologie maar is nie deel van hierdie studie plan nie:

- SQL
- Javascript
- HTML, CSS, en ander front-end tegnologie.

## Die Daaglikse Plan

Die kursus gaan oor baie onderwerpe. Elkeen sal heerwaarskynlik jou 'n paar dae vat, of dalk tog 'n week of meer. Dit hang af van jou skedule.

Elke dag, vat die volgende onderwerp op die lys, kyk 'n paar videos oor daardie onderwerp, en dan skryf 'n implimentering
van daardie datastruktuur of algoritme in die taal wat jy gekies het vir hierdie kursus.

Jy kan my kode hier sien:
 - [C](https://github.com/jwasham/practice-c)
 - [C++](https://github.com/jwasham/practice-cpp)
 - [Python](https://github.com/jwasham/practice-python)

Jy hoef nie elke algoritme the memoriseer nie. Jy moet net dit genoeg verstaan om jou eie implimenteering te skryf.

## Kodering Vrae Beoefening

    Hoekom is dié hier? Ek's nie gereed vir onderhoude nie.

[Dan gaan terug en lees die.](#3-doen-kodering-onderhoud-vrae-terwyl-jy-leer)

Hoekom jy oplossings na programeringprobleme moet oefen:
- Probleem erkenning, en waar die regte datastrukture en algoritmes inpas
- Versameling van vereistes vir die probleem
- Praat oor hoe jy die probleem oplos soos jy sal in die onderhoud
- Kodering op 'n wit bord of papier, nie 'n rekenaar nie
- Om te formuleer wat die tyd-en-spasie-kompleksiteit vir jou oplossing is (sien Big-O onder)
- Toets jou oplossing

Daar is 'n wonderlike inleiding vir metodiese, kommunikatiewe probleem oplossing in 'n onderhoud. Jy sal dié ook van die
programmeering boeke kry, maar ek het die uitstekend gevind:
[Algorithm design canvas](http://www.hiredintech.com/algorithm-design/)

Skryf kode op 'n wit bord of papier, nie 'n rekenaar nie. Toets met sommige insette. Dan tik en toets dit op 'n rekenaar.

As jy nie 'n wit bord by die huis het nie, tel 'n groot skryfblad op by die kuns winkel. Jy kan sit op die bank en oefen.
Dié is my "sofa whiteboard". Ek het die pen in die foto gesit vir skaal. As jy 'n pen gebruik gaan jy wens jy kon dit uitvee.
Word baie morsig. **Ek gebruik 'n potlood en uitveër.**

![my sofa whiteboard](https://d3j2pkmjtin6ou.cloudfront.net/art_board_sm_2.jpg)

**Kodering vrae oefening is nie oor oplossings van programmering probleme memoriseer nie.**

## Kodering Problem

Moenie jou sleutel kodering onderhoud boeke vergeet [hier](#onderhoud-voorbereidingsboeke) nie.

Probleme Oplos:
- [How to Find a Solution](https://www.topcoder.com/thrive/articles/How%20To%20Find%20a%20Solution)
- [How to Dissect a Topcoder Problem Statement](https://www.topcoder.com/thrive/articles/How%20To%20Dissect%20a%20Topcoder%20Problem%20Statement%20Content)

Kodering Onderhoud Vrae Videos:
- [IDeserve (88 videos)](https://www.youtube.com/playlist?list=PLamzFoFxwoNjPfxzaWqs7cZGsPYy0x_gI)
- [Tushar Roy (5 playlists)](https://www.youtube.com/user/tusharroy2525/playlists?shelf_id=2&view=50&sort=dd)
    - Super om deur oplossings vir die kode te loop
- [Nick White - LeetCode Solutions (187 Videos)](https://www.youtube.com/playlist?list=PLU_sdQYzUj2keVENTP0a5rdykRSgg9Wp-)
    - Goeie verduidelikings van oplossings en die kode
    - Jy kan 'n klomp kyk in 'n klein tyd
- [FisherCoder - LeetCode Solutions](https://youtube.com/FisherCoder)
- [Neetcode - BLIND 75 LeetCode Solutions](https://www.youtube.com/watch?v=KLlXCFG5TnA&list=PLot-Xpze53ldVwtstag2TL4HQhAnC8ATf)
    - Goeie verduidelikings van die oplossings en die python kode
    - Sien ook [excel sheet](https://docs.google.com/spreadsheets/d/1A2PaQKcdwO_lwxz9bAnxXnIQayCouZP6d-ENrBz_NXc/edit#gid=0) vir all die vrae lyste
    - [Github links](https://github.com/neetcode-gh/leetcode) vir al die oplossing lyste
    - [Neetcode 150](https://neetcode.io/)

Uitdaging webwerwe:
- [LeetCode](https://leetcode.com/)
    - My gunstelling kodering platform werf. Die geld vir die intekening is die moeite werd vir die moontlike 1-2 maande se voorbereiding.
    - Sien Nick White en FisherCoder Videos bo om deur die kode toe loop.
- [HackerRank](https://www.hackerrank.com/)
- [TopCoder](https://www.topcoder.com/)
- [Geeks for Geeks](https://practice.geeksforgeeks.org/explore/?page=1)
- [InterviewBit](https://www.interviewbit.com/)
- [Project Euler](https://projecteuler.net/)

## Begin Solank

Oraait, genoeg praat, kom ons leer!

Maar moet nie vergeet om kode probleme op te los terwyl jy leer nie!

## Algoritmiese kompleksiteit / Big-O / Asimptotiese analiese

- Niks hier om te implimenteer nie, jy kyk net videos en vat notas! Yay!
- Daar is baie videos hier. Kyk net genoeg tot dat jy dit verstaan. Jy kan altyd terug kom en revisie.
- Moenie bekommer as jy nie al die wiskunde verstaan nie.
- Jy moet net verstaan hoe om die kompleksiteit van 'n algoritme in terme van Big-O uit te druk.
- [ ] [Harvard CS50 - Asymptotic Notation (video)](https://www.youtube.com/watch?v=iOq5kSKqeR4)
- [ ] [Big O Notations (general quick tutorial) (video)](https://www.youtube.com/watch?v=V6mKVRU1evU)
- [ ] [Big O Notation (and Omega and Theta) - best mathematical explanation (video)](https://www.youtube.com/watch?v=ei-A_wy5Yxw&index=2&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN)
- [ ] [Skiena (video)](https://www.youtube.com/watch?v=z1mkCe3kVUA)
- [ ] [UC Berkeley Big O (video)](https://archive.org/details/ucberkeley_webcast_VIS4YDpuP98)
- [ ] [Amortized Analysis (video)](https://www.youtube.com/watch?v=B3SpQZaAZP4&index=10&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN)
- [ ] TopCoder (includes recurrence relations and master theorem):
    - [Computational Complexity: Section 1](https://www.topcoder.com/thrive/articles/Computational%20Complexity%20part%20one)
    - [Computational Complexity: Section 2](https://www.topcoder.com/thrive/articles/Computational%20Complexity%20part%20two)
- [ ] [Cheat sheet](http://bigocheatsheet.com/)

Well, dis genoeg van daardie.

Wanneer jy deur "Cracking the Coding Interview" gaan, is daar 'n hoofstuk oor hierdie, en by die einde is daar 'n quiz om te sien
of jy kan identifiseer wat die runtime kompleksiteit van verskeie algoritmes is. Dis 'n super revisie en toets.

## Datastrukture

- ### Skikkings
    - [ ] Oor Skikkings:
        - [Arrays (video)](https://www.coursera.org/lecture/data-structures/arrays-OsBSF)
        - [UC Berkeley CS61B - Linear and Multi-Dim Arrays (video)](https://archive.org/details/ucberkeley_webcast_Wp8oiO_CZZE) (Begin kyk van 15m 32s)
        - [Dynamic Arrays (video)](https://www.coursera.org/lecture/data-structures/dynamic-arrays-EwbnV)
        - [Jagged Arrays (video)](https://www.youtube.com/watch?v=1jtrQqYpt7g)
    - [ ] Implement 'n vektor (mutable skikking met outomatiese grootte verandering)
        - [ ] Oefen kodering met skikkings en wysers, en wysers wiskunde om te spring na 'n indeks in pleks van indeksering te gebruik.
        - [ ] Nuwe rou data skikking met gelokeerde geheue
            - kan int skikking alokeer onder die kap, maar net nie die kenmerke gebruik nie
            - begin met 16, of as begin nommer groter is, gebruik bevoegdhede van 2 - 16, 32, 64, 128
        - [ ] size() - hoeveelheid items
        - [ ] capacity() - hoeveelheid items dit kan hou
        - [ ] is_empty()
        - [ ] at(indeks) - lewer item by gegewende indeks, omplof as indeks buite grens is
        - [ ] push(item)
        - [ ] insert(indeks, item) - voeg item by indeks, skuif daardie indeks se waarde en rank elemente regs
        - [ ] prepend(item) - kan insert hierbo gebruik by indeks 0
        - [ ] pop() - verwyder van die einde, lewer waarde
        - [ ] delete(indeks) - skrap item by indeks, skuif al rank elemente links
        - [ ] remove(item) - kyk vir waarde en verwyder indeks wat dit hou (al is dit in verskeie plekke)
        - [ ] find(item) - kyk vir waarde en lewer eerste indeks met daardie waarde, -1 as dit nie bestaan nie
        - [ ] resize(new_capacity) // privaat funksie
            - wanner jy kapasiteit bereik, verander om die grootte te dubbel
            - wanneer 'n item pop, as grootte 1/4 van kapasiteit is, verander na half
        - [ ] Tyd
            - O(1) om te add/verwyder aan die einde (geamoriënteer vir toekening van meer spasie), indekx, of updateer
            - O(n) om te voeg/skrap elders
        - [ ] Spasie
            - aaneenlopend in geheue, so nabyheid help prestasie
            - spasie nodig - (skikking kapasiteit, wat >= n is) * item grootte, maar tot as dit 2n is, is dit steeds O(n)

- ### Linked Lists
    - [ ] Beskrywing:
        - [ ] [Singly Linked Lists (video)](https://www.coursera.org/lecture/data-structures/singly-linked-lists-kHhgK)
        - [ ] [CS 61B - Linked Lists 1 (video)](https://archive.org/details/ucberkeley_webcast_htzJdKoEmO0)
        - [ ] [CS 61B - Linked Lists 2 (video)](https://archive.org/details/ucberkeley_webcast_-c4I3gFYe3w)
    - [ ] [C Code (video)](https://www.youtube.com/watch?v=QN6FPiD0Gzo)
            - nie die hele video nie, net gedeeltes oor Node struct en geheue toekening
    - [ ] Linked List vs Skikkings:
        - [Core Linked Lists Vs Arrays (video)](https://www.coursera.org/lecture/data-structures-optimizing-performance/core-linked-lists-vs-arrays-rjBs9)
        - [In The Real World Linked Lists Vs Arrays (video)](https://www.coursera.org/lecture/data-structures-optimizing-performance/in-the-real-world-lists-vs-arrays-QUaUd)
    - [ ] [why you suld avoid linked lists (video)](https://www.youtube.com/watch?v=YQs6IC-vgmo)
    - [ ] Gotcha: Jy nodig wyser tot wyser kennis:
        (vir wanneer jy 'n wyser paas na 'n funksie wat die address na waar die wyser wys verander)
        Die blad is net om 'n houvas te kry op wyser na wyser. Ek beveel nie aan om hierdie lys transversale styl te lees nie. Leesbaarheid en onderhoudbaarheid ly van slimheid.
        - [Wysers na Wysers](https://www.eskimo.com/~scs/cclass/int/sx8.html)
    - [ ] Implement (Ek het dit gedoen met stert wyser en sonder):
        - [ ] size() - lewer hoeveelheid data elemente in lys
        - [ ] empty() - bool lewer waar as leeg
        - [ ] value_at(indeks) - lewer die waarde van die nth item (begin by 0 vir eerste)
        - [ ] push_front(waarde) - voeg 'n item aan die begin van die lys
        - [ ] pop_front() - verwyder voorste item en lewer die waarde
        - [ ] push_back(value) - voeg 'n item aan die einde
        - [ ] pop_back() - verwyder laaste item en lewer die waarde
        - [ ] front() - kry waarde van voorste item
        - [ ] back() - kry waarde van laaste item
        - [ ] insert(indeks, waarde) - voeg waarde by indeks, so huidige item by daardie indeks word gewys na deur nuwe item by daardie indeks
        - [ ] erase(indeks) - verwyder node by gegewe indeks
        - [ ] value_n_from_end(n) - lewer die waarde van die node by nth posisie van die einde van die lys af
        - [ ] reverse() - keer die lys om
        - [ ] remove_value(waarde) - verwyder die eerste item in die lys met dié waarde
    - [ ] Doubly-linked List
        - [Deskripsie (video)](https://www.coursera.org/lecture/data-structures/doubly-linked-lists-jpGKD)
        - Nie nodig om te implimenteer nie

- ### Stapel
    - [ ] [Stacks (video)](https://www.coursera.org/lecture/data-structures/stacks-UdKzQ)
    - [ ] Sal nie implementeer nie. Implementering met skikking is maklik

- ### Queue
    - [ ] [Queue (video)](https://www.coursera.org/lecture/data-structures/queues-EShpq)
    - [ ] [Circular buffer/FIFO](https://en.wikipedia.org/wiki/Circular_buffer)
    - [ ] Implementeer met linked-list, met stert wyser:
        - enqueue(waarde) - voeg waarde by posisie by stert
        - dequeue() - lewer waarde en verwyder die minste onlangse gevoegde element (voorkant)
        - empty()
    - [ ] Implementeer met vaste-grootte skikking:
        - enqueue(value) - voeg item aan einde van beskikbare
        - dequeue() - lewer waarde en verwyder minste onlangse gevoegde element
        - empty()
        - full()
    - [ ] Cost:
        - 'n Slegte implementering met linked list waar jy enqueue by die hoof en dequeue by die stert sal wees O(n)
            want you sal die alement langs die laaste nodig hê, wat 'n volle transversal elke dequeue veroorsaak
        - enqueue: O(1) (amortized, linked list en array [probing])
        - dequeue: O(1) (linked list en array)
        - empty: O(1) (linked list en  array)

- ### Hash table
    - [ ] Videos:
        - [ ] [Hashing with Chaining (video)](https://www.youtube.com/watch?v=0M_kIqhwbFo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=8)
        - [ ] [Table Doubling, Karp-Rabin (video)](https://www.youtube.com/watch?v=BRO7mVIFt08&index=9&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
        - [ ] [Open Addressing, Cryptographic Hashing (video)](https://www.youtube.com/watch?v=rvdJDijO2Ro&index=10&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
        - [ ] [PyCon 2010: The Mighty Dictionary (video)](https://www.youtube.com/watch?v=C4Kc8xzcA68)
        - [ ] [PyCon 2017: The Dictionary Even Mightier (video)](https://www.youtube.com/watch?v=66P5FMkWoVU)
        - [ ] [(Advanced) Randomization: Universal & Perfect Hashing (video)](https://www.youtube.com/watch?v=z0lJ2k0sl1g&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=11)
        - [ ] [(Advanced) Perfect hashing (video)](https://www.youtube.com/watch?v=N0COwN14gt0&list=PL2B4EEwhKD-NbwZ4ezj7gyc_3yNrojKM9&index=4)

    - [ ] Online Courses:
        - [ ] [Core Hash Tables (video)](https://www.coursera.org/lecture/data-structures-optimizing-performance/core-hash-tables-m7UuP)
        - [ ] [Data Structures (video)](https://www.coursera.org/learn/data-structures/home/week/4)
        - [ ] [Phone Book Problem (video)](https://www.coursera.org/lecture/data-structures/phone-book-problem-NYZZP)
        - [ ] distributed hash tables:
            - [Instant Uploads And Storage Optimization In Dropbox (video)](https://www.coursera.org/lecture/data-structures/instant-uploads-and-storage-optimization-in-dropbox-DvaIb)
            - [Distributed Hash Tables (video)](https://www.coursera.org/lecture/data-structures/distributed-hash-tables-tvH8H)

    - [ ] Implement met 'n skikking en gebruik linear probing
        - hash(k, m) - m is grootte van hash table
        - add(sleutel, waarde) - as sleutel al klaar beskikbaar is, opdateer waarde
        - exists(sleutel)
        - get(sleutel)
        - remove(sleutel)

## Meer Kennis

- ### Binary search
    - [ ] [Binary Search (video)](https://www.youtube.com/watch?v=D5SrAga1pno)
    - [ ] [Binary Search (video)](https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search)
    - [ ] [detail](https://www.topcoder.com/thrive/articles/Binary%20Search)
    - [ ] [blueprint](https://leetcode.com/discuss/general-discussion/786126/python-powerful-ultimate-binary-search-template-solved-many-problems)
    - [ ] Implement:
        - binary search (op 'n gesorteerde skikking van heelgetalle)
        - binary search met recursion

- ### Bitwise operations
    - [ ] [Bits cheat sheet](https://github.com/jwasham/coding-interview-university/blob/main/extras/cheat%20sheets/bits-cheat-sheet.pdf) - jy moet baie van die bevoegdhede van 2 ken van (2^1 na 2^16 na 2^32)
    - [ ] Verstaan baie goed hoe om bits te manipuleer met: &, |, ^, ~, >>, <<
        - [ ] [words](https://en.wikipedia.org/wiki/Word_(computer_architecture))
        - [ ] Goeie intro:
            [Bit Manipulation (video)](https://www.youtube.com/watch?v=7jkIUgLC29I)
        - [ ] [C Programming Tutorial 2-10: Bitwise Operators (video)](https://www.youtube.com/watch?v=d0AwjSpNXR0)
        - [ ] [Bit Manipulation](https://en.wikipedia.org/wiki/Bit_manipulation)
        - [ ] [Bitwise Operation](https://en.wikipedia.org/wiki/Bitwise_operation)
        - [ ] [Bithacks](https://graphics.stanford.edu/~seander/bithacks.html)
        - [ ] [The Bit Twiddler](https://bits.stephan-brumme.com/)
        - [ ] [The Bit Twiddler Interactive](https://bits.stephan-brumme.com/interactive.html)
        - [ ] [Bit Hacks (video)](https://www.youtube.com/watch?v=ZusiKXcz_ac)
        - [ ] [Practice Operations](https://pconrad.github.io/old_pconrad_cs16/topics/bitOps/)
    - [ ] 2 en 1 se kompliment
        - [Binary: Plusses & Minuses (Why We Use Two's Complement) (video)](https://www.youtube.com/watch?v=lKTsv6iVxV4)
        - [1s Complement](https://en.wikipedia.org/wiki/Ones%27_complement)
        - [2s Complement](https://en.wikipedia.org/wiki/Two%27s_complement)
    - [ ] Tel set bits
        - [4 ways to count bits in a byte (video)](https://youtu.be/Hzuzo9NJrlc)
        - [Count Bits](https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan)
        - [How To Count The Number Of Set Bits In a 32 Bit Integer](http://stackoverflow.com/questions/109023/how-to-count-the-number-of-set-bits-in-a-32-bit-integer)
    - [ ] Ruil waardes:
        - [Swap](https://bits.stephan-brumme.com/swap.html)
    - [ ] Absolute value:
        - [Absolute Integer](https://bits.stephan-brumme.com/absInteger.html)

## Bome

- ### Bome - Notas & Agtergrond
    - [ ] [Series: Trees (video)](https://www.coursera.org/lecture/data-structures/trees-95qda)
    - basiese boom konstruksie
    - traversal
    - manipulasie algoritmes
    - [ ] [BFS(breadth-first search) and DFS(depth-first search) (video)](https://www.youtube.com/watch?v=uWL6FJhq5fM)
        - BFS notas:
           - level order (BFS, met queue)
           - tyd kompleksiteit: O(n)
           - spasie kompleksiteit: beste: O(1), slegste: O(n/2)=O(n)
        - DFS notas:
            - tyd kompleksiteit: O(n)
            - spasie kompleksiteit:
                beste: O(log n) - gemidelde hoogte van boom
                slegste: O(n)
            - inorder (DFS: links, self, regs)
            - postorder (DFS: links, regs, self)
            - preorder (DFS: self, links, regs)

- ### Binary search trees: BSTs
    - [ ] [Binary Search Tree Revisie (video)](https://www.youtube.com/watch?v=x6At0nzX92o&index=1&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)    
    - [ ] [Inleiding (video)](https://www.coursera.org/learn/data-structures/lecture/E7cXP/introduction)
    - [ ] [MIT (video)](https://www.youtube.com/watch?v=76dhtgZt38A&ab_channel=MITOpenCourseWare)
    - C/C++:
        - [ ] [Binary search tree - Implementering in C/C++ (video)](https://www.youtube.com/watch?v=COZK7NATh4k&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=28)
        - [ ] [BST implementation - memory allocation met stapels en hope (video)](https://www.youtube.com/watch?v=hWokyBoo0aI&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=29)
        - [ ] [Kry min en max element in 'n binary search tree (video)](https://www.youtube.com/watch?v=Ut90klNN264&index=30&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P)
        - [ ] [Kry hooggte van 'n binary tree (video)](https://www.youtube.com/watch?v=_pnqMz5nrRs&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=31)
        - [ ] [Binary tree traversal - breadth-first en depth-first strategieë (video)](https://www.youtube.com/watch?v=9RHO6jU--GU&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=32)
        - [ ] [Binary tree: Level Order Traversal (video)](https://www.youtube.com/watch?v=86g8jAQug04&index=33&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P)
        - [ ] [Binary tree traversal: Preorder, Inorder, Postorder (video)](https://www.youtube.com/watch?v=gm8DUJJhmY4&index=34&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P)
        - [ ] [Kyk of 'n binary tree 'b binary search tree is of nie(video)](https://www.youtube.com/watch?v=yEwSGhSsT0U&index=35&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P)
        - [ ] [Verwyder 'n node van 'n Binary Search Tree (video)](https://www.youtube.com/watch?v=gcULXE7ViZw&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=36)
        - [ ] [Inorder Successor in 'n binary search tree (video)](https://www.youtube.com/watch?v=5cPbNCrdotA&index=37&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P)
    - [ ] Implement:
        - [ ] insert   // vog 'n waarde in 'n boom
        - [ ] get_node_count   // kry hoeveelheid waardes gestoor is
        - [ ] print_values   // print die waardes in die boom, van min na max
        - [ ] delete_tree
        - [ ] is_in_tree   // waar wanneer 'n gegewende waarde in 'n boom is
        - [ ] get_height   // gee die hooggte in nodes (enkel node se hooggte is 1)
        - [ ] get_min   // gee die minimum waarde wat gestoor is in die boom
        - [ ] get_max   // gee die maksimum waarde wat gestoor is in die boom
        - [ ] is_binary_search_tree
        - [ ] delete_value
        - [ ] get_successor   // gee volgende hoogste waarde in die boom na die gegewende waarde, -1 as niks

- ### Heap / Priority Queue / Binary Heap
    - gevisualiseer as 'n boom, maar is gewoonlik lineêr gestoor (skikking, linked list)
    - [ ] [Heap](https://en.wikipedia.org/wiki/Heap_(data_structure))
    - [ ] [Inleiding (video)](https://www.coursera.org/lecture/data-structures/introduction-2OpTs)
    - [ ] [Naïef implementering (video)](https://www.coursera.org/learn/data-structures/lecture/z3l9N/naive-implementations)
    - [ ] [Binary Trees (video)](https://www.coursera.org/learn/data-structures/lecture/GRV2q/binary-trees)
    - [ ] [Tree Height Remark (video)](https://www.coursera.org/learn/data-structures/supplement/S5xxz/tree-height-remark)
    - [ ] [Basese operasies (video)](https://www.coursera.org/learn/data-structures/lecture/0g1dl/basic-operations)
    - [ ] [Complete Binary Trees (video)](https://www.coursera.org/learn/data-structures/lecture/gl5Ni/complete-binary-trees)
    - [ ] [Pseudokode (video)](https://www.coursera.org/learn/data-structures/lecture/HxQo9/pseudocode)
    - [ ] [Heap Sort - spring na begin (video)](https://youtu.be/odNJmw5TOEE?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=3291)
    - [ ] [Heap Sort (video)](https://www.coursera.org/lecture/data-structures/heap-sort-hSzMO)
    - [ ] [Bou 'n heap (video)](https://www.coursera.org/lecture/data-structures/building-a-heap-dwrOS)
    - [ ] [MIT: Heaps en Heap Sort (video)](https://www.youtube.com/watch?v=B7hVxCmfPtM&index=4&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
    - [ ] [CS 61B Lecture 24: Priority Queues (video)](https://archive.org/details/ucberkeley_webcast_yIUFT6AKBGE)
    - [ ] [Lineêr Tyd BuildHeap (max-heap)](https://www.youtube.com/watch?v=MiyLo8adrWw)
    - [ ] Implementeer 'n max-heap:
        - [ ] insert
        - [ ] sift_up - nodig vir insert
        - [ ] get_max - gee die max item, sonder om dit te verwyder
        - [ ] get_size() - gee hoeveelheid elemente gestoor is
        - [ ] is_empty() - waar as heap geen elemente het nie
        - [ ] extract_max - gee max item, en verwyder dit
        - [ ] sift_down - nodig vir extract_max
        - [ ] remove(x) - verwyder item by indeks x
        - [ ] heapify - maak 'h heap van 'n skikking elemente, nodig vir heap_sort
        - [ ] heap_sort() - vat 'n ongesorteerde skikking en verander dit na 'n gesorteerde skikking in-plek met 'n max heap of 'n min heap

## Sorteer

- [ ] Notas:
    - Implementeer soterings & weet wat die beste/slegste gevalle is, gemidelde kompleksiteite van elk:
        - geen bubble sort - dis verskriklik sleg - O(n^2), behalwe wanneer n <= 16
    - [ ] Stabiliteit in sorteer algoritmes ("Is Quicksort stabiel?")
        - [Sorting Algorithm Stability](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability)
        - [Stability In Sorting Algorithms](http://stackoverflow.com/questions/1517793/stability-in-sorting-algorithms)
        - [Stability In Sorting Algorithms](http://www.geeksforgeeks.org/stability-in-sorting-algorithms/)
        - [Sorting Algorithms - Stability](http://homepages.math.uic.edu/~leon/cs-mcs401-s08/handouts/stability.pdf)
    - [ ] Watse algoritmes kan op linked lists gebruik word? Watses op arrays? Watses op beide?
        - I sal nie aan beveel om 'n linked list te sorteer nie, maar merge sort is doenbaar
        - [Merge Sort For Linked List](http://www.geeksforgeeks.org/merge-sort-for-linked-list/)

- Vir heapsort, sien Heap datastruktuur bo. Heap sort is fantasties, maar nie stabiel

- [ ] [Sedgewick - Mergesort (5 videos)](https://www.coursera.org/learn/algorithms-part1/home/week/3)
    - [ ] [1. Mergesort](https://www.coursera.org/lecture/algorithms-part1/mergesort-ARWDq)
    - [ ] [2. Bottom up Mergesort](https://www.coursera.org/learn/algorithms-part1/lecture/PWNEl/bottom-up-mergesort)
    - [ ] [3. Sorting Complexity](https://www.coursera.org/lecture/algorithms-part1/sorting-complexity-xAltF)
    - [ ] [4. Comparators](https://www.coursera.org/lecture/algorithms-part1/comparators-9FYhS)
    - [ ] [5. Stability](https://www.coursera.org/learn/algorithms-part1/lecture/pvvLZ/stability)

- [ ] [Sedgewick - Quicksort (4 videos)](https://www.coursera.org/learn/algorithms-part1/home/week/3)
    - [ ] [1. Quicksort](https://www.coursera.org/learn/algorithms-part1/lecture/vjvnC/quicksort)
    - [ ] [2. Selection](https://www.coursera.org/lecture/algorithms-part1/selection-UQxFT)
    - [ ] [3. Duplicate Keys](https://www.coursera.org/lecture/algorithms-part1/duplicate-keys-XvjPd)
    - [ ] [4. System Sorts](https://www.coursera.org/lecture/algorithms-part1/system-sorts-QBNZ7)

- [ ] UC Berkeley:
    - [ ] [CS 61B Lecture 29: Sorting I (video)](https://archive.org/details/ucberkeley_webcast_EiUvYS2DT6I)
    - [ ] [CS 61B Lecture 30: Sorting II (video)](https://archive.org/details/ucberkeley_webcast_2hTY3t80Qsk)
    - [ ] [CS 61B Lecture 32: Sorting III (video)](https://archive.org/details/ucberkeley_webcast_Y6LOLpxg6Dc)
    - [ ] [CS 61B Lecture 33: Sorting V (video)](https://archive.org/details/ucberkeley_webcast_qNMQ4ly43p4)

- [ ] [Bubble Sort (video)](https://www.youtube.com/watch?v=P00xJgWzz2c&index=1&list=PL89B61F78B552C1AB)
- [ ] [Analyzing Bubble Sort (video)](https://www.youtube.com/watch?v=ni_zk257Nqo&index=7&list=PL89B61F78B552C1AB)
- [ ] [Insertion Sort, Merge Sort (video)](https://www.youtube.com/watch?v=Kg4bqzAqRBM&index=3&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
- [ ] [Insertion Sort (video)](https://www.youtube.com/watch?v=c4BRHC7kTaQ&index=2&list=PL89B61F78B552C1AB)
- [ ] [Merge Sort (video)](https://www.youtube.com/watch?v=GCae1WNvnZM&index=3&list=PL89B61F78B552C1AB)
- [ ] [Quicksort (video)](https://www.youtube.com/watch?v=y_G9BkAm6B8&index=4&list=PL89B61F78B552C1AB)
- [ ] [Selection Sort (video)](https://www.youtube.com/watch?v=6nDMgr0-Yyo&index=8&list=PL89B61F78B552C1AB)

- [ ] Merge sort kode:
    - [ ] [Using output array (C)](http://www.cs.yale.edu/homes/aspnes/classes/223/examples/sorting/mergesort.c)
    - [ ] [Using output array (Python)](https://github.com/jwasham/practice-python/blob/master/merge_sort/merge_sort.py)
    - [ ] [In-place (C++)](https://github.com/jwasham/practice-cpp/blob/master/merge_sort/merge_sort.cc)
- [ ] Quick sort kode:
    - [ ] [Implementation (C)](http://www.cs.yale.edu/homes/aspnes/classes/223/examples/randomization/quick.c)
    - [ ] [Implementation (C)](https://github.com/jwasham/practice-c/blob/master/quick_sort/quick_sort.c)
    - [ ] [Implementation (Python)](https://github.com/jwasham/practice-python/blob/master/quick_sort/quick_sort.py)

- [ ] Implementeer:
    - [ ] Mergesort: O(n log n) gemiddelde en slegste gevalle
    - [ ] Quicksort O(n log n) gemiddelde geval
    - Selection sort en insertion sort is albei O(n^2) gemiddeld en slegste gevalle
    - Vir heapsort, sien Heap datastrukture bo

- [ ] Nie nodig nie, maar ek beveel hulle aan:
    - [ ] [Sedgewick - Radix Sorts (6 videos)](https://www.coursera.org/learn/algorithms-part2/home/week/3)
        - [ ] [1. Strings in Java](https://www.coursera.org/learn/algorithms-part2/lecture/vGHvb/strings-in-java)
        - [ ] [2. Key Indexed Counting](https://www.coursera.org/lecture/algorithms-part2/key-indexed-counting-2pi1Z)
        - [ ] [3. Least Significant Digit First String Radix Sort](https://www.coursera.org/learn/algorithms-part2/lecture/c1U7L/lsd-radix-sort)
        - [ ] [4. Most Significant Digit First String Radix Sort](https://www.coursera.org/learn/algorithms-part2/lecture/gFxwG/msd-radix-sort)
        - [ ] [5. 3 Way Radix Quicksort](https://www.coursera.org/lecture/algorithms-part2/3-way-radix-quicksort-crkd5)
        - [ ] [6. Suffix Arrays](https://www.coursera.org/learn/algorithms-part2/lecture/TH18W/suffix-arrays)
    - [ ] [Radix Sort](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#radixSort)
    - [ ] [Radix Sort (video)](https://www.youtube.com/watch?v=xhr26ia4k38)
    - [ ] [Radix Sort, Counting Sort (linear time given constraints) (video)](https://www.youtube.com/watch?v=Nz1KZXbghj8&index=7&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
    - [ ] [Randomization: Matrix Multiply, Quicksort, Freivalds' algorithm (video)](https://www.youtube.com/watch?v=cNB2lADK3_s&index=8&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
    - [ ] [Sorting in Linear Time (video)](https://www.youtube.com/watch?v=pOKy3RZbSws&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf&index=14)

As 'n opsomming, hier is 'n visuele verteenwoordiging van [15 sorting algorithms](https://www.youtube.com/watch?v=kPRA0W1kECg).
As jy nog detail nodig het op hierdie onderwer, sien "Sorteer" seksie in [Bykomende Detail op Sommige Vakke](#bykomende-detail-op-sommige-vakke)

## Grafieke

Grafieke kan gebruik word om baie problmeme in rekenaar wetenskap te verteenwoordig, so die seksie is lank, soos bome en sortering was.

- Notas:
    - Daar is 4 basiese maniere om 'n grafiek in geheue te verteenwoordig:
        - objects and pointers
        - adjacency matrix
        - adjacency list
        - adjacency map
    - Familiariseer jouself met elke verteenwoordiging en sy voor- en nadele
    - BFS en DFS - ken hulle computational kompleksiteit, hulle ruilings-waardes, en hoe om hulle te implimenteer in regte kode
    - Wanner 'n vraag gevra word, kyk vir 'n grafiek-gebaseerde oplossing eerste, dan begeen aan as niks

- [ ] MIT(videos):
    - [ ] [Breadth-First Search](https://www.youtube.com/watch?v=oFVYVzlvk9c&t=14s&ab_channel=MITOpenCourseWare)
    - [ ] [Depth-First Search](https://www.youtube.com/watch?v=IBfWDYSffUU&t=32s&ab_channel=MITOpenCourseWare)

- [ ] Skiena Lectures - great intro:
    - [ ] [CSE373 2020 - Lecture 10 - Graph Data Structures (video)](https://www.youtube.com/watch?v=Sjk0xqWWPCc&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=10)
    - [ ] [CSE373 2020 - Lecture 11 - Graph Traversal (video)](https://www.youtube.com/watch?v=ZTwjXj81NVY&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=11)
    - [ ] [CSE373 2020 - Lecture 12 - Depth First Search (video)](https://www.youtube.com/watch?v=KyordYB3BOs&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=12)
    - [ ] [CSE373 2020 - Lecture 13 - Minimum Spanning Trees (video)](https://www.youtube.com/watch?v=oolm2VnJUKw&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=13)
    - [ ] [CSE373 2020 - Lecture 14 - Minimum Spanning Trees (con't) (video)](https://www.youtube.com/watch?v=RktgPx0MarY&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=14)
    - [ ] [CSE373 2020 - Lecture 15 - Graph Algorithms (con't 2) (video)](https://www.youtube.com/watch?v=MUe5DXRhyAo&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=15)

- [ ] Graphs (revisie en meer):

    - [ ] [6.006 Single-Source Shortest Paths Problem (video)](https://www.youtube.com/watch?v=Aa2sqUhIn-E&index=15&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
    - [ ] [6.006 Dijkstra (video)](https://www.youtube.com/watch?v=NSHizBK9JD8&t=1731s&ab_channel=MITOpenCourseWare)
    - [ ] [6.006 Bellman-Ford (video)](https://www.youtube.com/watch?v=f9cVS_URPc0&ab_channel=MITOpenCourseWare)
    - [ ] [6.006 Speeding Up Dijkstra (video)](https://www.youtube.com/watch?v=CHvQ3q_gJ7E&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=18)
    - [ ] [Aduni: Graph Algorithms I - Topological Sorting, Minimum Spanning Trees, Prim's Algorithm -  Lecture 6 (video)]( https://www.youtube.com/watch?v=i_AQT_XfvD8&index=6&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
    - [ ] [Aduni: Graph Algorithms II - DFS, BFS, Kruskal's Algorithm, Union Find Data Structure - Lecture 7 (video)]( https://www.youtube.com/watch?v=ufj5_bppBsA&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=7)
    - [ ] [Aduni: Graph Algorithms III: Shortest Path - Lecture 8 (video)](https://www.youtube.com/watch?v=DiedsPsMKXc&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=8)
    - [ ] [Aduni: Graph Alg. IV: Intro to geometric algorithms - Lecture 9 (video)](https://www.youtube.com/watch?v=XIAQRlNkJAw&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=9)
    - [ ] [CS 61B 2014: Weighted graphs (video)](https://archive.org/details/ucberkeley_webcast_zFbq8vOZ_0k)
    - [ ] [Greedy Algorithms: Minimum Spanning Tree (video)](https://www.youtube.com/watch?v=tKwnms5iRBU&index=16&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
    - [ ] [Strongly Connected Components Kosaraju's Algorithm Graph Algorithm (video)](https://www.youtube.com/watch?v=RpgcYiky7uw)

- Full Coursera Kursus:
    - [ ] [Algorithms on Graphs (video)](https://www.coursera.org/learn/algorithms-on-graphs/home/welcome)

- Ek sou implimenteer:
    - [ ] DFS met adjacency list (recursive)
    - [ ] DFS met adjacency list (iterative met stack)
    - [ ] DFS met adjacency matrix (recursive)
    - [ ] DFS met adjacency matrix (iterative met stack)
    - [ ] BFS met adjacency list
    - [ ] BFS met adjacency matrix
    - [ ] single-source shortest path (Dijkstra)
    - [ ] minimum spanning tree
    - DFS-based algorithms (sien Aduni videos bo):
        - [ ] kyk vir cycle (nodig vir topological sort, aangesien ons wil kyk vir 'n cycle voordat ons begin)
        - [ ] topological sort
        - [ ] tel gekoppelde komponente in 'n grafiek
        - [ ] lys sterk gokoppelde komponente
        - [ ] kyk vir bipartite graph

## Nog Meer Kennis

- ### Recursion
    - [ ] Stanford lesings oor recursion & backtracking:
        - [ ] [Lecture 8 | Programming Abstractions (video)](https://www.youtube.com/watch?v=gl3emqCuueQ&list=PLFE6E58F856038C69&index=8)
        - [ ] [Lecture 9 | Programming Abstractions (video)](https://www.youtube.com/watch?v=uFJhEPrbycQ&list=PLFE6E58F856038C69&index=9)
        - [ ] [Lecture 10 | Programming Abstractions (video)](https://www.youtube.com/watch?v=NdF1QDTRkck&index=10&list=PLFE6E58F856038C69)
        - [ ] [Lecture 11 | Programming Abstractions (video)](https://www.youtube.com/watch?v=p-gpaIGRCQI&list=PLFE6E58F856038C69&index=11)
    - Wanneer is dit gepas om te gebruik?
    - Hoe is sterk recursion beter as nie?
        - [ ] [What Is Tail Recursion Why Is It So Bad?](https://www.quora.com/What-is-tail-recursion-Why-is-it-so-bad)
        - [ ] [Tail Recursion (video)](https://www.coursera.org/lecture/programming-languages/tail-recursion-YZic1)
    - [ ] [5 Simple Steps for Solving Any Recursive Problem(video)](https://youtu.be/ngCos392W4w)

	Backtracking Blueprint: [Java](https://leetcode.com/problems/combination-sum/discuss/16502/A-general-approach-to-backtracking-questions-in-Java-(Subsets-Permutations-Combination-Sum-Palindrome-Partitioning))
	[Python](https://leetcode.com/problems/combination-sum/discuss/429538/General-Backtracking-questions-solutions-in-Python-for-reference-%3A)
- ### Dinamiese Programering
    - Jy sal heelwaarskynlik geen dinamiese probleme in die onderhoud sien nie, maar dis die moeite werd om 
    'n probleem te herken as 'n dinamiese programering probleem.
    - Hierde onderwerp kan redelik moeilik wees, omdat elke DP oplosbare probleem gedefinieer moet word as 'n recursion verhouding, en om daarmee op te kom is moeilik.
    - Ek beveel aan om na soveel DP probleme te kyk as moontlik tot dat jy 'n goeie begrip van die patroon het.
    - [ ] Videos:
        - [ ] [Skiena: CSE373 2020 - Lecture 19 - Introduction to Dynamic Programming (video)](https://www.youtube.com/watch?v=wAA0AMfcJHQ&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=18)
        - [ ] [Skiena: CSE373 2020 - Lecture 20 - Edit Distance (video)](https://www.youtube.com/watch?v=T3A4jlHlhtA&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=19)
        - [ ] [Skiena: CSE373 2020 - Lecture 20 - Edit Distance (continued) (video)](https://www.youtube.com/watch?v=iPnPVcZmRbE&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=20)
        - [ ] [Skiena: CSE373 2020 - Lecture 21 - Dynamic Programming (video)](https://www.youtube.com/watch?v=2xPE4Wq8coQ&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=21)
        - [ ] [Skiena: CSE373 2020 - Lecture 21 - Dynamic Programming and Review (video)](https://www.youtube.com/watch?v=2xPE4Wq8coQ&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=21)
        - [ ] [Simonson: Dynamic Programming 0 (starts at 59:18) (video)](https://youtu.be/J5aJEcOr6Eo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=3558)
        - [ ] [Simonson: Dynamic Programming I - Lecture 11 (video)](https://www.youtube.com/watch?v=0EzHjQ_SOeU&index=11&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
        - [ ] [Simonson: Dynamic programming II - Lecture 12 (video)](https://www.youtube.com/watch?v=v1qiRwuJU7g&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=12)
        - [ ] List of individual DP problems (each is short):
            [Dynamic Programming (video)](https://www.youtube.com/playlist?list=PLrmLmBdmIlpsHaNTPP_jHHDx_os9ItYXr)
    - [ ] Yale Lecture notes:
        - [ ] [Dynamic Programming](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#dynamicProgramming)
    - [ ] Coursera:
        - [ ] [The RNA secondary structure problem (video)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/80RrW/the-rna-secondary-structure-problem)
        - [ ] [A dynamic programming algorithm (video)](https://www.coursera.org/lecture/algorithmic-thinking-2/a-dynamic-programming-algorithm-PSonq)
        - [ ] [Illustrating the DP algorithm (video)](https://www.coursera.org/lecture/algorithmic-thinking-2/illustrating-the-dp-algorithm-oUEK2)
        - [ ] [Running time of the DP algorithm (video)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/nfK2r/running-time-of-the-dp-algorithm)
        - [ ] [DP vs. recursive implementation (video)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/M999a/dp-vs-recursive-implementation)
        - [ ] [Global pairwise sequence alignment (video)](https://www.coursera.org/lecture/algorithmic-thinking-2/global-pairwise-sequence-alignment-UZ7o6)
        - [ ] [Local pairwise sequence alignment (video)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/WnNau/local-pairwise-sequence-alignment)

- ### Ontwerp patrone
    - [ ] [Quick UML review (video)](https://www.youtube.com/watch?v=3cmzqZzwNDM&list=PLGLfVvz_LVvQ5G-LdJ8RLqe-ndo7QITYc&index=3)
    - [ ] Leer hierdie patrone:
        - [ ] strategy
        - [ ] singleton
        - [ ] adapter
        - [ ] prototype
        - [ ] decorator
        - [ ] visitor
        - [ ] factory, abstract factory
        - [ ] facade
        - [ ] observer
        - [ ] proxy
        - [ ] delegate
        - [ ] command
        - [ ] state
        - [ ] memento
        - [ ] iterator
        - [ ] composite
        - [ ] flyweight
    - [ ] [Series of videos (27 videos)](https://www.youtube.com/playlist?list=PLF206E906175C7E07)
    - [ ] [Book: Head First Design Patterns](https://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124)
        - Ek weet die kanonieke boek is "Design Patterns: Elements of Reusable Object-Orientated Software", maar Head First is 'n goeie begin na OO ook.
    - [Handy reference: 101 Design Patterns & Tips for Developers](https://sourcemaking.com/design-patterns-and-tips)

- ### Kombinatorika (n kies k) & Probability
    - [ ] [Math Skills: How to find Factorial, Permutation and Combination (Choose) (video)](https://www.youtube.com/watch?v=8RRo6Ti9d0U)
    - [ ] [Make School: Probability (video)](https://www.youtube.com/watch?v=sZkAAk9Wwa4)
    - [ ] [Make School: More Probability and Markov Chains (video)](https://www.youtube.com/watch?v=dNaJg-mLobQ)
    - [ ] Khan Academy:
        - Kursus uitleg:
            - [ ] [Basic Theoretical Probability](https://www.khanacademy.org/math/probability/probability-and-combinatorics-topic)
        - Net die videos - 41 (elkeen is eenvoudig en elkeen is kort):
            - [ ] [Probability Explained (video)](https://www.youtube.com/watch?v=uzkc-qNVoOk&list=PLC58778F28211FA19)

- ### NP, NP-Complete en Approximation Algorithms
    - Ken die mees beroemde klasse van NP-complete probleme, soos traveling salesman en die knapsack probleem,
        en wees reg om hulle the herken wanneer 'n onderhoudvoerder jou vir hulle vra in vermomming.
    - Ken wat NP-complete beteken.
    - [ ] [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 2020 - Lecture 23 - NP-Completeness (video)](https://www.youtube.com/watch?v=ItHp5laE1VE&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=23)
        - [ ] [CSE373 2020 - Lecture 24 - Satisfiability (video)](https://www.youtube.com/watch?v=inaFJeCzGxU&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=24)
        - [ ] [CSE373 2020 - Lecture 25 - More NP-Completeness (video)](https://www.youtube.com/watch?v=B-bhKxjZLlc&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=25)
        - [ ] [CSE373 2020 - Lecture 26 - NP-Completeness Challenge (video)](https://www.youtube.com/watch?v=_EzetTkG_Cc&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=26)
         - [ ] [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 bespreek amper-optimale oplossings vir die travaling salesman probleem:
        - [Jupyter Notebook](http://nbviewer.jupyter.org/url/norvig.com/ipython/TSP.ipynb)
    - Bladsye 1048 - 1140 in CLRS as jy dit het.

- ### Hoe rekenare 'n program proseseer

    - [ ] [How CPU executes a program (video)](https://www.youtube.com/watch?v=XM4lGflQFvA)
    - [ ] [How computers calculate - ALU (video)](https://youtu.be/1I5ZMmrOfnA)
    - [ ] [Registers and RAM (video)](https://youtu.be/fpnE6UAfbtU)
    - [ ] [The Central Processing Unit (CPU) (video)](https://youtu.be/FZGugFqdr60)
    - [ ] [Instructions and Programs (video)](https://youtu.be/zltgXvg6r3k)

- ### 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-)

- ### Prosesse en Threads
    - [ ] Rekenaar Wetenskap 162 - Operating Systems (25 videos):
        - vir prosesse en threads sien 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)
    - Dek:
        - Prosesse, Threads, Concurrency kwessies
            - Verskil tussen prosesse en threads
            - Prosesse
            - Threads
            - Locks
            - Mutexes
            - Semaphores
            - Monitors
            - How they work?
            - Deadlock
            - Livelock
        - CPU aktiwiteit, onderbrekings, konteks verandering
        - Moderne concurrency konstrukte met multicore prosesse
        - [Paging, segmentation and virtual memory (video)](https://youtu.be/O4nwUqQodAg)
        - [Interrupts (video)](https://youtu.be/iKlAWIKEyuw)
        - Prosess hulpbronne benodighede (geheue: kode, statiese stoor, stack, heap, en ook file descriptors, i/o)
        - Thread hulpbronne benodighede (deel boonstes (minus stack) met ander threads in die selfde proses maar elk het sy eie pc, stack counter, registers, en stack)
        - Vurk is regtig net 'n kopie op skryf (net-lees) tot dat 'n nuwe proses na die geheue skryf, dan doen dit 'n vol kopie.
        - Konteks verandering
            - Koe konteks verandering geïnisieer word deur 'n operating sisteem en onderliggende hardeware?
    - [ ] [threads in C++ (series - 10 videos)](https://www.youtube.com/playlist?list=PL5jc9xFGsL8E12so1wlMS0r0hTQoJL74M)
    - [ ] [CS 377 Spring '14: Operating Systems from University of Massachusetts](https://www.youtube.com/playlist?list=PLacuG5pysFbDQU8kKxbUh4K5c1iL5_k7k)
    - [ ] 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)

- ### Toets
    - Om te dek:
        - hoe eenheidstoetse werk
        - wat is mock objects
        - wat is integrasietoetse
        - wat 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)

- ### String soek & manipulasies
    - [ ] [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/lecture/algorithms-part2/introduction-to-substring-search-n3ZpG)
        - [ ] [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/lecture/algorithms-part2/rabin-karp-3KiqT)
    - [ ] [Search pattern in text (video)](https://www.coursera.org/learn/data-structures/lecture/tAfHI/search-pattern-in-text)

    As jy meer detail op hierde onderwerp doek, sien die "String Matching" seksie in [Bykomende Detail op Sommige Vakke](#bykomende-detail-op-sommige-vakke)

- ### Bome
    - Let daarop dat daar verskillende soorte bome is. Somiges het prefikse, somige nie, en somige gebruik string in stede van bits
        om die pad te volg
    - Ek het deur die kode geliees, maar sal nie implimenteer nie
    - [ ] [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/thrive/articles/Using%20Tries)
    - [ ] [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)

- ### 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)
        - Baie tegniese gesprek vir kernel devs. Moenie warrie as meeste oor jou kop gaan nie.
        - Die eerste helfde is genoeg.

- ### Networking
    - **As jy netwerk ondervinding het of wil 'n reliability ingenieur of operations ingenieur word, verwag vrae**
    - Anders is hierdie net goed om te weet
    - [ ] [Khan Academy](https://www.khanacademy.org/computing/code-org/computers-and-the-internet)
    - [ ] [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)

---

## Finalde Revisie

    Die seksie sal korter videos hê wat jy kan kyk redelik vinnig vir revisie van die mees belangrike konsepte.
    Dis goed om die geheue tydelik te vervris.

- [ ] Reeks van 2-3 minute kort onderwerp videos (23 videos)
    - [Videos](https://www.youtube.com/watch?v=r4r1DZcx1cM&list=PLmVb1OknmNJuC5POdcDv5oCS7_OUkDgpj&index=22)
- [ ] Reeks van 2-5 minute kort onderwerp videos - Michael Sambol (38 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)

---

## Werk Jou CV By

- Sien Resume voorbereiding in die boeke: "Cracking The Coding Interview" en "Programming Interviews Exposed"
- Ek weet nie hoe belangrik dit is nie (jy kan jou eie navorsing doen) maar hier is 'n artikel oor hoe om jou resume ATS versoenbaar te maak:
    - [How to Create or Check if your Resume is ATS Compliant](https://ayedot.com/97/MiniBlog/Meaning-of-ATS-compliant-resume-and-How-to-create-ATS-Resume-for-Free)
- ["This Is What A GOOD Resume Should Look Like" by Gayle McDowell (author of Cracking the Coding Interview)](https://www.careercup.com/resume), 
    - Nota duer die outeur: "This is for a US-focused resume. CVs for India and other countries have different expectations, although many of the points will be the same."
- ["Step-by-step resume guide" by Tech Interview Handbook](https://www.techinterviewhandbook.org/resume/guide)
    - Gedetailleerde gids oor hoe om jou resume op te stel van niks, hoe om effektiewe resume inhoud te skryf, dit te optimiseer, en jou resume te toets

## Kry die Werk

- [Sites for Finding Jobs](https://ayedot.com/151/MiniBlog/Top-10-Best-Websites-for-Careers--Jobs)

## Onderhoudproses & Algemene Voorbereiding

- [ ] [How to Pass the Engineering Interview in 2021](https://davidbyttow.medium.com/how-to-pass-the-engineering-interview-in-2021-45f1b389a1)
- [ ] [Demystifying Tech Recruiting](https://www.youtube.com/watch?v=N233T0epWTs)
- [ ] Hoe om 'n werk by die Groot 4 te kry:
    - [ ] [How to Get a Job at the Big 4 - Amazon, Facebook, Google & Microsoft (video)](https://www.youtube.com/watch?v=YJZCUhxNCv8)
    - [ ] [How to Get a Job at the Big 4.1 (Follow-up video)](https://www.youtube.com/watch?v=6790FVXWBw8&feature=youtu.be)
- [ ] Cracking The Coding Interview Set 1:
    - [ ] [Gayle L McDowell - Cracking The Coding Interview (video)](https://www.youtube.com/watch?v=rEJzOhC5ZtQ)
    - [ ] [Cracking the Coding Interview with Author Gayle Laakmann McDowell (video)](https://www.youtube.com/watch?v=aClxtDcdpsQ)
- [ ] Cracking the Facebook Coding Interview:
    - [ ] [The Approach](https://www.youtube.com/watch?v=wCl9kvQGHPI)
    - [ ] [Problem Walkthrough](https://www.youtube.com/watch?v=4UWDyJq8jZg)

- Prep Courses:
    - [Software Engineer Interview Unleashed (paid course)](https://www.udemy.com/software-engineer-interview-unleashed):
        - Leer hoe om jouself gereed te maak vir sagteware ingeneur onderhoude van vorige Google onderhoudvoerders.
    - [Python for Data Structures, Algorithms, and Interviews (paid course)](https://www.udemy.com/python-for-data-structures-algorithms-and-interviews/):
        - 'n Python sentriese onderhoudsvoorbereiding kursus wat datastrukture, algoritmes, spot onderhoude en baie meer dek.
    - [Intro to Data Structures and Algorithms using Python (Udacity free course)](https://www.udacity.com/course/data-structures-and-algorithms-in-python--ud513):
        - 'n Verniet Python sentriese datastruktuur en algorithme kursus.
    - [Data Structures and Algorithms Nanodegree! (Udacity paid Nanodegree)](https://www.udacity.com/course/data-structures-and-algorithms-nanodegree--nd256):
        - Kry praktiese ervaring met oor 'n 100 datastrukture en algoritmiese oefeninge en leiding van 'n toegewyde mentor om jou te help voorberei vir onderhoude en on-the-job scenarios.
    - [Grokking the Behavioral Interview (Educative free course)](https://www.educative.io/courses/grokking-the-behavioral-interview):
        - Baie kere is dit nie jou tegniese bevoegdheid wat jou terug hou van jou droom werk kry nie, dis hoe jy in die gedragsonderhoude voer.

Spot Onderhoude:
- [Gainlo.co: Mock interviewers from big companies](http://www.gainlo.co/#!/) - Ek het die gebruik en dit het my gehelp ontspan vir die foon skerm en on-site onderhoud.
- [Pramp: Mock interviews from/with peers](https://www.pramp.com/) - peer-to-peer model van onderhoudoefeninge.
- [interviewing.io: Practice mock interview with senior engineers](https://interviewing.io) - anoniem algoritme/system design onderoude met senior ingeneurs van FAANG anoniem.

## Dink aan vir wanneer die onderhoud kom

Dink oor sowat 20 onderhoud vrae wat jy sal kry, in die rigting van dié hieronder. Hê ten minste een antwoord vir elkeen.
Hê ook 'n storie, nie net data, oor iets wat jy bereik het.

- Hoekom soek jy hierdie werk?
- Wat is 'n taai probleem wat jy opgelos het?
- Grootste uitdagings wat jy in die gesig gestaar het?
- Beste/slegste ontwerpe wat jy al gesien het?
- Idees om 'n produk te verbeter?
- Hoe werk jy beste as 'n individu en as deel van 'n span?
- Watse vernufte of ondervinding van jou sal 'n bate in die rol wees en hoekom?
- Wat het jy die meeste geniet by [werk x / projek y]?
- Wat was die grootste uitdaging wat jy in die gesig gestaar het by [werk x / pojek y]?
- Wat was die moeilikste gogga wat jy moes oplos by [werk x / projek y]?
- Wat het jy geleer by [werk x / projek y]?
- Wat sou jy beter gedoen het by [werk x / projek y]?

- As jy dit moelik vind om met goeie antwoorde op te kom vir hierdie vrae is hier 'n paar idees:
    - [General Interview Questions and their Answers](https://ayedot.com/119/MiniBlog/General-Interview-Questions-and-their-Answers-for-Tech-Jobs)

## Hê vrae vir die onderhoudvoerder

'n Paar van meine (Ek ken moontlik al klaar die antwoorde, maar wil hulle opinie of span perspektief hé):

- How groot is jou span?
- Hoe lyk jou dev cycle? Doen julle waterfall/sprints/agile?
- Is dit algemeen om na die sperdatum te jaag? Of is daar buigsaamheid?
- Hoe word besluite geneem op jou span?
- Hoeveel vergaderings het julle per week?
- Voel jy die omgewing help jou fokus?
- Wat werk jy aan?
- Wat hou jy van dit?
- Hoe is die werk lewe?
- Hoe is die werk/lewe belaans?

## Sodra Jy Die Werk Het

Geluk!

Hou aan leer.

Jy is nooit regtig klaar nie.

---

    *****************************************************************************************************
    *****************************************************************************************************

    Alles hieronder is opsioneel. Dit is NIE nodig vir 'n intreevlak ingeneur nie.
    Alhowel, deur om dit te studeer sal jy meer blootstelling kry met CS konsepte, en sal beter voorbereid wees vir
    enige sagteware ingeneur werk. Jy sal 'n veel meer afgeronde sagteware ingeneur wees.

    *****************************************************************************************************
    *****************************************************************************************************

---

## Bykomende Boeke

    Hierdie is hier sodat jy kan delf in 'n onderwerp wat jy interessant vind.

- [The Unix Programming Environment](https://www.amazon.com/dp/013937681X)
    - An oue maar goeie
- [The Linux Command Line: A Complete Introduction](https://www.amazon.com/dp/1593273894/)
    - 'n Moderne opsie
- [TCP/IP Illustrated Series](https://en.wikipedia.org/wiki/TCP/IP_Illustrated)
- [Head First Design Patterns](https://www.amazon.com/gp/product/0596007124/)
    - 'n Sagte inleiding na ontwerp patrone
- [Design Patterns: Elements of Reusable Object-Oriente​d Software](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612)
    - AKA die "Gang Of Four" boek, of GOF
    - Die kanoniese ontwerp patrone boek
- [Algorithm Design Manual](http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202) (Skiena)
    - As 'n revisie en probleem herkening
    - Die algoritme katalogus porsie is ver buite die omvang van probleme wat jy in die onderhoud sal kry
    - Die bok het 2 dele:
        - Klass teksboek oor datastrukture en algoritmes
            - Pros:
                - Is so goed 'n revisie soos enige teksboek sal wees
                - Goeie stories van sy ondervinding met probleme oplos in die bedryf en akademie
                - Kode voorbeelde in C
            - Cons:
                - Kan so dig en ondeurdringbaar soos CLRS wees, en in sommige gevalle, kan CLRS 'n beter alternatief wees vir sekere onderwerpe
                - Hoofstukke 7, 8, 9 kan pynlik wees om te probeer volg, omdat sommige items nie goed verduidelik word nie en bonodig meer brain wat ek nie het nie
                - Moenie my misverstaan nie: Ek hou van Skiena, sy onderrig style, en manerismes, maar ek mag dalk nie Stony Brook materiaal wees nie
        - Algorime katalogus:
            - Die is die egte rede hoekom jy hierdie boek koop.
            - Die boek is beter as 'n algoritme verwysing, en nie iets wat jy lees om heel te dek nie.
    - Kan op Kindle huur
    - Antwoorde
        - [Solutions](https://web.archive.org/web/20150404194210/http://www.algorithm.cs.sunysb.edu/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition))
    - [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)
    - Die boek was gepubliseer in 2004, en is sowat verouderd, maar dis 'n geweldige hulpbron om 'n rekenaar in kort te verstaan
    - Die outeur het [HLA](https://en.wikipedia.org/wiki/High_Level_Assembly) uitgeving, so vat noemings en voorbeelde in HLA met 'n graan sout. Nie wyd gebruik nie, maar goeie voorbeelde van hoe assembly lyk
    - Hierdie hoofstukke is die moeite werk om te lees vir 'n goeie fondament:
        - Hoofstuk 2 - Numeric Representation
        - Hoofstuk 3 - Binary Arithmetic and Bit Operations
        - Hoofstuk 4 - Floating-Point Representation
        - Hoofstuk 5 - Character Representation
        - Hoofstuk 6 - Memory Organization and Access
        - Hoofstuk 7 - Composite Data Types and Memory Objects
        - Hoofstuk 9 - CPU Architecture
        - Hoofstuk 10 - Instruction Set Architecture
        - Hoofstuk 11 - Memory Architecture and Organization
- [Introduction to Algorithms](https://www.amazon.com/Introduction-Algorithms-fourth-Thomas-Cormen/dp/026204630X)
    - **Belangrik:** Om hierdie boek te lees sal beperkte waarde hê. Die boek is 'n goeie revisie van algoritmes en datastrukture, maar sal jou nie leer hoe om goeie kode te skryf nie. Jy moet in staat wees om goeie, effektiewe oplossings te programeer
    - AKA CLR, soms CLRS, omdat Stein laat saamgekom het
- [Computer Architecture, Sixth Edition: A Quantitative Approach](https://www.amazon.com/dp/0128119055)
    - Vir 'n ryker, meer geopdateerde (2017), maar langer behandeling

## System Design, Scalability, Data Handling

**Jy kan 'n paar ondtwerp vrae verwag as jy 4+ jare ondervinding het.**

- Scalability en System Design is beide baie groot onderwerpe met onderwerpe en hulpbronne, omdat
      daar baie is om te oorweeg wanneer 'n sagtewaar/hardewaar sisteem wat kan skaal geontwerp word.
      Verwag om nogals 'n bikie tyd hierop te spandeer
- Oorwegings:
    - Scalability:
        - Distileer grood data stelle na 'n enkele waarde
        - Transformeer een data stel na 'n ander een
        - Hantering van baie groot bedrae van data
    - System design
        - features sets
        - interfaces
        - class hierarchies
        - ontwerp van 'n sisteem onder sekere beperkings
        - eenvoud en robuustheid
        - tradeoffs
        - performance analysis and optimization
- [ ] **BEGIN HIER**: [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) - Daar is baie hulpbronne in hierdie een. Look deur die artikels en voorbeelde. Ek wys 'n paar hieronder
- [ ] [How to ace a systems design interview](https://web.archive.org/web/20120716060051/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)
- [ ] Konsensus Algoritme:
    - [ ] 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:
    - Jy nodig nie al dié nie. Kies net 'n paar wat vir jou interressant is.
    - [ ] [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/thrive/articles/The%20Importance%20of%20Algorithms)
    - [ ] [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)
    - [ ] Sien "Messaging, Serialization, and Queueing Systems" ver onder vir informasie oor van die tegnologies wat dienste saam kan gom
    - [ ] 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)
    - Vir nog meer, sien "Mining Massive Datasets" video reeks in die [Video Reeks](#video-reeks) seksie
- [ ] Oefen die system design fase: Hier is 'n paar idees om op papier uit te werk, elkeen met dokumentasie oor hoe dit in die regte wêreld gehanteer was:
    - revisie: [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)
    - vloei:
        1. Verstaan die probleem en scope:
            - Defineer die gebruik gevalle, met die onderhoudvoerder se hulp
            - Stel addisionele kenmerke voor
            - Verwyder items wat die onderhoudvoerder buite die scope ag
            - Neem aan hoë beskikbaarheid sal nodig wees, voeg as 'n gebruik geval by
        2. Dink oor beperkings:
            - Vra hoeveel versoeke per maand
            - Vra hoeveel versoeke per sekonde (hulle mag dit dalk net gee of vir jou vra om dit uit te werk)
            - Skat lees vs. skryf persentasie
            - Hou 80/20 reel byderhands wanneer jy die skatting doen
            - Hoeveel data word geskryf per sekonde
            - Totale berging benodig oor 5 jaar
            - Hoeveel data lees per sekonde
        3. Abstrakte ontwerp:
            - Lae (dienste, data, caching)
            - Infristraktuur: load balancing, messaging
            - Rof oorsig van enige sleutel algoritmes wat die diens dryf
            - Oorweeg knelpunte en determineer oplossings
    - Oefeninge:
        - [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://web.archive.org/web/20220217064329/https://adayinthelifeof.nl/2011/02/06/memcache-internals/)

## Bykomende Leer

    Ek het hulle by gevoeg om jou te help 'n afgeronde sagteware ingeneur te word en bewus van sekere
    tegnologies en algoritmes is, sodat jy 'n groter toolbox het.

- ### 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)
    - Familiariseer jouself met 'n unix-gebaseerde kode 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/)
        - reeks van 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)
        - reeks van 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)
	- [The Absolute Beginner's Guide to Emacs (video by David Wilson)](https://www.youtube.com/watch?v=48JlgiBpw_I&t=0s)
	- [The Absolute Beginner's Guide to Emacs (notes by David Wilson)](https://systemcrafters.net/emacs-essentials/absolute-beginners-guide-to-emacs/)

- ### Unix command line tools
    - Ek het die lys hieronder met goeie gereedskap gevul.
    - bash
    - cat
    - grep
    - sed
    - awk
    - curl or wget
    - sort
    - tr
    - uniq
    - [strace](https://en.wikipedia.org/wiki/Strace)
    - [tcpdump](https://danielmiessler.com/study/tcpdump/)

- ### Inligtingsteorie (videos)
    - [Khan Academy](https://www.khanacademy.org/computing/computer-science/informationtheory)
    - Meer oor 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)
    - Sien meer in MIT 6.050J Information and Entropy reeks hieronder

- ### 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
    - Sien ook videos hieronder
    - Maak seker om die inligtingsteorievideos eers te kyk
    - [Information Theory, Claude Shannon, Entropy, Redundancy, Data Compression & Bits (video)](https://youtu.be/JnJq3Py0dyM?t=176)

- ### Cryptography
    - Sien ook videos hieronder
    - Maak seker om die inligtingsteorievideos eers te kyk
    - [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
    - Maak seker om die inligtingsteorievideos eers te kyk
    - 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)

- ### Rekenaar Sekuriteit
    - [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, en 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 (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
    - 'n Bloom filter met m bits en k hashing funksies, het albei insertion en membership testing as 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
    - Gebruik om die ooreenkoms van dokumente te bepaal
    - Die teenoorgestelde van MDS of SHA is gebruik om te bepaal of 2 dokumente/strings dieselfde is
    - [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
    - Ken ten minste een tipe balanced binary tree (en ken hoe om dit te implimenteer):
    - "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
    - Van die het ek gekies om splay tree's te implementeer. Van wat ek gelees het, sal jy nie
        'n balanced search tree in jou onderjoud implimenteer nie. Maar ek wou blootstelling hê met een kodeer
        en eerlikwaar is splay trees die bye se knieë. Ek het baie red-black tree kode gelees
        - Splay tree: insert, delete funksies
        As jy besluit om red/black trees te implimenteer, probeer hierdie:
        - Soek en insertion funksies, skiep delete
    - Ek wil meer oor B-Tree's leer omdat dit gebruik word met groot datastelle
    - [Self-balancing binary search tree](https://en.wikipedia.org/wiki/Self-balancing_binary_search_tree)

    - **AVL trees**
        - Prakties:
            Van wat ek kan sê, word hierdie nie veel in die praktyk gebruik nie, maar ek kan sien waar dit sou gebruik word:
            Die AVL boom is nog 'n stuktuur wat O(log n) search, insertion, en verwydering ondersteun. Dit is meer rigied
            gebalanseer as red-black trees, wat lei na stadiger insertion en verwydering maar vinniger herwinning. Dit maak 
            dit aantreklik vir datastrukture wat een keer gebou word en laai sonder herkonstuksie, soos taal
            woordeboeke (of program woordeboeke, soos die opcodes van 'n assembler of 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**
        - Prakties:
            Splay bome is tipies gebruik in die implementering van caches, memory allocators, routers, garbage collctors,
            data compression, ropes (vervanging van string gebruik vir lang teks strings), in Windows NT (in die virtual memory,
            networking en file system kode) etc
        - [CS 61B: Splay Trees (video)](https://archive.org/details/ucberkeley_webcast_G5QIXywcJlY)
        - MIT Lecture: Splay Trees:
            - Word baie wiskundig, maar kyk die laaste 10 minute vir seker
            - [Video](https://www.youtube.com/watch?v=QnPl_Y6EqMo)

    - **Red/black trees**
        - Die is 'n vertaling van die 2-3 boom (sien onder).
        - Prakties:
            Red-black trees bied slegste-geval waarborge vir insertion tyd, deletion tyd, en soek tyd.
            Dit maak hulle waardevol in tyd-sensitiewe toepe soos regte-tyd toepassings,
            maar dit maak hulle waardevolle bou blokke in ander datastrukture wat slegste-geval waarborge voorsien:
            byvoorbeeld, baie datastrukture wat in rekenaar meetkunde gebruik word kan gebaseer wees op red-black trees, en
            die Completely Fair Scheduler gebruik in huidige Linux kernels gebruik red-black trees. In die 8ste weergawe van Java
            word die Collection HashMap gemodifiseersodat in stede van 'n Linked List om identiese elemente te stoor met arm
            hashcodes, word 'n Red-Black tree gebruik
        - [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/thrive/articles/An%20Introduction%20to%20Binary%20Search%20and%20Red-Black%20Trees)

    - **2-3 search trees**
        - Prakties:
            2-3 bome het vinniger inserts teen die uitgawe van stadiger searches (aangesien hooggte meer is in vergelyking met AVL trees).
        - Jy sal 2-3 trees baie selde gebruik omdat die implentering verskeie tipe nodes gebruik. In plek daarvan, gebruk mense 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)**
        - Prakties:
            Vir elke 2-4 tree, is daar 'n ooreenstemmende red-black tree met data elemente in dieselfde orde. Die insertion en deletion
            operations op 2-4 trees is ook ekwivalent na kleur-verandering en rotasies in red-black trees. Die maak 2-4 trees 'n
            belangrike instrument om die logika angter red-black trees te verstaan, en dis hoekeom baie inleiding algoritmes tekste
            2-4 bome net voor red-black trees voorstel, selfs al word **2-4 trees nie gereeld in die praktyk gebruik word nie**.
        - [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**
        - let wel: die N of K is die branching faktoor (max branches)
        - binary trees is 'n 2-ary tree, met branching faktoor = 2
        - 2-3 trees is 3-ary
        - [K-Ary Tree](https://en.wikipedia.org/wiki/K-ary_tree)
    
    - **B-Trees**
        - Prettige feit: dis 'n misterie, maar die B kan staan vir Boeing, Balanced, of Bayer (mede-uitvinders)
        - Prakties:
            B-Trees word word gebruik in databasisse. Meeste moderne filesystems gebruik B-trees (of variante). Benewens
            die gebruik in databasisse, word dit ook gebruik in filesystems om vinnige ewekansige toegang tot 'n arbitrêre
            blok in 'n spesifieke lêer te gee. Die basiese probleem is om die lêer blok i address na 'n disk blok 
            (of eerder 'n cylinder-head-sektor) address te verander
        - [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)
                - dek cache-oblivious B-Trees, baie interessante datastrukture
                - die eerste 37 minute is baie tegnies en mag geskiep word (B is block size, cache line size)


- ### k-D Trees
    - Fantasties om die hoeveelheid punte in 'n vierkant of hoër dimensie objek te kry
    - 'n Goeie keuse vir k-nearest neighbors
    - [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)

- ### Lineêre Programering (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
    - Hoekom 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/tutorials)
    - [Practical Guide to implementing Neural Networks in Python (using Theano)](http://www.analyticsvidhya.com/blog/2016/04/neural-networks-python-theano/)
    - Kursusse:
        - [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)
        - [Google's Deep Learning Nanodegree](https://www.udacity.com/course/deep-learning--ud730)
        - [AWS Machine Learning Engineer Nanodegree](https://www.udacity.com/course/aws-machine-learning-engineer-nanodegree--nd189)
        - [Self-Driving Car Engineer Nanodegree](https://www.udacity.com/drive)
    - Hulpbronne:
        - Boeke:
            - [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/

---

## Bykomende Detail op Sommige Vakke

    Ek het die by gevoeg om sommige idees wat al klaar bo aagebied was, maar nie ingesluit was nie 
    omdat dit te veel is, te versterk. Dis maklik om 'n onderwerp te oordoen
    Jy wil in hierdie eeu aangestel word, nê?

- **SOLIED**
    - [ ] [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)

- **Meer Dinamiese Programering** (videos)
    - [6.006: Dynamic Programming I: Fibonacci, Shortest Paths](https://www.youtube.com/watch?v=r4-cftqTcdI&ab_channel=MITOpenCourseWare)
    - [6.006: Dynamic Programming II: Text Justification, Blackjack](https://www.youtube.com/watch?v=KLBCUx1is2c&ab_channel=MITOpenCourseWare)
    - [6.006: DP III: Parenthesization, Edit Distance, Knapsack](https://www.youtube.com/watch?v=TDo3r5M1LNo&ab_channel=MITOpenCourseWare)
    - [6.006: DP IV: Guitar Fingering, Tetris, Super Mario Bros.](https://www.youtube.com/watch?v=i9OAOk0CUQE&ab_channel=MITOpenCourseWare)
    - [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** (wiskundig, en gaan stadig, wat goed is vir wiskundige goed) (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/lecture/data-structures/rabin-karps-algorithm-c0Qkw)
        - [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)
        - Begin goed, maar teen die tyd wat dit verby KMP gaan word dit meer ingewikkeld as wat dit hoef te wees
        - goeie verduideliking van tries
        - kan geskiep word

- **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:
        - [CSE373 2020 - Mergesort/Quicksort (video)](https://www.youtube.com/watch?v=jUf-UQ3a0kg&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=8)
        - [CSE373 2020 - Linear Sorting (video)](https://www.youtube.com/watch?v=0ksyQKmre84&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=9)

## Video Reeks

Sit terug en geniet.

- [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)

- [Skiena lectures from Algorithm Design Manual - CSE373 2020 - Analysis of Algorithms (26 videos)](https://www.youtube.com/watch?v=22hwcnXIGgk&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&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)

- [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.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)

## Rekenaar Wetenskap Kursusse

- [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)

## Algoritmiese implementasie

- [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)
    - meestal gevervang deur 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)
    - Die Dynamo papier het die NoSQL revolusie afgeskop
- [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: 'n Vinnige 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)
