DEV Community: MMK2020

The Ultimate Guide to Getting Started in Data Science

MMK2020 — Sun, 03 Apr 2022 19:41:52 +0000

What is Data Science?
According to Wikipedia “Data science is an interdisciplinary field that uses scientific methods, processes, algorithms and systems to extract knowledge and insights from noisy, structured and unstructured data,and apply knowledge and actionable insights from data across a broad range of application domains.”

It further add adds “Data science is a "concept to unify statistics, data analysis, informatics, and their related methods" in order to "understand and analyse actual phenomena" with data.”

Who is a data scientist?
“A data scientist is someone who is able to lead a team of data analysts or data engineers to work towards solving a business problem, by collecting data and come out with relevant findings which can potentially help the company’s growth.” - https://thelead.io/ultimate-guide-data-science

Data Engineers focus on making the data available and accessible to data scientists integrating various data sources and optimizing access to data while the data analysts are responsible for extracting insight from the data.

Lifecycle of Data Science
The core job of Data Scientists is to address problems and construct Models to make better decisions for multifaceted business challenges. Data Science processes involve the following steps:

Defining Business Problem – This will be the main objective of the entire process so as to satisfy external stakeholders
Data Collection and Preparation
Exploratory Data Analysis
Model Building
Model Optimization
Model Deployment and Evaluation

Tools used in Data Science
Statistics and Probability – Basic to advance knowledge of statistics and probability is required. From the simple measure of central tendencies (mean, mode and median) to complex multivariate probability distributions.

Data Mining & Cleaning - How to collect, extract, query, clean, and aggregate data for analysis.

Exploratory Data Analysis - How to explore datasets using visual analytics and statistical analysis.

Data Visualization and Storytelling Skills - Data storytelling combines data with human communication to craft an engaging narrative that’s anchored by facts. It uses data visualization techniques (e.g., charts and images) to convey the meaning of the data in a way that’s compelling and relevant to the audience.

Modelling, Validation & Problem Solving - A model is a mathematical representation of the real world and is used in formulating hypotheses and trying to solve business problems. All models must be validated using test data in order to provide insight into real-world problems and solutions.

Programming Language – Learn to program in computer programming languages that are commonly used in data science like R and Python. Other programming languages can be used, but when it comes to data science these two are the most popular. In addition Python and R are supported by libraries and packages that are meant for data science.

Communication - Communicate key findings and results by creating an effective presentation.

A.I. & Machine Learning - Artificial Intelligence is broad field with many subfields with of which one of them is machine learning.

Big Data Analysis - Big data is information that has one or all of the following; volume, velocity, variety and veracity.

References
https://en.wikipedia.org/wiki/Data_science
https://hevodata.com/learn/data-science-simplified/
https://thelead.io/ultimate-guide-data-science

Something short about MongoDB

MMK2020 — Tue, 29 Mar 2022 19:45:36 +0000

I have worked with relational databases particularly MySQL and later on MariaDB.

So recently I decided to check out MongoDB and test the NoSQL world for a bit. Still there is much for me to learn.

MongoDB is a NoSQL, document oriented, cross platform database program. MongoDB uses JSON-like (Binary JSON - BSON) documents with optional schemas. Apparently the word MongoDB is derived from two words Humongous Database

NoSQL databases store data differently than relational tables, specifically they don’t have tables.

MongoDB stores data records as documents (specifically BSON documents) which are gathered together in collections. A database stores one or more collections of documents. Collections are analogous to tables in relational databases.

According to Wikipedia MongoDB comes in three editions MongoDB Community Server, MongoDB Enterprise Server and MongoDB Atlas

MongoDB Community Server
The MongoDB Community Edition is free and available for Windows, Linux, and macOS.

MongoDB Enterprise Server
MongoDB Enterprise Server is the commercial edition of MongoDB, available as part of the MongoDB Enterprise Advanced subscription.

MongoDB Atlas
MongoDB is also available as an on-demand fully managed service. MongoDB Atlas runs on AWS, Microsoft Azure, and Google Cloud Platform.

Restrictions on Database names
Database names are case-sensitive in MongoDB but they must also differ on more than just case otherwise you will get an error.
Database names for deployments running on Windows systems cannot contain any of the following characters: /. "$*<>:|? While those deployed on Linux/Unix systems cannot contain any of the following characters: /. "$
Database names cannot be empty and must have fewer than 64 characters.

Restriction on Collection Names
Collection names should begin with an underscore or a letter character, and cannot: contain the $, be an empty string, contain the null character, and begin with the system prefix.

Restrictions on Field Names
Field names cannot contain the null character.
The field name _id is reserved for use as a primary key; its value must be unique in the collection, is immutable, and may be of any type other than an array. If the _id contains subfields, the subfield names cannot begin with a ($) symbol.

The MongoDB Shell a.k.a mongosh is an interactive environment for interacting with MongoDB deployments, from here you can issue commands to query and interact with your database.

References
https://www.mongodb.com/docs
https://en.wikipedia.org/wiki/MongoDB

Modern Python for everyone: Mastering Modern Python the Right Way

MMK2020 — Thu, 03 Mar 2022 07:59:55 +0000

> "To become really good at anything, you have to practice and repeat, practice and repeat, until the technique becomes intuitive." - Paulo Coelho

