The document presents a talk by Alena Holligan about scope communication in PHP programming, covering definitions of scope, code examples, and scope types such as personal, functional, class, method, and project scope. It discusses access control, visibility keywords, interfaces, namespaces, project management tips to prevent scope creep, and shares resources for further learning. The session aims to clarify these concepts for better understanding and application in programming practices.

1. LET’S TALK SCOPE
COMMUNICATION IN CODE

2. Presented by: Alena Holligan
• Wife, and Mother of 3 young children
• PHP Teacher at Treehouse
• Portland PHP User Group Leader
www.sketchings.com
@sketchings
alena@holligan.us
Download Files: https://github.com/sketchings/scope

3. Definition of Scope
noun
1. the extent of the area or subject matter that something
deals with or to which it is relevant.
2. the opportunity or possibility to do or deal with something.
verb
1. assess or investigate (something).
2. look at carefully; scan.

4. It’s all about ACCESS

5. Personal Scope
Acquaintance (Social)
Friends
Professional
Family
Romantic

6. “MOM!”

7. “MOM!”

8. Identification: Chris
@fideloper
@assertchris
@grmpyprogrammer
@enygma
@crussell52_
@dragonmantank
@chwenz

9. Code Scope

10. Function Scope

11. function functionScope(&$passed){ //can pass by reference
$myvar = 2;
$passed++;
echo 'INSIDE FUNCTION' . '<br />' . PHP_EOL;
echo 'Global $myvar: ' . $GLOBALS['myvar']
. '<br />' . PHP_EOL;
echo '$myvar: ' . $myvar . '<br />' . PHP_EOL;
echo '$passed: ' . $passed . '<br />' . PHP_EOL;
global $myvar;
$myvar++;
echo 'Global $myvar: ' . $myvar .'<br />'.PHP_EOL;
return $passed;
}

12. $myvar = 1;
echo 'GLOBAL before function'.'<br />'.PHP_EOL;
echo '$myvar: ' . $myvar . '<br />' . PHP_EOL;
$returned = functionScope($myvar);
echo 'GLOBAL after function' .'<br />'.PHP_EOL;
echo '$myvar: ' . $myvar . '<br />' . PHP_EOL;
echo '$passed: ' . $passed . '<br />' .PHP_EOL;
echo '$returned: ' .$returned.'<br />'.PHP_EOL;

13. When the script is run, it will return:
GLOBAL before function
$myvar: 1
INSIDE FUNCTION
Global $myvar: 2
$myvar: 2
$passed: 2
Global $myvar: 3
GLOBAL after function
$myvar: 3
$passed: //error because we’re no longer in function
$returned: 3

14. Class & Method Scope

15. Access Control
Visibility: Public, Private, Protected
Keywords: Final, Static
Static Access: parent, self, static
//Late Static Binding

16. //file: src/AbstractScope.php
abstract class AbstractScope {
const CLASS_CONSTANT = 'abstract constant';
public $myvar = 101;
}

17. //file: src/ClassScopeA.php
class ClassScopeA extends AbstractScope {
const CLASS_CONSTANT = 'class constant';
public $myvar = 100;
public static $staticvar = 200;
private $privatevar = 300;
public function displayProperties() {
echo 'parent constant: '
. parent::CLASS_CONSTANT .'<br />'. PHP_EOL;
echo 'self constant: '
. self::CLASS_CONSTANT . '<br />' . PHP_EOL;
echo 'static constant: '
. static::CLASS_CONSTANT .'<br />'. PHP_EOL;
echo '$this->privatevar: '
. '(' . gettype($this->privatevar) . ') '
. $this->privatevar . '<br />' . PHP_EOL;
}
}

18. //file: src/ClassScopeB.php
class ClassScopeB extends ClassScopeA {
const CLASS_CONSTANT = 'classB constant';
public $myvar = 1000;
public static $staticvar = 2000;
private $privatevar = 3000;
final public function displayProperties()
{
parent::displayProperties();
}
}

19. echo "STATIC CALL ClassScopeA" . '<br />' . PHP_EOL;
echo ‘ClassScopeA $staticvar: '
. ClassScopeA::$staticvar. '<br />' . PHP_EOL;
$classA = new ClassScopeA();
echo "FROM classA Object" . '<br />' . PHP_EOL;
var_dump($classA);
$classA->displayProperties();
echo "FROM classB Object" . '<br />' . PHP_EOL;
$classB = new ClassScopeB();
var_dump($classB);
$classB->displayProperties();

