DEV Community: Nima jahan bakhshian

PHP CLI SAPI

Nima jahan bakhshian — Sun, 11 Oct 2026 22:35:27 +0000

Introduction

PHP is a general-purpose scripting language mainly known for web development.
However, PHP code does not run on its own. The Zend Engine compiles and
executes code, yet it still needs a host layer that feeds it the script, collects the output, and describes the environment. That layer is called a SAPI (Server Application Programming Interface).

PHP can run in different environments, and each one has its own SAPI:

cli -> Command line
fpm-fcgi -> PHP-FPM (FastCGI Process Manager)
cgi-fcgi -> CGI / FastCGI
apache2handler -> Apache module
embed -> PHP embedded in another C program
phpdbg -> The interactive debugger
cli-server -> PHP's built-in development server

This post focuses on the CLI SAPI, which lets you runs PHP scripts directly from the terminal without a web server.
The PHP command line interface (CLI) is a powerful tool for developers, and mastering it can significantly enhance your productivity.

What Makes The Cli Sapi Different

First, there’s no web server, so there’s no HTTP request.

Arguments arrive in $argv (the script name is at index 0) and $argc. STDIN, STDOUT and STDERR are already defined as stream constants.

A few INI defaults are overridden because the usual web settings don’t make sense in a terminal. CLI also looks for php-cli.ini before php.ini, which is why CLI and FPM often end up with different configurations.

The working directory is not changed to the script's directory. Relative paths resolve against where you launched the process, so use __DIR__ for paths relative to the script.

Exit codes also matter because shells, cron and CI act on them. exit(n) returns n to the shell, exit("message") prints the message and returns 0, and an uncaught fatal error returns 255.

How It Works

When you invoke PHP from the command line, the CLI SAPI starts the Zend Engine, loads configuration from php.ini or command-line overrides, processes the arguments, and runs the given script or code.

Usage

The CLI SAPI is useful for:

Run scripts without a web server
Test code snippets quickly
Automate routine tasks
- Database migrations and data imports
- Report generation and log processing
- Cleanup and maintenance jobs
Debug applications (with phpdbg or Xdebug)
Administer servers (deployment and maintenance scripts)
Use an interactive shell (REPL)
Manage dependencies (e.g., Composer)
Run framework commands and a development server
Inspect and override INI settings

Common Commands From The Terminal

Interactive Shell

php -a # starts an interactive php shell (REPL)

# Example
php -a
php > echo password_hash("pass", PASSWORD_DEFAULT);

Syntax Check (Lint)

php -l <file> # checks a php file for syntax errors without executing it

# Example
php -l script.php

Built-in Development Server

php -S <address>:<port> # starts php’s built-in web server

# Example
php -S localhost:8000

Execute a PHP File

php -f <file> # executes a php file

# Example
php -f migrate.php

Run PHP Code Directly

php -r <code> # runs php code without creating a file

# Example
php -r 'echo bin2hex(random_bytes(16));'

Show PHP Version

php -v # displays the current php version

# Example
php -v

Show Full PHP Information

php -i # displays detailed php configuration

# Example
php -i | grep "Loaded Configuration File"

Show Loaded Modules

php -m # lists all compiled and loaded php modules

# Example
php -m | grep -i redis

Define / Override INI Setting

php -d setting=value # temporarily sets or overrides a php configuration value

# Example
php -d memory_limit=1G -d max_execution_time=0 import-data.php

Set Document Root for Built-in server

php -S <address>:<port> -t <docroot> # starts the built-in server with a specific document root

# Example
php -S 0.0.0.0:8000 -t public

Show Loaded INI Files

php --ini # shows which php.ini and scanned .ini files are loaded

# Example
php --ini

Reflection Information

php --ri <extension> # shows the configuration of one extension
php --rf <function> # shows reflection info for a function
php --rc <class> # shows reflection info for a class
php --re <extension> # shows everything an extension provides

# Examples
php --ri pdo_mysql
php --rf array_map
php --rc DateTime

Use a Router Script with the Built-in Server

php -S <address>:<port> <router> # sends every request through a router script

# Example
php -S localhost:8000 -t public public/index.php

Strip Comments and Whitespace

php -w <file> # prints the source with comments and whitespace removed

# Example
php -w foo.php

Show Help

php -h # lists all available command-line options

# Example
php -h