> “You become a master in what you repeatedly do in consistency. Mastery is not born; it is acquired. It is not blood-linked; it is skill-learnt! “- Israelmore Ayivor

> “I fear not the man who has practiced 10,000 kicks once, but I fear the man who has practiced one kick 10,000 times." - Bruce Lee

This article is about mastering the Python programming language in most effective and efficient way. The steps shown here are very similar to the previous article I wrote about mastering JavaScript. You can find the previous article about JavaScript here.

Python is a language has syntax that is easy to understand. However mastering the language is another thing. The best and recommended way to master Python is through consistent practice and more practice until it becomes second nature.

However for you to practice Python in a manner that will lead to mastery, you have to fulfil some requirements as described below.

Step 1. Have you why for learning Python, it is easier to learn and understand something that you have passion about. Check out the documentation and code examples to get a feel for what is up ahead. Try some online tutorials or books. You can also use freely available eBooks on the internet

Step 2. Create time for study and time for practice. If you can’t allocate ample time for study, it will be very hard to move along.

Step 3. Learn the history of the language, why it was created, when it was created? , for whom and by whom was it created? Also learn its syntax, use cases and real life examples where Python is in use. Answering these questions will help you to know the strengths, weaknesses and peculiarity of Python. You should know that there is no perfect programming language.

Step 4. Learn the following concepts: For introduction understand how python works, environment and tools, and its comparison with other programming language. Write a hello world program. Learn input/output functions in Python, data types and variable declarations, python statements, operators (arithmetic, logical and comparison operators). Python conditionals (if statement, ifelse, if elif else and nesting of conditionals). Looping with for and while statement. Python collections namely; lists, tuples, sets and dictionaries. Python functions, classes and modules.

Step 5. Read Python documentation, blogs, watch online tutorial videos, read eBooks. The aim is to expose you to many scenarios where other people might be able to explain some concepts which you can’t grasp on your own.

Step 6. Participate actively in online Python forums, hackathons and other online activities. You can also form your own physical or virtual groups. Participate in open source projects and collaborate as much as possible. You can also participate in projects individually or as a group.

Step 7. Keep up with Python Enhancement Proposals (PEP). PEPs are documents that describe new proposals of the Python language. PEP8 for example provides guidelines and best practices for writing readable code.

This means new features are being added to the language to make it better and add more functionality. In that regard you have to keep abreast of any changes.

If you are psyched to get started with Python, visit my article Introduction to Modern Python

Modern JavaScript for everyone: Mastering Modern JavaScript the Right Way

MMK2020 — Wed, 02 Mar 2022 16:06:50 +0000

"To become really good at anything, you have to practice and repeat, practice and repeat, until the technique becomes intuitive." - Paulo Coelho

“You become a master in what you repeatedly do in consistency. Mastery is not born; it is acquired. It is not blood-linked; it is skill-learnt! “- Israelmore Ayivor

“I fear not the man who has practiced 10,000 kicks once, but I fear the man who has practiced one kick 10,000 times." - Bruce Lee

JavaScript as a language has syntax that is easy to understand. However mastering the language is another thing. The best and recommended way to master JavaScript is through consistent practice and more practice until it becomes second nature.

However for you to practice JavaScript in a manner that will lead to mastery, you have to fulfil some requirements.

Step 1. Have your why for learning JavaScript, it is easier to learn and understand something that you have passion about. Why are you learning JavaScript of all the available programming languages out there? Is it because it is most widely used for frontend and can be used for backend as well? Is it because it is open source?

Step 2. Create time for study and time for practice. If you can’t allocate ample time for study, it will be very hard to move along.

Step 3. Learn the history of the language, why it was created, when it was created? , for whom and by whom was it created? Also learn its syntax, use cases and real life examples where JavaScript is in use. Answering these questions will help you to know the strengths, weaknesses and peculiarity of JavaScript. You should know that there is no perfect programming language.

Step 4. Learn the following concepts: JavaScript environment and runtime engines, interaction with the user i.e. the input/output via HTML elements or browser console, JavaScript datatypes (numbers, strings, boolean …), comments, variable declarations (var, let and const) , operators (arithmetic, logical and comparison), conditional statements (if , if else, if else if and switch), looping/iteration (for , while and do while) , JavaScript functions, array, objects , classes ,JSON and modules. Another important concept is the JavaScript event loop, since JavaScript is single threaded you need to learn about asynchronous functions, setTimeOut function, promises etc.

Step 5: Read JavaScript documentation, blogs, watch online tutorial videos, read eBooks. The aim is to expose you to many scenarios where other people might be able to explain some concepts which you can’t grasp on your own.

Step 6: Participate actively in online JavaScript forums, hackathons and other online activities. You can also form your own physical or virtual groups. Participate in open source projects and collaborate as much as possible. You can also participate in projects individually or as a group.

Step 7: The JavaScript language specification known as ES is always being updated. This means new features are being added to the language to make it better and add more functionality. In that regard you have to keep abreast of any changes.

Introduction to Data Structures and Algorithms With Modern JavaScript.

MMK2020 — Sun, 20 Feb 2022 17:40:33 +0000

What are data structures?