20. STATIC CALL ClassScopeA
ClassScopeA $staticvar: 200
FROM classA Object
object(ClassScopeA)[1]
public 'myvar' => int 100
private 'privatevar' => int 300
parent constant: abstract class constant
self constant: class constant
static constant: class constant
$this->privatevar: 300
FROM classB Object
object(ClassScopeB)[2]
public 'myvar' => int 1000
private 'privatevar' => int 3000
private 'privatevar' (ClassScopeA) => int 300
parent constant: abstract class constant
self constant: class constant
static constant: classB constant
$this->privatevar: (integer) 300

21. Interface

22. //file: src/FirstInterface.php
interface FirstInterface
{
//cannot redefine constant
//const CLASS_CONSTANT = 'interface class constant';
//interfaces can only contain public methods KEPT public
public function InterfaceMethod($one);
}
//file: src/SecondInterface.php
interface SecondInterface extends FirstInterface
{
//cannot add a second parameter, must be compatable
//does not have to keep same param name
public function InterfaceMethod($two);
public function AdditionalMethod();
public function publicMethod();
public function addPassed(&$param);
}

23. //file: src/InterfaceClass.php
class InterfaceClass extends ClassScopeB
implements FirstInterface, SecondInterface
{
const CLASS_CONSTANT = 'interface class constant';
public $myvar = 100.0;
public static $staticvar = 2;
private $privatevar = 300.0;
public function interfaceMethod($one)
{
echo 'Interface Method' . '<br />’ . PHP_EOL;
echo self:: CLASS_CONSTANT . '<br />' . PHP_EOL;
echo '$this->privatevar: '
. '(' . gettype($this->privatevar) . ') '
. $this->privatevar . '<br />' . PHP_EOL;
}
public function additionalMethod()
{
echo 'Additional Method';
}
//cannot override final
//public function displayProperties(){}
}

24. require "src/AbstractScope.php";
require "src/ClassScopeA.php";
require "src/ClassScopeB.php";
require "src/FirstInterface.php";
require "src/SecondInterface.php";
require "src/InterfaceClass.php";
//Order is critical

25. Autoloading
//using composer, add to the file that calls the classes
require __DIR__ . '/vendor/autoload.php';
//file: composer.json
"autoload": {
"classmap": [
"src/ClassScopeA.php",
"src/AbstractScope.php",
"src/ClassScopeB.php",
"src/FirstInterface.php",
"src/SecondInterface.php",
"src/InterfaceClass.php"
]
}

26. Application Scope
Packages and Namespacing

28. Namespacing
namespace sketchingsscope;
//reference the global namespace
class NamespaceScopeA extends ClassScopeA {
public $myvar = 1.1;
private $privatevar = 1.2;
}
//reference the current namespace
class NamespaceScopeB extends NamespaceScopeA {
public $myvar = 402;
private $privatevar = 502;
}

29. use sketchingsscopeNamespaceScopeB as blah;
$classA = new sketchingsscopeNamespaceScopeA();
echo "FROM NamespaceScopeA Object".'<br />'.PHP_EOL;
var_dump($classA);
$classA->displayProperties();
$classB = new blah();
echo "FROM NamespaceScopeB Object".'<br />'.PHP_EOL;
var_dump($classB);
$classB->displayProperties();

30. FROM NamespaceScopeA Object
object(sketchingsoopNamespaceScopeA)[1]
public 'myvar' => float 1.1
private 'privatevar' => float 1.2
private 'privatevar' (ClassScopeA) => int 300
parent constant: abstract class constant
self constant: class constant
static constant: class constant
$this->privatevar: (integer) 300
FROM NamespaceScopeB Object
object(sketchingsoopNamespaceScopeB)[2]
public 'myvar' => int 402
private 'privatevar' => int 502
private 'privatevar' (sketchingsscopeNamespaceScopeA) => float
1.2
private 'privatevar' (ClassScopeA) => int 300
parent constant: abstract class constant
self constant: class constant
static constant: class constant
$this->privatevar: (integer) 300

31. Project Scope
“Scope creep” is an access issue

32. Types of Projects
Client Projects
Internal Company Projects
Company with Clients

33. Tips to Control Scope Creep
Project Manager
Start with Planning Scope
Have incremental goals
Make the Plan Visible to Everyone
How to handle changes
MVP

34. Resources
LeanPub: The Essentials of Object Oriented PHP
Head First Object-Oriented Analysis and Design
Apress: PHP Objects, Patterns, and Practice

35. Presented by: Alena Holligan
• Wife and Mother of 3 young children
• PHP Teacher at Treehouse
• Portland PHP User Group Leader
www.sketchings.com
@sketchings
alena@holligan.us
Download Files: https://github.com/sketchings/scope
https://joind.in/talk/1c622