DEV Community: Yogeswaran

What's New In DevTools (Chrome 76)

Yogeswaran — Sat, 01 Jun 2019 06:26:42 +0000

Autocomplete with CSS values After typing bold the Styles pane autocompletes to font-weight: bold
A new UI for network settings Network Settings. Mapping the old locations to the new.
WebSocket messages in HAR exports

...
"_webSocketMessages": [
  {
    "type": "send",
    "time": 1558730482.5071473,
    "opcode": 1,
    "data": "Hello, WebSockets!"
  },
  {
    "type": "receive",
    "time": 1558730482.5883863,
    "opcode": 1,
    "data": "Hello, WebSockets!"
  }
]
...

When exporting a HAR file from the Network panel to share network logs with your colleagues, your HAR file now includes WebSocket messages. The _webSocketMessages property begins with an underscore to indicate that it's a custom field.

HAR import and export buttons The new HAR buttons.
Real-time total memory usage The bottom of the Memory panel shows that the page is using 43.4 MB of memory in total. 209 KB/s indicates that total memory usage is increasing 209 KB per second.
Service worker registration port numbers Service worker ports.
Inspect Background Fetch and Background Sync events The Background Fetch pane. Demo by Maxim Salnikov. The Background Sync pane.

Resource: What's New In DevTools (Chrome 76)

Join the best and biggest Community!
Click Here

Samsung's "DeepFake" video of a TALKING Mona Lisa painting

Yogeswaran — Fri, 24 May 2019 07:09:56 +0000

While terrifying fake videos are nothing new, what the computer geeks in Moscow have managed to do it create them using only one image.

Previously, researchers would take multiple pictures of a celeb before “mapping” them onto the moving features of another person to create the so-called ‘DeepFake’ in a technique known as "puppeteering".

And while using several images creates a more convincing fake, the prospect of hackers being able to create bogus videos using a single photograph is frightening.

In the Mona Lisa example, the team shows how the animated painting looks slightly different depending on the person whose face is used behind the famous image.
Read more

Join My Community for daily resources and courses.
Join My Info Community for daily information around Technologies, Development, AI, Computing, etc.
Join My Blockchain Community for daily articles of blockchain and cryptocurrency.
Join My Memes Community for daily programming memes.

The Difference Between Malware, Viruses and Ransomware Explained

Yogeswaran — Thu, 23 May 2019 10:38:52 +0000

Virus
Virus is a type of malicious software capable of self-replication. A virus needs human intervention to be ran and it can copy itself into other computer programs, data files, or in certain sections of your computer, such as boot sector of the hard drive. Once this happens these elements will become infected. Computer viruses are designed to harm computers and information systems and can spread through the internet, through malicious downloads, infected email attachments, malicious programs, files or documents. Viruses can steal data, destroy information, log keystrokes and more. The best way to avoid viruses from infecting your computers is to install multiple anti-virus software, and scan for virus regularly.
Malware
Malware or Malicious Software is an umbrella term that refers to software that is defined by malicious intent. This type of ill-intentioned software can disrupt normal computer operations, harvest confidential information, obtain unauthorised to computer systems, display unwanted advertising and more.
Ransomware
Ransomware is type of malware which encrypts all the data on a PC or mobile devices, blocking the data owner's access to it. After the infection happens, the victim receives a message that tells him/her that a certain amount of money must be paid in order to get the decryption key. Usually, there is also a time-limit for the ransom to be paid. There's also no guarantee that the, if the victim pays the ransom, he/she will get the decryption key. The most reliable solution is to back up your data in at least 3-5 different places and keep those backups up-to-date, so you don't lose important progress.

Join My Community where i share resources and courses daily!
Click Here

Join My Info Community where i share the latest articles and information about technology
Click Here

Join My Blockchain Community where i share the latest info and resources on blockchain & cryptocurrency
Click Here

Join My Programming Memes Community where i share daily memes
Click Here

Share my articles and Join my community!

Part 2: Sorting Algorithm

Yogeswaran — Thu, 11 Apr 2019 11:50:36 +0000

Merge Sort

Merge sort is divided and conquer algorithm. It divides input array into two halves, calls itself for the two halves and then merges the two sorted halves. The merge() function is used for merging two halves. The merge(arr,l,m,r) is a key process that assumes that arr[l..m] and arr[m+l..r] are sorted and merges the two sorted sub-arrays into one.