A data structure is a method for storing and organizing data in a virtual system. It is used to denote a particular way of organizing data for particular types of operation such as modification, navigation, and access of information.

There are numerous data structures ranging from arrays and lists to more complex structures such as trees, heaps and graphs.

Data structures help to:

Manage and utilize large datasets
Quickly search for particular data from a database
Build clear hierarchical or relational connections between data points
Simplify and speed up data processing

Each data structure has a task or situation it is most suited to solve.

*Widely used basic data structures: *

Arrays
Linked lists
Stacks
Queues
Hash tables
Trees
Graphs

What is an algorithm?

An algorithm for a particular task is a finite sequence of instructions, each of which has a clear meaning and can be performed with a finite amount of effort in a finite length of time.

Some common categories of algorithms are:

Searching
Sorting
Graph/tree traversing
Dynamic programming
Hashing and regex (string pattern matching)

Why data structures and algorithms

When solving real-world coding problems, it is required that runtime and resource efficiency are achieved. Knowing the data structure and algorithm which best fits the current solution will increase program performance and reduce time required to make it.
Proper understanding of data structures and algorithms ensures well-optimized and efficient code.

The efficiency or performance (complexity) of an algorithm relates to the resources required by it, such as how quickly it will run (time complexity), or how much computer memory (space complexity) it will use.

The ability to formulate an efficient algorithm depends on being able to organize the data in an appropriate manner. It is for this reason coding some coding interviews ask for demonstration of comprehension of data structures and algorithms.

JavaScript data structures

JavaScript has primitive and non-primitive data structures.
Primitive data structures and data types are native to the programming language. These include boolean, null, number, string, etc.

Non-primitive data structures are not defined by the programming language but rather by the programmer. These include linear data structures, static data structures, and dynamic data structures, like queue and linked lists.

Data structures to consider in JavaScript;

Arrays
Queues & Stacks
Linked List
Trees
Graphs
Hashtables / maps

Arrays

Arrays are sequences of primitive data types, similar to a list. Each array has a fixed number of cells decided on its creation, and each cell has a corresponding numeric index used to select its data.

Queues & Stacks

Stacks and queues differ from the exact definition of arrays in other programming languages by how objects are added or removed.

Both queues and stacks offer the opportunity to display every datatype stored within the array and to slice and “peek” at particular elements. This is also true of the JavaScript array type, which is a specially defined object in JavaScript.

Queues are conceptually similar to stacks; both are sequential structures, but queues process elements in the order they were entered rather than the most recent element.

Queues are FIFO (first in, first out) while stacks are LIFO (last in, first out). As a result, queues can be thought of as a FIFO (First In, First Out) version of stacks. These are helpful as a buffer for requests, storing each request in the order it was received until it can be processed.

Linked Lists

Linked lists are a data structure which, does not use physical placement of data in memory. This means that, rather than indexes or positions, linked lists use a referencing system: elements are stored in nodes that contain a pointer to the next node, repeating until all nodes are linked.

This system allows efficient insertion and removal of items without the need for reorganization.

Trees

Trees are another relation-based data structure, which specialize in representing hierarchical structures. Like a linked list, nodes contain both elements of data and pointers marking its relation to immediate nodes.

Each tree has a “root” node, off of which all other nodes branch. The root contains references to all elements directly below it, which are known as its “child nodes”. This continues, with each child node, branching off into more child nodes.

Nodes with linked child nodes are called internal nodes while those without child nodes are external nodes. A common type of tree is the “binary search tree” which is used to easily search stored data.

These search operations are highly efficient, as its search duration is dependent not on the number of nodes but on the number of levels down the tree.

Graphs

Graphs are a relation-based data structure helpful for storing web-like relationships. Each node, or vertex, as they’re called in graphs, has a title (A, B, C, etc.), a value contained within, and a list of links (called edges) it has with other vertices.

The graph structure is invaluable in conveying relationship charts in textual form, anything from circuitry to train networks.

Hash Tables

A hash table is a dictionary-like data structure, where keys are paired with values. Hash tables are great for rapid retrieval and modification of data, though the array and list-like objects above are better for storage. Still, especially with the explosive growth of data, hash tables have become nearly ubiquitous. For example, popular NoSQL databases used in the web such as MongoDB and Redis are distributed hash tables and key/value stores.

References;
https://www.springboard.com/blog/software-engineering/data-structures-and-algorithms-in-javascript/

https://www.educative.io/blog/javascript-data-structures

Introduction to Data Structures and Algorithms with Python

MMK2020 — Sun, 20 Feb 2022 12:16:15 +0000

What are data structures?

There are numerous data structures ranging from arrays and lists to more complex structures such as trees, heaps and graphs.

Data structures help to:

Manage and utilize large datasets
Quickly search for particular data from a database
Build clear hierarchical or relational connections between data points
Simplify and speed up data processing

Each data structure has a task or situation it is most suited to solve.

*Widely used basic data structures: *

Arrays
Linked lists
Stacks
Queues
Hash tables
Trees
Graphs

What is an algorithm?

An algorithm for a particular task is a finite sequence of instructions, each of which has a clear meaning and can be performed with a finite amount of effort in a finite length of time.

Some common categories of algorithms are:

