Introduction
Thesaurus
Authors
Brands
$HTTP_RAW_POST_DATA
$_FILES
$_COOKIE
$_ENV
$_GET
$_POST
$_REQUEST
$_SERVER
$argc
$argv
$GLOBALS
$http_response_header
$php_errormsg
$this
__autoload
__call() Method
__callStatic() Method
__CLASS__
__clone() Method
__debugInfo() Method
__DIR__
__FILE__
__FUNCTION__
__get() Method
__halt_compiler()
__invoke() Method
__isset() Method
__LINE__
__METHOD__
__serialize() Method
__set() Method
__set_state() Method
__sleep() Method
__toString() Method
__TRAIT__
__unserialize() Method
__unset() Method
__wakeup() Method
abs()
Absolute Name
Absolute Value
Absolute
Abstract Class
Abstract Factory
Abstract Method
Abstract Keyword
Abstraction Layer
Abstraction
Acceptance Test
Accessibility
Accountability
ACID
Access Control List (ACL)
Active Record
Actor Model
Adapters
Addition
Architectural Decision Record (ADR)
Agile
Artificial Intelligence (AI)
AJAX
Algebraic Data Type
Algorithm
Algorithmic Complexity
Alias Types
Alias
Allow Dynamic Properties
Application-Layer Protocol Negotiation (ALPN)
Alternative Syntax
Asynchronous Markup Protocol (AMP)
Analysis
Anchor
And Operator
Anemic Domain Model
Annotations
Anonymize
Anonymous Catch
Anonymous Class
Anonymous Constant
Anonymous Function
Anonymous
Anti-Pattern
ANTLR4
Ahead Of Time
APCu
API Gateway
Application Programming Interface (API)
Application Performance Management (APM)
Application Server
Appeasement Pattern
Array Append
Application
Arbitrary Number Of Argument
Arcane
Architecture
Archive
Argon2
Argument
ArgumentCountError
ArithmeticError Error
Arity
Arm
Callable Arrays
Array Callback
Array With Curly Braces
Array Dot Notation
Array Element
Array Shape
Array Spread
Array Syntax
Array Zip
Array, []
array_column
array_combine()
array_diff()
array_diff_assoc()
array_diff_key()
array_fill()
array_filter()
array_find()
array_find_key()
array_intersect()
array_intersect_assoc()
array_intersect_key()
array_is_list()
array_key_exists()
array_key_first()
array_keys()
array_map()
array_merge()
array_pad()
array_pop()
array_push()
array_search
array_shift()
array_slice()
array_splice()
array_unique()
array_unshift()
array_values()
array_walk()
ArrayAccess
ArrayObject
Arrow Functions
Artifact
As
American Standard Code for Information Interchange (ASCII)
Aspect-Oriented
Aspect Oriented Programming
Assertions
AssertionError
Asset
Assignation
Associative Array
Assumption
Abstract Syntactic Tree (AST)
Asymmetric Cryptography
Asymmetric Property
Asymmetric Visibility
Async
Asynchronous
Atomic Operation
Attack Surface
Attack
Attribute Class
Attribute
Audit Trail
Audit
Authentication
Authorize
Auto-Increment
Preappend File Directive
Autocompletion
Class Autoloading
Automagic
Automatic Index
Autovivification
Autowiring
Availability
Backslash \
Backed Enum
Backed Property
Backed
BackedEnum
Backend
Backoff
Back-tick
Backtrace
Backward Compatible
Backward Incompatible
BadFunctioncallException
Balanced
Bang !
Base Class
Base
Base 64 Encoding
basename()
Batch
Bcmath
Behavior
Benchmarking
Best Practices
Big-o-notation
Binary Integer
Binary Not Operator
Binary Operator
Binary
Bind
Bitfield
Bitmask
Bitshift Operators
Bitwise Operators
Black Box Testing
Blade
Blast Radius
Blind Variable
Block
Blocking Wait
Bloom Filter
Body
Boilerplate
Broken Object Level Authorization (BOLA)
Boolean
Bootstrap
Ownership
Bottleneck
Bracket
Bracketless
Branch
Breach
Breadth-First Search
Break
Broken Access Control
Brownfield
browscap
Browser
Bucket
Bug
Build
Bulkhead
Business Logic
Passing By Reference
Passing By Value
Byte
bzip2 Extension
C10K
C2 Framework
Cache Stampede
Cache Warming
Cache
Calendar
Object Calisthenics
Call Graph
Call
Callables
Callbacks
Callstack
Camel Case
Canary
Cancellation
Canonical
CAP Theorem
CAPTCHA
Carriage Return
Cascading Failure
Cascading
Case Sensitivity
Case
Cast Operator
Catch
Catchable Fatal Error
Continuous Delivery (CD)
Content Delivery Network (CDN)
Centralization
Common Gateway Interface (CGI)
Chaining Assignation
Chaining New Without Parenthesis
Chaining
Change Data Capture
Channel
Chaos Engineering
Character
Cheat Sheet
Checksum
Child Class
Continuous Integration (CI)
Circuit Breaker
Circular Reference
Class Interface Trait Enumeration (CITE)
Class Aliases
Class Constant Syntax
Class Constants Visibility
Static Constant
Class Entities
Class Hierarchy
Class Hoisting
Class Invasion
Class Operator
Class
class_alias()
class_implements()
Clean Architecture
Clean Code
Command Line Interface (CLI)
Client
Clock
Clone
Close Naming
Close Tag
Closed Source
ClosedGeneratorException
Closure Binding
Closure Class
Closure
Cloud
Content Management System (CMS)
Coalesce Operator
Code Architecture
Code Coverage
Code Formatter
Coding Formatting
Code Freeze
Code Generation
Code Generator
Code Injection
Code Reuse
Code Review
Code Smell
Codepoint
Coding Conventions
Type Coercion
Cognitive Complexity
Cohesion
Cold Cache
Cold Start
Collation
Collection
Collision
Colon
Column Database
Comma
Command Bus
Command
Comments
Commit
Community
Compact Array
compact()
Comparison
Compatibility
Compensation Logic
Compile-time Evaluation
Compile Time
Compile
Compiler
Complexity
Compliance
Component
Composer
composer.json
composer.lock
Composite Type
Composition
Compression
Computed Property
Concatenation .
Concatenative
Concrete Method
Concrete Class
Concurrency
Condition
Conditional Structures
Conditional
Conditioned Structures
Configuration
Connection Pool
Connection
Connexion Persistence
Consistency
Const
Constant Case
Constant Combination
Constant Expression
constant()
Constants In Trait
Constant Scalar Expression
Constants
Constraint
Constructor
Container Orchestration
Container
Continuation
Continue
Design By Contract (DBC)
Contribution
Control Flow Analysis
Control Flow Graph (CFG)
Control Flow
Control Structures
Controller
Convention
Convert
Cookie
Copy On Write (COW)
Core
Coroutine
Correlation ID
count()
Countable Interface
Coupling
Coverage
Command Query Responsibility Segregation (CQRS)
Crack
Cyclic Redundancy Check 32-bit (CRC32)
CRLF Injection
Cron
Cross-cutting Concerns
Create, Read, Update And Delete (CRUD)
To Crypt
Cryptography
Content Security Policy (CSP)
Cross Site Request Forgery (CSRF)
CSS
CSV Injection
Comma Separated Values (CSV)
Capture The Flag (CTF)
Ctype
Client URL (CURL)
Curly Brackets
Currying
Custom Function
Custom
Common Vulnerabilities And Exposures (CVE)
Concurent Version System (CVS)
Cyclomatic Complexity
Dangling Reference
Data Access Object (DAO)
Data Container
Data Flow Analysis (DFA)
Data Hiding
Data Leak
Data Mapper
Data
Database Commit
Database
Dataset
Datastack
Data Structure
Dates
DateInterval
Datetime Trap
DateTime
DateTimeInterface
Days Are Not 86400 Seconds
Days In Month
Database Abstraction Layer (DBA) Extension
Database Abstraction Layer (DBAL)
Domain Design Driven (DDD)
Distributed Denial Of Service (DDOS)
Dead Code
Deadline
Technical Debt
Debug
debug_backtrace()
Debugger
decbin()
Declaration
Declarative Programming
declare Encoding
declare()
Decode
Decorator Pattern
Decoupling
To Decrypt
Deduplication
Deep Clone
Default Parameter
Default Value
Default
default_charset
Defensive Programming
Defer Statement
define()
defined()
Definition
delayedtargetvalidation
Delimiter
Dependency Injection Container
Dependency Injection
Dependency Inversion (DIP)
Dependency
Dependent Type
Deployment
Deprecated
Deprecation
Depth-First Search
Depth
Deque
Dereferencing
Design Pattern
Desktop Application
Destructor
Destructuring
Determinism
Deterministic
DevOps
Dictionary
Diff
Digital Signature
Dir
Direct Output
Directives
DIRECTORY_SEPARATOR
DirectoryIterator
dirname
Disable Classes
Disable Functions
Disable
display_errors
Distributed Monolith
Distributed State
Distributed Systems
Distributed Tracing
Distributed Transactions
Distributed
Division
DivisionByZeroError
Disjunctive Normal Form (DNF)
Domain Name System (DNS)
Do While
Docblock
Docker Container
Docker Image
Docker
Doctrine
Document Database
Documentation
Dog Fooding
Dollar $
Document Object Model (DOM)
Domain Name
Domain
DomainException
DOMChildNode
DOMParentNode
DOM
. Directory
Dot-dot Directory ..
. File
Dot Notation
Double Arrow
Double Check
Double Quotes Strings
Double
Downtime
Drop-in
Don't Repeat Yourself (DRY)
Data Structure
Data Source Name (DSN)
Data Transfer Object (DTO)
Duck Typing
Duplicate
Dynamic Call
Dynamic Class Constant
Dynamic Class
Dynamic Constant
Dynamic Expression
Dynamic Loading
Dynamic Method
Dynamic Properties
Dynamic Variable
Dynamic
E
each
Early Binding
Echo Tag
Echo
Ecosystem
Edge Case
Edge Computing
Edge Triggered
Effect System
Egress Filtering
Elephpant
Ellipsis
Email
Embed
Embeddings
Emoji
Empty String
Empty
Enable
Encapsulation
Encode
Text Encoding
Encoding
End To End Test
PHP Engine
Entities
Enumeration Case
Enumeration (enum)
.env File
Environment Variables
Environment
Eponymous
Equal Operator
Error Handler
Error Handling
Error Reporting
Error Suppression
Error
Error_log()
Error Reporting
Escape Character
Escape Data
HTML Escaping
Escape Sequences
escapeshellarg()
escapeshellcmd()
Extract, Transform, Load (ETL)
Eval()
Event Driven
Event Loop
Event Replay
Event Sourcing
Event Store
Event Storming
Event Streaming
Eventual Consistency
Chaining Exceptions
Exception Handler
Exception
Excimer
exec
Execution Path
Execution Time
Execution
execve()
Exhaustiveness
EXIF (Exchangeable Image File Format)
Existence
Existential Type
Exit
Explanation
Explicit Boolean Comparison
Explicit
explode()
Exponent
Exponential
expose_php
Expression
Expressive Interface
extends
Extension Method
Extensions
extract()
Function-as-a-Service (FaaS)
Facade
Factory
Faker
Fallback Function
Fallback To Global
Fallback
Switch Fallthrough
False
Falsy
Fast Artificial Neural Network (FANN)
FastCGI
Fat Controller
Fat
Fatal Error
Fault Isolation
fclose()
Feature Detection
Feature Flag
Feature Testing
Feature
Foreign Function Interface (FFI)
fgetc()
fgets()
Fibers
First In, First Out (FIFO)
File Extension
File Mode
File
file_get_contents()
file_put_contents()
File System
FileSystemIterator
filter
Filter_var()
Final Class Constants
Final Keyword
Finally
finfo
Fingerprint
Finite State Machine (FSM)
Fire-and-forget
Firewall
First Class Callable
First-Class Module
Fixture
Flag
Flame Graph
Flexibility
Floating Point Numbers
Fluent Interface
fnmatch()
Folklore
Footgun
fopen()
For
foreach()
Foreign Key (FK)
Form
Format
Forum
Forward Compatible
Fossilized Methods
FastCGI Process Manager (FPM)
Framework
fread()
Free
Front-end
fseek()
ftell()
File Transfer Protocol (FTP)
File Transfer Protocol Secure (FTPS)
Fully Qualified Name
func_get_args()
Function Subscripting
Functions
Functional Programming (FP)
Functional Test
Functor
Future
Fuzzing
fwrite()
Generalized Algebraic Data Type (GADT)
Garbage Collection
Graphic Draw (GD)
Gearman
Generative Engine Optimization (GEO)
Generator
Generics
GeoIP
Geolocation
get_browser()
get_class()
get_class_vars()
get_object_vars()
getenv()
Class Getter Method
gettext Extension
gettype()
Ghost Object
Graphics Interchange Format (GIF)
Git Hook
git
glob()
Global Code
Global Space
Global State
Global Variables
global Scope
Glue
GNU Multiple Precision (GMP)
God Object
Golf
Goto
Gradual Type Checking
Gradual Typing
Grammar
Graph Database
Graph
GraphQL
Greenfield
Green Thread
Green
gRPC (Google Remote Procedure Call)
Habit
Handle
PHP Handlers
Hard Coded
Hardening
Hash #
Hash Comparisons
Cryptographic Hash
hash() Function
Hash Table Attack
Hash Table
Hash
hash_equals()
Hashing
Haystack
Headers
Headless
Heredocs
Heuristics
Hexadecimal Integer
Hexagonal Architecture
hg
Hidden State
Higher-Kinded Type
HMAC
Hoisting
Homoiconicity
Honey Pot
Hook
Horizontal Scaling
Hosting
Hot Cache
hrtime()
.htaccess
HTML Entities
HTML Entity
HyperText Markup Language (HTML)
html_entity_decode
html_errors
htmlentities()
HTMLPurifier
htmlspecialchars
HTTP/3
HTTP Code
HTTP Encoding
HTTP Headers
HTTP Request Headers
HTTP Method
Hyper Text Transfer Protocol (HTTP)
http_build_query()
Hyper Text Transfer Protocol Secure (HTTPS)
Hydratation
Hygienic Macro
hypot()
IaaS
Infrastructure as Code (IaC)
Iconv
Integrated Environment of Development (IDE)
Idempotent
Identical Operator
Identification
Identifier
Identity Comparison
Identity
Idiomatic
Insecure Direct Object Reference (IDOR)
If Then Else
Iffectation
Ignored Catch
Image Injection
Image
imagick
ImagickException
ImagickPixelException
IMAP
Immutable
Imperative Programming
Implementation-Defined Behavior
implements
Implicit State
Implicit
implode()
Import
Impure Function
in_array()
include
include_path
Inclusion Hell
Incoming Data
Inconsistent
Increment
Indentation
Index For Arrays
Index For SQL
Index
Indexed Array
Indirect Reference Map
Inequality
INF
Infinite Loop
Infinite
InfiniteIterator
Inflector
Inheritance
Inherited Variable
INI
ini_set()
Initialisation
Injection
Inline Assembly
Inlining
Insecure Deserialization
Installation
instance
instanceof
Insteadof
Instruction
intdiv()
integer
Integration Test
Interface
Internals
Internationalization
Internet
Interoperability
Interpolation
Interpreted
Intersection Type
Internationalization Functions
Introspection
InvalidArgumentException
Type Invariant
Code Inventory
Invoke
Internet of Things (IoT)
Internet Protocol (IP)
is_a()
is_array()
is_bool()
is_float()
is_int()
is_iterable()
is_numeric()
is_object()
is_string()
Interface Segregation Principle (ISP)
Isset
Iterable
Iterator
iterator_to_array()
IteratorAggregate
Javascript
Just In Time (JIT)
Jitter
Jobqueue
JPEG
JSON-LD
JavaScript Object Notation (JSON)
json_decode()
json_encode()
JSON Lines (JSONC)
JsonException
JSON Lines (JSONL)
JsonSerializable
Jump
JSON Web Token (JWT)
Key-value Stores
Keyword
KISS
Kubernetes
Goto Labels
Linux Apache Mysql PHP (LAMP)
Language Construct
Language Server Protocol (LSP)
Laravel
Late Static Binding
Latency
Latin1
Layered Architecture
Lazy Evaluation
Lazy Loading
Lazy Objects
LDAP Injection
Lightweight Directory Access Protocol (LDAP)
Leading Numeric String
Leading Zero Means Octal
Leak
Legacy
Linux Nginx Mysql PHP (LEMP)
LengthException
Letter Logical Bug
Lexical Analysis
Lexical Variable
Library Loading
Library
libsodium
Licence
Lifecycle
Last In, First Out (LIFO)
Line Feed
Linear Type
Link
Lint, Won't Execute
Linting
Liskov Substitution Principle (LSP)
List Comprehension
List
Listener
Literal Types
Literal
Large Language Model (LLM)
Load Balancer
Local File Inclusion
Local Variable
Local Scope
Locale
Lock
Log File
Log
Logarithm
Logical Operators
LogicException
Look-up
Loops
Lossless
Lossy
LSP
Lvalue
Machine Learning
Macro
Magento
Magic Bytes
Magic Constants
Magic Hash
Magic Code
Magic Methods
Magic Numbers
Magic Property
Magic Values
Magic
Mail
Maintenability
Maintenance
Makefile
Man In The Middle
Map
Markdown
Marker Interface
Marketplace
Mass Assignment
Mass
Match
Math
max_execution_time
max_input_vars
max_memory_limit
Multibyte String
Model Context Protocol (MCP)
mcrypt Extension
Message Digest Algorithm 5 (MD5)
Memcached
Memoization
Memory Arena
Memory Leak
Memory
memory_limit
Merge
Message Bus
Message Digest
Message Queue
Meta-object Protocol (MOP)
Metaclass
Metadata
Metaprogramming
Method Collision
Method Compatibility
Method Overloading
Method Signature
Method
Methodcall
Metrics
Multi-Factor Authentication (MFA)
Micro-optimisation
Micro-second
Micro-framework
Microservice
microtime()
Middleware Pattern
Migration
Minification
Minus One -1
Minus -
Missing Subpattern
Missing Validation
Mixed
Mixin
Mobile Application
Mock
Model
Modifier
Module System with Explicit Exports
Module
Modulo
Monad
Monetary Formatting
MongoDB
Monitoring
Monkey Patch
Monolith
Monomorphization
Monotonic
Move Semantics
move_uploaded_file()
Method Resolution Order (MRO)
Multi-byte
Multi-pass Algorithm
Multidimensional Array
Multiple Dispatch
Multiple Return Values
Multiplication
Multithreading
Multiton
Mutability
Mutation Testing
Mutex
Model - View - Controller (MVC)
Minimum Viable Product (MVP)
MySQL
mysqli
mysqli_sql_exception
N+1 Query Problem
Name Conventions
Name
Named Constructors
Named Parameters
Named Return Values
Named Type
Namespace Alias
Namespace Name
Namespaces
Namespaced Name
Naming Conflict
Naming
Not A Number (NAN)
PHP Natives
Native
NativePHP
Needle
Negative Index
Nested Attributes
Nesting
Network
Neural Network
Neutral Element
Never Type
New In Initializers
New Line
New Without Parenthesis
new
The Nines (Availability)
NoDiscard
Nominal Type
Non-blocking
Non Breakable Spaces
Non-instantiable
Non-numeric
Non-static
Nonce
Noop
Normalisation
@, No Scream Operator
Nosql Database
Not Operator
Notice
Nowdocs
Null Byte
Null
Nullable
Null Pattern
Null Safe Object Operator
Nullsafe
Number
Numeric Base
Numeric Separator
Numeric String
Numeronym
OAuth
Obfuscation
Object API
Object Injection
Object Invasion
Object Lifecycle
Object Nullsafe Operator ?->
Object Operator ->
Object Persistence
Object Syntax
Object Type
Object
Oblic Quotes
Observer Pattern
Observer Design Pattern
Open Closed Principle (OCP)
Octal Integer
Offensive Programming
Offset
Open Knowledge Graph (OKG)
On Premise Software
One Liner
One-shot
one
Onion Architecture
OOP (Object Oriented Programming)
OPcache Preloading
Opcache
Opcode Specialisation
Opcode
Open Class
Open Data
Open Source
Open Tag
open_basedir
OpenID Connect (OIDC)
OpenSSL
OpenSwoole
OpenTelemetry
Operand
Operator Overloading
Operator Precedence
Operators
Opinionated
Optimisation
Option Type
Option
Optional Parameter
Oracle
Order Of Execution
Object Relational Mapping (ORM)
OSI Model
One-Time Password (OTP)
OuterIterator
Outgoing Data
OutOfRangeException
Output Buffering
Over-engineer
Overflow
OverflowException
Overloading
Override Attribute
Overriding
Overwrite
OWASP
Peer-to-Peer (P2P)
PaaS
pack
Package Manager
Package-Level
Packagist
Pagination
Pair
Paradigm
Parallel
Parameter Removal
Parameter
parent
Parenthesis
Parquet
Parse
parse_ini_file()
parse_str()
parse_url()
ParseError
Parser
Partial Application
Partial Function
Pascal Case
Passphrase
Password API
Password
Path Traversal
Path
Pattern-Based Analysis
Pattern Matching
Pattern
Pay-as-you-go
Payload
Process Control (pcntl)
pcntl_signal()
PCOV
Perl Compatible Regular Expressions (PCRE)
PDF
PHP Data Objects (PDO)
PDOException
Product Requirements Document (PDR)
PEAR
PHP Extension C Library (PECL)
Penetration Test
Percentile
Performance
Permission
Persistence
PostgreSQL
Phantom Type
Phar
PharException
PHP AI Editor
PHP Native Attributes
PHP Constants
PHP Docker Container
PHP Editor
PHP Extensions
Framework Interoperability Group (FIG)
php://filter
PHP Foundation
PHP Native Function
PHP Group
php://input
PHP Native Interfaces
PHP Manual
php://memory
PHP Native Attribute
php://output
PHP RFC
PHP Runtime
PHP Tags
php://tmp
PHP User Groups
PHP Variables
PHP Wrappers
PHP, Hypertext Preprocessor (PHP)
php.ini
PHP_EOL
PHP_INT_MAX
PHP_INT_MIN
PHPdoc
phpinfo()
PHPStan
Phptoken
PHPunit
PHP Installer For Extensions (PIE)
Pipe Operator |>
Pipe |, The Logical Operator
Pipeline
Plain Text
Plugin
Plus +
Portable Network Graphics (PNG)
Pointer
Poisoned Pipeline Execution (PPE)
Polling
Polyfill
Polyglot
Polymorphism
Pop
Plain Old PHP Object (POPO)
Port
Portability
Ports And Adapters
Positional Parameters
Positive Integer
Post-increment
Pound #
Pull Request (PR)
Pre-increment
Precedence
precision
Predefined Constants
PHP Predefined Exception
Prefix
Preg_match
preg_replace()
preg_split()
Premature Optimization
Prepared Query
Array Prepend
Preprocessing
Primary Key
Primitive Obsession
Print
print_r()
printf()
Privacy
Private Visibility
PRNG
Procedural Programming
Process
Production
PHP Profiler
Profiling
Program To Interface
Promise
Promoted Properties
Propagation
Property-Based Testing
Property Hook
Properties
Proprietary Source
Protected Visibility
Protocol Buffers
Protocol
Prototype
Proxy Class
Proxy
Psalm
Pseudo-type
Pseudo-variable
Pseudonymisation
PHP Standards Recommendations (PSR)
Public Visibility
Pub/Sub
Pure Function
Progressive Web App
Quality of Service (QoS)
Quality
Query String
Query
Question Mark ?
Queue
QUIC
Quine
Quoted Printable
Race Condition
RACI Model
Retrieval Augmented Generation (RAG)
Railroad Programming
Rainbow Table
Random Access
Random
Random\CryptoSafeEngine
Random\Engine
Range Type
range()
RangeException
Rate Limiting
Role Based Access Control (RBAC)
Remote Code Execution (RCE)
Relational DataBase Management System (RDBMS)
RDF Triple Store
RDF (Resource Description Framework)
RdKafka
ReactPHP
Readability
Readable
Reading
Readline
Readonly
Real Time
Real Numbers
Record Type
Rector
Recursion
Recursive Array
RecursiveArrayIterator
RecursiveDirectoryIterator
RecursiveIterator
RecursiveTreeIterator
Red-Green-Refactor
Redirect
Redis
Refactoring
Reference Count
References
Referential Integrity
Refinement Type
Reflection
ReflectionException
Reflector
Regular Expression
Regexploit
Register Globals
register_argc_argv
Registry
Regression
Relative Name
Relative Types
Relative
Relaxed Comparison
Relaxed Keywords
Relaxed Syntax
Relay Function
Release
Reliability
Render
Renderer
Read Eval Print Loop (REPL)
Replay
Request-Response
Request
Reserved Names
Resilience
Resource Leak
resource
Responsability
Response
REST API
Result Type
Retry
Return Carriage
Return Type
Return Value
Return
Return Type Will Change
Reverse Regex
Revision
rewind()
RFC
Request For Change (RFC)
Reserved For Future Use (RFU)
RGB
Rich Domain Model
Rich Text
Rigidity
robots.txt
Rollback
Rounding
Route
Row Polymorphism
Remote Procedure Call (RPC)
RSA
Rubber Ducking Debugging
Runtime Checks
RuntimeException
Software-as-a-Service (SAAS)
Security Assertion Markup Language (SAML)
Sandbox
Sanitation
Server Application Programming Interface (SAPI)
Static Application Security Testing (SAST)
Software Bill Of Material (SBOM)
Static Code Analysis (SCA)
Scaffolding
Scalar Types
Scaling
Schema
Scheme
Scope Resolution Operator ::
Scope
Software Development Kit (SDK)
Software Development Life Cycle (SDLC)
Sealed Class
Search Engine
Second Order SQL Injection
Secret
Security
SeekableIterator
Segmentation Fault
Self-documenting
Self-reference
Self
Semaphore
Semantic Analysis
Semantic Versioning
Semantics
Semicolon ;
Sensitive Parameter
Sentinel
Search Engine Optimization (SEO)
Separation Of Concerns
Separator
Sequence
Serde
Serializable
Serialization
serialize_precision
Server Architecture
Server
Serverless
Service Container
Service Discovery
Service Mesh
Service Registry
Service
Session Fixation
Session Hijacking
Session
SessionHandlerInterface
SessionIdInterface
SessionUpdateTimestampHandlerInterface
Set
set_error_handler()
setlocale
Class Setter Method
Secure Hash Algorithm (SHA)
Shallow Clone
Shard
Shared Database
Shared Memory
Shared-Nothing Architecture
Shared
Shell Exec
Shell Injection
Shell
shell_exec()
Ship
Shared Memory Operations (SHMOP)
Short Assignations
Short Syntax
Short Tags
Short Ternary Operator
short_open_tag
Shutdown Function
Shutdown
Side Effect
Sign
Signature
Signed Integer
Silent Behavior
Simple Switch
SimpleXML
Single Quotes Strings
Single
Singleton
sitemap
Service Level Agreement (SLA)
Slash /
sleep
Slim
Slug
Smart Cast
Simple Mail Transfer Protocol (SMTP)
Snake Case
Snapshot
Simple Network Management Protocol (SNMP)
SNMP3
Service-Oriented Architecture (SOA)
Simple Object Access Protocol (SOAP)
Socket
Soft Delete
Software Transactional Memory (STM)
SOLID
Sort
State of the Art (SOTA)
Source Of Truth
Source Code
Single Page Application (SPA)
Space
Spaceship Operator
SPARQL
Special Constant
Special Types
Specification
Spiral
Standard PHP Library (SPL)
SplDoublyLinkedList
SplFileInfo
SplFileObject
SplObjectStorage
SplObserver
SplStack
SplStorageObjects
SplSubject
sprintf
Spy
Sqids
SQL Database
SQL Injection
Structured Query Language (SQL)
SQLite3
sqrt()
Square Brackets
Single Responsability Principle (SRP)
Static Single Assignment Form (SSA)
sscanf()
Server Sent Event (SSE)
Secure Shell (SSH)
SSH2
Secure Sockets Layer (SSL)
Single Sign On (SSO)
Server-Side Request Forgery (SSRF)
Stack
Stale-While-Revalidate
Standalone Types
Standard
Star *
State
Stateful
Stateless
Statement
Static Call
Static Class
Static Expression
Static Method
Static Property
Static Variables
static
stdclass
STDOUT
Stealth Generator
Steganography
Storage Systems
Stored XSS
str_contains()
str_ends_with()
str_replace()
str_starts_with()
Strategy
Stream
Streamable
Streaming Database
Streamlining
Strict Comparison
Strict
strict_types
String Increment
String Interpolation
String
Stringable
Strpos() Syndrome
strpos
strtolower()
strtoupper()
strtr()
Struct Type
Structural Pattern Matching
Structural Typing
Structure
Stubs Files
Sub (prefix)
Subclass
Subnamespaces
substr()
subtype
Suffix
Sum Type
Sunsetting
Superglobal Variables
supertype
Supply Chain Attack
Supply Chain
Surrogate Key
Scalable Vector Graphics (SVG)
Support Vector Machine (SVM)
SVMException
SVN
Swagger
Swap
Switch Case
Switch Default
Switch
Swoole
Symbolic Analysis
Symfony
Synchronous
Syntax Error
Syntax
System Call
System Event
System
Tabulation
Taint Analysis
Tarpit
Task Runner
Task
Total Cost Of Ownership (TCO)
TCP
Tech Island
Tech Silo
Technical Reference
Telemetry
Tempest
Template Metaprogramming (TMP)
Template
Temporal Replay
Temporary Expression
Temporary
Ternary Operator
Test Data Provider
Test-Driven Development
Test Framework
Test Impact Analysis
Test Pyramid
Test
Testable
TestDox
Text
Thin Method
Thin
Thread
Three Dots
Throughput
throw
Throwable
Tick
Tilde ~
Time Travel
Timeout
Timing Attack
Transport Layer Security (TLS)
Time Of Check To Time Of Use (TOCTOU)
TODO
Token
Tokenizer
Tom's Obvious Minimal Language (TOML)
Tool
Token Oriented Object Notation (TOON)
Trace
Trailing Comma
Trait
Transaction
Transpile
Traversable
Traversal
Tree
Treemap
trigger_error()
trim
Triple
Troubleshoot
True
Truthy
Try-catch
Time To Live (TTL)
Terminal User Interface (TUI)
Tuple
Tutorial
Twig
Type Checking
Type Class
Contravariance
Covariance
Type Coverage
Property Type Declaration
Types Erasure
Type Inference
Type Juggling
Type Narrowing
Type Parametricity
Type System
Type Widening
Type System
Typed Constant
Typed Property
TypeError
Type Error
Typo
User Datagram Protocol (UDP)
Universally Unique Lexicographically Sortable Identifier (ULID)
Unary Operator
Unbacked Enum
Undefined Behavior
Undefined
Underflow
Underscore
UnexpectedValueException
UnhandledMatchError
Unicode
Uninitialized
Union Type
Unique Identifier
Unique (disambiguation)
Unit Test
UnitEnum
Unpacking
Unreachable Code
Unserialization
unset()
Unspecified Behavior
Unused
User Operations For Zend (UOPZ)
Upgrade
File Upload
URI Class
URI Extension
Universal Resource Identifier (URI)
Universal Resource Locator (URL)
Use Alias
Use In Traits
Use
Used
Useless
User-Agent
Userland
UTF-8
UUencode Encoding
Universally Unique IDentifier (UUID)
Validation
Value Object
Value Type
Value
ValueError
Vanilla PHP
Var
var_dump()
var_export()
Variable Arguments
Variable Scope
Variable Shadowing
Variable Variables
Variables
variable_order
Variadic
VCS Commit
Version Control System (VCS)
Vector Database
Vendor Lock-in
Version
Vertical Scaling
View In Presentation
SQL Views
View
Virtual Machine (VM)
Virtual Property
Visibility
Visual Debt
Value Object (VO)
(void) Cast
Void
Vulnerability
World Wide Web Consortium (W3C)
Write-Ahead Logging (WAL)
Warning
Waterfall
Weak Cryptography
Weak References
Weakmap
Web Application
Web-spider
World Wide Web (WWW)
Webhook
Web Real-Time Communication (WebRTC)
Webscraping
Webserver
Webshell
Websocket
Write Everything Twice (WET)
Web Hypertext Application Technology Working Group (WHATWG)
While
White Box Testing
Whitespace
WHM (WebHost Manager)
Wiki
Wildcard
Class Wither Method
Word Combination
Worker
Workflow
Worktree
Design Pattern Wrapper
file://
ftp://
http://
Wrapper Pattern
php://
Stream Wrapper
Wrapper
Writable
Write Context
Writeable
Writing
Xdebug
XHProf
XML Database
Extensible Markup Language (XML)
XMLReader
XMLwriter
XSS Payload
Cross Site Scripting (XSS)
XXTEA
You Are Not Going To Need It (YAGNI)
YAML Ain't Markup Language (YAML)
yield from Keyword
Yield Generator
Yield
Yoda Condition
zend.assertions
Zend Engine
Zero-code
Zero Cost
Zero Day Vulnerability
zero
zip Extension
zlib extension
Zombie Code
Zval
Annex