Building Modern PHP Applications

PHP has changed a lot in the last few releases. We'll introduce some of the recent and upcoming changes, some of the new tools and frameworks they have enabled, and how you can utilize them to improve your PHP projects. As an example, we'll walk through setup of an application using the Symfony2 framework.

Transcript

1. Building Modern PHP Applications How PHP language, tool, and framework advancements will help you improve your applications.
2. Me • Developer at Blend Interactive (blendinteractive.com) • Sioux Falls, SD • Contact Me: – shellrunner.com – @jacksonmurtha – github.com/jxn – gplus.to/jacksonmurtha – jackson@jacksonmurtha.com
3. Attendee Survey • Are you developing applications in PHP? – Which version? Which Platform(s)? – Are you using a framework? • What other languages are you using? • Are you testing your PHP applications? – Unit testing? Browser integration testing?
4. PHP's Image Problem • Language origins • Deprecated features • Disorganized/disparate community • Poor release-planning • Persistent myths • Bad code (in high-profile applications) • New features are not well known • Some legitimate concerns (threads, enforced security policies, naming / param consistency)
5. PHP Myths • OOP is difficult or impossible • Performance problems • Windows is a second-class citizen • Community in decline • Difficult/Impossible to separate responsibilities (view-code littered with business logic) • Not testable • Tools are focused on the document-web • No longer needed given client-side state • Dumb PHP “features” get in the way • New deployment methods are not available (e.g. Heroku) • Poorly-managed releases, slow release cycle • Not a “real” programming language – a preprocessor • Insecure • All “blog code” • Immature platform or only immature applications • Poor garbage collection • Tools are outdated • Everything is global • Fate of the language is tied to the fate of mod_php • No modern language features • Not enterprise-friendly • Difficult to add contributions • No visibility of roadmap
6. Valid Criticisms • Naming / parameter consistency* • Multi-byte strings can cause problems* • Threading* • Few “forced” conventions* • PHP is rarely “first to feature”* • ???
7. Changes to the web • emergence of “big data” • multi-server environments • viability of non-shared hosting • rise of the web application and decline of the document web • popularization of rails/django • viability of compiled languages (C# / Java) • growth of the mobile web • alternatives to database for storage • commercialization of software/developer tools and training • Javascript is now viable / sexy • ajax is ubiquitous • rising application complexity • client / browser enhancements • ascendancy of the web API • new code lifespan requirements • popularity of agile development • automated application testing • event-driven designs • virtualized environment advancements • return of the generated static page • new expectations and legal compliance • web development buzz and hype
8. PHP is constantly evolving • Release / cultural changes • Feature removal • New PHP features • New PHP tools • Second generation frameworks • New external tools
9. Release / core development changes • New developers on the core team • New RFC process • Reworked community resources • Feature-release timetable, ~1 year • Bugfix / maintenance timetable • Bug reporting improvements, reworked documentation approval process • Clearer expectations, more development visibility, smoother release transitions, greater predictability • Larger, more diverse developer community and a more experienced security team • Inter-framework cooperation & standards organizations
10. Framework Interop • http://php-fig.org • Growing influence, with three standards • PSR-0 – Autoloading/namespacing • PSR-1 – Basic coding standard • PSR-2 – Thorough style-guide • More coming....
11. Feature removal • Removal of some of the features caused the worst code offenses and security / predictability problems – Magic Quotes – register_globals – safe_mode – outdated mysql functions
12. New Features – PHP 5.0 – 5.3 • Improved inheritance model • Namespaces • PDO • Closures • Phar • Exceptions • SPL work / extensions improvements • Late static binding • Garbage collector improvements
13. Namespaces • Encapsulate Classes, Interfaces, Functions, Constants, Traits • Provide grouping, prevent collisions, allow aliasing • Encourage segregation of code • Replace hackish alternatives • Compile-time, not runtime
14. PDO • PHP Data Objects • “data-access” abstraction layer • Provide for object-oriented database access • Encourage prepared statements:
15. Phar • Single-file PHP archive • Executable package • Can access assets within and outside itself • phar:// stream wrapper available
16. Closures / Lambda functions • Hijacked from functional languages • More efficient than create_function() • Very useful for sort(), array_map(), array_filter(), or function using a callback parameter.
17. Garbage Collection / Late Static Binding / Performance and memory enhancements • Efficiency gains • Don't try to outsmart the compiler
18. New Features – 5.4 • upload progress • binary notation • array short syntax • array dereferencing • class member access on instantiation • indirect method call by array var • $this in closures • callable typehint • jsonSerializable interface • short echo tag always available • built-in webserver • traits
19. Array Dereferencing
20. Built-in webserver • Easy / no configuration in most environments • Development-only • To start: php -S localhost:8000 • Provides many server environment variables • Configuration php.ini, port, docroot can be changed at execution
21. Traits • Horizontal code-reuse (cf. mixins) • “Compiler-assisted copy and paste” • Obey most class behaviors, but cannot be instantiated
22. • Traits can be composed of other traits • Aliasing and collision prevention with 'as' and 'insteadof' • Multiple traits can be used at once
23. New Features – 5.5 • Password API • Setters / Getters • Generators • Intl improvements • array_column() • Fully-qualified class names • Try / Catch / Finally • Parameter skipping • Read-only properties • Named Parameters?
24. Generators • Simpler method for working with iterators • Nearly identical to the python implementation
25. Setters / Getters
26. Password API
27. New PHP Tools • Package tools – Composer (Pyrus/Pear2, Pear, Pecl, extensions, Pirum) • Testing tools – PHPUnit, Behat, Mink, php-selenium, goutte, phpspec • Static analysis tools – Php_Depend, phpcpd, phpdcd, codecoverage, codesniffer, mess detector, PHP-CS-Fixer
28. Composer • http://getcomposer.org • Repository management through packagist.org, bitbucket, github, etc. • Solves many issues with PEAR • easy install: • curl -s https://getcomposer.org/installer | php • Package lists, sources, dependencies, updates, installation locations • easy package setup, simple hosting setup, vcs/pear integration, github/bitbucket API tools, satis integration • library autoloading via require 'vendor/autoload.php';
29. Composer.json
30. Second Generation Frameworks • Post-PHP v. 5.3 – Symfony 2+, ZendFramework 2.0, Silex, (Lithium? CakePHP 2+ ?) • More modular than predecessors • Compliant with PHP-FIG (PSR-0) • Use modern PHP extensions, testing tools, OOP, abstraction layers
31. Symfony 2.0 • Installation/dependency resolution: Composer
32. Component Development • Bundles • Scaffolding • ORM • Components symfony.com/components: – Routing – EventDispatcher – HttpFoundation/HttpKernel – Assetic
33. Run Symfony • run php ./app/console server:run • or configure webserver manually
34. Create a bundle: the “hard” way • Create a bundle directory in src/ – e.g. src/MyPackage/MyBundle • Create bundle definition class • Create controller class • Create routes • Create view • Register bundle in AppKernel
35. Create the bundle definition class • contains namespaces and build functions for the bundle, if necessary
36. Create a controller class
37. Create view / Create routes
38. Register the bundle in AppKernel
39. Create a bundle: the easy way • Generates: – template skeleton – resource directories – appKernel registry – unit test skeleton – bundle definition class – default controller • multiple routing options
40. Run the app • Start / visit webserver – app/console server:run • Navigate to your route to see the response – e.g. http://localhost:8000/app_dev.php/yourRoute/yourParameter • How is this better than non-framework PHP? • How is this better than existing (first-generation) frameworks?
41. The End... • Questions... • Feedback...