Searching
Sorting
Graph/tree traversing
Dynamic programming
Hashing and regex (string pattern matching)

Why data structures and algorithms

Python Data Structures

There are four main types of data structures (Lists, Tuples, Sets, and Dictionaries) that come by default in Python and don’t need to be imported from user libraries.

There are four collection data types in the Python programming language:

List is a collection which is ordered and changeable. Allows duplicate members.
Tuple is a collection which is ordered and unchangeable. Allows duplicate members.
Set is a collection which is unordered and unindexed. No duplicate members.
Dictionary is a collection which is ordered* and changeable. No duplicate members. (*for python 3.7 and above)

Arrays in Python

An array is a collection of similar items which are indexed.
Python does not have a built in array type, but an array can be implemented using the inbuilt Python List.
An array is a collection of values of the same type saved under the same name. Each value in the array is called an “element” and indexing that represents its position. You can access specific elements by calling the array name with the desired element’s index. You can also get the length of an array using the len() method.

Queues in Python

Queues are a linear data structure that store data in a “first in, first out” (FIFO) order. Unlike arrays, you cannot access elements by index and instead can only pull the next oldest element. This makes it great for order-sensitive tasks like online order processing or voicemail storage.

In programming terms, putting items in the queue is called enqueue, and removing items from the queue is called dequeue.

The append() and pop() methods can be used to implement a queue. However, this is inefficient because lists must shift all elements by one index whenever you add a new element to the beginning.
Instead, use the deque class from Python’s collections module. Deques are optimized for the append and pop operations. The deque implementation also allows you to create double-ended queues, which can access both sides of the queue through the popleft() and popright() methods.
from collections import deque

# Initializing a queue
q = deque()

# Adding elements to a queue
q.append('a')
q.append('b')
q.append('c')

print("Initial queue")
print(q)

# Removing elements from a queue
print("\nElements dequeued from the queue")
print(q.popleft())
print(q.popleft())
print(q.popleft())

print("\nQueue after removing elements")
print(q)

# Uncommenting q.popleft()
# will raise an IndexError
# as queue is now empty

Stacks in Python

Stacks are a sequential data structure that act as the Last-in, First-out (LIFO) version of queues. The last element inserted in a stack is considered at the top of the stack and is the only accessible element. To access a middle element, you must first remove enough elements to make the desired element the top of the stack.

Adding elements is known as a push, and removing elements is known as a pop. You can implement stacks in Python using the built-in list structure. With list implementation, push operations use the append()method, and pop operations use pop().

stack = []

# append() function to push
# element in the stack
stack.append('a')
stack.append('b')
stack.append('c')

print('Initial stack')
print(stack)

# pop() function to pop
# element from stack in 
# LIFO order
print('\nElements popped from stack:')
print(stack.pop())
print(stack.pop())
print(stack.pop())

print('\nStack after elements are popped:')
print(stack)

# uncommenting print(stack.pop())  
# will cause an IndexError 
# as the stack is now empty

Linked lists in Python

Linked lists are a sequential collection of data that uses relational pointers on each data node to link to the next node in the list.

Unlike arrays, linked lists do not have objective positions in the list. Instead, they have relational positions based on their surrounding nodes.

The first node in a linked list is called the head node, and the final is called the tail node, which has a null pointer.

Linked lists can be singly or doubly linked depending if each node has just a single pointer to the next node or if it also has a second pointer to the previous node.

You can think of linked lists like a chain; individual links only have a connection to their immediate neighbours but all the links together form a larger structure.

Python does not have a built-in implementation of linked lists and therefore requires that you implement a Node class to hold a data value and one or more pointers.

class Node:
    def __init__(self, dataval=None):
        self.dataval = dataval
        self.nextval = None

class SLinkedList:
    def __init__(self):
        self.headval = None

list1 = SLinkedList()
list1.headval = Node("Mon")
e2 = Node("Tue")
e3 = Node("Wed")
# Link first Node to second node
list1.headval.nextval = e2

# Link second Node to third node
e2.nextval = e3

Linked lists are primarily used to create advanced data structures like graphs and trees or for tasks that require frequent addition/deletion of elements across the structure.

Circular linked lists in Python

The primary downside of the standard linked list is that you always have to start at the Head node.

The circular linked list fixes this problem by replacing the Tail node’s null pointer with a pointer back to the Head node. When traversing, the program will follow pointers until it reaches the node it started on.

The advantage of this setup is that you can start at any node and traverse the whole list. It also allows you to use linked lists as a loopable structure by setting a desired number of cycles through the structure.

Circular linked lists are great for processes that loop for a long time like CPU allocation in operating systems.

Trees in Python

Trees are another relation-based data structure, which specialize in representing hierarchical structures. Used to implement top searching and sorting algorithms like binary search trees and binary heap.

Like a linked list, they’re populated with Node objects that contain a data value and one or more pointers to define its relation to immediate nodes.

Each tree has a root node that all other nodes branch off from. The root contains pointers to all elements directly below it, which are known as its child nodes. These child nodes can then have child nodes of their own. Binary trees cannot have nodes with more than two child nodes.

Any nodes on the same level are called sibling nodes. Nodes with no connected child nodes are known as leaf nodes.

