Javascript is a dynamically (loosely) typed language. Instead of asking for a specific amount of memory, for a specific purpose, you simply declare a variable. The type is determined by the interpreter and how you use the variable in your code.

Javascript considers Numbers, Strings, and Booleans to be primitive types and abstracts the difference between int, double, or float and string or char.

Because Javascript is constantly changing and also due to its loose typing, there are many things one must understand about variables in JS that goes beyond the scope of this course. See the links below for more information.

// Declare some variables and optionally initialize them
var someNumber, someOtherNumber, x;    // 'undefined' until initialized
var y = 4, z;
let myBoolean = true;
let someString = 'Hello';
const MY_NAME = 'Superman', PI = 3.1415926;

Links

​Mutable vs Immutable - the mystery of const let vs var and variable scope​

Python is a dynamically (loosely) typed language. Similarly to Javascript:

Based on the data type of a variable, the interpreter allocates memory and decides what can be stored in the reserved memory. Therefore, by assigning different data types to variables, you can store integers, decimals or characters in these variables. ~ Tutorialspoint - Python Variable Types​

# Variables do not need an explicit declaration in Python
myVar = "Initialize as I go!"
x,y,z = 4,5,"Zed"   # Init multiple variables at once
myInteger = 40      # Integer
myFloat = 40.0      # Float
​
# In Python you can delete objects (variables) to release the memory
del myInteger       # Kaboom! Gone.

Variables, especially primitive types, are an essential building block of programming. It would be impossible to do anything on a computer without them - not even typing. The computer is constantly using various locations of memory (RAM) to store, retrieve, and destroy data while the computer does all the various things like create a visible interface, allow a mouse click or user input, make sound, show an animation, or do math...

Primitive types can be combined to make other, special variables. They can also be used as a way of describing something, creating an object. Object Oriented Programming (OOP) is an extremely powerful tool and it would not be possible without basic variables (primitive types).

Note: a string is a special kind of variable, made of up many char values. See Arrays, below.

Arrays in C++ can become confusing when you start to think about memory space and pointers. Let's keep it simple and look at declaring some arrays:

// Declaring an array of integers of size 20
int arrayOfInts[ 20 ];
​
// Initialize each item from 1 to 20 (and print them)
for (int x = 0; x < 20; x++) {
    arrayOfInts[ x ] = x + 1;
    std::cout << arrayOfInts[ x ] << std::endl;
}
​
// Another way to intialize (this creates an array of size 4
double arrayOfDoubles[] = {13.2, 10.0, 2.16, 32.75};
std::cout << arrayOfDoubles[ 3 ] << std::endl;  // Will output 32.75
​

Java works in a similar fashion but the syntax is different.

C++: type name[size]; Java: type[] name = new type;

// declare & allocate memory to integer array
int[] intArray = new int[20];  
​
// another way to declare an array
double[] dblArray = new double[]{ 1.1, 2.0, 3.6, 10.5 }; 
​
// Put values into the intArray
for (int i = 0; i < intArray.length; i++) {
    intArray[i] = i * (i + 1);   // some math... 
}
 
// Print the elements of the intArray
for (int i = 0; i < intArray.length; i++) {
    System.out.println("Element at index " + i + " : "+ intArray[i]);
} 

Note: The C++ syntax will work in Java but it was only implemented as a way to help C++ developers. It is not the preferred method. The examples above are the preferred methods.

Since Javascript does not have types like C++, we just make an array of variables. Javascript also has some great built-in methods that allow us to concatenate, join, search, and sort arrays (among other things).

// Let's declare an array, there are two ways to do it
let someArray = new Array();         // Bad
let otherArray = [];                 // Good 
/* While both methods work, it is considered 
   proper form to use the second method above  */
   
// Let's put some values into an array
let integers = [40, 100, 1, 5, 25, 10];
​
// Let's add another item by 'pushing' it on the end
integers.push(6);
​
// Let's add a string in the 8th position (index 7) without using push
integers[7] = "8th item!";
​
/* Javascript is so loosely typed that our array does not need to be all
   the same type! Also, the push() method puts a new element on the end of
   the array but we can add an element wherever we want by using the index. */
​
// Let's print out our array (Javascript has about 5 ways to do that)
for (let i = 0; i < integers.length; i++) {
    console.log(integers[i]);
}
​
// Using the for...of method
for (let value of integers) {
    console.log(value);
}

Tons more reading here and here.

Python has a more versatile 'array' type called a sequence. The most basic sequence is a list. Lists in Python act very similar to arrays in Javascript. They can be modified, contain any type of variable or object, and they have many built-in methods for utilization.

# Let's create two lists
listOne = ['Iron Man', 'Thor', 1980, 2018];
listTwo = [1, 'second', 3, 4, "fifth", 6, 7];
​
# Print the second item of listOne:  Thor
print listOne[1]
​
# Print items 2 through 6 (inclusive) of listTwo:  ['second', 3, 4, 'fifth']
print listTwo[1:5]
​
# Python has tons of awesome ways to interact with lists
# Highly recommend you read www.tutorialspoint.com/python/python_lists.htm

Aside from Lists, Python also has Tuples and Dictionaries. Read more about all of Python's types.

In programming, a string is actually an array of chars. So, the string "Hello" is actually a char array of size 5 where char[0] = 'H', char[1] = 'e', char[2] = 'l', etc.

Most languages allow you to manipulate a string using the indexes of the characters. Also, when you append to a string or concatenate multiple strings together the computer must allocate a new chunk of memory that is the specific size of the new char array and individually assign each index the appropriate letter.