def mergeSort(arr):
    if len(arr) > 1:
        mid = len(arr)
        L = arr[:mid]
        R = arr[mid:]
        mergeSort(L)
        mergeSort(R)
        i = j = k = 0
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1
        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1
        while i < len(R):
            arr[k] = R[j]
            j += 1
            k += 1

def printList(arr):
    for i in range(len(arr)):
        print(arr[i], end=" ")
    print()

if __name__ == '__main__':
    arr = [12, 11, 13, 5, 6, 7]
    print("Given array is", end="\n")
    printList(arr)
    mergeSort(arr)
    print("Sorted array is", end="\n")
    printList(arr)


# Output
Given array is
12 11 13 5 6 7
Sorted array is
5 6 7 11 12 13

The below function is recursive, hence it uses function call stack to store intermediate values of l and h. The function call stack stores other bookkeeping information together with parameters. Also, function calls involve overheads like staring activation record of the caller function and then resuming execution.

def merge(left, right):
    if not len(left) or not len(right):
        return left or right
    result = []
    i,j = 0,0
    while (len(result) < len(left) + len(right)):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
        if i == len(left) or j == len(right):
            result.extend(left[i:] or right[j:])
            break
    return result

def mergesort(list):
    if len(list) < 2:
        return list
    middle = len(list)/2
    left = mergesort(list[:middle])
    right = mergesort(list[middle:])
    return merge(left, right)
seq = (12, 11, 13, 5, 6, 7)
print("Given array is")
print(seq)
print("\n")
print("Sorted array is")
print(mergesort(seq))


# Output
Given array is
12 11 13 5 6 7
Sorted array is
5 6 7 11 12 13

Unlike Iterative Quick Sort, the interactive Merge Sort doesn't require an explicit auxiliary stack.

def mergeSort(a):
    current_size = 1
    while current_size < len(a) - 1:
        left = 0
        while left < len(a) - 1:
            mid = left + current_size - 1
            right = ((2 * current_size + left - 1,
                    len(a) - 1) [2 * current_size + left - 1 > len(a) - 1])
        merge(a, left, mid, right)
        left = left + current_size * 2
    current_size = 2 * current_size

def merge(a, l, m, r):
    n1 = m - l + 1
    n2 = r - m
    L = [0] * n1
    R = [0] * n2
    for i in range(0, n1):
        L[i] = a[l + i]
    for i in range(0, n2):
        R[i] = a[m + i + 1]
    i, j, k = 0, 0, l
    while i < n1 and j < n2:
        if L[i] > R[j]:
            a[k] = R[j]
            j += 1
        else:
            a[k] = L[i]
            i += 1
        k += 1
    while i < n1:
        a[k] = L[i]
        i += 1
        k += 1
    while j < n2:
        a[k] = R[j]
        j += 1
        k += 1

a = [12, 11, 13, 5, 6, 7]
print("Given array is")
print(a)
mergeSort(a)
print("Sorted array is")
print(a)


# Output
Given array is 
12 11 13 5 6 7
Sorted array is
5 6 7 11 12 13

HeapSort

Heapsort is a comparison based sorting technique based on a Binary Heap data structure. It's similar to selection sort where we first find the maximum element and place the maximum element at the end.

What is Binary Heap?
A binary heap is a heap data structure that takes the form of a binary tree. Binary heaps are a common way of implementing priority queues.

A binary heap is defined as a binary tree with two additional constraints:

Shape property: a binary heap is a complete binary tree; that is, all levels of the tree, except possibly the last one (deepest) are fully filled, and, if the last level of the tree is not complete, the nodes of that level are filled from left to right.
Heap property: the key stored in each node is either greater than or equal to (≥) or less than or equal to (≤) the keys in the node's children, according to some total order.

Heaps, where the parent key is greater than or equal to (≥) the child keys, are called max-heaps; those where it is less than or equal to (≤) are called min-heaps. (Read more on Wikipedia)

Why array-based representation for Binary Heap?
Since a Binary Heap is a complete binary tree, it can be easily represented as an array and array-based representation is space efficient. If the parent node is stored at index 1, the left child can be calculated by 2*I+1 and right child by 2*I*2.