The most common application of the binary tree is a binary search tree. Binary search trees excel at searching large collections of data, as the time complexity depends on the depth of the tree rather than the number of nodes.

Binary search trees have four strict rules:

The left subtree contains only nodes with elements lesser than the root.
The right subtree contains only nodes with elements greater than the root.
Left and right subtrees must also be a binary search tree. They must follow the above rules with the “root” of their tree.
There can be no duplicate nodes, i.e. no two nodes can have the same value.

Graphs in Python

Graphs are a data structure used to represent a visual of relationships between data vertices (the Nodes of a graph). The links that connect vertices together are called edges.

Edges define which vertices are connected but does not indicate a direction flow between them. Each vertex has connections to other vertices which are saved on the vertex as a comma-separated list.

Graphs are excellent for modelling networks or web-like structures. Can also be used to model social network sites like Facebook

There are also special graphs called directed graphs that define a direction of the relationship, similar to a linked list. Directed graphs are helpful when modelling one-way relationships or a flowchart-like structure.

They’re primarily used to convey visual web-structure networks in code form. These structures can model many different types of relationships like hierarchies, branching structures, or simply be an unordered relational web. The versatility and intuitiveness of graphs makes them a favourite for data science.

When written in plain text, graphs have a list of vertices (nodes) and edges:

V = {a, b, c, d, e}
E = {ab, ac, bd, cd, de}

In Python, graphs are best implemented using a dictionary with the name of each vertex as a key and the edges list as the values.

Create the dictionary with graph elements

graph = { "a" : ["b","c"],
                 "b" : ["a", "d"],
                 "c" : ["a", "d"],
                  "d" : ["e"],
                  "e" : ["d"]
         }

# Print the graph          
print(graph)

Hash tables in Python

Hash tables are a complex data structure capable of storing large amounts of information and retrieving specific elements efficiently.

This data structure uses key/value pairs, where the key is the name of the desired element and the value is the data stored under that name.

Each input key goes through a hash function that converts it from its starting form into an integer value, called a hash. Hash functions must always produce the same hash from the same input, must compute quickly, and produce fixed-length values. Python includes a built-in hash() function that speeds up implementation.
The table then uses the hash to find the general location of the desired value, called a storage bucket. The program then only has to search this subgroup for the desired value rather than the entire data pool.

Beyond this general framework, hash tables can be very different depending on the application. Some may allow keys from different data types, while some may have differently setup buckets or different hash functions.

Here is an example of a hash table in Python code:

import pprint
class Hashtable:
    def __init__(self, elements):
        self.bucket_size = len(elements)
        self.buckets = [[] for i in range(self.bucket_size)]
        self._assign_buckets(elements)
    def _assign_buckets(self, elements):
        for key, value in elements: #calculates the hash of each key
            hashed_value = hash(key)
            index = hashed_value % self.bucket_size # positions the element in the bucket using hash
            self.buckets[index].append((key, value)) #adds a tuple in the bucket
    def get_value(self, input_key):
        hashed_value = hash(input_key)
        index = hashed_value % self.bucket_size
        bucket = self.buckets[index]
        for key, value in bucket:
            if key == input_key:
                return(value)
        return None
    def __str__(self):
        return pprint.pformat(self.buckets) # pformat returns a printable representation of the object
if __name__ == "__main__":
     capitals = [
        ('France', 'Paris'),
        ('United States', 'Washington D.C.'),
        ('Italy', 'Rome'),
        ('Canada', 'Ottawa')
    ]
hashtable = Hashtable(capitals)
print(hashtable)
print(f"The capital of Italy is {hashtable.get_value('Italy')}")

References:

Introduction to Modern JavaScript

MMK2020 — Sun, 13 Feb 2022 18:13:56 +0000

JavaScript (JS) is a lightweight, interpreted, prototype-based, multi-paradigm, single-threaded, dynamic language, supporting object-oriented, imperative, and declarative programming styles.
JavaScript is used on web browsers for client-side but can be also used on the server-side.

Each browser runs a JavaScript engine, the most common is V8 engine. This tutorial code will be run and tested on the browser debugger console.

To get started download and install VS Code and NodeJS. Once installed you are ready to go.

Output

JavaScript can "display" data in different ways:

Writing into an HTML element, using innerHTML.
Writing into the HTML output using document.write().
Writing into an alert box, using window.alert().
Writing into the browser console, using console.log().

This tutorial will be printing to browser console window.

console.log(“Hello, World!”); //Prints Hello, World! to the debugger console

JS doesn’t need semicolon at the end of code line they are optional

For strings they can be enclosed with single or double quotes

Variables

JavaScript uses the keywords var, let and const to declare variables.
An equal sign is used to assign values to variables.
Lower camelCase highly recommended for variable names and should have meaning: firstName, lastName, masterCard, interCity.

4 Ways to Declare a JavaScript Variable:

Using var
Using let
Using const
Using nothing A variable declared without a value will have the value undefined. E.g. let carName;

A JavaScript name must begin with:

A letter (A-Z or a-z)
A dollar sign ($)
Or an underscore (_)

JavaScript `Let`

The let keyword was introduced in ES6 (2015).
Variables defined with let cannot be Redeclared.
Variables defined with let must be Declared before use.
Variables defined with let have Block Scope.