Simple arrays, as discussed in these sections, are called one dimensional arrays. They are linear in the sense that there is a beginning & end, and the indexes in-between have an element on either side, like links in a chain.

Arrays can be two dimensional as well (or even more). A 2D array has two indexes, [x, y], such that each element in the first index is, itself, an array.

You can also chain arrays into a 3D array. The idea there is that each element points to a 2D array of arrays. You can create all sorts of amazing combinations in this fashion.

Python syntax is a bit strange different - there are shortened words, it uses white space to exit a block of code, and notice the placement of colons:

if booleanExpression1:
   # statement(s)
elif booleanExpression2:
   # statement(s)
elif booleanExpression3:
   # statement(s)
else:
   # statement(s)
   
#  Note: "elif" and "else" statements are optional

If...else statements are the most basic tool for creating multiple pathways of code. There can also be shortcuts if you are comparing a simple boolean or want to combine items with And or Or boolean logic.

There is something called the ternary operator. It is used for simple yes/no situations and is worth learning.

// C++ ternary example
int a, b = 2, c = 3;
a = (b > c ? b : c);   // since b > c is false, a takes the value of c (3)

Python does not have a Switch / Case implementation. Instead, you use something called a dictionary and call it a switcher. You can read more about that on your own:

Switching on use input:

// Javascript
let userInput = prompt("Please enter a colour", "blue");
​
switch (userInput) {
   case "red":
      // code for what happens when user enters red
      break;
   case "blue":
      // code for what happens when user enters blue
      break;
   case "black":
      // code for what happens when user enters black
      break;
   case "yellow":
      // code for what happens when user enters yellow
      break;
   default:
      // code for what happens when user enters anything else
}

Don't forget - Python uses while space to end blocks of code.

for iterating_var in sequence:
   # Code to run repeatedly

Example: Print the remainder (modulo) of 10/i for i = 1 to 10 (Python)

for i in range(1, 10):
	print 10%i
# Output (each on a new line): 0 1 2 0 4 3 2 1 0

Here is an animated example:

This type of looping is called iterating. Some variable types are iterative - like arrays and lists.

Many languages have a method for looping through all of the items in an iterative type. For example, Java has the foreach loop, which is very handy. See the interactive sample below:

Python has a while loop and it works extremely similarly to any other language. Here is the syntax:

while expression:
   statement(s)

As long as expression is true, loop through the statements below it.

Example: Loop until a value is less than 10

import random
​
x = random.randint(1,100)
​
while x >= 10:
    print(x)
    x = random.randint(1,100)
​
print(x)

Similar to the example for C++, Java, and Javascript on the previous tab, this will print numbers greater than or equal to 10 (but below 100) until a number less than 10 is found. It might only print one number and never enter the loop.

You might wish to lookup the break and continue commands for while loops as well.

Some websites that teach coding have you create a while loop like this:

while(true) {
    // Your code here
}

An example of this is CodeCombat (although I do love CodeCombat overall).

What happens in the background is that their coding environment knows to stop this loop at some point. That's extremely dangerous. In my not-so-humble opinion, this should not be taught in this manner. You are creating an infinite loop and not explaining to the learner what that loop really does.

Python does not have a do...while loop construct. The short version of the story is that there has never been an agreed-upon syntax that matches the indented formatting of the Python language. Furthermore, it can easily be replicated or 'faked' with something like this:

while True:
    # statement(s)
    if not condition:
        break

If that syntax hurts your brain, you can understand why I decided not to teach Python for our first programming language.

Similar to C++, Java is a statically-typed language with a main() function. There is a terminology difference - in Java a user-defined function is called a method. This is due to the fact that Java is a true object-oriented language and not a functional programming language.

Since Java is object-oriented, the methods (user-defined functions) can have scope. This is beyond our course but crucial to understanding Java methods.

Syntax modifier returnType nameOfMethod(type parameter1, type parameter2, ...) { // Code inside the method return [optional value matching method type]; }

Unlike C++, Java does not require prototype methods - you can write your methods above or below the main() method.

Example - Return the minimum value given two integers.

class Main {
   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      
      System.out.println("Minimum Value = " + minimum(a, b));
   }
​
   // Return the minimum of two values
   public static int minimum(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;
​
      return min; 
   }
}

Final note - Java allows you to override a method. That means you can write a method with the same name as another but different parameters and return type. That allows for multiple options when calling a method (like integers values vs. doubles).

Creating a function in Javascript is simple. Since it is a loosely-typed language you do not declare a return type for the function. Furthermore, all parameters are optional and if you call the function with too many parameters, the extra ones are ignored.

Syntax function nameOfFunction(parameter1, parameter2, ...) { // Content inside the function return [optional value]; }

The return call is optional and you can return any type of data or object. If nothing is returned, the function is said to return undefined.

Example - Given a value and an array, return true if the value exists in the array.

// Ignoring the fact that we can use Array.includes()
function contains(theArray, value) {
  for (let i = 0; i < theArray.length; i++)
    if (theArray[i] == value) return true;
    
  return false;
}

(Here is the actual Array.includes() syntax)

Python utilizes the def keyword to define functions.

Syntax def name_of_function(parameter1, paramter2, ...): statement_1 statement_2 .... [optional return]

The return statement works exactly like other languages and you can return any type of value you like because Python is dynamically (loosely) typed.

Example - Return the average of two numbers.

def avg(num1, num2):
    return (num1 + num2)/2

Text here

​

​

​