“I’m not a real programmer. I throw together things until it works then I move on. The real programmers will say Yeah it works but you’re leaking memory everywhere. Perhaps we should fix that. I’ll just restart Apache every 10 requests.”

— Rasmus Lerdorf

Movies and Series Every Programmer Should Watch

Nima jahan bakhshian — Thu, 01 Oct 2026 21:21:08 +0000

1. Mr. Robot

2015–2019 — Series

IMDb: ⭐ 8.5/10

Rotten Tomatoes: 🍅 94%

Genre: Drama, Crime, Cybersecurity

Mr. Robot follows Elliot Alderson, a cybersecurity engineer and hacker who becomes involved with a group attempting to bring down a powerful corporation. The series focuses heavily on hacking, Linux, cybersecurity, privacy, social engineering, cryptography, networking, and digital infrastructure.

Why programmers should watch it?

Shows a serious representation of cybersecurity and hacking.
Introduces concepts such as Linux, networking, encryption, social engineering, and system vulnerabilities.
Demonstrates the importance of understanding how systems actually work rather than simply using frameworks and APIs.
Shows the relationship between technology, corporations, privacy, and society.
Encourages a security-oriented mindset: "What assumptions does this system make, and how could they fail?"

Key lesson:

Don't just learn how to use a system. Learn how the system works underneath.

2. Silicon Valley

2014–2019 — Series

IMDb: ⭐ 8.5/10

Rotten Tomatoes: 🍅 94%

Genre: Comedy, Sitcom

Silicon Valley follows Richard Hendricks, a programmer who develops a potentially revolutionary technology and attempts to build a company around it.

Why programmers should watch it?

Shows software startup culture.
Demonstrates the difference between writing software and building a software company.
Covers technical debt, scalability, architecture, funding, investors, hiring, founders, acquisitions, and product development.
Shows how programmers communicate with business people and investors.
Provides an entertaining representation of engineering-team dynamics.

Key lesson:

Great code is important, but software engineering exists inside a larger product and business ecosystem.

3. The Social Network

2010 — Movie

IMDb: ⭐ 7.8/10

Rotten Tomatoes: 🍅 96%

Genre: Biography, Drama

The movie dramatizes the creation and early growth of Facebook and the conflicts surrounding its founders and business relationships.

Why programmers should watch it?

Shows how a relatively simple software idea can become a massive product.
Demonstrates the importance of speed and execution.
Introduces product-market fit and competition.
Shows the relationship between programmers, founders, investors, and business.
Raises questions about intellectual property and ownership.
Demonstrates that technical ability alone does not determine the success of a product.

Key lesson:

Don't only ask "How do I build this?" Ask "Why are we building this, and who needs it?"

4. Halt and Catch Fire

2014–2017 — Series

IMDb: ⭐ 8.4/10

Rotten Tomatoes: 🍅 90%

Genre: Drama

The series follows engineers, entrepreneurs, and programmers during the evolution of the personal-computer and early Internet industries.

Why programmers should watch it?

Gives you perspective on the history of computing.
Shows hardware and software development.
Explores operating systems, reverse engineering, networking, and early Internet technologies.
Demonstrates how technological innovation actually happens.
Shows engineering teams dealing with technical and interpersonal problems.
Helps you understand that today's technology stack was built over decades.

Key lesson:

Every technology you use today is built on decades of previous engineering decisions.

5. The Imitation Game

2014 — Movie

IMDb: ⭐ 8.0/10

Rotten Tomatoes: 🍅 90%

Genre: Biography, Drama, War

The movie dramatizes Alan Turing's work during World War II and the effort to break the German Enigma encryption system.

Why programmers should watch it?

Introduces cryptography.
Demonstrates algorithmic thinking.
Shows computational problem solving.
Demonstrates how difficult problems can require completely new approaches.
Shows the importance of abstraction and automation.
Provides historical context for the development of computing.

Key lesson:

When a problem seems impossible, changing the way you represent the problem can be more powerful than simply working harder.

6. Pirates of Silicon Valley

1999 — Movie / TV Movie

IMDb: ⭐ 7.2/10

Rotten Tomatoes: 🍅 89%

Genre: Biography, Drama

The movie dramatizes the early history of Apple and Microsoft and the rivalry between Steve Jobs and Bill Gates.

Why programmers should watch it?

Introduces the early history of personal computing.
Shows how software and hardware companies evolved.
Demonstrates competition in the technology industry.
Shows how business strategy can be as important as technology.
Helps explain the origins of companies that shaped modern computing.

