book

Advanced PHP Programming

Name: Advanced PHP Programming
Author: George Schlossnagle
ISBN: 0672325616

by George Schlossnagle

February 2004

Intermediate to advanced

672 pages

14h 32m

English

Sams

Read now

Unlock full access

Copyright
Dedication
About the Author
Acknowledgments
We Want to Hear from You!
Reader Services
Foreword
Introduction
PHP in the EnterpriseThis Book’s Structure and OrganizationPart I, “Implementation and Development Methodologies”Chapter 1, “Coding Styles”Chapter 2, “Object-Oriented Programming Through Design Patterns”Chapter 3, “Error Handling”Chapter 4, “Implementing with PHP: Templates and the Web”Chapter 5, “Implementing with PHP: Standalone Scripts”Chapter 6, “Unit Testing”Chapter 7, “Managing the Development Environment”Chapter 8, “Designing a Good API”Part II, “Caching”Chapter 9, “External Performance Tunings”Chapter 10, “Data Component Caching”Chapter 11, “Computational Reuse”Part III, “Distributed Applications”Chapter 12, “Interacting with Databases”Chapter 13, “User Authentication and Session Security”Chapter 14, “Session Handling”Chapter 15, “Building a Distributed Environment”Chapter 16, “RPC: Interacting with Remote Services”Part IV, “Performance”Chapter 17, “Application Benchmarks: Testing an Entire Application”Chapter 18, “Profiling”Chapter 19, “Synthetic Benchmarks: Evaluating Code Blocks and Functions”Part V, “Extensibility”Chapter 20, “PHP and Zend Engine Internals”Chapter 21, “Extending PHP: Part I”Chapter 22, “Extending PHP: Part II”Chapter 23, “Writing SAPIs and Extending the Zend Engine”Platforms and Versions
I. Implementation and Development Methodologies
1. Coding Styles
Choosing a Style That Is Right for YouCode Formatting and LayoutIndentationLine LengthUsing WhitespaceSQL GuidelinesControl Flow ConstructsUsing Braces in Control StructuresConsistently Using Bracesfor Versus while Versus foreachUsing break and continue to Control Flow in LoopsAvoiding Deeply Nested LoopsNaming SymbolsConstants and Truly Global VariablesLong-Lived VariablesTemporary VariablesMultiword NamesFunction NamesClass NamesMethod NamesNaming ConsistencyMatching Variable Names to Schema NamesAvoiding Confusing CodeAvoiding Using Short Open TagsAvoiding Using echo to Construct HTMLUsing Parentheses JudiciouslyDocumentationInline CommentsAPI DocumentationUsing phpDocumentorFurther Reading
2. Object-Oriented Programming Through Design Patterns
Introduction to OO ProgrammingInheritanceEncapsulationStatic (or Class) Attributes and MethodsSpecial MethodsA Brief Introduction to Design PatternsThe Adaptor PatternThe Template PatternPolymorphismInterfaces and Type HintsThe Factory PatternThe Singleton PatternOverloadingSPL and Iterators_ _call()_ _autoload()Further Reading

