big O poster

http://bigocheatsheet.com/

Blind typing training online - typingclub.com GOOD RESOURCE

https://www.typingclub.com

typing games:
http://www.typingstudy.com/

MIT Open Courseware - GREAT COURSE RESOURCE!!!!

Publicly available MIT lectures (videos, notes, assignments)

https://ocw.mit.edu/courses/electrical-engineering-and-computer-science

very good book series Syncfusion Succinctly

https://www.syncfusion.com/resources/techportal/ebooks
https://www.syncfusion.com/resources/techportal/details/ebooks/Reactjs_Succinctly

List of recommended youtube channels from ycombinator

https://news.ycombinator.com/item?id=12702651

F# - Why you should give an F - Daniel Chambers - YouTube

F# - Why you should give an F - Daniel Chambers - YouTube

Stress Testing: the [Almost] Silver Bullet for Debugging | Coursera

1. It is very important to write programs that work correctly on all the allowed inputs.
2. Testing is essential to writing correct programs.
3. First test on a few small manual tests, then test for each type of answer, then test on large test cases for time limit and memory limit, then test on corner cases.
4. After that, apply stress testing to ensure your program works - it will almost always lead to correct solution. You can do it before your first attempt to submit your solution - and will often get it right from the first attempt!
5. Stress testing consists of implementing the intended solution, another simple possible slow solution, a test generator and an infinite loop which generates tests and compares answers of the two solutions.
6. Always try to find the smallest test cases on which your solution fails.
7. Try different regions of the test space when generating cases for stress testing.

https://www.coursera.org/learn/algorithmic-toolbox/supplement/RULv4/stress-testing-the-almost-silver-bullet-for-debugging

Interactive Vim tutorial

Interactive Vim tutorial:

http://www.labnol.org/internet/learning-vim-for-beginners/28820/

Heapsort Algorythm

procedure heapsort(a, count) is
    input: an unordered array a of length count
 
    (Build the heap in array a so that largest value is at the root)
    heapify(a, count)

    (The following loop maintains the invariants that a[0:end] is a heap and every element
     beyond end is greater than everything before it (so a[end:count] is in sorted order))
    end ← count - 1
    while end > 0 do
        (a[0] is the root and largest value. The swap moves it in front of the sorted elements.)
        swap(a[end], a[0])
        (the heap size is reduced by one)
        end ← end - 1
        (the swap ruined the heap property, so restore it)
        siftDown(a, 0, end)

(Put elements of 'a' in heap order, in-place)
procedure heapify(a, count) is
    (start is assigned the index in 'a' of the last parent node)
    (the last element in a 0-based array is at index count-1; find the parent of that element)
    start ← iParent(count-1)
    
    while start ≥ 0 do
        (sift down the node at index 'start' to the proper place such that all nodes below
         the start index are in heap order)
        siftDown(a, start, count - 1)
        (go to the next parent node)
        start ← start - 1
    (after sifting down the root all nodes/elements are in heap order)

(Repair the heap whose root element is at index 'start', assuming the heaps rooted at its children are valid)
procedure siftDown(a, start, end) is
    root ← start

    while iLeftChild(root) ≤ end do    (While the root has at least one child)
        child ← iLeftChild(root)   (Left child of root)
        swap ← root                (Keeps track of child to swap with)

        if a[swap] < a[child]
            swap ← child
        (If there is a right child and that child is greater)
        if child+1 ≤ end and a[swap] < a[child+1]
            swap ← child + 1
        if swap = root
            (The root holds the largest element. Since we assume the heaps rooted at the
             children are valid, this means that we are done.)
            return
        else
            swap(a[root], a[swap])
            root ← swap            (repeat to continue sifting down the child now)

Depth-first search - Wikipedia, the free encyclopedia

Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. One starts at the root(selecting some arbitrary node as the root in the case of a graph) and explores as far as possible along each branch beforebacktracking.

A recursive implementation of DFS:^[5]

1  procedure DFS(G,v):
2      label v as discovered
3      for all edges from v to w in G.adjacentEdges(v) do
4          if vertex w is not labeled as discovered then
5              recursively call DFS(G,w)

A non-recursive implementation of DFS:^[6]

1  procedure DFS-iterative(G,v):
2      let S be a stack
3      S.push(v)
4      while S is not empty
5            v = S.pop()
6            if v is not labeled as discovered:
7                label v as discovered
8                for all edges from v to w in G.adjacentEdges(v) do
9                    S.push(w)

UML 2 Diagrams

Introduction to the Diagrams of UML 2.X:

Robustness (computer science)

Robustness (computer science) - Wikipedia, the free encyclopedia: "In computer science, robustness is the ability of a computer system to cope with errors during execution. Robustness can also be defined as the ability of an algorithm to continue operating despite abnormalities in input, calculations, etc.

Fuzz testing ~ random input testing

Fuzz testing - Wikipedia, the free encyclopedia

Logarithm(log, lg, ln), Logarithmic Formulas

Heap (data structure)

Heap - specialized tree (usually binary) data structure adhere, conform to heap property: parent node key is greater(less) then child nodes for two heap types max heap (min heap)

Used in heap sort algorithm and Dijkstras graph algorithm

Heap Sort - use max-heapify alg N times

Heap (data structure) - Wikipedia, the free encyclopedia:

Stack (LIFO), QUEUE (FIFO) - mnemonics sample

STACK (LIFO)  - mnemonic vertical stack of leafs

QUEUE (FIFO) - mnemonic horizontal queue of football balls

FINO (First In Never OUT) FISH (First In Still There) - memory leak (memo leak in brain)

Stack (abstract data type) - Wikipedia, the free encyclopedia:

https://en.wikipedia.org/wiki/FIFO_(computing_and_electronics)

https://en.wikipedia.org/wiki/FINO