Key lesson:

Technology becomes powerful when engineering, business, distribution, and timing come together.

7. Devs

2020 — Series

IMDb: ⭐ 7.6/10

Rotten Tomatoes: 🍅 82%

Genre: Sci-Fi, Drama, Mystery

Devs follows a software engineer who investigates a secret technology project at a powerful technology company. The series explores computing, algorithms, determinism, artificial intelligence, and the possibility of predicting reality.

Why programmers should watch it?

Explores the philosophical limits of computation.
Raises questions about algorithms and prediction.
Discusses artificial intelligence and advanced computing.
Makes you think about determinism and free will.
Demonstrates that software engineering can involve philosophical questions, not only technical ones.

Key lesson:

Powerful computational systems force us to ask what computation can actually know, predict, and control.

8. The Matrix

1999 — Movie

IMDb: ⭐ 8.7/10

Rotten Tomatoes: 🍅⭐83%

Genre: Action, Sci-Fi

A computer hacker discovers that the reality he experiences is actually a sophisticated simulation controlled by machines.

Why programmers should watch it?

Explores abstraction and simulated environments.
Raises questions about information and reality.
Encourages you to question assumptions.
Provides an interesting metaphor for systems and software abstractions.
Demonstrates how a system can hide its underlying implementation.

Key lesson:

The abstraction you interact with is not necessarily the underlying reality.

For programmers, this is particularly relevant because almost every layer of software is an abstraction over another layer.

9. Ex Machina

2014 — Movie

IMDb: ⭐ 7.7/10

Rotten Tomatoes: 🍅 82%

Genre: Sci-Fi, Drama, Thriller

A programmer is invited to a private facility to participate in an experiment involving an advanced artificial intelligence embodied in a humanoid robot.

Why programmers should watch it?

Explores artificial intelligence.
Raises questions about machine consciousness.
Discusses AI behavior and human-machine interaction.
Examines privacy and data collection.
Raises questions about the responsibility of people who create powerful systems.
Demonstrates why technical capability and ethical considerations cannot always be separated.

Key lesson:

The fact that we can build something does not automatically answer whether we understand its consequences.

10. Hackers

1995 — Movie

IMDb: ⭐ 6.2/10

Rotten Tomatoes: 🍅 34%

Genre: Crime, Thriller, Drama

Hackers follows a group of young computer hackers who become involved in a conspiracy involving a computer virus and corporate crime.

Why programmers should watch it?

Captures the hacker culture of the 1990s.
Provides historical context for early Internet culture.
Shows how popular culture viewed hackers before modern cybersecurity became mainstream.
Introduces ideas around networks, passwords, viruses, social engineering, and digital identity.
Helps you appreciate how dramatically computing culture has changed.

Important:
The technical aspects are highly stylized and should not be considered an accurate cybersecurity tutorial.

Key lesson:

Technology changes quickly, but hacker culture and curiosity about systems have deep roots.

11. The IT Crowd

2006–2013 — Series

IMDb: ⭐ 8.5/10

Rotten Tomatoes: 🍅 85%

Genre: Comedy, Sitcom

A comedy centered around Roy, Moss, and Jen, who work in the IT department of a large corporation.

Why programmers should watch it?

Shows the funny side of working in IT.
Illustrates common misunderstandings between technical and non-technical employees.
Shows help-desk and IT-support culture.
Demonstrates the importance of communication.
Makes fun of unrealistic expectations placed on technical teams.
Reminds programmers that software engineering is ultimately a human profession.

Key lesson:

Technical knowledge is only part of being a good engineer. Communication matters too.

12. Sneakers

1992 — Movie

IMDb: ⭐ 7.1/10

Rotten Tomatoes: 🍅 80%

Genre: Crime, Comedy, Thriller

A team of security experts is hired to test organizations' security systems but becomes involved in a much larger operation involving cryptography and information security.

Why programmers should watch it?

Explores information security.
Introduces cryptography concepts.
Demonstrates social engineering.
Shows penetration testing from a historical perspective.
Explores the importance of information and access.
Demonstrates that security is not purely a technical problem.

Key lesson:

Security is a system involving technology, people, processes, and information—not merely passwords and firewalls.

I Recommend Watching Them In This Order

Mr. Robot
Silicon Valley
Halt and Catch Fire
The Social Network
The Imitation Game
Pirates of Silicon Valley
Hackers
Sneakers
The IT Crowd
Ex Machina
Devs
The Matrix