Heap Sort algorithm for sorting in increasing order:

Build a max heap from the input data.
The largest item is stored at the root of the heap. Replace it with the last item of the heap followed by reducing the size of a heap by 1. After that, heapify the root of the tree.
Repeat the above steps while the size of a heap is greater than 1.

def heapify(arr,n,i):
    largest = i
    l = 2*i+1
    r = 2*i+2
    if l < n and arr[i] < arr[l]:
        largest = l
    if r < n and arr[largest] < arr[r]:
        largest = r
    if largest != i:
        arr[i],arr[largest] = arr[largest],arr[i]
        heapify(arr,n,largest)

def heapSort(arr):
    n = len(arr)
    for i in range(n,-1,-1):
        heapify(arr,n,i)
    for i in range(n-1,0,-1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr,i,0)

arr = [12, 11, 13, 5, 6, 7]
heapSort(arr)
n = len(arr)
print("Sorted array is")
for i in range(n):
    print("%d" %arr[i])


# Output
Sorted array is
5 6 7 11 12 13

Counting Sort

Counting sort is a sorting technique based on keys between a specific range. It works by counting the number of objects having distinct key values. Then doing some arthmetic to calculate the position of each object in the output sequence.

def countSort(arr):
    output = [0 for i in range(256)]
    count = [0 for i in range(256)]
    ans = ["" for _ in arr]
    for i in arr:
        count[ord(i)] += 1
    for i in range(256):
        count[i] += count[i-1]
    for i in range(len(arr)):
        output[count[ord(arr[i])] -1] = arr[i]
        count[ord(arr[i])] -= 1
    for i in range(len(arr)):
        ans[i] = output[i]
    return ans

arr = "Yogeswaran"
ans = countSort(arr)
print("Sorted character array is %s" %("".join(ans)))


# Output
Sorted character array is Yaaegnorsw

Radix Sort

Radix sort is a non-comparative integer sorting algorithm that sorts data with integer keys by grouping keys by the individual digits which share the same significant position and value. A positional notation is required, but because integers can represent strings of characters (e.g., names or dates) and specially formatted floating point numbers, radix sort is not limited to integers.(Source Wikipedia)

You can check the example of Radix Sort Algorithm here

Bucket Sort

Bucket sort is mainly useful when input is uniformly distributed over a range.

Picture from SlideShare.net

def insertionSort(b):
    for i in range(1, len(b)):
        up = b[i]
        j = i - 1
        while j >= 0 and b[j] > up:
            b[j+1] = b[j]
            j -= 1
        b[j+1] = up
    return b

def bucketSort(x):
    arr = []
    slot_num = 10
    for i in range(slot_num):
        arr.append([])
    for j in x:
        index_b = int(slot_num * j)
        arr[i] = insertionSort(arr[i])
    k = 0
    for i in range(slot_num):
        for j in range(len(arr[i])):
            x[k] = arr[i][j]
            k += 1
    return x

x = [0.897, 0.565, 0.656,
    0.1234, 0.665, 0.3434]
print("Sorted array is")
print(bucketSort(x))


# Output
Sorted array is
0.1234 0.3434 0.565 0.656 0.665 0.897

ShellSort

Shellsort, also known as Shell sort or Shell's method, is an in-place comparison sort. It can be seen as either a generalization of sorting by exchange (bubble sort) or sorting by insertion (insertion sort). The method starts by sorting pairs of elements far apart from each other, then progressively reducing the gap between elements to be compared. Starting with far apart elements, it can move some out-of-place elements into position faster than a simple nearest neighbor exchange. (Source: Wikipedia)

def shellSort(arr):
    n = len(arr)
    gap = n
    while gap > 0:
        for i in range(gap,n):
            temp = arr[i]
            j = i
            while j >= gap and arr[j-gap] > temp:
                arr[j] = arr[j-gap]
                j -= gap
            arr[j] = temp
        gap

arr = [12, 34, 54, 2, 3]
n = len(arr)
print("Array before sorting")
for i in range(n):
    print(arr[i])
shellSort(arr)
print("\nArray after sorting")
for i in range(n):
    print(arr[i])


# Output
Array before sorting
12 34 54 2 3
Array after sorting
2 3 12 34 54

TimSort

Timsort is a hybrid stable sorting algorithm, derived from merge sort and insertion sort, designed to perform well on many kinds of real-world data.

