Advanced PHP

Advanced PHP Training in Kolkata

Prerequisite: Website Designing / development with HTML, CSS, JS, PHP & MySQL

Easing into the Fundamentals of Design Patterns

  1. PHP and Object-Oriented Programming
    • Entering into Intermediate and Advanced Programming
    • Why Object-Oriented Programming?
      • Making Problem-Solving Easier
      • Modularization
    • Classes and Objects
      • Single Responsibility Principle
      • Constructor Functions in PHP
    • The Client as a Requester Class
    • What About Speed?
      • The Speed of Development and Change
      • The Speed of Teams
    • What’s Wrong with Sequential and Procedural Programming?
      • Sequential Programming
      • Procedural Programming
  2. Basic Concepts in OOP
    • Abstraction
      • Abstract Classes
      • Abstract Properties and Methods
      • Interfaces
      • Interfaces and Constants
      • Type Hinting: Almost Data Typing
    • Encapsulation
      • Everyday Encapsulation
      • Protecting Encapsulation through Visibility
      • Getters and Setters
    • Inheritance
    • Polymorphism
      • One Name with Many Implementations
      • Built-In Polymorphism in Design Patterns
  3. Basic Design Pattern Concepts
    • The MVC Loosens and Refocuses Programming
    • Basic Principles of Design Patterns
      • The First Design Pattern Principle
      • Using Interface Data Types in Code Hinting
      • Abstract Classes and Their Interfaces
      • The Second Design Pattern Principle
      • Basic Composition Using a Client
      • Delegation: The IS-A and HAS-A Difference
    • Design Patterns as a Big Cheat Sheet
      • Organisation of Design Patterns
    • Choosing a Design Pattern
      • What Causes Redesign?
      • What Varies?
      • What Is the Difference Between Design Patterns and Frameworks?
  4. Using UMLs with Design Patterns
    • Why Unified Modeling Language (UML)?
    • Class Diagrams
    • Participant Symbols
    • Relationship Notations
      • Acquaintance Relations
      • Aggregation Relationship
      • Inheritance and Implementation Relations
      • Creates Relations
      • Multiple Relations
    • Object Diagrams
    • Interaction Diagrams
    • The Role of Diagrams and Notations in Object-Oriented Programming
    • Tools for UMLs

Creational Design Patterns

  1. Factory Method Design Pattern
    • What Is the Factory Method Pattern?
    • When to Use the Factory Method
    • A Minimalist Example
      • Factory Work
      • The Client
    • Accommodating Class Changes
      • Adding Graphic Elements
      • Coordinating Products
      • Changing the Text Product
      • Changing the Graphic Product
      • Adding New Products and Parameterized Requests
      • One Factory and Multiple Products
      • The New Factories
      • The New Products
      • The Client with Parameters
      • Helper Classes
      • File Diagram
      • Product Changes: Leave the Interface Alone!
  2. Prototype Design Pattern
    • What Is the Prototype Design Pattern?
    • When to Use the Prototype Pattern
    • The Clone Function
      • Constructor Does Not Relaunch with Clone
      • The Constructor Function Should Do No Real Work
    • A Minimalist Prototype Example
      • Studying Fruit Flies
    • Adding OOP to the Prototype
      • The Modern Business Organization
      • Encapsulation in the Interface
      • The Interface Implementations
      • The Organizational Client
      • Making Changes, Adding Features
      • Dynamic Object Instantiation
      • The Prototype in PHP Land