What Engineering Principle Is This Story Trying To Demonstrate?

Mr. Robot → Security mindset
Silicon Valley → Software + business
Halt and Catch Fire → Innovation
The Social Network → Product + execution
The Imitation Game → Algorithms + problem solving
Pirates of Silicon Valley → Technology + competition
Devs → Computation + philosophy
The Matrix → Abstraction + systems
Ex Machina → AI + ethics
Hackers → Hacker culture
The IT Crowd → Communication + IT culture
Sneakers → Security + social engineering

Linux common commands every developer should know

Nima jahan bakhshian — Sat, 12 Sep 2026 22:03:58 +0000

The command line is one of the most powerful and efficient ways to interact with Linux systems. For developers, knowing the commands can make tasks much faster and easier.
This article provides a reference of useful Linux commands for developers. this commands are organized by category so you can be easily found and used when needed.

Navigation and directory management

ls -> List directory contents

ls -l # long format (permissions, size, date)
ls -la # include hidden files
ls -lh # human-readable sizes
ls -lt # sort by modification time
ls -R # recursive listing

cd -> Change directory

cd /absolute/path
cd .. # go up one level
cd - # switch to previous directory
cd ~ or just cd # go to home directory

pwd -> Print working directory

pwd

mkdir -> Create directories

mkdir <dir_name>
mkdir -p path/to/nested/dir # create parent directories if needed
mkdir -m 755 new_dir # set permissions while creating

File operations

rm -> Remove files/directories

rm file.txt
rm -r directory/ # recursive delete
rm -rf directory/ # force recursive (dangerous!)
rm -i file # interactive confirmation

cp -> Copy files/directories

cp file1 file2
cp -r source/ dest/ # recursive copy
cp -a source/ dest/ # archive mode (preserve attributes)
cp -v file dest/ # verbose output

mv -> Move or rename

mv old_name new_name
mv file /path/to/destination/
mv -i file dest/ # interactive (ask before overwrite)

Viewing searching content

cat -> Display or create files

cat file.txt
cat file1 file2 # concatenate multiple files
cat > newfile.txt # create/overwrite a file
cat >> file.txt # append to a file
cat -n file.txt # show line numbers

grep -> Search text patterns

grep "pattern" file.txt
grep -r "pattern" . # recursive search
grep -i "pattern" file # case-insensitive
grep -n "pattern" file # show line numbers
grep -v "pattern" file # invert match (exclude)
grep -E "regex" file # extended regex

find -> Locate files and directories

find . -name "*.js"
find /path -type f -name "*.log" # only files
find . -mtime -7 # modified in last 7 days
find . -size +10M # files larger than 10MB
find . -name "*.tmp" -delete # find and delete

Permissions

chmod -> Change file permissions

chmod 755 script.sh # rwxr-xr-x
chmod +x script.sh # add execute permission
chmod -R 644 directory/ # recursive

Process management

ps -> List running processes

ps aux # all processes with details
ps -ef # full format listing
ps aux | grep node # filter specific process
ps -u username # processes of a specific user

kill / killall -> Terminate processes

kill PID # graceful termination (SIGTERM)
kill -9 PID # force kill (SIGKILL)
killall process_name # kill by name
kill -15 PID # same as default SIGTERM

Archiving

tar -> Archive and compress

tar -czvf archive.tar.gz folder/ # create gzip archive
tar -xzvf archive.tar.gz # extract
tar -tzvf archive.tar.gz # list contents
tar -cjvf archive.tar.bz2 folder/ # bzip2 compression

System resource monitoring

df -> Display disk space usage

df -h # human-readable sizes (GB/MB)
df -hT # show filesystem type
df -i # show inode usage

du -> Estimate file/directory space usage

du -sh folder/ # total size of a folder (summary)
du -h --max-depth=1 # size of each subfolder
du -ah # show all files and directories

free -> Display memory usage

free -h # human-readable
free -m # show in megabytes
free -s 5 # refresh every 5 seconds

uptime -> Show system uptime and load average

uptime -p # pretty format (“up 2 days, 3 hours”)

top -> Real-time overall system view

top # interactive view
Press M # sort by memory
Press P # sort by CPU
Press q # quit

vmstat -> System memory, processes, CPU, I/O stats