A stable sorting algorithm works in O(nLogn) time.
USed in Java's Arrays.sort() as well as Python's sorted() and sort().
First sort small pieces using insertion sort, then merges the pieces using merge of merge sort.

RUN = 32

def insertionSort(arr, left, right): 
    for i in range(left + 1, right+1): 
        temp = arr[i] 
    j = i - 1
    while arr[j] > temp and j >= left: 
        arr[j+1] = arr[j] 
        j -= 1
    arr[j+1] = temp 

def merge(arr, l, m, r): 
    len1, len2 = m - l + 1, r - m 
    left, right = [], [] 
    for i in range(0, len1): 
        left.append(arr[l + i]) 
    for i in range(0, len2): 
        right.append(arr[m + 1 + i]) 
    i, j, k = 0, 0, l 
    while i < len1 and j < len2: 
        if left[i] <= right[j]: 
            arr[k] = left[i] 
        i += 1
    else: 
        arr[k] = right[j] 
        j += 1
        k += 1 
    while i < len1: 
        arr[k] = left[i] 
        k += 1
        i += 1
    while j < len2: 
        arr[k] = right[j] 
        k += 1
        j += 1
def timSort(arr, n): 
    for i in range(0, n, RUN): 
        insertionSort(arr, i, min((i+31), (n-1))) 
    size = RUN 
    while size < n: 
        for left in range(0, n, 2*size): 
        mid = left + size - 1
        right = min((left + 2*size - 1), (n-1)) 
        merge(arr, left, mid, right) 
        size = 2*size 

def printArray(arr, n): 
    for i in range(0, n): 
        print(arr[i], end = " ") 
    print() 

if __name__ == "__main__": 
    arr = [5, 21, 7, 23, 19] 
    n = len(arr) 
    print("Given array is") 
    printArray(arr, n) 
    timSort(arr, n) 
    print("After sorting array is") 
    printArray(arr, n)


# Output
Given array is
5 21 7 23 19
After sorting array is
5 7 19 21 23

Join my Community

Stackoverflow Survey 2019

Yogeswaran — Wed, 10 Apr 2019 12:38:18 +0000

Key Results

Python, the fastest-growing major programming language, has risen in the ranks of programming languages in our survey yet again, edging out Java this year and standing as the second most loved language (behind Rust).
Over half of respondents had written their first line of code by the time they were sixteen, although this experience varies by country and by gender.
DevOps specialists and site reliability engineers are among the highest paid, most experienced developers most satisfied with their jobs, and are looking for new jobs at the lowest levels.

Join my community

Part 1: Sorting Algorithm

Yogeswaran — Tue, 09 Apr 2019 19:30:59 +0000

Selection Sort

The selection sort algorithm sorts an array by repeatedly finding the minimum element from the unsorted part and putting it at the beginning. The algorithm maintains two subarrays in a given array.

The subarray is already sorted.
Remaining subarray which is unsorted. In every iteration of selection sort, the minimum element from the unsorted subarray is picked and moved to the sorted subarray.

import sys
A = [55, 30, 15, 22, 9]
for i in range(len(A):
    min_idx = i
    for j in range(i+1, len(A)):
        if A[min_idx] > A[j]:
            min_idx = j

    A[i], A[min_idx] = A[min_idx], A[i]

print("Sorted Array")
for i in range(len(A))
    print("%d" %A[i])


# Output
Sorted array
9 15 22 30 55

Bubble Sort

Bubble sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they're in wrong order.

def bubbleSort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

arr = [73, 34, 27, 12, 22, 10, 110]
bubbleSort(arr)
print("Sorted array")
for i in range(len(arr)):
    print("%d", %arr[i])


# Output
Sorted array
10 12 22 27 34 73 110

There is also a recursive version of Bubble Sort
How to implement recursive bubble sort?
Recursive bubble sort has no performance or implementation advantages, but can be a good question to check one's understanding of bubble sort and recursion.
Recursion Idea

Base Case: If the array size is 1, return.
Do One Pass of normal bubble sort. This pass fixes the last element of the current subarray.
Recur for all elements except last of the current subarray.

def bubble_sort(listx):
    for i, num in enumerate(listx):
        try:
            if listx[i+1] < num:
                listx[i] = listx[i+1]
                listx[i+1] = num
                bubble_sort(listx)
        except IndexError:
            pass
    return listx

listx = [60, 36, 25, 13, 23, 10, 99]
bubble_sort(listx)
print("Sorted array")
for i in range(0, len(listx)):
    print(listx[i], end=' ')


# Output
Sorted array
10 13 23 25 36 60 99

Quick Sort

Quick sort is a divide and conquers algorithm. It picks an element as pivot and partitions the given array around the picked pivot. There are many different versions of quick sort that pick pivot in different ways.

Always pick first element as pivot.
Always pick last element as pivot.
Pick a random element as pivot.
Pick median as pivot.

The key process in quick sort is partition(). Target of partitions is, given an array and an element x of array as pivot, put x at its correct position in sorted array and put all smaller elements before x, and put all greater elements after x. All this should be done in linear time.

def partition(arr,low,high):
    i = (low-1)
    pivot = arr[high]
    for j in range(low, high):
        if arr[j] <= pivot:
            i = i+1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i+1], arr[high] = arr[j], arr[i+1]
    return (i+1)

