Introduction to IPO

Article Date: August 9, 2014
By Paul S. Tuon

• Sole Proprietorships
  
  
• Partnerships
  
  
• Trusts and Estates
  
  
• S Corporations
  
  
• C Corporations
  

IPO Journey

Conclusion: Was Twitter a Success for its IPO?

• Two days before the IPO, Facebook changed its mind about M (the number of shares it would offer). Though the mathematics is simple, this meant that all the major players who had planned on purchasing shares on IPO day had to recompute everything and update their plans.


• Many of the initial institutional investors reported in the days before IPO day that they intended to sell some of the shares they would receive. Remember that a lot of these so called institutional investors are people just like you and I who look to make money in the stock market. Except you and I don't get the privilege to obtain the shares at no cost and sell at the IPO debut trading to make quick bucks. In other words, a lot of these so called institutional investors are opportunistic dealers who seek to make quick bucks using their privilege and well-connected status.


• Facebook's initial offering price was much closer to the expected market price than Twitter's; as a result, the initial institutional investors in Facebook stood to gain much less on IPO day than the institutional investors in Twitter.


• The period of price discovery took exceptionally long (trading opened at 11:30am) and the process was marred by technical difficulties before and after the start of trading: orders did not come through, and investors were confused about whether or not their orders had been executed or even received.


• Extremely high volume (because of unprecedented excitement about Facebook) overwhelmed the NASDAQ servers, exacerbating the technical difficulties.


• The excitement was not only unprecedented, but also excessive: many retail investors wanted to purchase shares of Facebook because they were convinced it was the next big thing (for many young people, purchasing Facebook shares was their first foray into the financial markets), but the reality was that the prices at which it was trading were ridiculously high compared to its profitability. When "virgin" retail investors (who had been promised that the stock price might increase by as much as 50 percent on IPO day) saw prices dropping, they grew anxious and sold their positions, exacerbating the selloff.

Google's IPO

Snap is Going Public

• Net revenue: $404.48 million in 2016, up from $58.66 million in 2015. That means the ephemeral messaging service grew revenue almost seven times in a year -- but its losses outstripped its revenue


• Net loss: $514.64 million in 2016, wider than $372.89 million in 2015


• Loss from operations: $520.39 million in 2016, wider than $381.73 million in 2015


• Usage: 161 million daily active users in the December quarter (60 million daily active users in the United States and Canada)


• Average revenue per user: $1.05 in the December quarter ($2.15 in North America)


• Time spent: 25 to 30 minutes a day


• Head count: 1,859 employees

Snap Initial Public Offering Procession

• Snap closed at $24.48, up $7.48 or 44% from its offer price of $17. It's first day pop was bigger than Alibaba's, Facebook's and Google's, but smaller than LinkedIn's, Twitter's and Yelp's.
  
  
• It opened at $24, up 7.00 or 41.2% at 11:19 AM.
  
  
• Snap was the most actively traded US stock today, with more than 215 million shares changing hands today.
  
  
• At its high today, it was up $9.05 or 53.2%, to $26.05.
  
  
• Best first day pop for a U.S.-listed IPO that raised at least $1 billion since LendingClub's December 2014 IPO (LendingClub rose 56% the day it went public.)
  
  
• At the close, its market cap is $28.33 billion based on the 1.157 billion shares count in the SEC S1 filing.
  
  
• Snap's market value increased by nearly $9 billion on its first day of trading.

What is an option?

• Option 1 (ticker: T100918C00015000): Gives you the right to buy XYZ stock at $15 a share. option premium: $7.50 (the asking price. See the options chain above).
  
  
• Option 2 (ticker: T100918C00025000): Gives you the right to buy XYZ stock at $25 a share. option premium: $3.50 (Ask column. See the options chain above).

A Brief Introduction to Machine Learning/Neural Network

• Dendrites - Are brain cells that receive and response signals from/to other parts of the brain cells. They are tree-like branches, responsible for receiving the information from other neurons it is connected to. In other sense, we can say that they are like the ears of neuron.



• Soma - It is the cell body of the neuron and is responsible for processing of information received from dendrites.



• Axon - It is just like a cable through which neurons send the information.



• Synapses - It is the connection between the axon and other neuron dendrites.

Introduction to Biases

Introduction to Weight

• Male. Males are typically more aggressive drivers than females so the weight should be higher than females. So we'll give males a 2 as the input neuron.


• Female. Females are typically less aggressive drivers than males so the weight should be lower than males. And we'll give females a 1 as the input neuron.


• Bias. We'll give it a 1. Biases are optional but in this example I elected to use it. In a real insurance policy program we probably won't need to implement the biases. Or [in your real insurance policy program] you could use a bias as a special discount to special groups of drivers; for example, drivers who have special or extra trainings, such as the "Smith System", or for drivers who are also hold other classes of driver license, such as class, A, B, or C.

• Age: 18 and under. So we'll have to assign a weight scale of 10 for this age group of drivers.


• Age: 19 - 25. So we'll have to assign a weight scale of 8 for this age group of drivers.


• Age: 26 - 35. So we'll have to assign a weight scale of 5 for this age group of drivers.


• Age: 36 - 45. So we'll have to assign a weight scale of 2 for this age group of drivers.


• Age: 46 and older. So we'll have to assign a weight scale of 0 for this age group of drivers.

• $0 - $9,999. So we'll have to assign a weight scale of 10 for this income group of drivers.


• $10,000 - $29,999. So we'll have to assign a weight scale of 8 for this income group of drivers.


• $30,000 - $49,999. So we'll have to assign a weight scale of 5 for this income group of drivers.


• $50,000 - $99,999. So we'll have to assign a weight scale of 2 for this income group of drivers.


• $100,000 - up. So we'll have to assign a weight scale of 0 for this income group of drivers.

• FICO Score: lower than 500. So we'll have to assign a weight scale of 10 for this FICO score group of drivers.


• FICO Score: 500 - 549. So we'll have to assign a weight scale of 8 for this FICO score group of drivers.


• FICO Score: 600 - 649. So we'll have to assign a weight scale of 5 for this FICO score group of drivers.


• FICO Score: 650 - 699. So we'll have to assign a weight scale of 2 for this FICO score group of drivers.


• FICO Score: 700 - 749. So we'll have to assign a weight scale of 1 for this FICO score group of drivers.


• FICO Score: 750 and higher. So we'll have to assign a weight scale of 0 for this FICO score group of drivers.

• Traffic Violations: 1 or more in past 12-month or 3 or more in past 5 years. Notice the use of 'OR'. So we'll have to assign a weight scale of 10 for this traffic violations group of drivers.


• Traffic Violations: none in past 12-month and 3 or more in past 5 years. So we'll have to assign a weight scale of 8 for this traffic violations group of drivers.


• Traffic Violations: 1 in past 12-month and no more than 1 in past 5 years. Notice the use of 'AND'. So we'll have to assign a weight scale of 5 for this traffic violations group of drivers.


• Traffic Violations: none in past 12-month and none in past 5 years. Notice the use of 'AND'. So we'll have to assign a weight scale of 0 for this traffic violations group of drivers.

Introduction to Forward Propagation

Forward Propagation Processing Code

<?php
/**
 *  file: neuralnetwork.php
 *
 *  Simple MLP (Multi-layers Perceptron) Neural Network 
 */
class NeuralNetwork
    {
     private $input = array(); // input information
     private $hidden_layer = array(); // layers in the network

     /**
      * Constructor setting up layers
      * A calling program needs to create an instance of this class and passing
      * input layer, hidden layers, and output layer.
      *
      *  Usage:
      *
      *  $net = new NeuralNetwork([3, 25, 25, 1 ]);
      *
      *  After that, we need to call FeedForward() and BackPropagation().
      *  in this example, we pass the known value of XOR function as an array:
      *
      *  $net.FeedForward([ 0, 0, 0 ]);
      *  $net.BackPropagation([ 0 ]);
      *
      *  we can train some more:
      *
      *  $net.FeedForward([ 0, 0, 1 ]);
      *  $net.BackPropagation([ 1 ]);
      *
      *  $net.FeedForward([ 0, 1, 0 ]);
      *  $net.BackPropagation([ 1 ]);
      *
      *  $net.FeedForward([ 0, 1, 1 ]);
      *  $net.BackPropagation([ 0 ]);
      *
      *  $net.FeedForward([ 1, 0, 0 ]);
      *  $net.BackPropagation([ 1 ]);
      *
      *  $net.FeedForward([ 1, 0, 1 ]);
      *  $net.BackPropagation([ 0 ]);
      *
      *  $net.FeedForward([ 1, 1, 0 ]);
      *  $net.BackPropagation([ 0 ]);
      *
      *  $net.FeedForward([ 1, 1, 1 ]);
      *  $net.BackPropagation([ 1 ]);
      *
      * @param $input Layers of this network
      */
     // notice the type-hint which indicates $input is an array variable
     public __construct(array $input)
          {
           // initialize input layers that were passed in by the calling program
           for ($i = 0; $i < sizeof($input); $i++)
               {
                // $input argument contains: 3 inputs, 25 neurons in hidden layer 1,
                // 25 neurons in hidden layer 2, 1 output
                // store each argument in this class' array variable $input
                $this->input[$i] = $input[$i];
               }
               /*
                the for() loop above result in the following initialization:
                $this->input[0] = 3;
                $this->input[1] = 25;
                $this->input[2] = 25;
                $this->input[3] = 1;
               */

           // creates a bunch of neural network hidden layers,
           for ($i = 0; $i < count($input) - 1; $i++)
               {
                // for each argument in [count($input)], create a Layer object passing
                // this class' array variable $input
                // in other words, create one Layer object for the input layer (index 0),
                // one for the first hidden layer (index 1),
                // one for the 2nd hidden layer (index 2),
                // leaving the output (index 3) uneffected.
                // follow the for() loop iteration to make sense of all this:
                $this->hidden_layer[i] = new Layer($this->input[$i], $this->input[$i + 1]);
               }
           /*
            the for() loop above result in the following initialization:
            // input = 3, hidden layer = 25 => (3, 25)
            $this->hidden_layer[0] = new Layer($this->input[0], $this->input[0 + 1]);
            // hiddenl = 25, hiddenl = 25 => (25, 25)
            $this->hidden_layer[1] = new Layer($this->input[1], $this->input[1 + 1]);
            // hiddenl = 25, hidden layer = 25 => (25, 1)
            $this->hidden_layer[2] = new Layer($this->input[2], $this->input[2 + 1]);
            // so this last index is not iterated because of count($input) - 1, which is
            // when $i = 3. 3 < 3 is false,
            // so this last line is not executed at last iteration
            // hidden l = 25, hidden layer 2 = 25 => (1, null)
            // again, follow the for() loop iteration to make sense of all this:
            $this->hidden_layer[3] = new Layer($this->input[3], $this->input[3 + 1]);
           */
          }

     /**
      *  A feedforward for this network
      *  this function is called by the training app to kickstart the process:
      *
      *  // notice the argument is passed in as an array and the array
      *  can contain limitless size. here we pass in five layers.
      *  notice that we have two hidden layers 25 neurons each.
      *  if we have more hidden layers we can pass in more arguments seperate each
      *  argument with a comma, e.g.:  3 inputs, five hidden layers: 25, 25, 8, 4, 17
      *  one output: 1
      *
      *  for example:
      *  new NeuralNetwork([3, 25, 25, 8, 4, 17, 1 ])
      *
      *  Usage:
      *
      *  $net = new NeuralNetwork([3, 25, 25, 1 ]);
      *  calling FeedForward() passing the known answer. in this example, we're
      *  calling FeedForward() and passing the known value as an array. in this case,
      *  we pass an XOR function values: 0, 0, 0
      *  $net.FeedForward([ 0, 0, 0 ]);
      *  so all applications need to call this so called "train" function to start the process
      *  some programmers like to name this function as "train()" but I like "FeedForward()"
      *  @param $input inputs to be feed forward
      */
     // this function acts as a train() function to train or jumpstart the process
     public FeedForward($input)
          {
           // feed forward. notice the call to FeedForward--it's not a recursive call, but
           // rather, it is actually calling Layer's FeedForward($input) because
           // $this->hidden_layer[0] refers to Layer's object
           $this->hidden_layer[0]->FeedForward($input);
           // so after the above call to FeedForward($input),
           // Layer's $output should contains a weighted sum of the input
           for ($i = 1; $i < count($this->hidden_layer); $i++)
               {
                // start with the 2nd Layer object instance (index 1) and call
                // Layer's FeedForward() passing the output of layer 0
                $this->hidden_layer[$i]->FeedForward($this->hidden_layer[$i - 1]->output);
               }

           // return the output of the last layer
           return $this->hidden_layer[$i - 1]->output; // $i = 3
          }

     /**
      *  High level back propagation
      *  Note: It is expected the one feed forward was done before this back prop.
      *  @param $expected The expected output form the last feedforward
      */
     // notice that $expected is the known answer passed in by calling code
     public BackPropagation($expected)
          {
           // run over all layers backwards. notice that the for() loop starts from
           // the total number of hidden layers and iterated downward to 0
           for ($i = sizeof($this->hidden_layer) - 1; $i >= 0; $i--)
               {
                if ($i == sizeof($this->hidden_layer) - 1)
                   {
                    // doing a backward propagation output
                    $this->hidden_layer[$i]->BackPropagationOutput($expected);
                   }
                else
                   {
                    //back prop hidden
                    $this->hidden_layer[$i]->BackPropagationHidden($this->hidden_layer[$i +
                                                                               1]->gamma,
                    $this->hidden_layer[$i + 1]->weight);
                   }
               }

           //Update weights
           for ($i = 0; $i < sizeof($this->hidden_layer); $i++)
               {
                $this->hidden_layer[$i]->UpdateWeight();
               }
          } // end BackProp($expected)
    } // end class NeuralNetwork

/**
 *  Each individual layer in the ML
 */
