Init react

Commend

npx create-react-app .

npx means you use this package but don’t download it.

or with redux

npx create-react-app my-app --template redux

life cycle

shouldComponentUpdate()

Run before render() to check this component need to render or not.

Monitor

signal condition –> waiting monitor –> signaling

producer and consumer with a buffer whose size is one

monitor PC {
    Object buffer;

    void produce(Object o){
        if(buffer != null){ // while
            empty.wait();
        }
        buffer = o;
        full.signal();
    }

    Object consume() {
        if(buffer == null) // while
            full.wait();
        Object temp = buffer;
        empty.signal();
        return temp;
    }
}

Semaphore

// Assumption: E < S < W (Signal and urgent wait)
monitor Semaphore {
    int permit;

    void acquire() {
        if(permit == 0){
            permitsAvailable.wait();
        } else {
            permit--;
        }
    }

    void release(){
        if(!permitAvailable.isEmpty()){
            permitsAvailable.signal();
        } else{
            permit++;
        }
    }
}

readers and writers

assume start first and stop

Content

• Content
• Algorithm Overview
• Copy
• For each
• Generation
• Heap
• Merge
• Move
• Number
• Partition
• Permutation
• Remove
• Replace
• Reverse
• rotate
• Search
• Set
• Shuffle
• Sort
• Swap
• Test range
• Unique

Algorithm Overview

* –> new feature from C++11

Copy

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main(int argc, char const *argv[])
{
	vector<int> iv = {1,2,3,4,5,6};

	vector<int> iv2(6);
	copy(iv.begin(), iv.end(), iv2.begin());
	// iv2: 1 2 3 4 5 6

	vector<int> iv3(3);
	copy_if(iv.begin(), iv.end(), iv3.begin(), [](int a){return a % 2 == 0;});
	// iv3: 2 4 6

	vector<int> iv4(5);
	copy_n(iv.begin(), 5, iv4.begin());
	// iv4: 1 2 3 4 5 6

	vector<int> iv5(6);
	copy_backward(iv.begin(), iv.end(), iv5.end());
	// iv5: 1 2 3 4 5 6

	return 0;
}

Back to top

SCSS features

Variables

$font-stack: Helvetica, sans-serif;
$primary-color: #333;

body {
    font: 100% $font-stack;
    color: $primary-color;
}

Operator

.container {
    width: 100%;
}

article[role='main'] {
    float: left;
    width: 600px / 960px * 100%;
}

article[role='complementary'] {
    float: right;
    width: 300px / 960px * 100%;
}

String interpolation

$name: foo;
$attr: border;
p.#{$name} {
    #{$attr}-color: blue;
}

This is compile to:

Semaphore

Initialize how many permissions you will use.

acquire() will add one permission.

release() will remove one permission.

Permission must ≥ 0.

Semaphore solution for the MEP

1. #criticalSection + permissions = 1
2. #criticalSection = #acquires − #releases

Mutual exclusion: #criticalSection ≤ 1 since #permission ≥ 0. Absence of deadlock: It never happens that #permission = 0 and #criticalSection = 0

Java

public class Turnstile extends Thread {
    static volatile int counter = 0; // keyword is recommended for variables that are shared
    static Semaphore mutex = new Semaphore (1);
    public void run() {
        for(int i = 0; i < 50; i++){
            mutex.acquire();
            counter ++;
            mutex.release();
            System.out.println(id+"- In comes: "+i );
        }
    }

    public static void main(String args[]) {
        try{
            Thread m1 = new Turnstile (1); m1.start();
            Thread m2 = new Turnstile (2); m2.start();
        } catch(Exception e){}
    }
}

Strong semaphore

Possibility of starvation is caused by the fact that blocked processes are placed in a set of processes. But this can be remedied by changing the set to be a queue.

Race condition

Multiple thread access one same variables of object concurrently and at least one does update.

Bad situation.

Atomic operation

An operation is atomic if it execute until it completion without interruption

Critical section

A part of program that accesses shared memory and which we which to execute automatically.

mutual exclusion problem (MEP)

1. Mutex: at and point in time, there is at most one thread in the critical section
2. Absence of livelock: If various of threads try to entry the critical section, at lease one of them will succeed.
3. Free from starvation: A thread trying to enter its critical section will eventually be able to do so.

Deadlock is not exit for a interleaving in a transition system.

Agile Vs Traditional SDLC Models

Agile is based on the adaptive software development methods, whereas the traditional SDLC models like the waterfall model is based on a predictive approach. Predictive teams in the traditional SDLC models usually work with detailed planning and have a complete forecast of the exact tasks and features to be delivered in the next few months or during the product life cycle.

Predictive methods entirely depend on the requirement analysis and planning done in the beginning of cycle. Any changes to be incorporated go through a strict change control management and prioritization.

Document constructor

$$f(x) = sin(x)$$

What is concurrency

Systems of interacting computer programs which share resource and run concurrently.

parallelism and concurrency

Parallelism: Occurring physically at the same time.

Concurrency: Occurring logically at the same time.

synchronization

Process synchronization: Ensure the instructions are executed in certain order.

Synchronization is irrelevant if processes do not interact with each other.

Concurrency, and hence process synchronized, is useful only when processes interact with each other.

interaction

Share memory is kind of interact.

See all algorithm click here

Mutating and Non-mutating algorithms

Mutating algorithms

Mutating algorithms means this algorithm will change the content that iterator pointed to. Like copy, swap, replace, fill, remove, permutation, partition, random shuffling and sort.

If your give these algorithms a const iterator, only error will be returned.

#include <iostream>
#include <vector>
using namespace std;

int main(int argc, char const *argv[])
{
    std::vector<int> iv = {22,30,30,17,33,40,17,23,22,12,20};

    vector<int>::iterator ib = iv.begin();
    vector<int>::iterator ie = iv.end();

    sort(ib,ie); //works

    for (std::vector<int>::iterator i = iv.begin(); i != iv.end(); ++i)
    {
        cout << *i << ' ';
    }
    cout << endl;

    // vector<int>::const_iterator ib = iv.begin();
    // vector<int>::const_iterator ie = iv.end();

    // sort(ib,ie); // error
    return 0;
}

Non-mutating algorithm

Algorithm not change any element that iterator pointed to. Like: find, search, for_each, count, equal_mismatch, max, min.