def quickSort(arr,low,high):
    if low < high:
        pi = partition(arr,low,high)
        quickSort(arr,low,pi-1)
        quickSort(arr,pi+1,high)

arr = [10, 8, 7, 5, 9, 1]
n = len(arr)
quickSort(arr,0,n-1)
print("Sorted array")
for i in range(n):
    print("%d" %arr[i])


# Output
Sorted array
1 5 7 8 9 10

The recursive quick sort implementation can be optimized in many ways.

The recursive quick sort implementation uses last index as pivot. This causes worst-case behaviour on already sorted arrays, which is a commonly occurring case. The problem can be solved by choosing either a random index for the pivot or choosing the middle index of the partition or choosing the median of the first, middle and last element of the partition for the pivot.
To reduce the recursion depth, recur first for the smaller half of the array, and use a tail call to recurse into the other.
Insertion sort works better for small subarrays. Insertion sort can be used for invocations on such small arrays.

Below is the typical recursive quick sort implementation.

def partition(arr,low,high):
    i = (low-1)
    pivot = arr[high]
    for j in range(low,high):
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return (i+1)

def quickSort(arr,low,high):
    if low < high:
    pi = partition(arr,low,high)
    quickSort(arr,low,pi-1)
    quickSort(arr,pi+1,high)

if __name__ == '__main__':
    arr = [4, 2, 6, 9, 2]
    n = len(arr)
    quickSort(arr, 0, n-1)
    for i in range(n):
        print(arr[i], end=" ")

# Output
2 2 4 6 9

The below mentioned optimizations for recursive quick sort can also be applied to iterative version.

Partition process is same in both recursive and interactive. The same techniques to choose optimal pivot can also be applied to iterative version.
To reduce the stack size, first push the indexes of smaller half.
Use insertion sort when the size reduces below a experimentally calculated threshold.

def partition(arr,l,h):
    i = (l-1)
    x = arr[h]
    for j in range(l,h):
        if arr[j] <= x:
            i = i+1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i+1], arr[h] = arr[h], arr[i+1]
    return (i+1)

def quickSortIterative(arr,l,h):
    size = h-l+1
    stack = [0]*(size)
    top = -1
    top = top+1
    stack[top] = 1
    top = top+1
    stack[top] = h
    while top >= 0:
        h = stack[top]
        top = top-1
        l = stack[top]
        top = top-1
        p = partition(arr,l,h)
        if p-1 > 1:
            top = top+1
            stack[top] = p+1
            top = top+1
            stack[top] = h

arr = [4, 3, 5, 2, 1, 3, 2, 3]
n = len(arr)
quickSortIterative(arr,0,n-1)
print("Sorted array")
for i in range(n):
    print("%d" %arr[i])


# Output
Sorted array
1 2 2 3 3 3 4 5

Insertion Sort

Insertion sort is a simple sorting algorithm that works the way we sort playing cards in our hands.

def insertionSort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i-1
        while j >= 0 and key < arr[j]:
            arr[j+1] = arr[j]
            j -= 1
        arr[j+1] = key

arr = [12, 11, 13, 5, 6]
insertionSort(arr)
for i in range(len(arr)):
    print("%d" %arr[i])