class Layer
    {
     public $numberOfInput; //# of neurons in the previous layer
     public $numberOfOuput; //# of neurons in the current layer

     public $output = array(); //outputs of this layer
     public $input_layer = array(); //inputs in into this layer
     public $weight[][]; //weights of this layer, a two-dimensional array
     public $weightDelta[][]; //deltas of this layer, a two-dimensional array
     public $gamma = array(); //gamma of this layer
     public $error = array(); //error of the output layer

     public static $random = new rand(); //Static random class variable

     /**
      *  Constructor initilizes various data structures
      *
      *  @param $numberOfInput Number of neurons in the previous layer
      *  @param $numberOfOuput Number of neurons in the current layer
      *
      *  note that $this->input refers to NeuralNetwork's member array variable $input
      *  // input = 3, hidden layer = 25 => (3, 25)
      *  $this->hidden_layer[0] = new Layer($this->input[0], $this->input[0 + 1]);
      *  // hiddenl = 25, hiddenl = 25 => (25, 25)
      *  $this->hidden_layer[1] = new Layer($this->input[1], $this->input[1 + 1]);
      *  // hidden l = 25, hidden layer 2 = 25 => (25, 1)
      *  $this->hidden_layer[2] = new Layer($this->input[2], $this->input[2 + 1]);
      *  // so this last index is not iterated because of count($input) - 1, which is
      *  // when $i = 3. 3 < 3 is false
      *  // hiddenl = 25, hidden layer = 25 => (1, null)
      *  $this->hidden_layer[3] = new Layer($this->input[3], $this->input[3 + 1]);
      */
     public __construct($numberOfInput, $numberOfOuput)
          {
           $this.numberOfInput = $numberOfInput; // 3
           $this.numberOfOuput = $numberOfOuput; // 25

           //initialize data structures
           // these need to be refined and probably involve matrix manipulation
           // or we can use for loops to initialize the matrix:

           for ($i = 0; $i < $this->numberOfOuput; $i++)
               {
                for ($j = 0; $j < $this->numberOfInput; $j++)
                    {
                     // need to refine these
                     $this->weight[$i][$j] = 0;
                     $this->weightDelta[$i][$j] = 0;
                    }
               }

           // all it does above is initializing the array elements to their default values.
           // all the array elements are initialized to zero.

           $this->InitilizeWeight(); //initilize weights
          }

     /**
      *  Initilize weights between -0.5 and 0.5
      */
     public InitilizeWeight()
          {
           for ($i = 0; $i < $this->numberOfOuput; $i++)
               {
                for ($j = 0; $j < $this->numberOfInput; $j++)
                    {
                     // I need to refine this. It doesn't seem right!
                     $this->weight[$i][$j] = rand(- 0.5, 0.5);
                    }
               }
          }

     /**
      *  Feedforward this layer with a given input
      *
      *  @param $input The output values of the previous layer
      */
     public FeedForward($input)
          {
           // initialize the layers which can be used for backward propagation
           $this->input_layer = $input;

           //feed forward
           for ($i = 0; $i < $this->numberOfOuput; $i++)
               {
                $this->output[$i] = 0;
                for ($j = 0; $j < $this->numberOfInput; $j++)
                    {
                     // this is the output sum of the activation function: sigmoid, tanH,...
                     // this is where we can add a bias to the output sum
                     // $this->input_layer[$j] * $this->weight[$i][$j] + $this->bias[$j]
                     $this->output[$i] += $this->input_layer[$j] * $this->weight[$i][$j];
                    }

                // I need to refine and maybe use sigmoid() instead
                //$this->output[$i] = (float)Math.Tanh($this->output[$i]);
                $this->output[$i] = call_user_func_array(array('sigmoid', $this->output[$i]);
               }

           // in the calling code only returns output of the last layer is used even though
           // we return the full array of result
           return $this->output;
          }

     /**
      *  Activation functions.
      *
      *  You can use other activation functions as well: sigmoid(), ReLU(), softmax, etc.
      *
      *	 public function sigmoid($x)
      *       {
      *        return 1 / (1 + pow(M_E, -$x));
      *       }
      *
      *  a derivative of sigmoid()
      *  
      *  public function dsigmoid($y)
      *       {
      *        // return sigmoid($x) * (1 - sigmoid($x));
      *        return $y * (1 - $y);
      *       }
      *
      *  ReLU
      *
      *  public function relu($x)
      *       {
      *        //$x = $x > 0 ? 1 : 0;
      *        return $x > 0 ? 1 : 0;
      *       }
      *
      *  TanH:
      *
      *  public function getTanH($x)
      *       {
      *        // return the computed tanH()
      *        return tanh($x);
      *       }
      *
      * Or use it directly:
      *
      *      echo tanh(M_PI_4);    // output:  0.65579420263267
      *      echo tanh(0.50);      // output:  0.46211715726001
      *      echo tanh(-0.50);     // output: -0.46211715726001
      *      echo tanh(5);         // output:  0.9999092042626
      *      echo tanh(-5);        // output: -0.9999092042626
      *      echo tanh(10);        // output:  0.99999999587769
      *      echo tanh(-10);       // output: -0.99999999587769
      */

     /**
      *  TanH derivative
      *
      *  @param $value An already computed TanH value, for example: 0.65579420263267
      *
      *  Notice that to use this TanHDer() you first have to get the value of tanh() and
      *  then call this function passing the computed value to it. See example above.
      */
     public TanHDer($value)
          {
           return 1 - ($value * $value);
          }

     /**
      *  Back propagation for the output layer
      *
      *  @param $expected The expected output
      */
     public BackPropagationOutput($expected)
          {
           //Error derivative of the cost function
           for ($i = 0; $i < $this->numberOfOuput; $i++)
               {
                $this->error[$i] = $this->output[$i] - $expected[$i];
               }

           //Gamma calculation
           for ($i = 0; $i < $this->numberOfOuput; $i++)
               {
                $this->gamma[$i] = $this->error[$i] * $this->TanHDer($this->output[$i]);
               }

           //Caluclating delta weights
           for ($i = 0; $i < $this->numberOfOuput; $i++)
               {
                for ($j = 0; $j < $this->numberOfInput; $j++)
                    {
                     $this->weightDelta[$i, $j] = $this->gamma[$i] * $this->input_layer[$j];
                    }
               }
          }

     /**
      *  Back propagation for the hidden layers
      *
      *  @param $gammaForward the gamma value of the forward layer
      *  @param $weightFoward the weights of the forward layer
      */
     public BackPropagationHidden($gammaForward, $weightFoward[][])
          {
           //Caluclate new gamma using gamma sums of the forward layer
           for ($i = 0; $i < $this->numberOfOuput; $i++)
               {
                $this->gamma[$i] = 0;

                for ($j = 0; $j < count($gammaForward); $j++)
                    {
                     $this->gamma[$i] += $gammaForward[$j] * $weightFoward[$j, $i];
                    }

                $this->gamma[$i] *= $this->TanHDer($this->output[$i]);
               }

           //Caluclating detla weights
           for ($i = 0; $i < $this->numberOfOuput; $i++)
               {
                for ($j = 0; $j < $this->numberOfInput; $j++)
                    {
                     $this->weightDelta[$i, $j] = $this->gamma[$i] * $this->input_layer[$j];
                    }
               }
          }

     /**
      *  Updating weights
      */
     public UpdateWeight()
          {
           for ($i = 0; $i < $this->numberOfOuput; $i++)
               {
                for ($j = 0; $j < $this->numberOfInput; $j++)
                    {
                     // learning rate is hardcoded to 0.033
                     $this->weight[$i, $j] -= $this->weightDelta[$i, $j] * 0.033f;
                    }
               }
          }
    } // end class Layer
?>

Introduction to Backward Propagation

Introduction to Probability

Introduction to Activation Functions

Introduction to Supervised Learning

Introduction to Unsupervised Learning

Introduction to Linearly Separable Problem

Introduction to Gradient descent

Introduction to PDO Database

Article Date: October 20, 2013
By Paul S. Tuon

• mysql - the very popular and easy to use, original API.
• mysqli - MySQL Improved (the much improved API)
• pdo - PHP Data Objects (the uniform connection API - the new kid on the block, if you will)

• Escaping: The process of escaping user input is left to the developer - many of which don't understand or know how to sanitize the data.
  
  
• Flexibility: The API isn't flexible; the code that people normally used to write for MySQL is tailor-made for working with a MySQL database and not portable to other databases. What if you want to switch your code to work with a different database, say, PostgreSQL, SQLite, ADO ( ActiveX Database Objects), Interbase, or any other databases out there?
  
  The good old and very popular MySQL API isn't going to allow you to port your code to other databases; while, Java API, and comes the new kid on the block, PDO, or PHP Data Objects, provide a more powerful API that doesn't care about the driver you use; it's database agnostic (neutral). Furthermore, it offers the ability to use prepared statements, virtually eliminating any worry of SQL injection.
  
  
• Deprecated: Though it hasn't been officially deprecated - due to widespread use - in terms of best practice and education, it might as well be.

Connecting to MySQL Database

Getting Started

File name incuding directory: Home/Database/connection.php

<?php
// arbitrarily name you give it when
// you create during phpMyAdmin setup
$databaseName = "db1.abc.10077";
//given to you by your hosting co.
$hostingserver = "db1.abc10077.example.com";
// either given to you or you create it yourself
$username  = "yourUsername";
// either given to you or you create it yourself
$password  = "yourPassword";
?>
    

<?php
include('Home/Database/connection.php');
$conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                                        $username, $password,
     array(PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8'));
?>
   

<?php
include('Home/Database/connection.php');
$conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName;
port=your_database_port_number;charset=utf8",
$username, $password);
?>
   

• mysql - driver. Note that the colon (:) is not part of a driver. It's a PDO operator or command to signify that all parameters that follow it belonged to the driver; in this case, mysql driver. The semicolon is a PDO operator to seperate each name/value pairs.
  
  
• host - hosting server (e.g., host='www.dbserver.com/db100770')- host=name_of_hosting_company, also commonly known as localhost or local host if you're working offline (not live online) on a local environment or platform such as MAMP, WAMP, XAMPP, VAGRANT or DOCKER.io. It refers to the database hosting company in the form of a server address that contains the database engine you're trying to connect to. For example, http://db1005.server.example.com.
  
  
• dbname - database name (dbname=your_database_name).
  
  
• Optional: charset - utf8 or other charset relevant to your language.

<?php
include('Home/Database/connection.php');
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                                             $username, $password);
     $conn->setAttribute(PDO::ATTR_ERRMODE,
                         PDO::ERRMODE_EXCEPTION);
    }
catch (PDOException $e)
    {
     echo 'Cannot connect to the database. ' . $e->getMessage();
    }
?>
   

• PDO::ERRMODE_SILENT
• PDO::ERRMODE_WARNING
• PDO::ERRMODE_EXCEPTION

Persistence Database Connection

<?php
include('Home/Database/connection.php');
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                     $username, $password,
                     array(PDO::ATTR_PERSISTENT => true,
                     PDO::ATTR_ERRMODE => true,
                     PDO::ERRMODE_EXCEPTION => true));
    }
catch (PDOException $Exception)
    {
     echo 'Connection error: ' . $Exception->getMessage();
    }
?>  
   

<?php
include('Home/Database/connection.php');
try
    {
     //initiate an instantiation
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                     $username, $password);
     //after instantiation
     $conn->setAttribute(PDO::ATTR_PERSISTENT, PDO::ATTR_ERRMODE,
                     PDO::ERRMODE_EXCEPTION));
    }
catch (PDOException $ex)
    {
     echo 'Connection error: ' . $ex->getMessage();
    }
?>  
   

Closing the Database

<?php
include('Home/Database/connection.php');
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
     $username, $password);
     // use the connection here
     // ....
    }
catch (PDOException $exception)
    {
     echo 'Cannot connect to the database. '.$exception->getMessage();
    }

// and now we're done; close it
$conn = null;
?>
   

Insert Data Into Database

<?php
//create a table named membership_table if it doesn't exist in the database name
try
    {
     $conn->query("CREATE TABLE IF NOT EXISTS `membership_table`
           (
            `id` int(10) NOT NULL auto_increment, //id is increment automatically
            `name` varchar(25) NOT NULL,
            `address` varchar(64),
            `email` varchar(64) NOT NULL,
            //just to have a variety for demonstrative purpose
            `price` float(10,2), //can be null,10 digits with 2 decimal
            `description` text(64), //also can be null
            `date_time` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL,
            // the following definitions are advanced uses for key manipulations
            PRIMARY KEY (`id`), //used for referring to certain id
            UNIQUE KEY `id` (`id`), //for referring to a unique id
            // full text searching similar to Google search
            FULLTEXT (`name`, `address`, `email`, `description`)
           )
     //MySQL 5.7 or higher: InnoDB is the default storage engine but
     //consumes more bytes.
     //So MyISAM is the preferred choice here/consuming less bytes and
     //runs faster.
     ENGINE=MyISAM  DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=2 ");
    }
catch (PDOException $e)
    {
     echo "Error: Fail to create a table. " . $e->getMessage();
    }
?>
   

<?php
//Let's prepare to insert Joe's data into membership database
$name     = 'Joe Public1';
$email    = 'abc@example.com';
$address  = '123 Main St';
//hours in 24-hour military time
 //displays: 04-26-2016 20:01:04
$current_date_time = date("m-d-Y H:i:s");
 //displays: 26-04-2016 20:01:04
$current_date_time = date("d-m-Y H:i:s");
 //displays: 2016-04-26 20:01:04
$current_date_time = date("Y-m-d H:i:s");
try
    {
     # Prepare to insert Joe's data into club's membership database
     # using ??????
     $stmt = $conn->prepare('INSERT INTO membership_table
        (name, address, email, price, description, created_time)
                          VALUES(?, ?, ?, ?, ?, ?)');
     $stmt->execute(array(
                          'name' => ' . $name . ',
                          'address' => ' . $address . ',
                          'email' => ' . $email . '.
                          'price' => ' . $price . '.
                          'description' => ' . $description . '.
                          'date_time' => ' . $current_date_time . '
                         ));
     # For debugging purpose? Affected rows?
     # output 1 row.
     # rowCount() is similar to mysql_num_rows() for the old PHP API
     echo "Data has been entered successfully: " . $stmt->rowCount();
    }
catch (PDOException $e)
    {
     echo 'Can't insert data into database. ' . $e->getMessage();
    }
?>
   

Binding Data Using bindParan() and bindValue()

<?php
include('Home/Database/connection.php');
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$dbname",
     $username, $password);
     // set the PDO error mode to exception
     $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    }
catch (PDOException $e)
    {
     echo 'ERROR: Can't connect to the database. ' . $e->getMessage();
    }