3. Error Handling
Handling ErrorsDisplaying ErrorsLogging ErrorsIgnoring ErrorsActing On ErrorsHandling External ErrorsExceptionsUsing Exception HierarchiesA Typed Exceptions ExampleCascading ExceptionsHandling Constructor FailureInstalling a Top-Level Exception HandlerData ValidationWhen to Use ExceptionsFurther Reading
4. Implementing with PHP: Templates and the Web
SmartyInstalling SmartyYour First Smarty Template: Hello World!Compiled Templates Under the HoodSmarty Control StructuresSmarty Functions and MoreCaching with SmartyAdvanced Smarty FeaturesWriting Your Own Template SolutionFurther Reading
5. Implementing with PHP: Standalone Scripts
Introduction to the PHP Command-Line Interface (CLI)Handling Input/Output (I/O)Parsing Command-Line ArgumentsCreating and Managing Child ProcessesClosing Shared ResourcesSharing VariablesCleaning Up After ChildrenSignalsSIGCHLDSIGALRMOther Common SignalsWriting DaemonsChanging the Working DirectoryGiving Up PrivilegesGuaranteeing ExclusivityCombining What You’ve Learned: Monitoring ServicesFurther Reading
6. Unit Testing
An Introduction to Unit TestingWriting Unit Tests for Automated Unit TestingWriting Your First Unit TestAdding Multiple TestsWriting Inline and Out-of-Line Unit TestsInline PackagingSeparate Test PackagingRunning Multiple Tests SimultaneouslyAdditional Features in PHPUnitCreating More Informative Error MessagesAdding More Test ConditionsUsing the setUp() and tearDown() MethodsAdding ListenersUsing Graphical InterfacesTest-Driven DesignThe Flesch Score CalculatorTesting the Word ClassBug Report 1Unit Testing in a Web EnvironmentFurther Reading
7. Managing the Development Environment
Change ControlCVS BasicsModifying FilesExamining Differences Between FilesHelping Multiple Developers Work on the Same ProjectSymbolic TagsBranchesMaintaining Development and Production EnvironmentsManaging PackagingPackaging and Pushing CodePackaging BinariesPackaging ApachePackaging PHPFurther Reading
8. Designing a Good API
Design for Refactoring and ExtensibilityEncapsulating Logic in FunctionsKeeping Classes and Functions SimpleNamespacingReducing CouplingDefensive CodingEstablishing Standard ConventionsUsing Sanitization TechniquesFurther Reading
II. Caching
9. External Performance Tunings
Language-Level TuningsCompiler CachesOptimizersHTTP AcceleratorsReverse ProxiesOperating System Tuning for High PerformanceProxy CachesCache-Friendly PHP ApplicationsContent CompressionFurther ReadingRFCsCompiler CachesProxy CachesContent Compression
10. Data Component Caching
Caching IssuesRecognizing Cacheable Data ComponentsChoosing the Right Strategy: Hand-Made or Prefab ClassesOutput BufferingIn-Memory CachingFlat-File CachesCache Size MaintenanceCache Concurrency and CoherencyDBM-Based CachingCache Concurrency and CoherencyCache Invalidation and ManagementShared Memory CachingCookie-Based CachingCache Size MaintenanceCache Concurrency and CoherencyIntegrating Caching into Application CodeCaching Home PagesUsing Apache’s mod_rewrite for Smarter CachingCaching Part of a PageImplementing a Query CacheFurther Reading
11. Computational Reuse
Introduction by Example: Fibonacci SequencesCaching Reused Data Inside a RequestCaching Reused Data Between RequestsComputational Reuse Inside PHPPCREsArray Counts and LengthsFurther Reading
III. Distributed Applications
12. Interacting with Databases
Understanding How Databases and Queries WorkQuery Introspection with EXPLAINFinding Queries to ProfileDatabase Access PatternsAd Hoc QueriesThe Active Record PatternThe Mapper PatternThe Integrated Mapper PatternTuning Database AccessLimiting the Result SetLazy InitializationFurther Reading
13. User Authentication and Session Security
Simple Authentication SchemesHTTP Basic AuthenticationQuery String MungingCookiesRegistering UsersProtecting PasswordsProtecting Passwords Against Social EngineeringMaintaining Authentication: Ensuring That You Are Still Talking to the Same PersonChecking That $_SERVER['REMOTE_IP'] Stays the SameEnsuring That $_SERVER['USER_AGENT'] Stays the SameUsing Unencrypted CookiesThings You Should DoUsing EncryptionUsing Expiration LogicExpiration on Every RequestExpiration After a Fixed TimeCollecting User Identity InformationCollecting Versioning InformationLogging OutA Sample Authentication ImplementationSingle SignonA Single Signon ImplementationFurther Reading
14. Session Handling
Client-Side SessionsImplementing Sessions via CookiesBuilding a Slightly Better MousetrapServer-Side SessionsTracking the Session IDNative Methods for Tracking the Session IDA Brief Introduction to PHP SessionsCustom Session Handler MethodsGarbage CollectionGarbage Collection in the files HandlerGarbage Collection in the mm HandlerGarbage Collection in the MySession HandlerChoosing Between Client-Side and Server-Side SessionsImplementing Native Session Handlers
15. Building a Distributed Environment
What Is a Cluster?Clustering Design EssentialsPlanning to FailWorking and Playing Well with OthersAlways Namespace Your FunctionsReference Services by Full Descriptive NamesNamespace Your System ResourcesDistributing Content to Your ClusterScaling HorizontallySpecialized ClustersCaching in a Distributed EnvironmentCentralized CachesFully Decentralized Caches Using SpreadScaling DatabasesWriting Applications to Use Master/Slave SetupsAlternatives to ReplicationAlternatives to RDBMS SystemsFurther Reading
16. RPC: Interacting with Remote Services
XML-RPCBuilding a Server: Implementing the MetaWeblog APIAuto-Discovery of XML-RPC ServicesSOAPWSDLRewriting system.load as a SOAP ServiceAmazon Web Services and Complex TypesGenerating Proxy CodeSOAP and XML-RPC ComparedFurther ReadingSOAPXML-RPCWeb LoggingPublicly Available Web Services
IV. Performance
17. Application Benchmarks: Testing an Entire Application
Passive Identification of BottlenecksLoad GeneratorsabhttperfThe Log-Based GeneratorThe Session SimulatorThe Realistic Data GeneratorDaiquiriFurther Reading
18. Profiling
What Is Needed in a PHP ProfilerA Smorgasbord of ProfilersInstalling and Using APDA Tracing ExampleProfiling a Larger ApplicationSpotting General InefficienciesRemoving Superfluous FunctionalityFurther Reading
19. Synthetic Benchmarks: Evaluating Code Blocks and Functions
Benchmarking BasicsBuilding a Benchmarking HarnessPEAR’s Benchmarking SuiteBuilding a Testing HarnessAdding Data Randomization on Every IterationRemoving Harness OverheadAdding Custom Timer InformationWriting Inline BenchmarksBenchmarking ExamplesMatching Characters at the Beginning of a StringMacro ExpansionsInterpolation Versus Concatenation
V. Extensibility
20. PHP and Zend Engine Internals
How the Zend Engine Works: Opcodes and Op ArraysVariablesFunctionsClassesThe Object HandlersObject CreationOther Important StructuresThe PHP Request Life CycleThe SAPI LayerThe PHP CoreThe PHP Extension APIThe Zend Extension APIHow All the Pieces Fit TogetherFurther Reading
21. Extending PHP: Part I
Extension BasicsCreating an Extension StubBuilding and Enabling ExtensionsUsing FunctionsA Function ExampleManaging Types and MemoryParsing StringsOther Return MacrosManipulating TypesType Testing Conversions and AccessorsUsing ResourcesReturning ErrorsUsing Module HooksModule Startup and ShutdownDefining ConstantsEnabling GlobalsParsing INI EntriesModule ShutdownRequest Startup and ShutdownRequest StartupRequest Shutdownphpinfo() RegistrationAn Example: The Spread Client WrapperMINITMSHUTDOWNModule FunctionsUsing the Spread ModuleFurther Reading
22. Extending PHP: Part II
Implementing ClassesCreating a New ClassAdding Properties to a ClassClass InheritanceAdding Methods to a ClassAdding Constructors to a ClassThrowing ExceptionsUsing Custom Objects and Private VariablesUsing Factory MethodsCreating and Implementing InterfacesWriting Custom Session HandlersThe Streams APIFurther Reading
23. Writing SAPIs and Extending the Zend Engine
SAPIsThe CGI SAPIThe CGI SAPI ApplicationThe Embed SAPISAPI Input FiltersModifying and Introspecting the Zend EngineWarnings as ExceptionsAn Opcode DumperAPDAPCUsing Zend Extension CallbacksHomework

Content preview from Advanced PHP Programming

Chapter 1. Coding Styles

	“Everything should be made as simple as possible, but not one bit simpler.”
	--Albert Einstein (1879–1955)

	“Seek simplicity, and distrust it.”
	--Alfred North Whitehead (1861–1947)

No matter what your proficiency level in PHP, no matter how familiar you are with the language internals or the idiosyncrasies of various functions or syntaxes, it is easy to write sloppy or obfuscated code. Hard-to-read code is difficult to maintain and debug. Poor coding style connotes a lack of professionalism.

If you were to stay at a job the rest of your life and no one else had to maintain your code, it would still not be acceptable to write poorly structured code. Troubleshooting and augmenting libraries that I wrote two or three years ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0672325616Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Advanced PHP Programming

by George Schlossnagle

Chapter 1. Coding Styles

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.