JavaScript `const`

The const keyword was introduced in ES6 (2015).

Variables defined with const cannot be Redeclared.
Variables defined with const cannot be Reassigned.
Variables defined with const have Block Scope.

It does not define a constant value. It defines a constant reference to a value.
As a general rule, always declare a variable with const unless you know that the value will change.

Use const when you declare:

A new Array
A new Object
A new Function
A new RegExp

Data type

String, number, boolean, object, undefined
typeof keyword is used indicate the type of a variable

var  num = 23
var hello = “hello”
var isLate = “true”
var empty = undefined;
var dob = new Date(1973,8,28);
var person = {};
console.log(typeof num);// prints number to console
console.log(typeof hello); // prints string to console
console.log(typeof isLate); // prints boleean to console
console.log(typeof dob); // prints object to console
console.log(typeof person); // prints object to console
console.log(typeof empty); // prints undefined to console

Strings

var brand = "Shekey";
console.log(typeof brand); // prints string
console.log(brand.length); //  prints 6
console.log(brand.toUpperCase()); // prints SHEKEY
console.log(brand.substring(0,4)); // prints Shek

var a = "She";
var b = "key";
console.log(a + b); // prints Shekey
console.log(a +" "+ b); // prints She Key
console.log(`${a}${b}`);// backticks ` ` in use prints Shekey
console.log(`${a}  ${b}`);// backticks ` ` in use prints She  key

Type Conversion

JavaScript variables can be converted to a new variable and another data type:

By the use of a JavaScript function
Automatically by JavaScript itself Number() Returns a number, converted from its argument parseFloat() Parses a string and returns a floating point number parseInt() Parses a string and returns an integer

The global method String() can convert numbers to strings.
It can be used on any type of numbers, literals, variables, or expressions:
The Number method toString() does the same.

JavaScript Objects

JavaScript objects are written with curly braces {}.
Object properties are written as key:value pairs, separated by commas.
An object is a collection of properties
You can access object properties in two ways:
objectName.propertyName
or
objectName["propertyName"]

var person = {
    firstname: "Martin",
    age: 47,
    isMale: true,
    balance: 453.435,
    dob: new Date(1973, 1, 28).toJSON(),
    address: {
        city: "Nairobi",
        postCode: "00100"
    }
};

console.log(person);
console.log(person.firstname);
console.log(person.age)
console.log(person.balance);

console.log(person.address);
console.log(person.address.city);
console.log(Object.values(person));
console.log(Object.keys(person));
console.log(JSON.stringify(person));

Boolean

// Boolean takes on a true of false value
var isAdult = true;
console.log(isAdult); // prints true
The ! operator can be used to negate (i.e. flip) the value 
console.log(!isAdult); //prints false
console.log(!true); //print false
console.log(!false) // prints true

Arrays

JavaScript arrays are written with square brackets.
Array items are separated by commas.
Used for storing multiple values

// Arrays
var names = [
    "Alex", 
    "Joe", 
    "Ann", 
    "Mike"
];

console.log(names); // prints [‘Alex’, ‘Joe’, ‘Ann’, ‘Mike’]
console.log(names[0]); // prints Alex
console.log(names[1]); // prints Joe
console.log(names[2]); // prints Ann
console.log(names[3]); // prints Mike
console.log(names.length); // prints length of arrar i.e. 4

Arithmetic Operators

// Arithmetic Operators
var addition = 2 + 2;
var subtraction = 2- 2;
var division = 10/2;
var multiplication = 10*2;
var remainder = 10%2;
var exponentation = 3**4

console.log(addition);
console.log(subtraction);
console.log(division);
console.log(multiplication);
console.log(remainder);
console.log(exponentation);

Functions

A JavaScript function is defined with the function keyword, followed by a name, followed by parentheses (). Function names can contain letters, digits, underscores, and dollar signs (same rules as variables). The parentheses may include parameter names separated by commas:
(parameter1, parameter2, ...)
The code to be executed, by the function, is placed inside curly brackets: { }
A collection of statements that perform a task or calculate a value
Function parameters are listed inside the parentheses () in the function definition.
Function arguments are the values received by the function when it is invoked.
Inside the function, the arguments (the parameters) behave as local variables.

// Functions
function addNumbers(){
    var addition = 2 + 5;
    console.log(addition);
};

  addNumbers();

A function may or may not have parameters
// Functions
function addNumbers(number1, number2){
    var addition = number1 + number2;
    return addition;
};

var result1 = addNumbers(2,5);
var result2 =  addNumbers(7,5);

console.log(result1); // prints 7

console.log(result2); // prints 12

Arrow Function

Arrow functions were introduced in ES6.
Arrow functions allow us to write shorter function syntax:

let myFunction = (a, b) => a * b;

hello = () => {
  return "Hello World!";
}

hello = () => "Hello World!";

Loops

Used to repeat a piece of code over and over until a condition is met

// Loops
for (var i=0; i<=10; i++){
    console.log(i);
}

Looping an array

// Loops
var names = [
    "Alex",
    "John",
    "Mary",
    "Joe"
];
for (var i=0; i<names.length; i++){
    console.log(names[i]);
}

`for` of and `foreach`