try
    {
     // prepare sql and bind parameters
     $stmt = $conn->prepare("INSERT INTO membership_table (name,
     address, email, price, description, created_time) 
     VALUES (:name, :address, :email, :price, :description, :created_time)");
     $stmt->bindParam(':name', $name);
     $stmt->bindParam(':address', $address);
     $stmt->bindParam(':email', $email);
     $stmt->bindParam(':price', $price);
     $stmt->bindParam(':description', $description);
     $stmt->bindParam(':created_time', $created_time);

     // insert a row
     $name = "Joe Public";
     $address = "123 main st";
     $email = "joe@example.com";
     $price = 10.00;
     $description = "this is a description";
     $created_time = date("Y-m-d H:i:s");
     $stmt->execute();

     // insert another row
     $name = "Joe Public";
     $address = "123 main st";
     $email = "joe@example.com";
     $price = 10.00;
     $description = "this is a description";
     $created_time = date("Y-m-d H:i:s");
     $stmt->execute();

     // insert another row
     $name = "John Doe";
     $address = "999 main st";
     $email = "john@example.com";
     $price = 30.00;
     $description = "this is another description";
     $created_time = date("Y-m-d H:i:s");
     $stmt->execute();

     echo "New records created successfully";
    }
catch (PDOException $e)
    {
     echo "Cannot insert data into the database. " . $e->getMessage();
    }
?>
   

<?php
//include all database credential, e.g., $host, $database, $username,
//$password
include("Home/Database/Credential.php");
try
    {
     $conn = new PDO("mysql:host=$host;dbname=$database", $username,
     $password);
     $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    }
catch (PDOException $e)
    {
     echo 'ERROR: Cannot connect to the database. ' . $e->getMessage();
    }
//try to create a table if one doesn't exist
try
    {
     $conn->query("CREATE TABLE IF NOT EXISTS `Products`
               (
                ID int(6) NOT NULL auto_increment,
                ProductNum VARCHAR(8) NOT NULL,
                ProductName VARCHAR(35) NOT NULL,
                Price DOUBLE(8, 2) NOT NULL,
                Image VARCHAR(45),
                URL VARCHAR(45) NOT NULL,
                Description VARCHAR(64),
                PRIMARY KEY (ID),
                UNIQUE ID (ID),
                // full text searching similar to Google search
                FULLTEXT (ProductNum, ProductName, Description)
               )
     //MySQL 5.7 or higher: InnoDB is the default storage engine but
     //consumes more bytes.
     //So MyISAM is the preferred choice here/consuming less bytes and
     //runs faster.
     ENGINE=MyISAM  DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=2 ");
    }
catch (PDOException $e)
    {
     echo 'ERROR: Cannot create a table! ' . $e->getMessage();
    }
try
    {
     $result = $conn->prepare("INSERT INTO `Products`
             (
              `ProductNum`, `ProductName`, `Price`, `Image`, `URL`,
              `Description`
             )
       VALUES
             (
              :ProductNum, :ProductName, :Price, :Image, :URL,
              :Description
             ) ");
     $result->bindParam(':ProductNum', $ProductNum, PDO::PARAM_STR);
     $result->bindParam(':ProductName', $ProductName, PDO::PARAM_STR);
     //No PDO::PARAM_DOUBLE OR PDO::PARAM_FLOAT,
     //so use PDO::PARAM_STR instead
     ////all float or decimal # treat as string, eg '12.30'
     $result->bindParam(':Price', $Price, PDO::PARAM_STR);
     $result->bindParam(':Image', $Image, PDO::PARAM_STR);
     $result->bindParam(':URL', $URL, PDO::PARAM_STR);
     $result->bindParam(':Description', $Description, PDO::PARAM_STR);
     $result->execute();
    }
catch (PDOException $e)
    {
     echo 'Can't insert data into database. ' . $e->getMessage();
    }
//Notice that you can place these values after the
//execute() statement
//and outside the try ... catch block as well and it still works.
if (isset($_POST['num']) && ($_POST['num'] != '') )
   {
    $ProductNum  = $_POST['num'];
   }
else
   {
    $Error       = 'You forgot to type in the product number.';
    $Flag        = true;
   }
if (isset($_POST['name']) && ($_POST['name'] != '') )
   {
    $ProductName = $_POST['name'];
   }
else
   {
    $Error       = 'You forgot to type in the product name.';
    $Flag        = true;
   }
if (isset($_POST['price']) && ($_POST['price'] != '') )
   {
    $Price       = $_POST['price'];
   }
else
   {
    $Error       = 'You forgot to type the product price.';
    $Flag        = true;
   }
if (isset($_POST['image']) && ($_POST['image'] != '') )
   {
    $Image       = $_POST['image'];
   }
else
   {
    $Error       = 'You forgot to type the product image.';
    $Flag        = true;
   }
if (isset($_POST['url']) && ($_POST['url'] != '') )
   {
    $URL         = $_POST['url'];
   }
else
   {
    $Error       = 'You forgot to type in the product url.';
    $Flag        = true;
   }
if (isset($_POST['description']) && ($_POST['description'] != ''))
   {
    $Description = $_POST['description'];
   }
else
   {
    $Error       = 'You forgot to type in the product description.';
    $Flag        = true;
   }
?>
   

Insert Data Using bindValue()

<?php
include('Home/Database/connection.php');
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$dbname",
     $username, $password);
     // set the PDO error mode to exception
     $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    }
catch (PDOException $e)
    {
     echo 'ERROR: Cannot connect to the database. ' . $e->getMessage();
    }
try
    {
     // prepare sql and bind parameters
     $stmt = $conn->prepare("INSERT INTO customer_table (firstname,
     lastname, email, address) 
     VALUES (:firstname, :lastname, :email, :address)");

     //for placeholders, do like this:
     //VALUES (?, ?, ?, ?)");

     $stmt->bindValue(':firstname', $firstname, PDO::PARAM_STR);
     $stmt->bindValue(':lastname', $lastname, PDO::PARAM_STR);
     $stmt->bindValue(':email', $email, PDO::PARAM_STR);
     $stmt->bindValue(':address', $address, PDO::PARAM_STR);

     //for placeholders, do like this:
     //$stmt->bindValue(1, 'firstname', $firstname, PDO::PARAM_STR);
     //$stmt->bindValue(2, 'lastname', $lastname, PDO::PARAM_STR);
     //$stmt->bindValue(3, 'email', $email, PDO::PARAM_STR);
     //$stmt->bindValue(4, 'address', $address, PDO::PARAM_STR);

     // insert a row
     $firstname = "Joe";
     $lastname = "Public";
     $email = "joe@example.com";
     $address = "123 Main St";
     $stmt->execute();

     // insert another row
     $firstname = "Jane";
     $lastname = "Doe";
     $email = "jane@example.com";
     $address = "666 Main St";
     $stmt->execute();

     // insert another row
     $firstname = "Julie";
     $lastname = "Johnson";
     $email = "julie@example.com";
     $address = "777 Main St";
     $stmt->execute();

     echo "New records created successfully";
    }
catch (PDOException $e)
    {
     echo "Error: Cannot insert data into the database. " .
     $e->getMessage();
    }
?>
   

Query the Database

<?php
include('Home/Database/connection.php');

$customer_name = 'Bill'; # user-supplied data
 
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                                             $username, $password);
     $conn->setAttribute(PDO::ATTR_ERRMODE,
                         PDO::ERRMODE_EXCEPTION);
    }
catch (PDOException $e)
    {
     echo 'Cannot connect to the database. ' . $e->getMessage();
    }
try
    {
     $data = $conn->query('SELECT * FROM customer_table
             WHERE customer_name = ' . $conn->quote($customer_name));
 
     foreach($data as $row)
           {
            print_r($row); 
           }
    }
catch (PDOException $ex)
    {
     echo 'ERROR: Cannot select the data. ' . $ex->getMessage();
    }
?>
   

Prepared Statements

1. Prepared statements work in two steps: prepare and execute.
   
   
2. Prepare: Prepare an SQL statement by creating a blank SQL template similar to a blank form where fields contain no values and sent that blank template to the database. Certain values of the template, called placeholders (labeled "?") and named values or parameters (labeled ":"), are left unspecified. For example: INSERT INTO Membership_Table(name, id, email) VALUES(?, ?, ?) or in colon notation, called named parameters (labeled ":").
   
   
3. The database parses, compiles, and performs query optimization on the SQL statement template, and stores the result without executing it.
   
   
4. Execute: At a later time, the application references the blank SQL template containing the compiled result and binds the values (that were sent later in a seperate query) to the parameters (that were sent earlier in the template), and the database executes the final query to get the final result. The application may execute the statement as many times as it wants with different values and binding those values to the fields in the blank template.

Prepared statements offer two major benefits:

• The query only needs to be parsed (or prepared) once, but can be executed multiple times with the same or different parameters. When the query is prepared, the database will analyze, compile and optimize its plan for executing the query. For complex queries this process can take up enough time that it will noticeably slow down an application if there is a need to repeat the same query many times with different parameters. By using a prepared statement the application avoids repeating the analyze/compile/optimize cycle. This means that prepared statements use fewer resources and thus run faster.
  
  
• The parameters to prepared statements don't need to be quoted (unlike the one example above); the driver automatically handles this kind of escaping on its own without programmers need to mannually do it themselves. If you write your application exclusively using prepared statements, you can be sure that no SQL injection will occur (however, if other portions of your query are being built up with unescaped input, SQL injection is still possible).
  
  So, you still have to be carefull with your code even though prepared statements take care most of security issues for you.

<?php
include('Home/Database/connection.php');

//get username and password from user input
$user = $_GET['username']; //e.g.: myuser123
$pass = $_GET['password']; //e.g.: mypass123
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                                             $username, $password);
     $conn->setAttribute(PDO::ATTR_ERRMODE,
                         PDO::ERRMODE_EXCEPTION);
     }
catch (PDOException $e)
    {
     echo 'Cannot connect to the database. ' . $e->getMessage();
    }
try
    {
     $stmt = $conn->prepare("SELECT * FROM membership_table
             WHERE username = :username AND password = :password");
     $result = $stmt->execute(array($user, $pass));
     //here if you want to know how many rows selected
     $rowcount = $result->rowCount();
     if ($rowcount > 0)
        {
         echo($rowcount . ' rows'); // output # of rows selected
        }
     // set any fetch mode constants: OBJ, NUM, ASSOC, BOTH,
     // LAZY, CLASS, etc. Here I use OBJ
     $result->setFetchMode(PDO::FETCH_OBJ);
     while ($rows = $result->fetch())
         {
          $username = $rows->username;
          $password = $rows->password;
         }
    }
catch (PDOException $e)
    {
     echo 'ERROR: Cannot retrieve data. ' . $e->getMessage();
    }
?>
   

<?php
include('Home/Database/connection.php');

//get username and password from user input
$user = $_GET['username']; //e.g.: myuser123
$pass = $_GET['password']; //e.g.: mypass123
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                                             $username, $password);
     $conn->setAttribute(PDO::ATTR_ERRMODE,
                         PDO::ERRMODE_EXCEPTION);
    }
catch (PDOException $e)
    {
     echo 'Cannot connect to the database. ' . $e->getMessage();
    }
try
    {
     //a fancy way of programming but not easy to understand!
     $format = sprintf("SELECT * FROM %s
                        WHERE username = :%s AND password = :%s",
                        membership_table, username, password);
     $stmt = $conn->prepare("$format");
     $result = $stmt->execute(array($user, $pass));
     //here if you want to know how many rows selected
     $rowcount = $result->rowCount();
     if ($rowcount > 0)
        {
         echo($rowcount . ' rows'); // output # of rows selected
        }
     // set any fetch mode constants: OBJ, NUM, ASSOC, BOTH,
     // LAZY, CLASS, etc. Here I use ASSOC
     $result->setFetchMode(PDO::FETCH_ASSOC);
     while ($rows = $result->fetch())
         {
          $username = $rows['username'];
          $password = $rows['password'];
         }
    }
catch (PDOException $e)
    {
     echo 'ERROR: Cannot retrieve data. ' . $e->getMessage();
    }
?>
   

<?php
include("Home/Database/Credential.php");
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                         $username, $password);
     $conn->setAttribute(PDO::ATTR_ERRMODE,
                         PDO::ERRMODE_EXCEPTION);
     }
catch (PDOException $e)
    {
     echo 'Cannot connect to the database. ' . $e->getMessage();
    }
try
    {
     $result = $conn->prepare("SELECT * FROM Products");
     $result->execute();
     // set any fetch mode constants: OBJ, NUM, ASSOC, BOTH,
     // LAZY, CLASS, etc. Here I use BOTH
     $result->setFetchMode(PDO::FETCH_BOTH);
     echo '<table>';
     while ($rows = $result->fetch())
         {
          echo '<tr>';
          echo '<td>' .  $rows->ProductNum . </td>;
          echo '<td>' .  $rows->ProductName . </td>;
          echo '<td>' .  $rows->ProductPrice . </td>;
          echo '<td>' .  $rows[3] . </td>; /* ProductImage */
          echo '<td>' .  $rows[4] . </td>; /* ProductURL */
          echo '<td>' .  $rows[5] . </td>; /* ProductDescr. */
          echo '</tr>';
         }
     echo '</table>';
    }
catch (PDOException $e)
    {
     echo 'ERROR: Cannot retrieve data. ' . $e->getMessage();
    }
?>
   

Named Parameters

<?php
include('Home/Database/connection.php');
/*
 * The Prepared Statements Method
 * Best Practice
 */
$cutomer_id = xyz999; //obtained from a user input insecure form
$order_number = 'abc123'; //user-supplied input from an insecure form

try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                                             $username, $password);
     $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    }
catch (PDOException $e)
    {
     echo 'Cannot connect to the database. ' . $e->getMessage();
    }
try
    {
     //Initiate the database handshake with mysql by passing the 
     //query to it
     $stmt = "SELECT * FROM customer_table
             WHERE order_number like ? AND customer_id like ? ";
     # Prepare to retrieve customer's data from database
     # using ??????
     $stmt = $conn->prepare($stmt);
     # Execute the retrieval and binds the palceholders using ?? to
     # customer's data (variables)
     $result = $stmt->execute(array(
                          'order_number' => ' . $order_number . ',
                          'customer_id' => ' . $cutomer_id . '
						  ));
     // Affected Rows?
     //Like if you want to know how many rows selected?
     // Use rowCount() and it is similar to mysql_num_rows()
     echo $stmt->rowCount(); //  1 row
     //Or grab values in selected row in resultset
     $result->setFetchMode(PDO::FETCH_BOTH);
     while ($rows = $result->fetch())
         {
          $ProductNum = $rows->ProductNum;
          $ProductName = $rows->ProductName;
          $ProductPrice = $rows->ProductPrice;
          $ProductImage = $rows[3];
          $ProductURL = $rows[4];
          $Description = $rows[5];
         }
    }
catch (PDOException $e)
    {
     echo 'ERROR: Cannot retrieve the data. ' . $e->getMessage();
    }
?>
   

Positional Placeholders

Updating Records

<?php
include("Home/Database/Credential.php");
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                         $username, $password);
     $conn->setAttribute(PDO::ATTR_ERRMODE,
                         PDO::ERRMODE_EXCEPTION);
    }