vmstat 1 # update every 1 second
vmstat -s # summary of memory statistics
vmstat -d # disk statistics

Process viewing

pstree -> Display processes in a tree structure

pstree # basic tree
pstree -p # show PIDs
pstree -u # show usernames
pstree -a # show command-line arguments

Command history

history -> View previously executed commands

history # full list
history 20 # last 20 commands
!123 # re-run command number 123
!! # re-run the last command
history | grep "docker" # search past commands

Practical Git Commands Every Developer Should Know

Nima jahan bakhshian — Sun, 06 Sep 2026 08:31:15 +0000

Git is the most widely used version control system in the world. Whether you’re working alone or collaborating with a team, knowing the right commands can save you hours of frustration and help you work more confidently.

Below is a practical collection of the most useful Git commands, organized by real-world workflows.

1. Getting Started

Creates a new Git repository in the current directory

git init

Downloads an existing repository from a remote server and creates a local copy

git clone <repository-url>

Sets your identity so every commit is correctly attributed to you

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

2. Daily Workflow

Check the current status of your working directory

git status # shows which files are modified, staged, or untracked

git status -sb # the shorter and cleaner version

git add <file> # stage a specific file

git add . # stage all changes

# Show unstaged changes (working directory vs staging area)
git diff

# Show staged changes (staging area vs last commit)
git diff --staged

# Create a commit
git commit -m "feat: add image uploader"

3. Working with Branches

Switching Branches with

git switch is the dedicated command for switching branches (safer and clearer than the old git checkout).

# Switch to an existing branch
git switch feature-branch

# Create a new branch and switch to it in one command
git switch -c new-feature

git branch # List all local branches

4. Working with Remotes

Managing Remotes

# Show remote repositories with their fetch and push URLs
git remote -v

# List remote names only
git remote

# Remove a remote
git remote remove origin

# Add a new remote
git remote add origin <repository-url>

# Remove a remote
git remote remove <name>

# Fetch latest changes without merging
git fetch --all --prune

5. Hunting Down Bugs

If a bug has appeared and you're not sure which commit introduced it, bisect uses binary search across your commit history

# Start a binary search to find which commit introduced a bug
git bisect start

# Mark the current commit as bad (contains the bug)
git bisect bad

# Mark a known good commit (for example version v1.0)
git bisect good v1.0

# used to end a Git bisection session, clean up the bisection state
# and return your working directory to the commit you were on before you started
git bisect reset

6. Undoing Changes

Cleaning Up Untracked Files

# Dry-run: show which untracked files would be deleted (safe preview)
git clean -n

# Actually delete untracked files and directories
git clean -fd

# Discard changes in a specific file
git restore <file>

# Discard all local uncommitted changes (dangerous)
git restore .
git clean -fd

# Undo the last commit but keep the changes staged
git reset --soft HEAD~1

# Undo the last commit and unstage the changes
git reset HEAD~1

7. Temporarily Saving Work (Stash)

Always give a meaningful message with git stash push -m "...".

After a few days stash@{0}, stash@{1} become completely useless without messages.

# Temporarily save (stash) your uncommitted changes so you can work on something else
git stash

# Save your current uncommitted work (both staged + unstaged) with a clear message
# Very useful when you need to urgently switch branch or pull latest changes
git stash push -m "WIP: login form validation and dark mode toggle"

# Apply the most recent stash and remove it from the stash list
git stash pop

# List all saved stashes
git stash list

# Apply a specific stash (without removing it from the list)
git stash apply stash@{2}

# See what is inside a particular stash
git stash show -p stash@{1}

# Delete a specific stash after you're done with it
git stash drop stash@{1}

# Delete ALL stashes (use carefully)
git stash clear

8. Attaching Notes to Commits

git notes lets you attach extra information to a commit, without changing the commit itself or its hash

git notes add -m "This commit caused a regression in v2.3" <commit-hash>
git log --show-notes

9. A Clean Summary of Contributors

Instead of scrolling through a full commit log, shortlog gives you a ranked summary of who committed what, and how often a quick way to generate a contribution report without external tooling.

git shortlog
git shortlog -sn --all
git shortlog -sn --since="1 month ago"

10. Inspect Any Single Commit in Detail

# Show the full details of a specific commit (message, author, date, and the full diff of changes)
git show <commit-hash>

# Show the content of a specific file as it existed in a particular commit
git show <commit-hash>:path/to/file

Happy coding, and may your commits always be meaningful!