Advanced PHP

Course Duration: 3 months
Class Type: Online / Offline

Shibaji Debnath

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

Course Duration: 3 Months

Class Type: Online

Fees Rs. 16,000/-

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. Dependency Managment / Composer Handling.
    1. What id Dependency?
    2. Why required dependencies.
    3. How to setup basic dependency.
    4. Dependency managed by Composer.
    5. What is Composer?
    6. Composer Setup.
    7. Composer Project Buildings.
  6. PHP UnitTesting:
    1. What is UnitTesting?
    2. Why use UnitTest in PHP?
    3. Quality Assurance.
    4. Automation Testing.
    5. Utility Testing.
    6. Manual Testing.
  7. Framework Learning With Symfony / Laravel
    1. Create Project with Framework
    2. Develop a  small project

Call Now