catch (PDOException $e)
    {
     echo 'Cannot connect to the database. ' . $e->getMessage();
    }
try
    {
     $conn->query("UPDATE Customers_Table
               SET Price = 99.95 AND Description =
               "Men's Suits On Sale" WHERE ID = ($_POST['id'])");
    }
catch (PDOException $e)
    {
     echo 'ERROR: Cannot update the records. ' . $e->getMessage();
    }
?>
   

<?php
include("Home/Database/Credential.php");
try
    {
     $conn = new PDO("mysql:host=$hostingserver;dbname=$databaseName",
                         $username, $password);
     $conn->setAttribute(PDO::ATTR_ERRMODE,
                         PDO::ERRMODE_EXCEPTION);
    }
catch (PDOException $e)
    {
     echo 'Cannot connect to the database. ' . $e->getMessage();
    }
try
    {
     $stmt = $conn->prepare("UPDATE Customers_Table
                   SET Price = ? AND Description = ?
                   WHERE ID = ?)
                   ");
     //And here we're supplying the actual values
     $id = 'abc123';
     $price = 99.95;
     $description = "Men's Suits On Sale";
     $stmt->execute(array($price, $description, $id));
     $affected_rows = $stmt->rowCount();
    }
catch (PDOException $e)
    {
     echo 'ERROR: Cannot update the records. ' . $e->getMessage();
    }
?>
   

My Coding Convention

<?php
class Foo{
  public test($x) {
    if ($x == 1){
    // do something with $x
    }elseif ($x == 2){
    // do something with $x again
    }elseif ($x == 3){
    // do something with $x again
    }else{
    // do nothing with $x
    }
  }

  private getFoo(){
    for ($i = 1; $i < 10; ++i){
      // do something with $i
    }
  }
}
?>
   

<?php
class Foo
    {
     private $arr;

     public function config()
          {
           return [
                   'id' => 'app',
                   'basePath' => dirname(__DIR__),

                   'component' => [
                                   'request' => [
                                                 'csrf' => 'csrf-app',
                                                ],
                                   'user' => [
                                              'identity' => 'app\model\User',
                                              'autoLogin' => true,
                                              'cookie' => [
                                                           'name' => 'id-app',
                                                           'httpOnly' => true
                                                          ],
                                              'error' => [
                                                          'action' => 'site/error',
                                                         ],
                                             ],
                                  ],
                  ];
          } // end config()

     public function example($arg1 = null, $arg2 = null)
          {
           if (!empty($arg1))
              {
               // do something with $arg1
               foreach ($arg1 as $item)
                     {
                      // do something with $item
                      try
                          {
                           switch ($item)
                                {
                                 case 1:
                                       // do something
                                       if ($something)
                                          {
                                           for ($i = 0; $i < $something; $i++)
                                               {
                                                $dosomething[$i] = getSomething();
                                               }
                                          }
                                       elseif ($otherThing)
                                          {
                                           foreach ($otherThing)
                                                 {
                                                  try
                                                      {
                                                       $doOtherThing = getOtherthing();
                                                      }
                                                  catch (Exception $e)
                                                      {
                                                       // doOtherThing with $e;
                                                      }
                                                  catch (OtherException $o)
                                                      {
                                                       // doOtherThing with $o
                                                      }
                                                 } // end foreach
                                          } // end elseif ($something)
                                 break;
                                 case 2:
                                      // do something
                                 break;
                                 case 3:
                                      // do something
                                 break;
                                 default:
                                      // do something
                                 break;
                                } // end switch
                          } // end try
                      catch (Exception $e)
                          {
                           // Error! Do something with the error $e
                          }
                     } // end foreach
              } // end if $arg1 is not empty
           elseif ($arg2 != null)
              {
               // do ... while and for() loops
               $test = false;
               do
                   {
                    for ($i = 0; $i < count($arg2); ++$i)
                        {
                         if ($arg2[$i] == 1)
                            {
                             $test = true;
                             break;
                            }
                        } // end for()
                   } // end do
               while ($test == false);
              } // end elseif
           else
              {
               // do nothing
               return '';
              }

           $connect = '';
           $attempt = 3;
           while (!$connect AND $attempt > 0)
               {
                $authConn->connect();
                $connect = $authConn->isConnect();
                $attempt = $attempt - 1;
               }
          } // end example()
    } // end class Foo
?>
   

1. Robustness. Robustness should maintain readability, flexibility, consistency, and extensibility that can easily be extensible seamlessly and be well-understood by different groups of developers.


2. Bug-free. Use sound coding practices to achieve bug-free.


3. Productivity. Productivity translates more money.

1. Naming convention.
   
   
   • Use camelCase, not_under_scores_, for class names and function/method names. For example: siteController -- as appose to site_controller; arrayAccessTrait -- as appose to Array_Access_Trait. Avoid using _under_scores_ for single word names as well, for example, using get() as appose to _get(), set() as appose to _set(), unset() as appose to _unset(), etc.
   
   
   • Use lower case for file names, even if the name contains multiple words, e.g., myindexfile, privateimagefile. DO NOT use _under_scores_ in file names. This is illegal: my_index_file.php.
   
   
   • Use _under_scores_ for variable names, and arguments names. Example: item_1, num_1. Add($annual_salary, $current_bonus).
     See exception below.
   
   
   • Always use singular, not plural, for all naming convention. This includes all class, method/function, variable names and directory names.
     
     For example, addValue() instead of addValues(); getTwoRow() instead of getTwoRows(); getView() instead of getViews(); Theme instead of Themes; ad instead of ads; lib instead of libs; site instead of sites; user instead of users; arg instead of args; item instead of items; and so forth.
     
     The most popular variables that most programmers use are: views, models, controllers, params, users, items, libs, utils, pages, files, args, lines, rows, images, assets, etc. While it may seems very logical to use plural to name class, method, and variable names to reflect the true description of the variables, it is a very bad idea and it will cause confusions and problems later on.
     
     Let's face it, we all use proper grammar in our everyday language and it becomes a natural thing to do as well when it comes to programming when naming class, method, and variable names convention. We have a tendency to use proper grammar in our programming work. It's also a habit that is hard to break.
     
     But it's a habit that we should try to break away from and not following it in programming. So proper grammar is not the best way to program. So please avoid using pluralities. It creates confusions and bugs later on. ALWAYS USE SINGULAR! PERIOD!
   
   
   • Use a clear distinct naming convention for all class, method, argument, and variable names. Avoid using the same word as verb/noun to declare two distinct variables, for examples: rate (verb) and rater (noun), use (verb) and user (noun), code (verb) and coder (noun), serve (verb) and server (noun), or even page (noun) and pager (noun), etc. Furthermore, avoid using past tense as well. For example, use connect instead of connected, etc.
     
     Do not use something like these either: usr and user for two distinct variables; or user/users for two distinct variables (no plural is allowed--only singular); or use/usr/users for three distinct variables; or route/routes/router/routers for four distinct variables (again no plural is allowed--only singular); or use/used/user/users for four distinct variables (again no past tense and plural are allowed).
     
     If you insist on having the same lexicon in your variables, just add _under_scores_and_additional_variable_and_some_suffix_identification_to_your_lexicon word. For examples, user_new_1, user_old_2, user_var_1, route_1, route_2, etc. Just keep in mind that a good naming convention gives less problems later on. A good rule of thumb is, make it very distinct from one another.
   
   
   • Exception: Enumerate the naming convention is ok (like: $num1, $num2, $num3, $arr1, $arr2, $arr3, $arg1, $arg2, $arg3, $param1, $param2, $param3, etc.); however, please try to limit its use to an absolute minimum.
   
   
   • Class Constants: Class constants must be all upper case letters (e.g., DEMO, PROFILE, DASHBOARD) and if multiple words are used (e.g., DEV_DEBUG, EVENT_BEFORE_ACTION, CORE_ROOT_DIR) _under_scores_ must be used to seperate the multiple words. Notice that the word dashboard is considered as a single word.
   
   
   • camelCase: A camelCase is when you have multiple words as one word and that word begins with a lower case letter for the first sub-word and the rest of the sub-words' initial letter are upper case letters. For examples, the word 'camel case' becomes camelCase; the word 'error exception trait' becomes errorExceptionTrait; the word 'my product category list' becomes myProductCategoryList.
   
   
   • Use lower case for the most part except when camelCase is warranted. And for single-word method/function, class names can be an upper case letter for the beginning letter and the rest are lower case letters. Or it can be all lower case letter but cannot be all upper case letters. For example, these are ok: Add(), add(), but these are not allowed: ADD(), $ITEM, $PARAM, $LIB, etc.
     
     If you use an upper case letter for the initial letter of the single-word names, make sure to stick to that convention and if you use lower case for the initial letter of the single-word names, also be consistent and stick to that convention as well. Be consistent!
   
   
   • Important: Failure to adhere to these naming convention and other guidelines outlined in here can cause your code to contain bugs later on.
   
   
   • Naming a file name the same as its class name. For example, class errorExceptionTrait has its file being named as errorexceptiontrait.php. For any other files, they don't have to have the same name.
   
   
   • Naming all folder names without using _under_scores_ even if there are multiple words. For example, naming your folders as AdminController as appose to Admin_Controller, VendorComponent as appose to Vendor_Component, LibUtil as appose to Lib_Util, etc. No plural is allowed as well. So name your folders as image as appose to images. Yes, it seems like overwhelming majority of programmers like to name their folders as 'images' as appose to 'image' because it makes a logical sense to name their folders using plural to hold images. Always use singular. Period! No 'and', 'if', or 'but'.
   
   
   • Summary: So the key point to remember is that ONLY variables can contain _under_scores_. Anything else cannot contain _under_scores_.
   
   
   • Always comment your class, method, and function ending demarcations if your code is lengthy. For shorter code, you can go without the comment. This helps you and others follow the logic of your code. For example, assuming you have a lengthy code:
     
     

     <?php
     class Foo
         {
          public addValue($x, $y)
               {
                // method body
               } // end addValue()
     
          private getFoo()
                {
                 // method body
                } // end getFoo()
         } // end class Foo
     
     ?>
     Notice the comments: // end addValue(), // end getFoo(), // end class Foo
        

     
     
   • Always comment your condition blocks ending demarcations if your code is lengthy. This includes: if/else/else if/ and other condition blocks such as while, do ... while, and for loop blocks such as for() and foreach(), and for try ... catch() blocks as well. For shorter code, you can go without the comment. This helps you and others follow the logic of your code. For example, assuming you have a lengthy code:
     
     

     <?php
     class Foo
         {
          if ($expr1)
             {
              // lengthy multiple statements code block
              // lengthy multiple statements code block
              // lengthy multiple statements code block
             } // end if ($expr1)
          elseif ($expr2)
             {
              // lengthy multiple statements code block
              // lengthy multiple statements code block
              // lengthy multiple statements code block
             } // end elseif ($expr2)
          else
             {
              // lengthy multiple statements code block
              // lengthy multiple statements code block
              // lengthy multiple statements code block
             } // end else if ($expr2)
     
          try
              {
               // lengthy multiple statements code block
               // lengthy multiple statements code block
               // lengthy multiple statements code block
               // lengthy multiple statements code block
              } // end try block
          catch (Exception $e)
              {
               // lengthy multiple statements code block
              } // end Exception $e
          catch (OtherException $o)
              {
               // lengthy multiple statements code block
              } // end OtherException $o
         } // end class Foo
     ?>
     Notice the comments:
          // end if ($expr1), // end elseif ($expr2), // end else if ($expr2)
          // end try block,   // end Exception $e,    // end OtherException $o
          // end class Foo
        

     
     
   
   
   
2. Killing Tabs. When you indent your code (or line statements) make sure to kill all tabs; because if you don't, the indentation that contains tabs will not aligned properly from one editor to the next if you use multiple editors. Yes, all of us use different editor all the time. Furthermore, even the same editor that you use regularly will behave differently if you upgrade its version from one version to the next. So make sure to kill all tabs. Period!
   
   Tabs are text editor's special feature that enable you to speed up the moving of spaces by skipping the individual space when you press the "tab" button or the "advance forward" horizontall bar or the "return" key (or bar).
   
   In other words, when you press the "return" key the editor will jump pass the beginning of the line to the level that the immediate previous line starts, so that the beginning line of your code align with the beginning line of the previous line. All editors have this feature to save time of moving the beginning of your line to align it with the beginning of the previous line.
   
   Contrary to popular opinions, this so called "speed up" feature of the editors is actually slowing down the over all productivity of your finished (programming) products.
   
   How so? For one, if you're familiar with the Python programming language, you know that tabs can and do alter the meaning of the code you are writing; second, some Javascript interpreters see tabs as foreign objects and behave un-expectedly. There are other bad behaviors that tabs can cause your programing code to slow down your productivity and I don't want to list them here and only want to hi-light a few to let you know that tabs in programming generally is bad.
   
   So you don't want this default feature of the editor to mess your indentation by not killing them. So always kill all tabs.


3. Shorthand Arrays. Shorthand array syntax [...elements...] is used instead of the regular long form array(...elements...). And (shorthand) arrays used in the configurations can optionally contain a comma (",") as well at the end of the array element list. As examples, the below configurations contain a comma following the last array element [particularly 'charset => utf8' for shorthand array] even though there isn't another array element following it.

   As a matter of fact, both regular arrays and shorthand arrays can contain a comma (",") at the end of the array element list. This is legal (for both) and you can choose to put it there or take it out and it is perfectly fine. It's not a requirement to have a comma at the end of the last array element. So it's up to your personal preference.

   However, this coding standard strongly recommends putting a comma after all array elements because it avoids bugs. The reason that it is legal to have a comma after the last array element is to speed up coding process and avoid bugs. So it is strongly suggested that you put a comma after the last array element to avoid bugs.

   Here is a snippet of code using the regular array:

   $requirement = array(
                        array(
                              'name' => 'PHP Some Extension',
                              'mandatory' => true,
                              'condition' => extension_loaded('some_extension'),
                              'by' => 'Some application feature',
                              'memo' => 'PHP extension "some_extension" required',
                             ),    // <== notice the the comma!
                       );
   

   In the following, a configuration is used to create and initialize a database connection. Notice the comma following the array element 'charset => utf8' even though there isn't another array element following it:

   $config = [
              'class' => 'core\db\Connection',
              'dsn' => 'mysql:host=127.0.0.1;dbname=demo',
              'username' => 'root',
              'password' => '',
              'charset' => 'utf8',    // <== notice the the comma!
             ];
   $db = core::createObject($config);
   

   If you look at the example preview earlier [in the function config()], you'll see shorthand arrays are being used and all last elements of the arrays have a comma after each of the last element of the arrays. So it is definitely recommended that shorthand arrays and a comma on the last element of the array are being used--on your own programming chores--because it is much cleaner and easier to visualize, and most importantly, it speeds up your application development by eliminating bugs and unnecessary syntax corrections.




4. Readability. There must be a space between variables and arithmetic signs/operations, comment demarcation, comparison/assignment operations. For examples:
   
   

      $a = $b + $c; // add b to c
      Do not do this: $a=$b+$c; //add b to c
   
      if ($b == $c)
      Do not do this: if($b==$c)
   
      Do not do this: for($i=0;$i<10;$i++)
      Do this instead: for ($i = 0; $i < 10; $i++)
      



5. Class and function hierarchical structures and indentations
   
   Most modern coding conventions indent only four spaces for all code hierarchical structures, and because keywords have different lengths, it causes the hierarchical levels of indentation to look weird and not very clean. For example, to indent four spaces for the class, it looks like this:
   
   

   class Example
       {
       }
   

   That looks very good, but on longer reserved/keywords like public, private, protected, static, etc., it looks awful. For examples:
   
   

   public class Example
       {
       }
   
   private class Example
       {
       }
   
   protected class Example
       {
       }
   
   static class Example
       {
       }
   
   Or for conditional structures:
   
   if (condition)
       {
       }
   else
       {
       }
   elseif
       {
       }
   
   foreach
       {
       }

   As you can see, indenting four spaces for all code structures, [although very uniformed], is a bad idea, and it looks weird visually and logically. That's why I chose to indent the code according to the length of the reserved keyword.
   
   For a better view of the examples of hierarchical structures and indentations that make use of the reserved keywords, see the preview example earlier or the following examples.
   
   The guidelines for class and function structures and indentations follow what I call a common sense rule, and that is, the placement of parentheses, spaces, indentations, and braces are placed based on the position of the clause either at the end of the keyword or one space after the keyword in the case for short keywords.
   
   For long keywords like abstract, private, protected, etc. (public is o.k.), you can indent just five positions to align with 'public' and it's fine. Although indent the full keyword is o.k., too. See examples for a better visualization.
   
   DO NOT place the opening parenthesis on the same line as the class, method definition, and do not place the closing parenthesis on the same line as the last statement. The opening and closing parentheses should be aligned vertically and indented the exact amount of spaces. The following is the default, old fashion style of coding. It's past its legacy. So don't do this:
   
   

   class Example {
        private $myVar;
   
        public myMethod($x) {
         // ... code
         return $x; }
   
        // ... more class code here!
   }
   

   Nowaday, the trend is leaving the legacy style behind and more and more programmers are adopting new modern style of coding and my coding convention is a byproduct of the new trend. So do these instead:
   
   

   <?php
   class Foo
       {
        /**
         * class body declaration.
         * notice the four spaces indentation of the class' opening "{" and
         * the five spaces indentation of the method declaration: public.
         * notice also that the opening/closing parentheses are aligned vertically at the
         * same level, and all respective code body are inside the parentheses.
         * it looks very clean and easy to follow the logic of the code flow.
         */
        public $arr = array();
        private $dbConnection;
   
        public addValue($x, $y)
             {
              // method body
              // notice that the indentation and placement of the opening "{" and
              // closing "}" directly leveled with the last letter of its keyword.
             }
   
        private getFoo()
              {
               // method body
               // notice that the indentation and placement of the opening "{" and
               // closing "}" directly leveled with the last letter of its keyword.
              }
   
        protected getBar()
                {
                 // method body
                 // notice that the indentation and placement of the opening "{" and
                 // closing "}" directly leveled with the last letter of its keyword.
                }
   
        // this is ok, too, and is preferred, indent five spaces to align with
        // 'public' which is the most commonly use visibility clause
        protected setFoo($x)
             {
              // method body
             }
   
        public addFoo()
             {
              // method body
             }
   
        // this is ok
        abstract protected function zeroBar();
               {
                // method body
               }
   
        // this is ok, too, indent five spaces to align with 'public' which is
        // the most commonly use visibility clause
        abstract arrayHelper()
             {
              // code body here for this abstract method
             }
   
        public static function bar()
             {
              // method body
             }
   
        // this is ok, too
        private static function bar()
              {
               // method body
              }
   
        // this is ok, too, indent five spaces
        private static function bar()
             {
              // method body
             }
   
        final public static function bar()
            {
             // method body
            }
   
        // same as above
        final private static function bar()
            {
             // method body
            }
   
        static function bar()
             {
              // method body
             }
   
        // this is ok, too
        function bar()
               {
                // method body
               }
   
        // this is ok, too, indent five spaces to align with 'public'
        function bar()
             {
              // method body
             }
   
        // this is ok, too, because it has at least five spaces indented for body code
        function bar()
        {
              // code body.
              // notice the placing of "{}" at the same level as the method declaration.
              // notice also the indented five spaces for coding statements
              // starting position
              // .....
        }
       } // end class body
      ?>
   
   
   Notice that the parentheses are aligned vertically at the same level of indentation.
   This applies to all other code blocks/structures that contain parentheses, e.g.,
   if/elseif/else, for() and foreach() loops.
   This makes it very easy to visualize the block of code, especially if the code is
   very lengthy.
   
   Note also that the examples showed multiple styles of indentation, but you need to
   decide which one is more suited to your style and stick with it consistently and
   do not use one variation for certain project and another for another project.
   Be consistent and choose one style and stick with it for the long haul.
   
   Traits: Traits are special form of class and they are similar to a normal class.
   
   trait ArrayHelper
       {
        // main body code of a trait
       }
   
   CSS: For CSS and other languages (such as Javascript, Java, C#, C/C++, etc.) do
   follow the guideline outlined in this coding standard and follow a five-space rule
   to align with 'public' visibility clause. For examples:
   
   <style>
   html,
   body
       {
        width: 100%;
        height: 100%;
        background-color: #e6e6ff;
       }
   
   #product-item
       {
        background-color: white;
        padding-left: 10px;
        padding-right: 10px;
       }
   
   div .some-selector
       {
        background-color: white;
        width: 400px;
        height: 200px;
       }
   
   .nav li > form > button.logout
       {
        padding: 15px;
        border: none;
       }
   
   a.asc:after, a.desc:after
       {
        position: relative;
        top: 1px;
        display: inline-block;
        font-family: 'Glyphicons Halflings';
        font-style: normal;
        font-weight: normal;
        line-height: 1;
        padding-left: 5px;
       }
   
   a.asc:after
       {
        content: "\e151";
       }
   
   a.desc:after
       {
        content: "\e152";
       }
   </style>
   
   <script type="text/javascript">
   $(document).ready(function()
       {
        public function example(arg)
             {
              // function code
             }
   
        // this is ok, too
        function example(arg)
               {
                // function code
               }
   
        // this ok, too, to align with 'public'
        function example(arg)
             {
              // function code
             }
   
        // this ok, too
        static public function example(arg)
             {
              // function code
             }
       });
   </script>
   
   Notice the braces are aligned vertically and indented at the same amount of spaces (5).
   

   
   HTML: Always use lower-cased letters for HTML tags with the exception of the doctype interface. The heading code (or tags), e.g., meta, link, script, etc need not be indented but the css, javascript code, and the code inside the body tag MUST be indented of at least three spaces and can be indented up to six spaces. For example:
   
   

   <!DOCTYPE html>
   <html lang="en-US">
   <head>
   <title>Untitled</title>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <meta name="language" content="en" >
   <link href="./asset/44ab1983/css/style.css" rel="stylesheet">
   <script src="./asset/16eb9947/jquery.js"></script>
   <style>
   html,
   body
       {
        width: 100%;
        height: 100%;
        background-color: #e6e6ff;
       }
   
   #product-item
       {
        background-color: white;
        padding-left: 10px;
        padding-right: 10px;
       }
   </style>
   
   <script type="text/javascript">
   $(document).ready(function()
       {
        public function example(arg)
             {
              // function code
             }
       });
   </script>
   
   </head>
   
   <body>
        <div>
            content of the div
        </div>
   
        <div>
          <table>
            <tr>
              <td>
                td content
              </td>
            </tr>
          </table>
        </div>
   
        <div>
          content of the div
          <a href="#">link</a>
        </div>
   </body>
   </html>
   



6. Control hierarchical structures
   
   For a better view of the hierarchical structures and indentations, see the preview example earlier.
   
   if, elseif, else
   
   An if structure looks like the following. Note the placement of parentheses, indentation of spaces, and braces; and that else and elseif are aligned vertically on different lines as the closing brace from the earlier body. Notice also the use of braces to group a single statement even though it is not required. Doing so improves readability and eliminates unforced errors.
   
   DO NOT place the opening parenthesis on the same line as the condition expression, and do not place the closing parenthesis on the same line as the elseif/else condition expression. This applies to other control clauses as well, such as foreach, while, do ... while, etc.
   
   

   <?php
   if ($expr1)
      {
       // single statement block. notice the use of braces even though it is not required!
      }
   elseif ($expr2)
      {
       // elseif code block. single statement block
      }
   elseif ($expr3)
      {
       // multiple statements code block
       // multiple statements code block
       // multiple statements code block
      }
   else
      {
       // else single statement block code block
      }
      

   
   switch, case
   
   A switch structure looks like the following. Note the placement of parentheses, indentation of spaces, and braces. The case statement MUST be indented for the length of the keyword 'switch' from switch, and the break keyword (or other terminating keyword) MUST be indented at the same level as the case block. Statements inside the case block MUST indent to the start if case condition's first position. For example, if case 0, the indentation of the case statements should align vertically with '0'. There MUST be a comment such as // no break when fall-through is intentional in a non-empty case block (see case 1, 2, 3, 4). Notice that there are no break clauses in any of them.
   
   DO NOT place the opening parenthesis on the same line as the switch condition expression, and do not place the closing parenthesis on the same line as the last break clause of the switch clause. This applies to other control clauses as well, such as foreach, while, do ... while, etc.
   
   

   <?php
   switch ($expr)
        {
         case 0:
              echo 'First case, with a break';
         break;
         case 1:
              echo 'Second case, which falls through';
              // no break
         case 2:
         case 3:
         case 4:
              echo 'Third case, return instead of break';
              return;
         default:
              echo 'Default case';
         break;
        }
      

   
   while, do while, for, foreach, try, catch
   
   The guidelines for all these clauses are basically identical to one another and follow what I call a common sense rule, and that is, the placement of parentheses, spaces, indentations, and braces follow the guidelines outlined thus far. So looking back at the indentation of the switch clause we can see that the indentation is to the length of the keyword 'switch'. This applies to the rest of the clauses as well. So a while statement looks like the following. Note the placement of parentheses, spaces, indentation of spaces, and braces. The braces are all on seperate lines from the clause, even for a (do ... while) condition.
   
   

   <?php
   while ($expr)
       {
        // structure of code block
       }
      

   
   Similarly, a do while statement looks like the following. Notice the placement of braces.
   
   

   <?php
   do
    {
     // structure of code block;
    }
   while ($expr);
      

   
   It can also be like the following as well. Notice the placement of braces which aligned directly with the end of the keyword 'while'.
   
   

   <?php
   do
       {
        // structure of code block;
       }
   while ($expr);
      

   
   A for() loop structure is also identical to other condition clauses and follow what I call a common sense rule that looks like the following. Note the placement of parentheses, spaces, and braces. Notice the indentation to the first position after a space following the keyword 'for'. This rule applies to try, and catch as well but not to foreach() in which it indents to the last position of the keyword 'foreach'.
   
   

   <?php
   for ($i = 0; $i < 10; $i++)
       {
        // for code block
       }
      

   
   A foreach statement looks like the following. Note the placement of parentheses, spaces, and braces. It indents to the last position of the keyword 'foreach'.
   
   

   <?php
   foreach ($iterable as $key => $value)
         {
          // foreach code block
         }
      

   
   A try...catch block looks like the following. Note the placement of parentheses, spaces, and braces. The braces indents one space past the last position of the keyword 'try' to align the braces of the 'catch' clause.
   
   

   <?php
   try
       {
        // try code block
       }
   catch (FirstExceptionType $e)
       {
        // catch code block
       }
   catch (OtherExceptionType $e)
       {
        // catch code block
       }
      



7. Closures
   
   Closures MUST be declared with NO space after the function keyword, and a space before the use keyword, but no space after the use keyword.
   
   The opening brace MUST go on a seperate line as is typically for all braces, and the closing brace MUST go on the next line following the body as is typically for all braces.
   
   There MUST NOT be a space after the opening parenthesis of the argument list or variable list, and there MUST NOT be a space before the closing parenthesis of the argument list or variable list.
   
   In the argument list and variable list, there MUST NOT be a space before each comma, and there MUST be one space after each comma. Closure arguments with default values MUST go at the end of the argument list.
   
   A closure declaration looks like the following. Note the placement of parentheses, commas, spaces, indentations (five spaces) and braces:
   
   

   <?php
   $closureWithArg = function($arg1, $arg2)
        {
         // body
        };
      

   
   Or you do this:
   
   

   <?php
   $longArg_noVar = function(
                             $longArgument,
                             $longerArgument,
                             $muchLongerArgument
                            )
        {
         // code body
        };
   
   $noArg_longVar = function()
        use(
            /* notice naming variables using enumerated variables, although $longVar1 is fine */
            $longVar1,
            /* notice naming variables using enumerated variables, although $longVar2 is fine */
            $longerVar2,
            /* notice naming variables using enumerated variables, although $longVar3 is fine */
            $muchLongerVar3
           )
        {
         // code body
        };
   
   $longArg_longVar = function(
                               $longArgument,
                               $longerArgument,
                               $muchLongerArgument
                              )
        use(
            // readability: indents some spaces
            $longVar1,
            $longerVar2,
            $muchLongerVar3
           )
        {
         // code body
        };
   
   // this is ok too
   $longArg_shortVar = function(
                                $longArgument,
                                $longerArgument,
                                $muchLongerArgument
                               ) use($var1)
        {
         // code body
        };
   
   // this is ok, too
   $shortArg_longVar = function($arg) use(
                                          $longVar1,
                                          $longerVar2,
                                          $muchLongerVar3
                                         )
        {
         // code body
        };
      

   
   Note that the formatting rules also apply when the closure is used directly in a function or method call as an argument.
   
   

   <?php
   $foo->bar(
             $arg1,
             function($arg2) use($var1)
                 {
                  // code body
                 },
             $arg3
            );
      

   
   A Brief Few Words About the Use() Function
   
   Use() is a PHP special function that allows the passing of anonymous function argument variables into the code block of the closure. For example, in the above closure, use() contains one argument called $var1 and this $var1 argument variable is passed in from the outside and gets used by the anonymous function.
   
   If you look at the next one up from the one above, that use() contains three argument variables called $longVar1, $longerVar2, and $muchLongerVar3, and these three argument variables are passed in from the outside. For more on user(), please checkout PHP documentation.
   
   The following are not my coding standard -- they are from PSR-1 and PSR-2, and if overlapping, my coding standard above should take precedent and override these third-party standards. If any standard in these two versions, PSR-1 and PSR-2, are overlapping, PSR-2 takes precedent over PSR-1.
   
   Please visit their website for more. Here is a summary of the third-party standards.
   



8. Third-Party Standards
   
   PSR-1 - Basic Coding Standard
   PSR-2 - Coding Style Guide
   
   Introduction
   
   Some noteworthy rules:
   
   Use camelCase, not_underscores, for variable names, function names, method names, and arguments names.
   
   PSR-1 - Basic Coding Standard
   
   Files MUST use only UTF-8 without BOM for PHP code.
   
   Files SHOULD either declare symbols (classes, functions, constants, etc.) or cause side-effects (e.g. generate output, change .ini settings, etc.) but SHOULD NOT do both.
   
   Namespaces and classes MUST follow an "autoloading" PSR: [PSR-0, PSR-4].
   
   Class names MUST be declared in StudlyCaps.
   
   Class constants MUST be declared in all upper case with underscore separators.
   
   Method names MUST be declared in camelCase.
   
   Namespace and Class Names
   
   Namespaces and classes MUST follow an "autoloading" PSR: [PSR-0, PSR-4].
   
   This means each class is in a file by itself, and is in a namespace of at least one level: a top-level vendor name.
   
   Class names MUST be declared in StudlyCaps.
   
   Code written for PHP 5.3 and after MUST use formal namespaces.
   
   For example:
   
   

   <?php
   // PHP 5.3 and later:
   namespace Vendor\Model;
     
   class Foo
       {
   	 // code block
       }
      

   
   Code written for 5.2.x and before SHOULD use the pseudo-namespacing convention of Vendor_ prefixes on class names.
   
   

   <?php
   // PHP 5.2.x and earlier:
   class Vendor_Model_Foo
       {
   	 // code block
       }
      

   
   Class Constants, Properties, and Methods
   
   The term "class" refers to all classes, interfaces, and traits.
   
   Constants
   
   Class constants MUST be declared in all upper case with underscore separators. For example:
   
   

   <?php
   namespace Vendor\Model;
     
   class Foo
       {
        const VERSION = '1.0';
        const DATE_APPROVED = '2012-06-01';
       }
      

   
   Properties
   
   This guide intentionally avoids any recommendation regarding the use of $StudlyCaps, $camelCase, or $under_score property names. Whatever naming convention is used SHOULD be applied consistently within a reasonable scope. That scope may be vendor-level, package-level, class-level, or method-level.
   
   Methods
   
   Method names MUST be declared in camelCase().
   
   PSR-2 - Coding Style Guide
   
   Overview
   
   
   • Code MUST follow a "coding style guide" PSR [PSR-1].
   
   
   • Code MUST use 4 spaces for indenting, not tabs.
   
   
   • There MUST NOT be a hard limit on line length; the soft limit MUST be 120 characters; lines SHOULD be 80 characters or less.
   
   
   • There MUST be one blank line after the namespace declaration, and there MUST be one blank line after the block of use declarations.
   
   
   • Opening braces for classes MUST go on the next line, and closing braces MUST go on the next line after the body.
   
   
   • Opening braces for methods MUST go on the next line, and closing braces MUST go on the next line after the body.
   
   
   • Visibility MUST be declared on all properties and methods; abstract and final MUST be declared before the visibility; static MUST be declared after the visibility.
   
   
   • Control structure keywords MUST have one space after them; method and function calls MUST NOT.
   
   
   • Opening braces for control structures MUST go on the same line, and closing braces MUST go on the next line after the body.
   
   
   • Opening parentheses for control structures MUST NOT have a space after them, and closing parentheses for control structures MUST NOT have a space before. Example
     
     This example encompasses some of the rules below as a quick overview:
     
     

     <?php
     namespace Vendor\Package;
       
     use FooInterface;
     use BarClass as Bar;
     use OtherVendor\OtherPackage\BazClass;
       
     class Foo extends Bar implements FooInterface
         {
          public function sampleFunction($a, $b = null)
               {
                if ($a === $b)
                   {
                    bar();
                   }
                elseif ($a > $b)
                   {
                    $foo->bar($arg1);
                   }
                else
                   {
                    BazClass::bar($arg2, $arg3);
                   }
               }
     
          final public static function bar()
              {
               // method body
              }
         }
        

     
     

A Programmers' Handy JavaScript Regex Cheat Sheet

What is a blockchain?

<?php
/*
 * file: block.php
 *
 * a complete blockchain implementation will still need a P2P network
 * so we need to implement a P2P network.
 */

class Block
    {
     public __constructor($index, $timestamp, $transaction, $previousHash = '')
          {
           $this->index = $index;
           $this->previousHash = $previousHash;
           $this->timestamp = $timestamp;
           //$this->data = $data;
           $this->transaction = $transaction;
           $this->hash = $this->calculateHash();
           $this->nonce = 0;
          }

     public function calculateHash()
          {
           // return hash('SHA256', strval($this->previousHash .
           // $this->timestamp . json_encode($this->transaction) . $this->nonce));
           return hash('SHA256', $this->previousHash .
                        $this->timestamp . ((string)$this->transaction) . $this->nonce);
          }

     // Implementing Proof-of-Work
     public function mineBlock($difficulty)
          {
           // takes the array elements, converts to string and concatenates 0 to it
           while (substr($this->hash, 0, $difficulty) !== str_repeat("0", $difficulty))
               {
                $this->nonce++;
                $this->hash = $this->calculateHash();
               }

           //echo("BLOCK MINED: " + $this->hash);
          }
    } // end class Block
   

<?php
/*
 * file: blockchain.php
 *
 * a complete blockchain implementation will still need a P2P network
 * so we need to implement a P2P network.
 */

/**
 *  usage:
 *
 *  $coin = new Blockchain();
 *  $coin->createTransaction(new Transaction('address1', 'address2', 100));
 *  $coin->createTransaction(new Transaction('address2', 'address1', 50));
 *
 *  echo('\n Start mining...');
 *  $coin->minePendingTransaction('john-doe-address');
 *
 *  echo('\nBalance of John Doe is') . $coin->getBalanceOfAddress('john-doe-address');
 *
 *  echo('\n Start mining again...');
 *  $coin->minePendingTransaction('john-doe-address');
 *
 *  echo('\nBalance of John Doe is') . $coin->getBalanceOfAddress('john-doe-address');
 */
class Blockchain
    {
     public $chain = array();

     public __constructor()
          {
           // need to refine.
           // this chain should hold an array of object of genesis block
           // should be without the "[]"
           // $chain holds an array of Block objects ... lots of it.
           // this is where we hold blocks of transaction.
           $this->chain = [$this->createGenesisBlock()];
           $this->difficulty = 2;
           // this array propery is assigned transactions by minePendingTransaction() below
           $this->pendingTransaction = array();
           $this->miningReward = 100;
          }

     public function createGenesisBlock()
          {
           // the return statement just returns an instance of Block.
           // so the constructor that calls this function assigns an instance of Block and
           // that is it!
           //return new Block(0, strtotime("2017-01-01"), "Genesis Block");
           return new Block(new DateTime('2000-01-01'), [], "0"); // [] short cut array
          }

     public function getLatestBlock()
          {
           // count the # of array elements in the chain by subtracting 1 to get the
           // last element in the array and therefore getting the last block.
           // array element starts at 0, 2nd element is 1, 3rd element is 2, etc.
           return $this->chain[count($this->chain) - 1];
          }

     public function minePendingTransaction($miningRewardAddress)
          {
           // $this->getLatestBlock()->hash refers to the chain's property hash which
           // holds the block's hash strings
           $block = new Block(new DateTime(), $this->pendingTransaction,
           $this->getLatestBlock()->hash);
           $block->mineBlock($this->difficulty);

           echo ('Block successfully mined!');
           // push the chain onto the block to be stored in the blockchain serial
           array_push($this->chain, $block);

           // storing the transactions in this class's
           // array property $this->pendingTransaction
           $this->pendingTransaction = [
                                        new Transaction(null, $miningRewardAddress,
                                                        $this->miningReward)
                                       ];
          }

     // create a transaction passing an instance of the Transaction object containing
     // $fromAddress, $toAddress, $amount
     // and then push this transaction object onto the array list: pendingTransaction
     // createTransaction() receives a 'new Transaction("address1", "address2", 100)'
     // instance object as its argument
     public function createTransaction($transaction)
          {
           // storing the transactions in this class's
           // array property $this->pendingTransaction
           array_push($this->pendingTransaction, $transaction);
          }

     public function getBalanceOfAddress($address)
          {
           $balance = 0;

           foreach ($this->chain as $block)
                 {
                  foreach ($block->transaction as $trans)
                        {
                         if ($trans->fromAddress === $address)
                            {
                             $balance -= $trans->amount;
                            }

                         if ($trans->toAddress === $address)
                            {
                             $balance += $trans->amount;
                            }
                        }
                 }

           return $balance;
          }

     public function isChainValid()
          {
           for ($i = 1; $i < count($this->chain) + 1; $i++)
               {
                $currentBlock = $this->chain[$i];
                $previousBlock = $this->chain[$i - 1];

                if ($currentBlock->hash !== $currentBlock->calculateHash())
                   {
                    return false;
                   }

                if ($currentBlock->previousHash !== $previousBlock->hash)
                   {
                    return false;
                   }
               }

           return true;
          }
    } // end class Blockchain
   

<?php
/*
 * file: transaction.php
 *
 * a complete blockchain implementation will still need a P2P network
 * so we need to implement a P2P network.
 */

class Transaction
    {
     public __constructor($fromAddress, $toAddress, $amount)
          {
           $this->fromAddress = $fromAddress;
           $this->toAddress = $toAddress;
           $this->amount = $amount;
          }
    } // end class Transaction
   

A Trading Strategy: Selling "Put" Options

• First, sell one October 19, 2018 put option with a strike price of $67.50 for $2.50 a share in premium. Since each put contract controls 100 shares, you'll be collecting $250 (100 x $2.50). Your account will show you've sold one put contract and immediately your cash balance is higher by $250.
  
  For some investors, this is called naked put, which doesn't require you to have enough money to pay for the total price of the stock because their broker allows them to buy on margin. This is for people who have some experience trading options. However, for this tutorial, I am aiming for the non-experience options traders, i.e., long term investors who don't trade options for a living.
  
  So in your case, you would buy a cash-secured put, which requires you to have enough money in your account to cover the transaction. No big deal! Because your intention is to invest for the long haul and part of investing for the long term is to come up with the money to buy the stock outright. But in this case, you're not buying the stock outright--well, not at the moment of your trading. Eventually, you'll have to buy the stock outright when the buyer of your cash-secured put decides to exercise his/her option from you. That's why you have to have enough money in your account to trade this option.

A typical stocks/options order entry screen interface platform for entering orders looks something like this:



Notice that the various key items in the screen interface maybe arranged in different order and location for different brokerage services interface, but all the items should be there.


• In technical term, you would in your brokerage account web interface select the type of trades you want to trade: stocks or options. In this case, you want to trade options and you select 'options' from the panel and the interface displays the options pane for you to trade.
  
  Next, select the symbol of the stock (XOM), select the expiration date (October 19, 2018), select the type of trade (in this case, a "Put"), select the "Sell to Open" (you're opening a position as a seller to sell the option), select the quantity of the option [1 for one contract], select the strike price (in this case $67.50) of the option you want to sell and immediately the premium for that strike price is automatically calculated by the brokerage system and appeared instantly (in this case $2.50).
  
  Next, click on "Preview" to see your order and if it's what you entered, click "Send" or "Order," depending your interface.
  
  Congratulation! Now you're an expert on how to trade options--well, a put option.


• And that is it! Very simple!
  
  This is called cash-secured put or covered put -- you're securing the trade with your money deposited in your account ready to buy the stock as soon as the buyer of your put option decides to excerise the option.
  
  Meanwhile, you don't have to do anything but only wait for the expiration date to arrive. You can also work on your next cash-secured put trade because at any time from now until expiration, your outstanding cash-secured put option may get exercised. Once it does, you can pull the trigger on your next trade.
  
  
• As of now, your trade is on, now you just need to wait for Exxon Mobil's stock to approach $67.50.
  
  But hold on, as expiration approaches, some interesting scenarios can play out.
  
  If October expiration passes and Exxon Mobil's is still trading at around $75 a share, you're sitting pretty. The put option you sold expires worthless (to the buyer) and you get to keep the $250 premium as pure profit. That's a 4% yield on the cash you were holding to buy the stock (which is $6750 = 100 x $67.50.) Again, you have to have at least $6750 in your account. In addition, if you did this every four months, that would be a 12% annual yield.
  
  Let's face it... you're certainly not going to earn 12% interest from your bank right now.



• Now you can sell another put option on Exxon Mobil's and collect more premium. And you can continue to capitalize as long as your put options keep expiring worthless.

• Step 1: Find a Stock You Want to Own.
  
  The first step to take when looking to buy stocks by selling puts is to find a stock that you would like to own. After all, in the end when you employ this strategy, you are hoping to own the stock as a part of your portfolio. And since you wouldn't just go out and buy any old stock in a standard stock trade, you shouldn't just settle for any old stock when implementing this strategy. This may seem obvious, but when we get into the next step, you will see that if you don't start with Step 1, it is easy to be tempted to simply sell puts on the stocks that are offering the highest premium-which can be a big mistake.
  
  When you're looking for stocks you would like to own, make sure you look for stocks with strong fundamentals-especially in turbulent markets because they have a good chance of rebounding faster than other stocks.


• Step 2: Sell Put Options
  
  Your next step to buying stocks at a discount is identifying which put option you are going to sell and then selling it. As an option seller, you have three choices when looking at which put option to sell. You can sell the at-the-money option (ATM), an out-of-the money option (OTM) or an in-the-money option (ITM). When selling puts to buy stocks, you are typically going to use an at-the-money put option. At-the-money options offer a nice balance between paying a good premium and giving you a good chance of actually having the stock put to you.
  
  The premium you receive for selling the put option directly impacts the discount you will get on your stock purchase if the stock is put to you. The higher the premium, the better the discount. As I mentioned above, some stocks offer extremely high premiums on their put options either because the stocks are extremely volatile or everybody believes the stock is going to be moving lower. If you haven't done your homework and determined that the stock is one you would want to own, you may be tempted to go for the stock with the highest premium. Don't fall into that trap and always do your homework!
  
  
• Step 3: Manage Your Trade.
  
  Once you have sold your put option, it is time to sit back and see what happens to the price of the stock. Basically, one of the following four things can happen to the price of the stock:
  
  
  • The stock price can go up a lot
  • The stock price can go up a little
  • The stock price can go down a little
  • The stock price can down a lot

What is a covered call option?

• Record revenue from Datacenter, Professional Visualization, Automotive platforms


• Quarterly cash dividend raised 7 percent to $0.16 per share


• Company intends to return an additional $3 billion to shareholders through fiscal 2020

Goldman said it remains "Buy-rated on the stock as our view that Nvidia has access to one of the best growth opportunity sets in Semis and that it has a sustainable competitive lead within remains unchanged."
   

"The stock will likely not bounce back right away, given the severity of the miss," Morgan Stanley said.
   

Wells Fargo Analyst:

Concerns (and now frustration) over a significant gaming channel inventory burn-off have materialized ... While we can appreciate that NVIDIA's weak F4Q19 outlook is impacted by a 1-2 quarter work-down of Pascal mid-range gaming card inventory in the channel ($600M; assuming no sell-in in F4Q19 as crypto-related dynamics flush through the channel), couple with a seasonal decline in game console builds, we think investors will be frustrated by NVIDIA's comments exiting F2Q19 that: "...we [NVIDIA] see inventory at the lower-ends of our stack...inventory is well positioned for back-to-school and building season that's coming up on F3Q19..."

Bottom Line: Well, even if we model a strong double-digit growth in DCG next year, we think there is a high likelihood that NVIDIA will not grow next year. We are modeling for as such. The large shortfall in guidance due to a bloated channel due to crypto-currency is in sharp contrast to the comments around channel inventory from the company at the last earnings call. Our estimates and target price are going lower. We remain Market Perform rated.

We are Buyers on weakness.
   

SunTrust Analyst:

The surprisingly weak Q4 guide appears temporary. NVDA guided Q4 20% below consensus revs as the company halts 1/3 of gaming segment sales to flush channel inventory built during the crypto enthusiasm in 1H18. This badly damages near-term revenue and profits, but Datacenter, Pro-Viz, and Automotive results support our structural growth view. Gaming resets our 2019 & 2020 EPS to $7.33 & $8.70 (from $8.18 & $9.59). PT goes to $237 (from $316) based on 30x (17x discount to rapid-growth tech peers) our CY20 EPS, discounted back 1 year. Buy.
   

RBC Analyst:

Going forward, we think the focus will now shift to Data Center as gaming expectations are now reset due to crypto currencies and a product transition (Turing) which will unlikely ramp until around the Jul-qtr time frame. Net Net: we lower our price target due to the lower than expected results (PT to $260 from $310). Positively, gaming and Pro Visualization will likely be up q/q in January helping gross margins and offsetting the material gaming weakness.
   

• AbbVie continues to grow its top line and bottom line as management raises guidance into the second half of 2018.


• The share price looks attractive at these levels, and is trading at a discount to fundamental earnings.


• A $10 billion buyback program put to use, combined with annual dividend increases, makes this company easy to hold as it develops its pipeline to supplement Humira sales.

Here is how to get started trading options for beginners

• Individual (Individual, Joint, and Retirement Account). This is a regular account for individual single person, married joint account, or a retirement account such as for an investment club.


• Individual (Trust and UGMA/UTMA). This is an account for a trust or for accounts setup for your minors for their retirement investment account.


• IRA (Individual Retirement Account). This is an account setup for an IRA/401k retirement account.


• Single Fund. This is an account setup as a managed fund such as an investment fund, a hedge fund or a mutual fund that has only one type of fund under management, e.g., a long term growth fund.


• Multiple Funds. This is an account setup as a multiple managed fund such as an investment fund, a hedge fund or a mutual fund that has multiple types of fund under management, e.g., a value fund, an aggressive fund, a long term growth fund, a bond fund, an emerging fund, etc.


• Financial Advisor. This is an account type for individuals or companies setup to offer and manage investment for their clients.


• Institution (Partnership, Corporation, Limited Liability Corporation, and Unincorporated Business). This is an account type for institutions such as endowment, schools/churches/non-profit organizations retirement funds, individuals formed as a partnership, for a corporation setup to manage their own investment or their clients' investment. Also, an account for an investment club can signup for institution account as well.

• Level 1: Is for beginners who have no experience in options trading.
  
  Level 1 allows you to trade:
  • Covered calls. Covered calls sold against stocks held long in your brokerage account.
    
    • Buy-writes (simultaneously buying a stock and writing a covered call).
    
    
    • Covered call roll-ups/roll-downs.
  • Cash Secured Puts. Covered Puts sold against funds held in your brokerage account.
  
  This is for you beginners who had no idea what an option was before reading my tutorials. Well, even after reading my tutorials, consider yourself as a beginner and signup for level 1. In this level you are allowed to buy/sell stocks and trade two types of options: covered call and cash-secured put. For most of you, level 1 is enough for a while.
  
  Once you have demonstrated that you know how to trade covered calls and cash-secured puts and also show an increased in your account balance because of your trades were successful, and then you can apply for an upgrade to the next trading level, which is level 2.
  
  Again, in level 2, you have to demonstrate that you know how to trade vertical legs strategies before you are granted to the next level, which is level 3.


• Level 2: Is for intermediate level or people who have some experience in options trading--for people who know how to trade vertical legs strategies.
  
  Level 2 includes all Level 1 strategies, plus:
  
  
  • Married puts or Married puts here!
  
  
  • Long calls
  
  
  • Long puts
  
  
  • Long straddles
  
  
  • Long strangles
  
  
  • Covered puts (short stock and short put position) or Covered puts here!
  
  
• Level 3: Intermediate to advanced strategies for people who know how to trade credit spreads and other multiple legs strategies. Check out the tutorials on options spreads: Option Spread Strategies. Level 3 includes all Levels 1 and 2 strategies, plus:
  
  
  • Equity debit spreads (commonly called debit spreads).
  
  
  • Equity credit spreads (commonly called credit spreads).
  
  
  • Equity calendar/diagonal spreads
  
  
  • Index debit spreads (commonly called debit spreads but using index instead of individual stocks).
  
  
  • Index credit spreads (commonly called credit spreads but using index instead of individual stocks).
  
  
  • Index calendar/diagonal spreads


• Level 4: Advanced strategies for people who know how to trade credit spreads and other multiple legs strategies--options traders who have lots of experience in options trading.

Level 4 includes all Level 1, 2, and 3 strategies, plus:


• Naked equity puts


• Level 5: Advanced strategies for people who have lots of experience in options trading and trade millions and billions of dollars per year. Level 5 is very strict to qualify to get in and requires large sum of money to open an account. It is usually reserved for sophisticated professional and institutional traders. Levels higher than 3 is for specialized traders.

Level 5 includes all Level 1, 2, 3, and 4 strategies, plus:


• Naked equity calls


• Level 6: Advanced strategies for people who have lots of experience in options trading and trade millions and billions of dollars per year. Level 6 is very strict to qualify to get in and requires large sum of money to open an account. It is usually reserved for sophisticated professional and institutional traders. Levels higher than 3 is for specialized traders.

Level 6 includes all Level 1, 2, 3, 4, and 5 strategies, plus:


• Naked index calls


• Naked index puts


• To apply for the upgrade steps, say level 2, 3, etc, you would contact your brokerage service and tell them you want to upgrade your account level. In most brokerage services, there is a button in your account dashboard that you can press to send your request and a notification of your approval/disapproval will be sent to you via email.

A Brief Overview of Buying Puts and Calls

A Long Term Investment for Kids/Teens

What is a Stop Loss?

What is a Trailing Stop?

Can you set a stop loss on options?

• Since we now know that the next level of significant support is about $12.53 [$327.78 - $315.25] from the current price we can go ahead and calculate an appropriate stop loss by using the Option Greeks.
  
  NOTE: For those who do not know, the Greeks are nothing more than a couple of metrics/numbers that are used to price and gauge the risk profile an option. Don't be intimidated by them. For our purposes, we are primarily concerned with the Delta. The Delta is basically the rate at which an Option will change based on the change in the stock price and it is usually stated as a percentage.
  
  For instance, if a call option has a .50 Delta it basically means that for every 1.00 move in the price of the stock, the option will rise by .50 (theoretically). This tutorial/guide is not for beginners so I am assuming you already know the basics. If not, you might want to check out a book called Trading Options Greeks which is by far the best book on Options trading.
  
  For most brokerage services interface, you should be able to find this Greek easily by looking around in the options chain. Here is what it looks like for this particular screen interface.

• Now a quick look at the contract profile for the TSLA AUG 350.00 calls reveals that the Delta is currently .35. So this means, in theory, that for every 1.00 move in TSLA, the contract should move by .35 cents. At this point, I have to remind you that time decay will also have an impact on how the option contract responds to movement in the stock price. So be mindful of that. But for this exercise, we will assume that only the Delta is important.


• Now that we know that the Delta is .35 and we know that the next support level is at $315.25 we can do some calculations and get closer to an appropriate stop loss level for our trade. So, since we have decided that we want to get out of the trade on a break below the $315.25 level, we are basically saying we are willing to give up/risk $12.53 [$327.78 - $315.25] (or 3.81%) per share on the trade. With a delta of .35 that would be $4.38 [$12.53 * 0.35] on the AUG 350.00 Contract which is now trading at $9.00. Therefore, the stop loss will be set at $4.62 [$9 - $4.38] initially.

What is a Relative Strength Index?

Ex-Dividend Date

1. Record date: the deadline date the company sets on its books for investors to be on to qualify for the dividend.



2. Ex-dividend date: the date the stock exchanges or the National Association of Securities Dealers, Inc. set to two days prior to the record date set by the company. So the "ex-" (in theory) stands for extra--as in extra or in addition to the company's date.

What is a bond?

• Interest Rate is the percentage rate of Par Value that will be paid in interest to the bondholder on a regular basis. For example, this $1,000 bond would pay 12 3/8%, or $123.75 a year.


• Maturity indicates when the term of the loan expires ("is due") and the bond will be retired ("paid off" in full).


• Par Value is the amount the bondholder will be repaid when the loan is over. Usually, par value is $1,000. A Baby Bond is a bond with a par value of less than $1,000. Governments--especially federal government--usually issue Baby Bonds in par value (denominations or units) of $500, $250, $100, and $50.

• Federal governments. The U.S. Federal government always issue bonds to pay for a wide range of federal government activities: defense spending, war costs, catastrophic events (hurricans, floods, eartquakes, etc), infrastructures, federal aid to states, and so forth.


• Federal government agencies. Bonds issued by federal government agencies are indirect obligations of the U.S. government. Some of the most well-known are the U.S. Postal Service, which borrows heavily to fund its operation; FANNIE MAE, FREDDIE MAC, GINNIE MAE, FHA, and the Tennessee Valley Authority.


• Municipal governments. States, cities, counties, and towns issue bonds to pay for a wide range of publicly beneficial projects: schools, roads, sewage systems, other infrastructures (bridges, camp/play ground), stadiums, and so forth.


• Foreign governments. Many foreign governments issue bonds specifically to U.S. investors. Just like U.S. governments, foreign governments also issue bonds to pay for a wide range of publicly beneficial projects and other essential services.


• (U.S. and Foreign) Corporations. For corporations, bonds are a primary way of raising cash to fund its operations. The money raised pays for expansion, modernization, acquisitions, and other expenses.

• Yield. How much you'll earn from interest payments compared to what you could earn from other investments. The higher the yield on your bond the more money you earn, and also the more people wanting to buy your bond from you. Bonds are tradeable securities.
  
  A bond's yield is not the same as its interest rate. The term yield describes what you'll actually earn from a bond, based on a simple calculation. Investors determine bond values largely by comparing yields.
  
  Dividing the amount of money a bond will pay in interest by the price of the bond gives you a bond's yield. For example, if a bond value (or price) is $1,000 that pays 8% annual interest rate for 5 years, so $80 / $1,000, youll receive $80 a year from this bond. It would yield 8% on that bond. In this case, a bond's yield is the same as its interest rate.
  
  If, however, a year later, the bond loses value and it's sold in the secondary market for $800, the new buyer would still receive the $80 a year in interest payments from the bond issuer. Remember that the par value of that bond is still $1,000, but the same bond is sold for only $800 in the secondary market, a difference yield of 2.1% per year.
  
  Now the $200 difference yields a 2.1% per year (200/800)/12. You hold the bond only for 4 years, and therefore, the total percentage return on that is 8.4% (2.1 X 4).
  
  Now that was just the return on the $800 investment principal. What about the interest payments for four years? Don't they get counted as return on investment?
  
  The correct answer is: yes, they all get counted as return on investment. So, since the bond was sold for only $800 the yield for interest payment for each of the four year is 10% (80/800). Add the two yields (2.1% + 10%) together and you would get 12.1%. The new buyer would receive a 12.1% return on investment (or yield).
  
  As you can see, a bond's yield is not the same as its interest rate. The interest rate for the bond is 8% while the yield for that bond is 12.1%.
  
  On the other hand, should the bond be sold in the secondary market--a year later--for a premium, say $1200, the new buyer would still receive the $80 a year in interest payments from the bond issuer. Remember that the par value of the bond is still $1,000, but the same bond is sold for a premium at $1,200 in the secondary market. This means that when the same bond is due, you will get only $1,000 (not $1,200).
  
  Now the $200 difference yield a negative of 2.1% per year (200/800)/12. Meaning that your return on your investment is 2.1% lower than you would have gotton had the same bond had been sold for the same amount of $1,000 in the secondary market. You hold the bond only for 4 years, and therefore, the total percentage return (or yield) on that $200 is 8.4% lower (-2.1 X 4).
  
  Now that was just the return (or yield) on the $1,200 investment principal. What about the interest payments for four years? Don't they get counted as return on investment?
  
  The correct answer is: yes, they all get counted as return on investment. So, since the bond was sold for $1200 in the secondary market, the yield for interest payment for each of the four year is 6.67% (80/1200). Add the two yields (-2.1% + 6.67%) together and you would get 4.67%. The new buyer would receive a 4.67% return on investment (or yield).
  
  As you can see, a bond's yield is not the same as its interest rate. The interest rate for the bond is 8% while the yield for that bond is only 4.67%.


• Safety. How safe is your bond? In other words, how sure are you that the issuer will repay the loan when it comes due? High safetyness also attracts other investors wanting to buy your bond from you.

Looking to add bonds to your portfolio?

1. Understand the basics of how bonds work. To get yourself up to speed on how bonds work, familarize yourself in my other tutorial called "Introduction to Bonds."


2. Decide which type of bonds to buy. Not all bonds are created equal. In fact, there are several types of bonds you might choose to buy:
   
   • Corporate bonds are those issued by companies to raise money for things like research and capital improvements. The interest you receive from corporate bonds is taxable at both the state and federal level.
   
   
   • Municipal bonds are those issued by cities, states, and other localities to finance public projects and increase public services. The interest you receive from municipal bonds is always tax-exempt at the federal level, and if you buy bonds issued by your home state, you can avoid state and local taxes as well.
   
   
   • Treasury bonds, or T-bonds, are those issued by the U.S. government. The interest you receive from T-bonds is taxable at the federal level, but exempt from state and local taxes.
   
   
   • Convertible bonds are bonds issued by publicly traded corporations. In other words, convertible bonds are bonds that can be converted into publicly traded stocks. Convertible bonds can be a very lucrative investment if you happen to find convertible bonds issued by explosive growth companies, because stocks of growth companies tend to grow explosively along the companies themselves. So make sure you do your due diligence on the companies and its future prospect and don't forget to read the bond's debenture or terms.
   
   
3. Choose an investment horizon or maturity date. While you're not required to hold your bonds to maturity, if the value of your bonds falls after you buy them, you may have no choice but to retain them long term to avoid taking a hit on your principal investment.
   
   That's a big reason why you'll need to put some thought into your ultimate investment horizon. Because bonds come with differing terms (10 versus 20 versus 30 years, for example), setting some investment goals can help you determine how long to potentially lock your money away for.
   
   Remember that you can sell your bonds at any time and you don't have to hold them to maturity, but be aware that the price of your bonds may fluctuate according to market conditions.
   
   
4. Research your investments. You'll often hear people making statements like these: "Bonds are a safe investment, and stocks aren't." But it's rarely that simple.
   
   While bonds are typically less volatile than stocks, choosing the wrong bonds could expose you to more risk than you may have bargained for. That's why it's important to look at bond ratings when choosing a company or municipality to invest in. The higher the rating, the less likely your issuer is to default on its obligations.
   
   On the flip side, bond investors tend to be rewarded for taking on more risk, so if you buy bonds from an issuer with a lower rating, you'll typically snag a higher interest rate.
   
   If you don't want to shoulder the risk of buying individual bonds, you could always invest in a bond fund instead, which gives you instant diversification. Think about it: If you buy bonds from a single issuer and that issuer defaults, you're out of luck. But if you buy a bunch of bonds and a single issuer defaults, you'll continue to make money from the rest of the bonds in that pool.
   
   The downside of bond funds, however, is that your income stream will be less predictable, as you won't get those same steady interest payments that holders of individual bonds collect. One of the reasons is that bond funds are actively managed buy fund managers who buy/sell bonds the moment they feel the bonds are in/out of favor.
   
   In other words, like stock fund managers, bond fund managers buy/sell bonds actively and rarely hold their bonds to maturity.
   
   You can also check out the rating agencies such as Moody's Investors Service, Fitch Ratings, Standard and Poor Ratings, and learn their rating classification.
   
   No matter your age, bonds can play a big role in helping you meet your investment goals. Just make sure to weigh the pros or cons of bonds versus other instruments so that your choices align with your ultimate objectives.


5. The best place to get your feet wet with bond investing is to signup a trading account with one of the brokerage services. Check out an instruction that I put out called "Get Started Trading Options." Once you have an account, you can trade stocks, bonds, options, mutual funds, etfs, etc.
   
   As always, if you have any question you can ask your brokerage representative on how to invest in bonds or any other investment (for that matter).

What is a yield curve and why is everybody talking about it so much?

• If you invest in equities, you should keep an eye on the bond market.


• If you invest in real estate, you should keep an eye on the bond market.


• If you invest in bonds (or bond ETFs), you should definitely keep an eye on the bond market!

1. borrow as much money.


2. for as long a period of time.


3. at the lowest interest rate possible to get rich.

A brief introduction to SPL auto load

Autoloading of classes is a daily chore if you're a programmer. Every time you build an application (big or small) requires you to load your classes from the directories where classes are located. Most inexperienced programmers (or maybe all inexperienced programmers) typically load their classes at the class level rather than at the application level. Here is an example of loading of classes at a class level:

<?php
include '/home/package/someclass.php';
include_once '/home/package/someotherclass.php';
require '/home/package/somemoreclass.php';
require_once '/home/package/someothermoreclass.php';

/**
 * An example of loading classes at a class level
 */
class MyClass extends OtherClass
    {
     // more code here
     // .....
    }

As you can see, this class loads four classes (someclass.php, someotherclass.php, somemoreclass.php, someothermoreclass.php) files at the top of the class file. This is called class level loading. This is the most popular way of doing for most of us programmers, including experienced and inexperienced programmers.

There is absolutely nothing wrong with class level loading and it can accomplish tasks (large or small) very well. However, pattern programming methodologies are becoming more and more popular and thus making use of application level loading even more mainstream.

Pattern programming methodologies, such as the MVC pattern, loading of classes are taking place at the application level -- and that is, we don't put the include, include_once, require, or require_once at the top of every class or at anywhere in the class. Rather it is autoloaded directly into the base class. The following description shows how SPL autoloads of classes.

SPL Autoloading

First, here is a simple version that uses an anonymous function to attempt to load the classes ExampleClass1 and ExampleClass2 from the files exampleclass1.php and exampleclass2.php, respectively. This is the simplest version you can use:

<?php
spl_autoload_register(function ($class_name)
                             {
                              // Of course, you need to specify a complete path to the
                              // class file
                              include $class_name . '.php';
                             }
                     );
?>

The code above registers anonymous function (along with its argument variable $class_name) with PHP.

Now any time you create an instance of a class:

$obj1 = new ExampleClass1();

Or

$obj2 = new ExampleClass2();

PHP will attemp to create an instance of the class, but if PHP doesn't recorgnize that class it will tries to load and include that class name specified in variable $class_name--or classes ExampleClass1 and ExampleClass2 in this case.

In other words, if PHP doesn't recorgnize that class it will call the anonymous function() above passing a string--ExampleClass1 or ExampleClass1--to the anonymous function.

Suppose you want to incorporate an spl_autoload functionality in your base class called Example. Here is how you would do it:

<?php
/**
 * Example is the base class serving common functionalities.
 */
class Example extends ParentClass
    {
     // Using anonymous function, you can put spl_autoload_register() statements anywhere in
     // your main base class including inside the constructor
     // In an MVC pattern, you can put spl_autoload_register() statements inside
     // the starting script file as well
     spl_autoload_register(function ($class_name)
                                  {
                                   // Of course, you need to specify a complete path to the
                                   // class file
                                   include $class_name . '.php';
                                  }
                          );
    }
?>

Here again, if PHP doesn't recorgnize the class that is being instantiated, it will call the anonymous function() inside class Example passing a string contains in the variable $class_name to the anonymous function. Remember that autoloading of classes is often being done in the base class or sometimes called base controller class.

Secondly, here is a more sophisticated version that uses a function name to autoload the classes. This is the preferred version if you're developing large-scale applications.

spl_autoload_register() allows you to register multiple functions (or static methods ['myAutoloader' in this case] from your own autoload class) that PHP will put into a stack/queue and call sequentially when PHP sees an unknown class being referenced or instantiated.

In other words, PHP will call a function name that has been registered in the spl_autoload_register() and tries to load and include that class name inside that function. For example:

<?php
         spl_autoload_register('myAutoloader');
?>

That code above will register a function named 'myAutoloader' which is illustrated below:

So if you defined an autoload function named 'myAutoloader' [as shown below] and registered it in spl_autoload_register() [as shown above], PHP will call that function name whenever it sees an unknown class being referenced or instantiated. The two keywords that we're interested in are: referenced and instantiated. For example, when you reference or create an instance of a class, like so:

<?php
// here, we referenced MyClass and if PHP doesn't recorgnize this class it will
// call 'myAutoloader'
MyClass::$some_static_property_variable = $this;

// here, we create an instance of MyClass() and if PHP doesn't recorgnize this class it
// will call 'myAutoloader'
$myClass = new MyClass();
?>

If PHP does not recorgnize this class (i.e., "MyClass" hasn't been instantiated and included), PHP will call a function named myAutoloader() and tries to include that class file inside that function named myAutoloader():

<?php
// PHP calls this function passing a class name as a string like so: myAutoloader("MyClass")
function myAutoloader($className)
       {
        $path = '/path/to/class/';

        // you must name your class file name the same as class name.
        // this is the reason why my coding standard states that class file name should be
        // the same as class name.
        include $path.$className.'.php';
       }
?>

In the example above, "MyClass" is the name of the class that you are trying to reference or instantiate, PHP passes this class name as a string to spl_autoload_register(), which allows you to pick up the variable ($className) and use it to "include" the appropriate class/file [as shown above].

As a result, you don't specifically need to include that class via an include/require statement. Just simply reference or instantiate the class you want to reference/instantiate like in the examples above, and since you registered a function (via spl_autoload_register()) of your own, PHP will call that function and it will figure out where all your classes are located.

Notice that this custom function is a function that you have to create and then register it in the spl() autoloader.

Remember that autoloading of classes is often being done in the application's base class, sometimes called controller base class in an MVC pattern talk.

To register your custom auto load function, you typically put spl_autoload_register() statements in your main base helper class and call that class from inside the starting script file. For example:

<?php
/**
 * Application is the base helper class serving base class common functionalities.
 */
class Application extends Example
    {
     // PHP automatically registers the custom 'myAutoloader' function of the class 'Example'
     spl_autoload_register(['Example', 'myAutoloader']);
    }
?>

In the starting script file, typically in the index.php, you do it like the following:

<?php
/**
 * The main index.php starting script file
 */
// loads the helper class
require __DIR__ . '/home/package/application.php';
?>

Assuming Example is an application's base class, here is how you would implement your own custom auto load function:

<?php
/**
 * Example is the base class serving common functionalities.
 */
class Example extends ParentClass
    {
     // PHP automatically calls this function along with passing in a class name as a string
     public function myAutoloader($class_name)
          {
           $path = '/path/to/class/';

           // you must name your class file name the same as class name
           include $path.$className.'.php';
          }
    }
?>

In the above base class Example, if somewhere in your application [most likely in the controller], you reference or create an instance of any class, like so:

<?php
// here, we referenced MyClass and if PHP doesn't recorgnize this class it will
// call 'myAutoloader'
MyClass::$some_static_property_variable = $this;

// here, we create an instance of MyClass() and if PHP doesn't recorgnize this class
// it will call 'myAutoloader'
$myClass = new MyClass();
?>

PHP will trigger a call to the function myAutoloader($class_name) above passing along the class name MyClass as a string to the function. As a result, that class gets included and instantiated.

The benefit of using spl_autoload_register() is that, unlike PHP's __autoload(), you don't need to implement an autoload function in every file that you create or use the include, include_once, require, or require_once at the top of every class or at anywhere in the class.

<?php
/**
 * 'Autoloader', 'Helper', 'Database' are class names.
 * Notice that you can place autoloaders in the same class as well:
 *              'ClassLoader', 'LibraryLoader'
 */
class Example extends fromParentClass
    {
     // register classes and their functions
     public function __construct()
          {
           // Load a class: 'Autoloader' is the class name,
           // 'ClassLoader' is the name of a function
           spl_autoload_register('Autoloader::ClassLoader');

           // Load a library: 'LibraryLoader' is the name of a function
           spl_autoload_register('Autoloader::LibraryLoader');

           // Load a helper class: 'Helper' is the name of the class
           spl_autoload_register('Helper::HelperLoader');

           // Load a database: 'DatabaseLoader' <== name of a function
           spl_autoload_register('Database::DatabaseLoader');
          }
    }
?>

Here is the implementation of the class Autoloader:

<?php
/**
 * Autoloader is the class libraries.
 */
class Autoloader extends fromOtherParentClass
    {
     // PHP automatically calls this function along with passing in a class name as a string
     public function ClassLoader($class_name)
          {
           $path = '/path/to/class/';

           // you must name your class file name the same as class name
           include $path.$className.'.php';
          }
    }
?>

The other classes are implemented in the same fashion. Self-explanatory.

For more see spl autoload.

Do you ever wanted to know how they calculate indexes?

• pork costs $6.89 per pound. This base-year amount is set to equate to the starting index value of 100.


• fish cost $14.99 per pound. This base-year amount is set to equate to the starting index value of 100.


• bread costs $4.89 per loaf. This base-year amount is set to equate to the starting index value of 100.


• milk costs $5.49 per cart. This base-year amount is set to equate to the starting index value of 100.


• lettuce costs $2.89 per head. This base-year amount is set to equate to the starting index value of 100.

• For pork: (new price / base price of $6.89) * 100 = ?
  
  If new price is $6.99, then the index for pork is 101.45.


• For fish: (new price / base of $14.99) * 100 = ?
  
  If new price is $15.59, then the index for fish is 104.


• For bread: (new price / base of $4.89) * 100 = ?
  
  If new price is $4.99, then the index for bread is 102.50.


• For milk: (new price / base of $5.49) * 100 = ?
  
  If new price is $4.99, then the index for milk is 90.89. Notice that the price of milk has gone down 9.11% from the previous year. This will effect the overall index number.


• For lettuce: (new price / base of $2.89) * 100 = ?
  
  If new price is $2.99, then the index for lettuce is 103.46.

Do you ever wonder how analysts get all the information about a particular publicly traded company?

• The year the company was organized.


• The company's form of organization.


• Principal products produced, the principal markets for the products, and the methods of distribution.


• Number of employees and anticipated material changes in the number of employees in various departments.


• Competitive Conditions.


• Research and Development.

• Asset Purchase Agreements.


• Bridge Loan Agreements.


• Cash Bonus Plans.


• Director Fee Agreements.


• Director Indemnification Plans.


• Employment Agreements.


• Executive Compensation Plans and Incentive Plans.


• Financial Services Agreements.


• Joint Venture Agreements.


• Lease Agreements.


• Letters of Intent.


• License Agreements.


• Pension Plans.


• Profit Sharing Plans.


• Purchase Agreements.


• Stock Option Agreements.


• Stock Purchase Agreements.


• Termination Agreements.