diff --git a/processing.html.markdown b/processing.html.markdown
index 2d70e082..83f774ee 100644
--- a/processing.html.markdown
+++ b/processing.html.markdown
@@ -8,9 +8,9 @@ contributors:
 
 Processing is a programming language for creation of digital arts and multimedia content, allowing non-programmers to
 learn fundamentals of computer programming in a visual context.  
-While the language is based off on Java language,
+While the language is based on Java language,
 its syntax has been largely influenced by both Java and Javascript syntaxes. [See more here](https://processing.org/reference/)  
-The language also comes with its official IDE to compile and run the scripts.
+The language is statically typed, and also comes with its official IDE to compile and run the scripts.
 
 ```processing
 /* ---------
@@ -38,10 +38,19 @@ void setup() {
   println("Hello World!"); // Another language with a semi-column trap, ain't it?
 }
 
-// Normally, we put all the static codes inside the setup() method as the name suggests.
+// Normally, we put all the static codes inside the setup() method as the name suggest since it only runs once.
 // It can range from setting the background colours, setting the canvas size.
 // You will see more of them throughout this document.
 
+// If you want to run the codes indefinitely, it has to be placed in draw() method.
+// draw() must exist if you want the code to run continuously and obviously, there can only be one draw() method.
+int i = 0;
+void draw() {
+  // This block of code loops forever until stopped
+  print(i);
+  i++; // Increment Operator!
+}
+
 // Now that we know how to write the working script and how to run it,
 // we will proceed to explore what data types and collections are supported in Processing.
 
@@ -68,8 +77,73 @@ double doubleValue = 1.12345D; // Double (64-bit floating-point numbers)
 // they need to be converted into "int" and "float" datatypes respectively,
 // using (int) and (float) syntax before passing into a function.
 
+// There is a whole bunch of default composite datatypes available for use in Processing.
+// Primarily, I will brief through the most commonly used ones to save time.
 
+// String
+// While char datatype uses '', String datatype uses "" - double quotes.
+String sampleString = "Hello, Processing!";
+// String can be constructed from an array of char datatypes as well. We will discuss array very soon.
+char source = {'H', 'E', 'L', 'L', 'O'};
+String stringFromSource = new String(source); // HELLO
+// As in Java, strings can be concatenated using the "+" operator.
+print("Hello " + "World!"); // Hello World!
 
+// Array
+// Arrays in Processing can hold any datatypes including Objects themselves.
+// Since arrays are similar to objects, they must be created with the keyword "new".
+int[] intArray = new int[5];
+int[] intArrayWithValues = {1, 2, 3}; // You can also populate with data.
+
+// ArrayList
+// Functions are similar to those of array; arraylists can hold any datatypes.
+// The only difference is arraylists resize dynamically,
+// as it is a form of resizable-array implementation of the Java "List" interface.
+ArrayList<Integer> intArrayList = new ArrayList<Integer>();
+
+// Object
+// Since it is based on Java, Processing supports object-oriented programming.
+// That means you can basically define any datatypes of your own and manipulate them to your needs.
+// Of course, a class has to be defined before for the object you want.
+// Format --> ClassName InstanceName
+SomeRandomClass myObject // then instantiate later
+//or
+SomeRandomClass myObjectInstantiated = new SomeRandomClass(); // Assuming we have nothing to pass into the constructor
+
+// Processing comes up with more collections (eg. - Dictionaries and Lists) by default,
+// for the simplicity sake, I will leave them out of discussion here.
+
+/* -----------
+  Maths
+  ------------
+*/
+// Arithmetic
+1 + 1 // 2
+2 - 1 // 0
+2 * 3 // 6
+3 / 2 // 1
+3.0 / 2 // 1.5
+3.0 % 2 // 1.0
+
+// Processing also comes with a set of functions that simplify mathematical operations.
+float f = sq(3); // f = 9.0
+float p = pow(3, 3); // p = 27.0
+int a = abs(-13) // a = 13
+int r1 = round(3.1); // r1 = 3
+int r2 = round(3.7); // r2 = 4
+float sr = sqrt(25); // sr = 5.0
+
+// Vectors
+// Processing provides an easy way to implement vectors in its environment using PVector class.
+// It can describe a two or three dimensional vector and comes with a set of methods which are useful for matrices operations.
+// You can find more information on PVector class and its functions here. (https://processing.org/reference/PVector.html)
+
+// Trigonometry
+// Processing also supports trigonometric operations by supplying a set of functions.
+// sin(), cos(), tan(), asin(), acos(), atan() and also degrees() and radians() for convenient conversion.
+// However, a thing to note is those functions take angle in radians as the parameter so it has to be converted beforehand.
+float one = sin(PI/2); // one = 1.0
+// As you may have noticed, there exists a set of constants for trigonometric uses; PI, HALF_PI, QUARTER_PI and so on...
 
 ```
 Processing is easy to learn and is particularly useful to create multimedia contents (even in 3D) without