Introduction

Today, we are going to finish up with our initial pass at the PHP language.
For Hw3, besides making use of the PHP language feature we have discussed, you will create your project in a more real-world way using a version control system.
We will use GIT to do version control.
After finishing PHP in this lecture, we are going to look at different kinds of version control systems and how bug/issue tracking is handled.
I will use the term bug in a very flexible sense: It might mean a software defect that needs to be fixed, it might mean a software enhancement that is desired.

Inheritance

So far we've described how to make a PHP class, constructors, destructors, and cloning.
We've said unlike the default copy-on-write semantics of array assignment, object assignment in PHP is by reference. Let's now turn to inheritance.
Inheritance in PHP is very similar to Java.
A PHP class can extend one other class.
```
class A{}
class B extends A {}
```

PHP also has a notion of interface:

interface MyInterface
{
    function method1($a, $b);
}

A PHP class can implement multiple interfaces:

class C implements MyInterfaceA, MyInterfaceB {}

If you want to have a class with some but not all of its methods defined. You can use the keyword abstract on those methods which will be overriden in subclasses.

Referring to Parents, Final

Consider:

class A {function foo(){} }
class B extends A {function foo(){} }

Within B, self::foo() refers to the redefinition of foo given in (2). (Instance methods can also be called using $this->method())
Within B, parent::foo() refers to class A's version of foo.
To prevent a function from being overridden in a subclass you can use the keyword final.
```
class A {final function foo() {} /* can't override*/ }
```

Traits

Traits are a PHP language feature added in PHP 5.4, probably deriving from Python/Common Lisp mix-ins.

They allow one to define a collection of method implementations and then reuse them in several classes:

trait MyMethods 
{
    function getFoo() { /* code for getFoo */ }
    function getGoo() { /* code for getFoo */ }
}

class SomeClassA extends NeedsMethods 
{
    use MyMethods; //as if I had written the code in MyMethods here
    /* rest of SomeClassA code */
}

class SomeClassB extends NeedsMethods 
{
    use MyMethods;
    /* rest of SomeClassB code */
}

$a = new SomeClassA();
$a->getFoo();

You can import more that one trait by comma separating them:
```
class A  
{
   use MyMethodsA, MyMethodsB;
   // ...
}
```
Suppose both MyMethodsA and MyMethodsB define a function named foo and one named goo. This will result in a fatal error unless one explicitly resolves the conflict using the insteadof operation to say which to use, or uses the as operator to rename one:
```
use MyMethodsA, MyMethodsB {
    MyMethodsA::foo insteadof MyMethodsB;
    MyMethodsB::goo insteadof MyMethodsA;
    MyMethodsA::goo as gooey;
    MyMethodsB::foo as protected fooey; //notice can change visibility if want
}
```

Namespaces

Like C++, PHP supports a notion of namespace. This is similar to the Java notion of package. It allows one to group together a collection of functions, constants, classes, interfaces under one name.
Namespaces must be declared at the start of the file they are in (only the declare command can occur earlier)
A namespace might be declared with a line like:
```
namespace TheNameOfMyNamespace;
// code for namespace
class A
{
  //code for class A
}
function foo()
{
}
```
This declaration with the same name can be at the top of multiple files if you would like to group the contents of these files into the same namespace.
A sub-namespace of a namespace can be declared using backslashes:
```
namespace TheNameOfMyNamespace\MySubNameSpace;
//code
```
Within one file you can switch what namespace you are defining, but it is not recommended:
```
namespace D {
  // code for D
}
namespace E {
  // code for E
}
```

Using Namespaces

Function or class names without qualifications are assumed to come from the current namespace:
```
namespace N;
function foo()
{
  //some code
}

foo(); //assume N namespace.
```

Before function, interface, class, or constant names we can also give the namespace path (either relative or absolute):

M\foo(); /*in context of above we are in N namespace already, 
          so M\foo() means the foo() in N\M namespace. */
\N\M\foo();
\time(); //time function in the global (default) namespace.

You can import a namespace using the use keyword:

use A\B\C;
//rather than typing A\B\C\foo(); could type foo();
use D\E\F as G;
//rather than typing D\E\F\goo(); could type G\goo();

Quiz

Which of the following statements is true?

On Unix, PHP typically communicates with a Mysql database using LINQ.
In PHP, the constructor function of a class is a method with the same name as the name of the class.
PHP sessions make use of HTTP cookies.

Exceptions

PHP supports try catch blocks like Java.

try {} catch(MyException $e){} catch(Exception $ee){}

You can use the keyword throw to throw an exception

if($denom == 0){
    throw new Exception("divide by zero");
}

You can subclass Exception to create custom exceptions.

Generators

Generators are a PHP 5.5 feature that allow one to generate a sequence of values via function. They are similar to Python generators.
They are suitable for use in statements like foreach where the array argument might go.
Generator functions execute until a yield statement is reached.
This statement is like a return statement except that the context of the function is preserved. The next time the generator is called execution resumes in this context after where the yield statement was.

For example, in PHP, range(0, 10000) returns an array of elements 0 - 9999 which we could use in a foreach. A similar effect could be achieved with the code:

function my_gen($start, $end) {
    for ($i = $start; $i < $end; $i++) {
        // $i is preserved between yields.
        yield $i;
    }
}

$generator = my_gen(0, 10000);
foreach ($generator as $value) {
    echo "$value\n";
}

The advantage of the above code is that it uses less memory.
You can yield key value pairs with a syntax like:
```
yield $k => $v;
```
A yield statement without an argument returns a pair NUM_TIME_YIELD_CALLED => null.

Version Control Systems

A version control system solves the problem of how many people can work on the same code base at the same time.
There are many different such systems on the market, the oldest is Source Code Control System developed at Bell Labs in 1972.
It was subsequently supplanted in popularity by RCS (Revision Control System) which in turn was supplanted by CVS (Concurrent Version System).
Nowadays, there are many different versions control systems on the on the market.
There are traditional central repository systems: CVS, Subversion (open source); BitKeeper, Perforce, ClearCase ( proprietary)
There are also distributed version control systems: Bazaar, git, Mercurial.
Here is a round-up of the different features of these systems http://en.wikipedia.org/wiki/Comparison_of_revision_control_software
We are going to look at an example of each of these major type of systems.
We will look at Subversion because: (a) it uses http and https as its means of accessing the repository; (b) it is open source and has been around along enough that it seems for real; and (c) According to Eclipse Community Survey 2013, at least among Eclipse user's it has a 38% market share (CVS has about 4.5%).
In comparison, GIT/GitHub has a 36% share and is currently the most popular distributed version control system.
On Wednesday we will talk about Git.

Finish up PHP, Creating and Administering a Web Development Environment

Outline