// Loops
var names = [
    "Alex",
    "John",
    "Mary",
    "Joe"
];

// for of
for (const name of names) {
    console.log(name);
}

// for each

names.forEach(function(name) {
    console.log(name);
});

`while` loop

Repeats code until a certain condition is false

// While Loops

var names = [
"Alex",
"John",
"Mary",
"Joe",
"Bob"
];
var index = 0;
while(index<names.length){
    console.log(names[index]);
    index+=1;
}

`do while` loop

Loops at least once no matter the condition

do {

    } while(true);

The break and continue keywords can be used within loops to terminate or go back to start of loop respectively.

Increment and Decrement operators (`++` and `--`)

Num++ // Increments but returns the number before the increment

Example

// Postfix
var number = 0;
console.log(number++); // prints 0
console.log(number); // prints 1
// Prefix increments/decrements  and returns the number
Var numberTwo  = 0;
console.log(++numberTwo); // Prints 1

Comparison Operators

Evaluates values(numbers, strings, objects) and returns true or false
< ,!=, <= , >, >=, ==

Logical Operators

&&, ||, !

`if` statements

Allows execution of code based on a conditions
if( ){ }
if ( ) { } else{ }
if ( ) { } else if ( ) { } else { }
You can have as much else if ( ) { }

Ternary Statement `? :`

var number = 6;
var result = number % 2 ==0 ?"Even":"Odd";
console.log(result)

`switch` statement

var gender = “M”;
switch(gender){
case “M”:
break;
case “F”:
break;
default:

}

Hoisting

Hoisting is JavaScript's default behaviour of moving all declarations to the top of the current scope (to the top of the current script or the current function).
Accessing a variable outside its scope.
Use let or const key words to declare variables to avoid hoisting. Avoid var keyword.
const prevents the variable from being reassigned

JavaScript Classes

Use the keyword class to create a class.
Always add a method named constructor():

class ClassName {
  constructor() { ... }
}

A JavaScript class is not an object.
It is a template for JavaScript objects.
The constructor method is a special method:

It has to have the exact name "constructor"
It is executed automatically when a new object is created
It is used to initialize object properties
If you do not define a constructor method, JavaScript will add an empty constructor method. Use the keyword class to create a class. Always add a constructor() method. Then add any number of methods.

let myCar1 = new Car("Ford", 2014);
let myCar2 = new Car("Audi", 2019);

class Car {
  constructor(name, year) {
    this.name = name;
    this.year = year;
  }
}
class Car {
  constructor(name, year) {
    this.name = name;
    this.year = year;
  }
  age() {
    let date = new Date();
    return date.getFullYear() - this.year;
  }
}

let myCar = new Car("Ford", 2014);

JSON

JSON is a format for storing and transporting data.
JSON is often used when data is sent from a server to a web page.

What is JSON?

JSON stands for Java*Script **Object **N*otation
JSON is a lightweight data interchange format
JSON is language independent *
JSON is "self-describing" and easy to understand
The JSON syntax is derived from JavaScript object notation syntax, but the JSON format is text only. Code for reading and generating JSON data can be written in any programming language.

JSON Syntax Rules

Data is in name/value pairs
Data is separated by commas
Curly braces hold objects
Square brackets hold arrays

JSON Objects
JSON objects are written inside curly braces.
Just like in JavaScript, objects can contain multiple name/value pairs:

{"firstName":"John", "lastName":"Doe"}

JSON Arrays
JSON arrays are written inside square brackets.
Just like in JavaScript, an array can contain objects:

"employees":[
  {"firstName":"John", "lastName":"Doe"},
  {"firstName":"Anna", "lastName":"Smith"},
  {"firstName":"Peter", "lastName":"Jones"}
]

Sources:

Amigoscode YouTube Channel
https://developer.mozilla.org/en-US/docs/Web/JavaScript
w3schools.com

Introduction to Modern Python

MMK2020 — Sat, 12 Feb 2022 15:54:03 +0000

Wikipedia states that the Python programming language is an interpreted high-level general-purpose programming language that is dynamically-typed and garbage-collected. It supports multiple programming paradigms, including procedural object-oriented and functional programming.

Getting Started with Python

Getting started with Python is as easy as downloading and installing the. Python interpreter
Download the latest stable release for your operating system from https://www.python.org/downloads/
After installing run the python interpreter from the terminal by typing the word python