Structural Design Patterns

  1. The Adapter Pattern
    • What Is the Adapter Pattern?
    • When to Use the Adapter Pattern
    • The Adapter Pattern Using Inheritance
      • A Minimal Example of a Class Adapter: The Currency Exchange
    • The Adapter Pattern Using Composition
      • From Desktop to Mobile
      • Adapters and Change
  2. Decorator Design Pattern
    • What Is the Decorator Pattern?
    • When to Use the Decorator Pattern
    • Minimalist Decorator
      • The Component Interface
      • The Decorator Interface
      • Concrete Component
      • Concrete Decorators
      • The Client
    • What About Wrappers?
      • Primitives in Wrappers
      • Built-in Wrappers in PHP
      • Design Pattern Wrappers
    • Decorators with Multiple Components
      • Multiple Concrete Components
      • Concrete Decorators with Multiple States and Values
      • The Developer Dating Service
    • HTML User Interface (UI)
      • The Client Class Passing HTML Data
      • From a Variable Name to an Object Instance
      • Adding a Decoration

Behavioural Design Patterns

  1. The Template Method Pattern
    • What Is the Template Method Pattern?
    • When to Use the Template Method
    • Using the Template Method with Images and Captions: A Minimal Example
      • The Abstract Class
      • The Concrete Class
    • The Client
    • The Hollywood Principle
    • Using the Template Method with Other Design Patterns
      • The Client’s Reduced Workload
      • The Template Method Participants
    • The Factory Method Participants
    • The Hook in the Template Method Design Pattern
      • Setting Up the Hook
      • Implementing the Hook
      • The Client and Tripping the Hook
    • The Small and Mighty Template Method
  2. The State Design Pattern
    • What Is the State Pattern?
    • When to Use the State Pattern?
    • The State Machine
    • Light On, Light Off: The Minimal State Design Pattern
      • Context Is King
      • The States
      • The Client Request through the Context
    • Adding States
      • Changing the Interface
      • Changing the States
      • An Updated Client
    • The Navigator: More Choices and Cells
      • Setting Up a Matrix Statechart
      • Setting Up the Interface
      • The Context
      • The States
      • The Client Picks a Path
    • The State Pattern and PHP

MySQL and PHP Design Patterns

  1. A Universal Class for Connections and a Proxy Pattern for Security.
    • A Simple Interface and Class for MySQL
      • The Pregnant Interface
      • Universal MySQL Connection Class and Static Variables
      • Easy Client
    • The Protection Proxy for Login
      • Setting Up Login Registration
      • Implementing the Login Proxy
    • The Proxy and Real-World Security
  2. The Flexibility of the Strategy Design Pattern.
    • Encapsulating Algorithms
      • Differentiating the Strategy from the State Design Pattern
      • No Conditional Statements, Please
      • A Family of Algorithms
    • A Minimalist Strategy Pattern
      • The Client and the Trigger Scripts
      • The Context Class and Strategy Interface
      • The Concrete Strategies
    • Expanded Strategy Pattern with Data Security and Parameterized Algorithms
      • A Data Security Helper Class
      • Adding a Parameter to an Algorithm Method
      • The Survey Table
      • Data Entry Modules
      • The Client Calls for Help
      • The Minor but Major Change in Context Class
      • The Concrete Strategies
    • The Flexible Strategy Pattern
  3. The Chain of Responsibility Design Pattern
    • Passing the Buck
    • The Chain of Responsibility in a MySQL Help Desk
      • Building and Loading the Response Table
      • The Help Desk Chain of Responsibility
    • Automated Chain of Responsibility and Factory Method
      • The Chain of Responsibility and Date-Driven Requests
      • Factory Method Finishes Job
    • Ease of Update
  4. Building a Multidevice CMS with the Observer Pattern
    • Built-In Observer Interfaces
    • When to Use the Observer Pattern
    • Using SPL with the Observer Pattern
      • SplSubject
      • SplObserver
      • SplObjectStorage
      • The SPL Concrete Subject
      • The SPL Concrete Observer
      • The SPL Client
    • Free Range PHP and the Observer Pattern
      • The Abstract Subject Class and ConcreteSubject Implementation
      • Observer and Multiple Concrete Observers
      • The Client
    • Making a Simple CMS
      • CMS Utilities
      • The Multiple Device Observer
    • Thinking OOP
  5. Framework Learning With Symfony / Laravel
    1. Create Project with Framework
    2. Develop a  small project