# Output
5 6 11 12 13

Example of Recursive Insertion Sort

How to implement insertion sort recursively?
Recursive insertion sort has no performance or implementation advantages, but can be a good question to check one's understanding of insertion sort and recursion. If we take a closer look at insertion sort algorithm, we keep processed elements sorted and insert new elements one by one in the inserted array.
Recursion Idea

Base Case: If array size is 1 or smaller, return.
Recursively sort first n-1 elements.
Insert last elements at its correct position in sorted array.

def insertionSortRecursive(arr,n):
    if n<=1:
        return
    insertionSortRecursive(arr,n-1)
    '''Insert last elements at its correct position in sorted array'''
    last = arr[n-1]
    j = n-2
    while (j>=0 and arr[j]>last):
        arr[j+1] = arr[j]
        j = j-1
    arr[j+1] = last

def printArray(arr,n):
    for i in range(n):
        print arr[i],
arr = [12, 11, 13, 5, 6]
insertionSortRecursive(arr,n)
printArray(arr,n)

# Output
5 6 11 12 13

Don't forget to join my telegram community

P.S: There is going to be several parts of the Top 7 Algorithms series.

The Mega CSS3 Cheatsheet

Yogeswaran — Thu, 28 Mar 2019 16:03:31 +0000

You can download The Mega CSS3 Cheatsheet here.

Don't forget to subscribe to my newsletter

The Mega HTML5 CheatSheet

Yogeswaran — Wed, 27 Mar 2019 08:28:29 +0000

Link to The Mega HTML5 CheatSheet

Don't forget to subscribe to my newsletter

P.S: File is too big to be open in your smartphone

Chrome 74 beta supports dark mode in Windows

Yogeswaran — Sun, 24 Mar 2019 05:51:32 +0000

In a post on Google Developers blog about the feature, Developer Advocate Thomas Steiner explained the technology behind the feature:

"...with flashing ads, fancy parallax effects, surprising reveal animations, autoplaying videos, etc., the web sometimes can honestly be quite overwhelming... Happily, unlike in real life, there is a solution to that. The CSS media query prefers-reduced-motion lets developers create a variant of a page for users who, well, prefer reduced motion. This can comprise anything from refraining from having autoplaying videos to disabling certain purely decorative effects, to completely redesigning a page for certain users."

Learn more about Chrome 74 beta "Dark Mode".

Python VS Javascript

Yogeswaran — Wed, 20 Mar 2019 17:46:09 +0000

1. REPL (Read Eval Print Loop)

Python:

You’ll get it with the installation of python and call different python versions depending on the installation.

JavaScript:

Javascript doesn’t have inbuilt REPL as most of the time developers run in a browser, but you can use REPL by installing node.js.

2. Mutability

Python:

Python has mutable and immutable data types like set (mutable) and list (immutable).

JavaScript:

Javascript has no concept of mutable and immutable.

3. Strings

Python:

In python source code is ASCII by default unless you specify any encoding format.

JavaScript:

Javascript should be encoded as UTF-16 and no built-in support for manipulating raw bytes.

4. Numbers

Python:

In python, you’ve different numeric types like integer (int), float, fixed-point decimal, etc.

JavaScript:

Javascript has only floating point numbers only.

5. Hash tables

Python:

Python has built-in hash tables, called dictionaries, sets, etc, which can be used in hashing with keys and values.

JavaScript:

Javascript has no built-in hash table support.

6. Inheritance

Python:
Python uses class-based inheritance model.

The example above shows you a class definition and init function is a constructor.

JavaScript:
Javascript uses prototype based inheritance model.

7. Code Blocks

Python:
JavaScript:

8. Function Arguments

Python:
JavaScript:

9. Data types

Python:
JavaScript:

10. Properties and Attributes

Python:
JavaScript

11. Modules

Python:
JavaScript:

Join my telegram channel

ROADMAP BECOMING A WEB DEVELOPER IN 2019

Yogeswaran — Tue, 19 Mar 2019 13:43:50 +0000

Introduction to Web Development

Front-end Development

Back-end Development

DevOps

Join my telegram channel

Moving my Blog

Yogeswaran — Mon, 18 Mar 2019 04:54:42 +0000

I'm moving all my blogs to my personal website from now on, you could check the site here