If successful you should get something likes shown below;
Python 3.9.4 (tags/v3.9.4:1f2e308, Apr 6 2021, 13:40:21) [MSC v.1928 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information

Introduction to python program structure

Input/Output (I/O) in python

The input() and print() functions are used for accepting and displaying data on the terminal respectively.
Accepting user input using input() function and converts it into a string. To change value use typecasting

name = input(‘Enter name’)
print(“Your name is: " + name)

To convert input to integer, float, list, tuple etc. Use the following examples i.e. casting

num = int(input("Enter a number:"))
num =float(input("Enter number "))
li =list(input("Enter number "))
num =tuple(input("Enter number "))`

Variables and Datatypes

Variables can store data of different types, and different types can do different things

Operators

The operators +, -, *** and **/ work just like in most other languages (for example, Pascal or C); parentheses (()) can be used for grouping
Division (/) always returns a float. To do floor division and get an integer result (discarding any fractional result) you can use the // operator; to calculate the remainder you can use %:

17 / 3 # classic division returns a float
5.666666666666667
17 // 3 # floor division discards the fractional part
5
17 % 3 # the % operator returns the remainder of the division

Operator Name Example

== Equal x == y
!= Not equal x != y
> Greater than x > y
< Less than x < y
>= Greater than or equal to x >= y
<= Less than or equal to x <= y
Operator Description Example
and Returns True if both statements are true x < 5 and x < 10
or Returns True if one of the statements is true x < 5 or x < 4
not Reverse the result, returns False if the result is true not(x < 5 and x < 10)

Lists, Tuples, Sets and Dictionaries

There are four collection data types in the Python programming language:

List is a collection which is ordered and changeable. Allows duplicate members.
Tuple is a collection which is ordered and unchangeable. Allows duplicate members.
Set is a collection which is unordered and unindexed. No duplicate members.
Dictionary a set of key: value pairs, with the requirement that the keys are unique (within one dictionary) It is ordered* and changeable. No duplicate members. (*for python 3.7 and above)

fruits= [‘Apple’, ’Mango’, ’Banana’] #List
fruits =(‘Apple’, ’Mango’, ’Banana’) #Tuple
basket = {'orange', 'apple', 'pear', 'banana'}#Set
a = {‘name’:’John’, ’surname’:’Ford’} #Dictionary

Conditionals

if b > a:
print("b is greater than a")
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")

There can be zero or more elif parts, and the else part is optional.
The keyword elif is short for ‘else if’, and is useful to avoid excessive indentation.
An if … elif … elif … sequence is a substitute for the switch or case statements found in other languages.

Loops

for statement
Python’s for statement iterates over the items of any sequence (a list or a string), in the order that they appear in the sequence

# Measure some strings:
... words = ['cat', 'window', 'defenestrate']
for w in words:
... print(w, len(w))
...
cat 3
window 6
defenestrate 12

While loop

count = 0
while (count<5):
count = count + 1
print("Hello there!")

Functions

A function is a block of code which only runs when it is called.
You can pass data, known as parameters, into a function.
A function can return data as a result.
You can send any data types of argument to a function (string, number, list, dictionary etc.), and it will be treated as the same data type inside the function. The syntax for a user defined function is as follows using the def keyword; def function_name(parameters): #some code return expression

A function is invoked by declaring it as follows;
function name(parameters)

def fib(n): # write Fibonacci series up to n
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
# Now call the function we just defined:
... fib(2000)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Classes

Almost everything in Python is an object, with its properties and methods.
A Class is like an object constructor, or a "blueprint" for creating objects. class MyClass: #class named MyClass, with a property named x x = 5 p1 = MyClass() #object named p1, and print the value of x print(p1.x) # print the value of x

__init__() function
All classes have a function called __init__(), which is always executed when the class is being initiated. The __init__() function is called automatically every time the class is being used to create a new object.
Use the __init__() function to assign values to object properties, or other operations that are necessary to do when the object is being created
class Person:

def __init__(self, name, age):
self.name = name
self.age = age

p1 = Person("John", 36)

print(p1.name)
print(p1.age)

Visit my article Introduction to Data Structures and Algorithms with Python to get familiar with data structures and algorithms. Understanding Data Structures and Algorithms (DSA) will help you write effective and efficient programs that work optimally under given conditions in terms of speed (execution time) and memory usage.

sources;
en.wikipedia.org
w3schools.com

DEV Community: MMK2020

The Ultimate Guide to Getting Started in Data Science

Something short about MongoDB

Modern Python for everyone: Mastering Modern Python the Right Way

Modern JavaScript for everyone: Mastering Modern JavaScript the Right Way

Introduction to Data Structures and Algorithms With Modern JavaScript.

What are data structures?

What is an algorithm?

Why data structures and algorithms

JavaScript data structures

Arrays

Queues & Stacks

Linked Lists

Trees

Graphs

Hash Tables

Introduction to Data Structures and Algorithms with Python

What are data structures?

What is an algorithm?

Why data structures and algorithms

Python Data Structures

Arrays in Python

Queues in Python

Stacks in Python

Linked lists in Python

Circular linked lists in Python

Trees in Python

Graphs in Python

Create the dictionary with graph elements

Hash tables in Python

Introduction to Modern JavaScript

Output

Variables

JavaScript Let

JavaScript const

Data type

Strings

Type Conversion

JavaScript Objects

Boolean

Arrays

Arithmetic Operators

Functions

Arrow Function

Loops

Looping an array

for of and foreach

while loop

do while loop

Increment and Decrement operators (++ and --)

Comparison Operators

Logical Operators

if statements

Ternary Statement ? :

switch statement

Hoisting

JavaScript Classes

JSON

Introduction to Modern Python

Getting Started with Python

Input/Output (I/O) in python

Variables and Datatypes

Operators

Lists, Tuples, Sets and Dictionaries

Conditionals

Loops

Functions

Classes

JavaScript `Let`

JavaScript `const`

`for` of and `foreach`

`while` loop

`do while` loop

Increment and Decrement operators (`++` and `--`)

`if` statements

Ternary Statement `? :`

`switch` statement