Lang Compare

JavaScript runs in every browser. For server-side / local development, install a runtime like Node.js, Deno, or Bun.

# Node.js — install via nvm (recommended)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash
nvm install --lts
node --version

# Or via Homebrew (macOS)
brew install node

# Deno — built-in TypeScript, no config needed
curl -fsSL https://deno.land/install.sh | sh
deno --version

# Bun — fast all-in-one runtime
curl -fsSL https://bun.sh/install | bash
bun --version

# REPL — start an interactive session
node           # Node.js REPL
deno           # Deno REPL
bun repl       # Bun REPL

# Run a script
node script.js
deno run script.js
bun run script.js

# Quick one-liner
node -e "console.log('Hello!')"

TypeScript requires a JavaScript runtime plus the TypeScript compiler. Some runtimes (Deno, Bun) support TypeScript natively.

# Install Node.js (see JavaScript) then add TypeScript
npm install -g typescript
tsc --version

# Or install locally per-project
npm install --save-dev typescript
npx tsc --version

# Deno — runs TypeScript natively, no setup
deno --version
deno run script.ts

# Bun — native TypeScript support
bun run script.ts

# tsx — run TS files directly in Node.js
npm install -g tsx
tsx script.ts

# REPL — no official TS REPL, but use tsx or ts-node
npx tsx          # Interactive TypeScript REPL
npx ts-node      # Alternative REPL
deno             # Deno REPL supports TypeScript

# Compile and run
npx tsc script.ts && node script.js

# Type-check without emitting
npx tsc --noEmit

PHP is pre-installed on many systems. For local development, use a package manager or a bundled environment.

# macOS (Homebrew)
brew install php

# Ubuntu / Debian
sudo apt install php php-cli php-mbstring php-xml

# Windows — use XAMPP, Laragon, or Scoop
scoop install php

# Check version
php --version

# REPL — interactive mode
php -a

# Run a script
php script.php

# Quick one-liner
php -r "echo 'Hello, PHP!' . PHP_EOL;"

# Built-in development server
php -S localhost:8000

# Built-in server with router
php -S localhost:8000 router.php

Ruby is pre-installed on macOS. Use a version manager like rbenv or asdf for managing versions.

# macOS (Homebrew)
brew install ruby

# rbenv — recommended version manager
brew install rbenv ruby-build
rbenv install 3.3.0
rbenv global 3.3.0

# Or use asdf
asdf plugin add ruby
asdf install ruby 3.3.0
asdf global ruby 3.3.0

# Ubuntu / Debian
sudo apt install ruby-full

# Check version
ruby --version

# IRB — interactive Ruby (REPL)
irb

# Pry — enhanced REPL
gem install pry
pry

# Run a script
ruby script.rb

# Quick one-liner
ruby -e "puts 'Hello, Ruby!'"

# Run with warnings
ruby -w script.rb

Download from the official site or use a package manager. Go is a single binary with everything included.

# macOS (Homebrew)
brew install go

# Linux
wget https://go.dev/dl/go1.22.0.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.22.0.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

# Windows — download installer from https://go.dev/dl/

# Verify installation
go version

# No REPL built-in — but alternatives exist:
# gore — a Go REPL
go install github.com/x-motemen/gore/cmd/gore@latest
gore

# Go Playground — try Go in the browser
# https://go.dev/play/

# Run a file directly (no build step needed)
go run main.go

# Quick one-liner (via go run)
echo 'package main; import "fmt"; func main() { fmt.Println("Hello!") }' > /tmp/hello.go && go run /tmp/hello.go

Install via rustup, the official Rust toolchain installer. It manages Rust versions, components, and targets.

# Install Rust via rustup (recommended)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# macOS (Homebrew — not recommended, use rustup)
brew install rust

# Verify installation
rustc --version
cargo --version

# Update Rust
rustup update

# Install a specific toolchain
rustup install nightly
rustup default stable

# No built-in REPL — but evcxr is a popular Rust REPL
cargo install evcxr_repl
evcxr

# Rust Playground — try in the browser
# https://play.rust-lang.org/

# Run a file directly
rustc hello.rs && ./hello

# Run via Cargo (preferred)
cargo run

# Quick script with cargo-script
cargo install cargo-script
cargo script hello.rs

Install a C++ compiler (GCC, Clang, or MSVC) and optionally CMake for build management.

# macOS — Clang comes with Xcode Command Line Tools
xcode-select --install
clang++ --version

# Linux (Ubuntu/Debian) — GCC
sudo apt install build-essential cmake
g++ --version

# Linux — Clang
sudo apt install clang

# Windows — MSVC via Visual Studio, or MinGW/MSYS2
# Download from https://visualstudio.microsoft.com/

# Verify
g++ --version    # or clang++ --version
cmake --version

# No built-in REPL — but cling provides one
# Install cling: https://github.com/root-project/cling
cling

# Compiler Explorer — try in the browser
# https://godbolt.org/

# Compile and run
g++ -std=c++20 -o hello hello.cpp && ./hello
clang++ -std=c++20 -o hello hello.cpp && ./hello

# With CMake
cmake -B build && cmake --build build && ./build/app

# Quick compile + run
echo '#include <iostream>
int main() { std::cout << "Hello!\\n"; }' > /tmp/h.cpp && g++ -o /tmp/h /tmp/h.cpp && /tmp/h

Install the .NET SDK, which includes the C# compiler, runtime, and CLI tools.

# macOS (Homebrew)
brew install dotnet

# Linux (Ubuntu/Debian)
sudo apt install dotnet-sdk-8.0

# Windows — download from https://dotnet.microsoft.com/download

# Or use the install script
curl -sSL https://dot.net/v1/dotnet-install.sh | bash

# Verify installation
dotnet --version

# REPL — C# Interactive (csi)
dotnet tool install -g dotnet-script
dotnet script    # Interactive REPL

# Or use C# Interactive in Visual Studio
# Tools > C# Interactive

# .NET Fiddle — try in the browser
# https://dotnetfiddle.net/

# Run a project
dotnet run

# Run a single file script (.csx)
dotnet script hello.csx

# Quick one-liner
dotnet script eval "Console.WriteLine(\"Hello!\")"

Swift comes bundled with Xcode on macOS. On Linux, install via the official toolchain or swiftly.

# macOS — included with Xcode
xcode-select --install
swift --version

# macOS — standalone (without Xcode)
brew install swift

# Linux (Ubuntu)
# Download from https://swift.org/download/
# Or use swiftly (version manager)
curl -L https://swiftlang.github.io/swiftly/swiftly-install.sh | bash
swiftly install latest

# Windows — download from https://swift.org/download/

# Verify
swift --version

# REPL — Swift has a built-in REPL
swift                  # Start REPL
# > let x = 42
# > print(x)

# Swift Playgrounds — interactive learning (macOS/iPad)
# Xcode Playgrounds — rapid prototyping in Xcode

# Run a script
swift hello.swift

# Run a package
swift run

# Online playground
# https://swiftfiddle.com/

Install the Kotlin compiler standalone, or get it bundled with IntelliJ IDEA or Android Studio. Kotlin runs on the JVM, so a JDK is required.

# macOS (Homebrew)
brew install kotlin

# SDKMAN (recommended for JVM languages)
curl -s https://get.sdkman.io | bash
sdk install kotlin
sdk install java 21-tem  # Also install a JDK

# Linux (snap)
sudo snap install kotlin --classic

# Verify
kotlin -version
kotlinc -version
java -version  # JDK required

# REPL — Kotlin has a built-in REPL
kotlinc          # Start REPL
# >>> val x = 42
# >>> println(x)

# Kotlin Playground — try in the browser
# https://play.kotlinlang.org/

# Run a script (.kts file)
kotlin script.main.kts

# Compile and run
kotlinc hello.kt -include-runtime -d hello.jar
java -jar hello.jar

# Run directly (Kotlin 1.9+)
kotlin hello.kt

# Kotlin Notebooks — in IntelliJ IDEA
# Similar to Jupyter, for interactive exploration

Python comes pre-installed on macOS and most Linux distros. Use pyenv or the official installer for version management.

# macOS (Homebrew)
brew install python

# Using pyenv (recommended for version management)
brew install pyenv
pyenv install 3.12
pyenv global 3.12

# Using uv (fast Python version management)
uv python install 3.12
uv python pin 3.12

# Verify installation
python3 --version

# REPL — Python has an excellent built-in REPL
python3             # Standard REPL
python3 -i script.py  # Run script then drop into REPL

# IPython — enhanced REPL with autocomplete, syntax highlighting
pip install ipython
ipython

# Jupyter — interactive notebooks
pip install jupyter
jupyter notebook

# Run a script
python3 script.py

# Quick one-liner
python3 -c "print('Hello!')"

Use npm init for a basic project or a framework CLI for a full setup.

# Basic project
mkdir my-project && cd my-project
npm init -y

# Using Vite
npm create vite@latest my-app

# Using Next.js
npx create-next-app@latest my-app

# Using Astro
npm create astro@latest

# Run the project
npm run dev

Initialize a tsconfig.json or use a framework CLI that includes TypeScript.

# Basic TypeScript project
mkdir my-project && cd my-project
npm init -y
npm install --save-dev typescript
npx tsc --init

# Using Vite with TypeScript
npm create vite@latest my-app -- --template vanilla-ts

# Using tsx for scripts (no build step)
npm install --save-dev tsx
npx tsx src/index.ts

# Run with ts-node
npx ts-node src/index.ts

Use Composer to create projects from templates. Laravel and Symfony have dedicated installers.

# Basic project with Composer
mkdir my-project && cd my-project
composer init

# Laravel — full-stack web framework
composer create-project laravel/laravel my-app
cd my-app && php artisan serve

# Laravel via installer
composer global require laravel/installer
laravel new my-app

# Symfony
composer create-project symfony/skeleton my-app
cd my-app && symfony server:start

# Slim (micro-framework)
composer create-project slim/slim-skeleton my-app

# Run development server
php -S localhost:8000 -t public

Use bundler for dependency management and Rails or Sinatra for web projects.

# Basic Ruby project
mkdir my-project && cd my-project
bundle init            # Creates Gemfile

# Ruby on Rails — full-stack web framework
gem install rails
rails new my-app
cd my-app && rails server

# Rails with specific options
rails new my-api --api                  # API-only
rails new my-app --database=postgresql  # PostgreSQL

# Sinatra — lightweight web framework
mkdir my-app && cd my-app
bundle init
# Add: gem 'sinatra' to Gemfile
bundle install
ruby app.rb

# Gem scaffold (create a new gem/library)
bundle gem my-gem
# Creates lib/, spec/, Gemfile, .gemspec

Initialize a module with go mod init. No external scaffolding tools needed.

# Create a new project
mkdir my-project && cd my-project
go mod init github.com/user/my-project

# Create main file
cat > main.go << 'EOF'
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}
EOF

# Run the project
go run .

# Build a binary
go build -o my-app .

Cargo creates the full project structure with one command.

# Create a new binary project
cargo new my-project
cd my-project

# Create a library project
cargo new my-lib --lib

# Project structure created:
# my-project/
#   Cargo.toml
#   src/
#     main.rs  (or lib.rs)

# Run the project
cargo run

# Build for release
cargo build --release

# Run tests
cargo test

Create a CMake project manually or use a tool like cmake --init.

# Basic CMake project
mkdir my-project && cd my-project
mkdir src

cat > CMakeLists.txt << 'EOF'
cmake_minimum_required(VERSION 3.20)
project(MyProject)
set(CMAKE_CXX_STANDARD 20)
add_executable(app src/main.cpp)
EOF

cat > src/main.cpp << 'EOF'
#include <iostream>
int main() {
    std::cout << "Hello, World!\n";
}
EOF

# Build and run
cmake -B build
cmake --build build
./build/app

The dotnet CLI creates projects from built-in templates.

# Console app
dotnet new console -n MyApp
cd MyApp

# Web API
dotnet new webapi -n MyApi

# Class library
dotnet new classlib -n MyLib

# List available templates
dotnet new list

# Run the project
dotnet run

# Build for release
dotnet build -c Release

# Publish self-contained
dotnet publish -c Release --self-contained

Use SPM for command-line tools or Xcode for app projects.

# Create a new package (library)
swift package init --name MyLib

# Create an executable
swift package init --type executable --name MyApp

# Project structure created:
# MyApp/
#   Package.swift
#   Sources/
#     main.swift

# Build and run
swift build
swift run

# Create an iOS/macOS app
# Open Xcode > File > New > Project
# Select template (App, Framework, etc.)

# Build for release
swift build -c release

Use IntelliJ IDEA, Android Studio, or the Kotlin project wizard.

# Using Gradle init
gradle init --type kotlin-application

# Project structure:
# app/
#   build.gradle.kts
#   src/
#     main/kotlin/App.kt
#     test/kotlin/AppTest.kt

# Run the project
./gradlew run

# Build
./gradlew build

# Android project: use Android Studio wizard
# Multiplatform: use start.kotlinlang.org

# Kotlin scripting
echo 'println("Hello!")' > script.main.kts
kotlin script.main.kts

Create a virtual environment and a pyproject.toml or requirements.txt.

# Basic project with venv
mkdir my-project && cd my-project
python -m venv .venv
source .venv/bin/activate

# Using uv (recommended)
uv init my-project
cd my-project
uv run python main.py

# Using poetry
poetry new my-project
cd my-project
poetry install

# Django web project
pip install django
django-admin startproject mysite

# FastAPI project
pip install "fastapi[standard]"

npm is the default package manager. Yarn, pnpm, and Bun are popular alternatives.

# Install a package
npm install lodash

# Install as dev dependency
npm install --save-dev vitest

# Install globally
npm install -g typescript

# Using pnpm
pnpm add lodash

# Using yarn
yarn add lodash

# Using bun
bun add lodash

Uses the same package managers as JavaScript. Type definitions are installed separately for untyped packages.

# Install a package
npm install zod

# Install type definitions
npm install --save-dev @types/node

# Most modern packages include types
npm install axios  # types included

# Using pnpm
pnpm add zod

# Using bun (has built-in TS support)
bun add zod

Composer is the standard dependency manager for PHP. Packages are hosted on Packagist.

# Install Composer
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

# Install a package
composer require guzzlehttp/guzzle

# Install as dev dependency
composer require --dev phpunit/phpunit

# Install all dependencies
composer install

# Update dependencies
composer update

# Autoload classes
composer dump-autoload

// composer.json
{
  "require": {
    "php": "^8.2",
    "guzzlehttp/guzzle": "^7.0",
    "laravel/framework": "^11.0"
  },
  "require-dev": {
    "phpunit/phpunit": "^11.0"
  },
  "autoload": {
    "psr-4": {
      "App\\": "src/"
    }
  }
}

RubyGems is the package manager. Bundler manages project dependencies via a Gemfile.

# Install a gem globally
gem install rails
gem install pry

# Bundler — project dependency management
gem install bundler

# Install all dependencies from Gemfile
bundle install

# Add a gem to the project
bundle add sidekiq

# Update dependencies
bundle update
bundle update rails  # Update specific gem

# Execute a command in bundle context
bundle exec rails server
bundle exec rspec

# Gemfile
source 'https://rubygems.org'

ruby '3.3.0'

gem 'rails', '~> 7.1'
gem 'pg'
gem 'puma'
gem 'redis'

group :development, :test do
  gem 'rspec-rails'
  gem 'pry-byebug'
  gem 'factory_bot_rails'
end

group :development do
  gem 'rubocop', require: false
end

Go modules (go mod) is the built-in dependency management system.

# Add a dependency
go get github.com/gin-gonic/gin

# Add a specific version
go get github.com/gin-gonic/gin@v1.9.1

# Tidy up (remove unused, add missing)
go mod tidy

# List dependencies
go list -m all

# Update all dependencies
go get -u ./...

# Vendor dependencies
go mod vendor

Cargo is Rust’s built-in package manager and build tool. Packages are called “crates”.

# Add a dependency
cargo add serde

# Add with features
cargo add serde --features derive

# Add a dev dependency
cargo add --dev tokio-test

# Remove a dependency
cargo remove serde

# Update dependencies
cargo update

# Search for crates
cargo search json

No built-in package manager. vcpkg and Conan are the most popular options.

# Using vcpkg
vcpkg install fmt
vcpkg install boost:x64-linux

# Using Conan
conan install . --build=missing

# CMake FetchContent (download at build time)
# In CMakeLists.txt:
# FetchContent_Declare(fmt
#   GIT_REPOSITORY https://github.com/fmtlib/fmt
#   GIT_TAG 10.1.1)
# FetchContent_MakeAvailable(fmt)

# System package managers
sudo apt install libboost-all-dev  # Debian/Ubuntu
brew install fmt                    # macOS

NuGet is the package manager for .NET. Managed via the dotnet CLI or Visual Studio.

# Add a package
dotnet add package Newtonsoft.Json

# Add a specific version
dotnet add package Serilog --version 3.1.0

# Remove a package
dotnet remove package Newtonsoft.Json

# Restore packages
dotnet restore

# List installed packages
dotnet list package

# Update packages
dotnet outdated  # requires dotnet-outdated tool

Swift Package Manager (SPM) is built into Swift and Xcode.

# Add a dependency in Package.swift:
# dependencies: [
#     .package(url: "https://github.com/Alamofire/Alamofire",
#              from: "5.0.0")
# ]

# Resolve dependencies
swift package resolve

# Update dependencies
swift package update

# Show dependencies
swift package show-dependencies

# In Xcode: File > Add Package Dependencies
# Paste the repository URL and select version

Uses Gradle (Kotlin DSL or Groovy) to manage dependencies from Maven Central.

// build.gradle.kts
dependencies {
    implementation("com.squareup.okhttp3:okhttp:4.12.0")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")
    testImplementation("junit:junit:4.13.2")
}

// Version catalogs (libs.versions.toml)
// [versions]
// okhttp = "4.12.0"
// [libraries]
// okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }

# Sync dependencies
./gradlew build

# Show dependency tree
./gradlew dependencies

pip is the standard package manager. uv and poetry are modern alternatives.

# Install a package
pip install requests

# Install from requirements file
pip install -r requirements.txt

# Using uv (fast, modern)
uv pip install requests
uv add requests

# Using poetry
poetry add requests

# Virtual environments
python -m venv .venv
source .venv/bin/activate  # macOS/Linux

Rich ecosystem of formatters and linters. Most projects use a combination.

# Prettier — opinionated code formatter
npm install --save-dev prettier
npx prettier --write .

# ESLint — linting and code quality
npm install --save-dev eslint
npx eslint --init
npx eslint .

# Biome — fast all-in-one (format + lint)
npm install --save-dev @biomejs/biome
npx biome check --write .

# oxlint — extremely fast linter (Rust-based)
npx oxlint .

// .prettierrc
{
  "semi": false,
  "singleQuote": true,
  "trailingComma": "all",
  "printWidth": 100
}

// eslint.config.js (flat config)
import js from '@eslint/js'
export default [
  js.configs.recommended,
  { rules: { 'no-unused-vars': 'warn' } },
]

Same tools as JavaScript, with TypeScript-aware configurations. tsc itself is the primary type checker.

# Prettier — formats TS natively
npx prettier --write "**/*.ts"

# ESLint with TypeScript
npm install --save-dev eslint typescript-eslint
npx eslint .

# Biome — supports TypeScript out of the box
npx biome check --write .

# Type checking (not a linter, but essential)
npx tsc --noEmit

// eslint.config.js (flat config with TypeScript)
import eslint from '@eslint/js'
import tseslint from 'typescript-eslint'

export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.strictTypeChecked,
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
      },
    },
  },
)

# Editor support
# VS Code: ESLint + Prettier extensions
# Biome: Biome VS Code extension
# Type errors shown inline via TypeScript language server

PHP has mature code quality tools for formatting, linting, and static analysis.

# PHP CS Fixer — code formatter
composer require --dev friendsofphp/php-cs-fixer
./vendor/bin/php-cs-fixer fix src/

# PHP_CodeSniffer — linter & fixer
composer require --dev squizlabs/php_codesniffer
./vendor/bin/phpcs src/         # Lint
./vendor/bin/phpcbf src/        # Auto-fix

# PHPStan — static analysis
composer require --dev phpstan/phpstan
./vendor/bin/phpstan analyse src/ --level=max

# Psalm — static analysis (alternative)
composer require --dev vimeo/psalm
./vendor/bin/psalm

# Rector — automated refactoring
composer require --dev rector/rector
./vendor/bin/rector process src/

// .php-cs-fixer.dist.php
<?php
return (new PhpCsFixer\Config())
    ->setRules([
        '@PSR12' => true,
        'array_syntax' => ['syntax' => 'short'],
        'no_unused_imports' => true,
        'ordered_imports' => true,
    ])
    ->setFinder(
        PhpCsFixer\Finder::create()->in(__DIR__ . '/src')
    );

RuboCop is the standard linter and formatter. Sorbet adds static typing.

# RuboCop — linter & formatter
gem install rubocop
rubocop                    # Lint
rubocop -a                 # Auto-fix safe cops
rubocop -A                 # Auto-fix all cops (including unsafe)

# RuboCop with Rails extensions
gem install rubocop-rails rubocop-rspec rubocop-performance
rubocop --require rubocop-rails

# Standard Ruby — opinionated RuboCop config (zero config)
gem install standard
standardrb                 # Lint
standardrb --fix           # Auto-fix

# Sorbet — static type checker
gem install sorbet sorbet-runtime
srb init                   # Initialize in project
srb tc                     # Type check

# Steep — alternative type checker (uses RBS)
gem install steep
steep check

# .rubocop.yml
require:
  - rubocop-rails
  - rubocop-rspec

AllCops:
  NewCops: enable
  TargetRubyVersion: 3.3

Style/StringLiterals:
  EnforcedStyle: single_quotes

Metrics/MethodLength:
  Max: 15

Go has strong built-in tooling. Formatting is enforced by convention — all Go code looks the same.

# gofmt — built-in formatter (canonical style)
gofmt -w .

# goimports — gofmt + auto-manage imports
go install golang.org/x/tools/cmd/goimports@latest
goimports -w .

# go vet — built-in static analysis
go vet ./...

# golangci-lint — meta-linter (runs many linters)
# Install: https://golangci-lint.run/usage/install/
golangci-lint run

# staticcheck — advanced static analysis
go install honnef.co/go/tools/cmd/staticcheck@latest
staticcheck ./...

# .golangci.yml
linters:
  enable:
    - errcheck
    - govet
    - staticcheck
    - unused
    - gosimple
    - ineffassign
    - misspell
    - revive

# Editor: gopls (Go language server) provides
# formatting, linting, and refactoring in all editors

Rust ships with rustfmt and clippy as official tools. The compiler itself is an excellent linter.

# rustfmt — official formatter
rustfmt src/main.rs
cargo fmt              # Format entire project
cargo fmt -- --check   # Check without modifying

# Clippy — official linter (hundreds of lints)
cargo clippy
cargo clippy -- -W clippy::pedantic  # Stricter lints
cargo clippy --fix     # Auto-fix suggestions

# cargo check — fast type/borrow checking (no codegen)
cargo check

# rustfmt.toml
max_width = 100
edition = "2021"
use_field_init_shorthand = true

# Clippy config in Cargo.toml
[lints.clippy]
pedantic = { level = "warn", priority = -1 }
needless_pass_by_value = "allow"

# rust-analyzer — language server for all editors
# Provides inline errors, completions, refactoring,
# hover docs, and inlay type hints

C++ uses clang-format for formatting and clang-tidy for linting. Both are part of the LLVM toolchain.

# clang-format — code formatter
clang-format -i src/*.cpp src/*.h
clang-format --style=file -i main.cpp  # Use .clang-format

# clang-tidy — linter and static analyzer
clang-tidy src/*.cpp -- -std=c++20
clang-tidy --fix src/main.cpp

# cppcheck — additional static analysis
cppcheck --enable=all src/

# include-what-you-use — minimize #includes
iwyu src/main.cpp

# .clang-format
BasedOnStyle: Google
ColumnLimit: 100
IndentWidth: 4
Language: Cpp
Standard: c++20
AllowShortFunctionsOnASingleLine: Inline

# .clang-tidy
Checks: >
  -*,
  bugprone-*,
  modernize-*,
  performance-*,
  readability-*,
  -modernize-use-trailing-return-type
WarningsAsErrors: ''

C# uses .editorconfig for style rules and Roslyn analyzers for linting. dotnet format is the built-in formatter.

# dotnet format — built-in formatter
dotnet format                 # Format entire solution
dotnet format --verify-no-changes  # CI check

# Roslyn analyzers (NuGet packages)
dotnet add package Microsoft.CodeAnalysis.NetAnalyzers
dotnet add package StyleCop.Analyzers

# CSharpier — Prettier-inspired opinionated formatter
dotnet tool install csharpier -g
dotnet csharpier .

# .editorconfig
[*.cs]
indent_style = space
indent_size = 4
dotnet_sort_system_directives_first = true
csharp_new_line_before_open_brace = all
csharp_prefer_braces = true
dotnet_diagnostic.CA1062.severity = warning

<!-- Directory.Build.props — enable analyzers project-wide -->
<Project>
  <PropertyGroup>
    <AnalysisLevel>latest-recommended</AnalysisLevel>
    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>
</Project>

Swift uses swift-format (Apple’s official formatter) or SwiftLint for linting. Xcode provides built-in formatting.

# swift-format — official formatter
brew install swift-format
swift-format format --in-place Sources/
swift-format lint Sources/

# SwiftLint — community linter (widely adopted)
brew install swiftlint
swiftlint
swiftlint --fix       # Auto-fix

# .swiftlint.yml
disabled_rules:
  - trailing_whitespace
opt_in_rules:
  - empty_count
  - closure_spacing
  - force_unwrapping
excluded:
  - .build
  - Packages
line_length:
  warning: 120
  error: 150

// .swift-format (JSON config)
{
  "version": 1,
  "indentation": { "spaces": 4 },
  "lineLength": 120,
  "maximumBlankLines": 1,
  "respectsExistingLineBreaks": true
}

# Xcode: Editor > Structure > Re-Indent (Ctrl+I)
# Periphery — detect unused code
brew install peripheryapp/periphery/periphery
periphery scan

Kotlin uses ktlint for linting/formatting and detekt for static analysis. IntelliJ IDEA provides built-in formatting.

# ktlint — linter + formatter (follows Kotlin style guide)
brew install ktlint
ktlint                # Lint
ktlint --format       # Auto-format

# detekt — static analysis
# Add to build.gradle.kts:
# plugins { id("io.gitlab.arturbosch.detekt") version "1.23.0" }
./gradlew detekt

# ktfmt — Google's Kotlin formatter
# Alternative to ktlint with Google/Meta style

# detekt.yml
complexity:
  LongMethod:
    threshold: 30
  ComplexCondition:
    threshold: 4
style:
  MaxLineLength:
    maxLineLength: 120
  WildcardImport:
    active: true

// build.gradle.kts — Spotless plugin (multi-formatter)
plugins {
    id("com.diffplug.spotless") version "6.25.0"
}
spotless {
    kotlin {
        ktlint()
        target("src/**/*.kt")
    }
}
// Run: ./gradlew spotlessApply

Python has mature formatting and linting tools. Ruff is rapidly becoming the standard for both.

# Ruff — extremely fast linter + formatter (Rust-based)
pip install ruff
ruff check .          # Lint
ruff format .         # Format
ruff check --fix .    # Auto-fix

# Black — opinionated formatter
pip install black
black .

# isort — import sorting (built into Ruff)
pip install isort
isort .

# mypy — static type checker
pip install mypy
mypy src/

# pyright — fast type checker (Microsoft)
pip install pyright
pyright

# pyproject.toml
[tool.ruff]
line-length = 100
target-version = "py312"

[tool.ruff.lint]
select = ["E", "F", "I", "N", "UP", "B"]

[tool.mypy]
strict = true

Interpreted / JIT-compiled. JavaScript is parsed and JIT-compiled at runtime by the engine (V8, SpiderMonkey, JavaScriptCore).

# No compile step — run directly
node app.js
deno run app.js
bun run app.js

# Bundling for browsers (not compilation, but required)
npx vite build         # Vite (esbuild + Rollup)
npx esbuild app.js --bundle --outfile=out.js
npx webpack            # webpack

# Output: .js bundles, source maps
# No binary output — always JavaScript

Execution model:

• Source → Parse → AST → Bytecode → JIT machine code
• V8 uses TurboFan (optimizing compiler) and Sparkplug (baseline)
• No ahead-of-time compilation (except experimental with Hermes, QuickJS)
• Tree-shaking and dead-code elimination happen at bundle time, not compile time

Transpiled to JavaScript, then interpreted/JIT. TypeScript is compiled to JS by tsc, or stripped/transpiled by faster tools.

# tsc — official compiler (type-check + emit JS)
npx tsc                    # Compile project
npx tsc --noEmit           # Type-check only (no output)
npx tsc --watch            # Watch mode

# Faster alternatives (strip types, no type-checking)
npx esbuild src/index.ts --bundle --outfile=out.js
npx tsup src/index.ts      # Library bundler
npx tsx src/index.ts        # Run directly (no build)

# Output: .js + .d.ts (type declarations) + .js.map

Execution model:

• TypeScript → JavaScript (types erased) → Engine JIT
• tsc performs full type checking but is slow for large projects
• Most build tools (esbuild, SWC, Bun) only strip types — no type checking
• --isolatedDeclarations enables parallel .d.ts generation
• Node.js 22+ can run .ts files directly (type stripping)

Interpreted with optional OPcache. PHP scripts are compiled to bytecode at runtime. OPcache stores precompiled bytecode in shared memory.

# No compile step — run directly
php app.php

# Built-in web server (development)
php -S localhost:8000 -t public

# Production — typically served via PHP-FPM + Nginx/Apache
# PHP-FPM compiles and caches bytecode via OPcache

# Check OPcache status
php -r "var_dump(opcache_get_status());"

Execution model:

• Source → Lexer → Parser → AST → Opcodes → Zend VM execution
• OPcache: Stores compiled opcodes in shared memory (skip parse/compile on each request)
• JIT compiler (PHP 8.0+): Compiles hot opcodes to machine code via DynASM
• Preloading (PHP 7.4+): Load files into memory at server start
• No standalone binary output — always requires PHP runtime
• RoadRunner / FrankenPHP: Keep PHP workers alive between requests (no per-request boot)

Interpreted. Ruby code is parsed into an AST, compiled to bytecode, and executed by YARV (Yet Another Ruby VM). JIT compilation available since Ruby 2.6.

# No compile step — run directly
ruby app.rb

# Ruby with JIT (YJIT — default since Ruby 3.3)
ruby --yjit app.rb

# Check if YJIT is enabled
ruby -e "puts RubyVM::YJIT.enabled?"

# MJIT (older JIT, deprecated in 3.3)
ruby --mjit app.rb

# Precompile to bytecode (for inspection)
ruby --dump=insns script.rb

Execution model:

• Source → Lexer → Parser → AST → YARV bytecode → VM execution
• YJIT (Ruby 3.1+): Lazy Basic Block Versioning JIT compiler, written in Rust
• YJIT is enabled by default in Ruby 3.3+ and gives 15-25% speedup for Rails apps
• mruby: Lightweight Ruby for embedded systems
• TruffleRuby: GraalVM-based implementation with aggressive JIT
• JRuby: Ruby on the JVM — true threads, Java interop

Ahead-of-time compiled to native binary. Go compiles directly to machine code. No VM, no runtime dependency.

# Compile and run
go run main.go           # Compile + run in one step
go build -o myapp .      # Compile to binary
./myapp                  # Run the binary

# Release build
go build -ldflags="-s -w" -o myapp .  # Strip debug info

# Cross-compilation (built-in!)
GOOS=linux GOARCH=amd64 go build -o myapp-linux .
GOOS=darwin GOARCH=arm64 go build -o myapp-mac .
GOOS=windows GOARCH=amd64 go build -o myapp.exe .

# Output: single static binary (no dependencies)

Execution model:

• Source → AST → SSA IR → Machine code (single binary)
• Compilation is extremely fast (seconds for large projects)
• Statically linked by default — one binary, zero dependencies
• Includes a small runtime (goroutine scheduler, GC) in the binary
• No JIT — all optimization happens at compile time

Ahead-of-time compiled to native binary via LLVM. Rust produces highly optimized machine code with zero-cost abstractions.

# Debug build (fast compile, slow runtime)
cargo build
./target/debug/myapp

# Release build (slow compile, fast runtime)
cargo build --release
./target/release/myapp

# Compile + run
cargo run
cargo run --release

# Cross-compilation
rustup target add x86_64-unknown-linux-musl
cargo build --target x86_64-unknown-linux-musl --release

# Check without building (fastest feedback)
cargo check

# Output: native binary, or .rlib/.so/.a for libraries

Execution model:

• Source → HIR → MIR (borrow checking) → LLVM IR → Machine code
• No runtime, no GC — zero-cost abstractions
• Compile times are slower than Go/C due to deep optimization + borrow checker
• Incremental compilation and sccache help with rebuild speed
• Can target WASM: cargo build --target wasm32-unknown-unknown

Ahead-of-time compiled to native binary. C++ compiles through a preprocessor → compiler → assembler → linker pipeline.

# Direct compilation
g++ -std=c++20 -O2 -o myapp main.cpp
clang++ -std=c++20 -O2 -o myapp main.cpp

# With CMake (standard build system)
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build
./build/myapp

# Compile steps (explicit)
g++ -c main.cpp -o main.o    # Compile to object file
g++ main.o -o myapp           # Link

# Cross-compilation
x86_64-linux-gnu-g++ -o myapp main.cpp

# Output: native binary, .o object files, .a/.so libraries

Execution model:

• Source → Preprocessor (#include expansion) → Compiler → Assembly → Object files → Linker → Binary
• Headers are textually included (slow — modules in C++20 help)
• Template instantiation happens at compile time (can be slow)
• No runtime, no GC — manual memory or RAII
• Link-time optimization (LTO) can significantly improve performance

Compiled to IL (Intermediate Language), then JIT or AOT compiled. C# targets the .NET runtime (CLR).

# Build (compiles to IL in .dll)
dotnet build
dotnet build -c Release

# Run (JIT compiles IL to native at runtime)
dotnet run

# Publish — framework-dependent (needs .NET installed)
dotnet publish -c Release

# Publish — self-contained (includes runtime)
dotnet publish -c Release --self-contained -r linux-x64

# Native AOT (ahead-of-time, .NET 8+)
dotnet publish -c Release -r linux-x64 /p:PublishAot=true
# Output: single native binary, no .NET runtime needed

Execution model:

• Source → Roslyn compiler → IL (.dll) → JIT (RyuJIT) → Machine code
• JIT compilation happens at runtime, method by method
• Native AOT eliminates JIT — compiles directly to native binary
• Tiered compilation: quick JIT first, re-optimize hot paths
• ReadyToRun (R2R) pre-compiles IL for faster startup

Ahead-of-time compiled via LLVM. Swift compiles to native code. Apps can also use the Swift runtime for dynamic features.

# Compile a single file
swiftc hello.swift -o hello

# Build with SPM
swift build                   # Debug
swift build -c release        # Release

# Run
swift run

# Xcode build
xcodebuild -scheme MyApp -configuration Release build

# Output: native binary (macOS/Linux), .app bundle (macOS/iOS)

Execution model:

• Source → SIL (Swift Intermediate Language) → LLVM IR → Machine code
• Whole-module optimization (-whole-module-optimization) for release builds
• Swift runtime is included in the OS on Apple platforms (since iOS 12.2)
• On Linux, the Swift runtime is bundled with the binary
• Supports both static and dynamic linking
• Incremental compilation for fast debug builds

Compiled to JVM bytecode (default), or native/JS. Kotlin targets multiple backends via the Kotlin compiler.

# Compile to JVM bytecode
kotlinc hello.kt -include-runtime -d hello.jar
java -jar hello.jar

# Build with Gradle
./gradlew build
./gradlew run

# Kotlin/Native — compile to native binary (no JVM)
# Uses Kotlin/Native compiler (LLVM-based)
# Output: native executable

# Kotlin/JS — compile to JavaScript
# Output: .js files for browser or Node.js

# Kotlin Multiplatform — shared code across targets
./gradlew :shared:build

Execution model:

• JVM: Source → Kotlin IR → JVM bytecode (.class/.jar) → JIT (HotSpot)
• Native: Source → Kotlin IR → LLVM IR → Machine code
• JS: Source → Kotlin IR → JavaScript
• WASM: Source → Kotlin IR → WebAssembly (experimental)
• JVM target benefits from HotSpot JIT, tiered compilation, and GC
• Gradle build can be slow — use build cache and configuration cache

Interpreted with bytecode compilation. Python compiles source to bytecode (.pyc), then executes on the CPython VM.

# No explicit compile step — run directly
python3 app.py

# Bytecode is auto-cached in __pycache__/
# Force compile all files
python3 -m compileall src/

# PyInstaller — bundle into standalone executable
pip install pyinstaller
pyinstaller --onefile app.py
# Output: dist/app (single binary)

# Nuitka — compile to C, then native binary
pip install nuitka
nuitka --standalone app.py

# Cython — compile Python to C extension modules
cython module.pyx

Execution model:

• Source → Bytecode (.pyc) → CPython VM interpreter
• CPython has a GIL (Global Interpreter Lock) — one thread executes Python at a time
• Alternative runtimes: PyPy (JIT), GraalPy, Cython (AOT to C)
• Python 3.13+ has experimental free-threaded mode (no GIL)
• No static binary output by default — requires third-party tools

JavaScript has an enormous ecosystem. Key libraries and frameworks by category:

Web Frameworks - React, Vue, Svelte, Angular, Solid, Astro, Next.js, Nuxt, SvelteKit, Remix

Server / API - Express, Fastify, Hono, Koa, Nest.js, tRPC

Build Tools - Vite, esbuild, Rollup, webpack, Turbopack, Parcel

State Management - Zustand, Jotai, Redux Toolkit, Pinia (Vue), Signals

Styling - Tailwind CSS, Styled Components, CSS Modules, UnoCSS

Databases / ORM - Prisma, Drizzle, Mongoose, Knex, TypeORM

Utilities - Lodash, date-fns, Zod, Axios, Ramda

Testing - Vitest, Jest, Playwright, Cypress, Testing Library

Desktop - Electron, Tauri

Mobile - React Native, Expo, Capacitor, NativeScript

TypeScript uses the same ecosystem as JavaScript. These libraries are TypeScript-first or have excellent type support:

Type-First Libraries - Zod (schema validation), tRPC (end-to-end typesafe APIs), Drizzle ORM, Effect, ts-pattern

Web Frameworks - Next.js, Nuxt, SvelteKit, Remix, Astro, Hono - all have first-class TS support

Full-Stack - T3 Stack (Next.js + tRPC + Prisma + Tailwind), Blitz.js, RedwoodJS

Runtime/Build - tsx, tsup, unbuild, Vite, esbuild

State Management - Zustand, Jotai, XState - all TypeScript-first

Validation - Zod, Valibot, ArkType, io-ts, Yup

API Clients - Axios, ky, openapi-typescript, GraphQL Code Generator

Type Utilities - type-fest, ts-essentials, utility-types

Testing - Vitest, Jest, Playwright - all TypeScript-native

PHP has a mature ecosystem with powerful frameworks and libraries:

Web Frameworks - Laravel, Symfony, Slim, CodeIgniter, CakePHP, Laminas (Zend)

CMS - WordPress, Drupal, Joomla, Craft CMS, Statamic

API - API Platform (Symfony), Laravel API Resources, Lumen

Database / ORM - Eloquent (Laravel), Doctrine, Propel, RedBeanPHP

Templating - Blade (Laravel), Twig (Symfony), Plates

HTTP Clients - Guzzle, Symfony HttpClient, cURL wrapper

Testing - PHPUnit, Pest, Mockery, Codeception

Utilities - Carbon (dates), Flysystem (filesystem), Monolog (logging), League packages

Queue / Async - Laravel Queues, Symfony Messenger, ReactPHP, Swoole

Admin Panels - Filament, Nova, Backpack

Ruby has a rich ecosystem centered around web development and developer tooling:

Web Frameworks - Rails, Sinatra, Hanami, Roda, Grape (API)

Background Jobs - Sidekiq, GoodJob, Solid Queue, Delayed Job, Resque

Database / ORM - ActiveRecord (Rails), Sequel, ROM (Ruby Object Mapper)

API - GraphQL Ruby, Grape, JSONAPI::Resources, jbuilder

Authentication - Devise, Rodauth, OmniAuth, Sorcery

Testing - RSpec, Minitest, Capybara, FactoryBot, VCR

HTTP Clients - Faraday, HTTParty, Net::HTTP (stdlib), Typhoeus

CLI - Thor, TTY toolkit, OptionParser (stdlib)

Utilities - Nokogiri (HTML/XML), Pry (debugging), Dry-rb (functional patterns), ActiveSupport

DevOps - Capistrano (deployment), Chef, Puppet, Vagrant

Go has a rich standard library and a growing ecosystem focused on cloud, networking, and backend services.

Web Frameworks - Gin, Echo, Fiber, Chi, net/http (stdlib)

API / RPC - gRPC, Connect, Twirp, OpenAPI generators

Databases - GORM, sqlx, pgx, ent, database/sql (stdlib)

Cloud / Infra - Docker, Kubernetes client-go, Terraform Plugin Framework, AWS SDK

CLI - Cobra, urfave/cli, Bubble Tea (TUI), Charm tools

Logging - slog (stdlib), Zap, zerolog, logrus

Config - Viper, envconfig, koanf

Testing - testify, gomock, ginkgo, go-cmp

Concurrency - errgroup, semaphore (x/sync), conc

Serialization - encoding/json (stdlib), json-iterator, protobuf

HTTP Clients - net/http (stdlib), resty, req

Rust’s ecosystem is centered on crates.io. Strong focus on performance, safety, and systems programming.

Web Frameworks - Actix Web, Axum, Rocket, Warp, Poem

Async Runtime - Tokio, async-std, smol

Serialization - serde, serde_json, bincode, postcard

Databases - SQLx, Diesel, SeaORM, rusqlite

CLI - clap, structopt, dialoguer, indicatif, ratatui (TUI)

Error Handling - anyhow, thiserror, eyre, miette

HTTP Clients - reqwest, hyper, ureq

Logging - tracing, log, env_logger

Concurrency - rayon, crossbeam, tokio, parking_lot

Crypto - ring, rustls, rust-crypto

WASM - wasm-bindgen, wasm-pack, Leptos, Yew, Dioxus

Embedded - embedded-hal, embassy, probe-rs

C++ has a vast ecosystem spanning systems, games, embedded, and high-performance computing.

Standard Library - STL, containers, algorithms, iterators, ranges, <format>, <filesystem>

GUI / Graphics - Qt, Dear ImGui, SDL, SFML, wxWidgets, GLFW

Game Engines - Unreal Engine, Godot, Cocos2d-x

Networking - Boost.Asio, cpp-httplib, libcurl, gRPC

Serialization - nlohmann/json, protobuf, cereal, MessagePack

Databases - SQLite (C API), SOCI, libpq, sqlpp11

Build Systems - CMake, Meson, Bazel, xmake

Package Managers - vcpkg, Conan, CPM.cmake

Testing - Google Test, Catch2, Doctest, Boost.Test

Concurrency - std::thread, std::async, Intel TBB, OpenMP

Math / Science - Eigen, Armadillo, BLAS/LAPACK, OpenCV

Embedded - Arduino, ESP-IDF, Zephyr, mbed

C# has a mature ecosystem centered around .NET and NuGet. Strong in enterprise, web, games, and desktop.

Web Frameworks - ASP.NET Core, Minimal APIs, Blazor (WASM), Carter

Desktop / UI - WPF, WinUI 3, MAUI, Avalonia, WinForms

Game Development - Unity, Godot (C# support), MonoGame, Stride

ORM / Data - Entity Framework Core, Dapper, LINQ to DB, NHibernate

API / Communication - gRPC, SignalR, MassTransit, MediatR, Refit

Serialization - System.Text.Json, Newtonsoft.Json, MessagePack

Logging - Serilog, NLog, Microsoft.Extensions.Logging

Testing - xUnit, NUnit, FluentAssertions, Moq, NSubstitute, Bogus

Cloud - Azure SDK, AWS SDK, Pulumi

CLI - System.CommandLine, Spectre.Console, Cocona

DI / IoC - Microsoft.Extensions.DependencyInjection, Autofac

Swift’s ecosystem is centered around Apple platforms but expanding to server-side and cross-platform.

Apple Frameworks - SwiftUI, UIKit, AppKit, Combine, Core Data, CloudKit, ARKit, Metal

Server-Side - Vapor, Hummingbird, Smoke (AWS)

Networking - Alamofire, URLSession (stdlib), AsyncHTTPClient, Moya

Databases - Fluent (Vapor ORM), GRDB, SQLite.swift, Core Data, SwiftData

Reactive - Combine (stdlib), RxSwift, OpenCombine

UI Components - SnapKit (Auto Layout), Kingfisher (images), Lottie (animations)

Architecture - The Composable Architecture (TCA), swift-dependencies

Testing - Swift Testing, XCTest, Quick/Nimble, ViewInspector

CLI - Swift Argument Parser, Rainbow, swift-log

Concurrency - Swift Concurrency (async/await, actors), swift-async-algorithms

Cross-Platform - Skip (Swift to Kotlin/Android), SwiftCrossUI

Kotlin has access to the entire Java ecosystem plus Kotlin-specific libraries. Strong in Android, server, and multiplatform.

Android - Jetpack Compose, Android KTX, Hilt (DI), Room, Navigation, Lifecycle

Server - Ktor, Spring Boot (Kotlin support), Micronaut, http4k, Javalin

Multiplatform - Kotlin Multiplatform (KMP), Compose Multiplatform, KMM

Coroutines - kotlinx.coroutines, Flow, Channels

Serialization - kotlinx.serialization, Moshi, Gson (Java)

Networking - Ktor Client, OkHttp, Retrofit

Databases - Exposed, SQLDelight, Room (Android), ktorm

DI - Koin, Hilt (Android), Kodein

Testing - JUnit 5, Kotest, MockK, Turbine (Flow testing)

Build - Gradle Kotlin DSL, Amper (experimental)

Desktop - Compose for Desktop, TornadoFX

Functional - Arrow (FP library), kotlin-result

Python has a vast ecosystem spanning web, data science, machine learning, and automation.

Web Frameworks - Django, Flask, FastAPI, Starlette, Litestar

Data Science - NumPy, Pandas, Polars, SciPy, Matplotlib, Seaborn, Plotly

Machine Learning - scikit-learn, PyTorch, TensorFlow, Keras, Hugging Face Transformers, JAX

LLM / AI - LangChain, LlamaIndex, OpenAI SDK, Anthropic SDK

HTTP / API - Requests, httpx, aiohttp, urllib3

Databases / ORM - SQLAlchemy, Django ORM, Tortoise ORM, Peewee, databases

CLI - Click, Typer, argparse, Rich

Async - asyncio, trio, anyio, uvloop

Testing - pytest, unittest, hypothesis, coverage

DevOps / Automation - Fabric, Ansible, Boto3 (AWS), Celery

Type Checking - mypy, pyright, Pydantic

Popular testing frameworks include Vitest, Jest, and the built-in Node.js test runner. Playwright and Cypress are used for end-to-end testing.

// Vitest (recommended — fast, Vite-native)
import { describe, it, expect } from 'vitest'

describe('math', () => {
  it('adds numbers', () => {
    expect(1 + 2).toBe(3)
  })

  it('handles arrays', () => {
    expect([1, 2, 3]).toContain(2)
    expect([1, 2, 3]).toHaveLength(3)
  })
})

// Node.js built-in test runner (v18+)
import { describe, it } from 'node:test'
import assert from 'node:assert'

describe('math', () => {
  it('adds numbers', () => {
    assert.strictEqual(1 + 2, 3)
  })
})

# Run tests
npx vitest           # Vitest (watch mode)
npx vitest run       # Vitest (single run)
npx jest             # Jest
node --test          # Node.js built-in

# E2E testing
npx playwright test  # Playwright
npx cypress run      # Cypress

Same testing tools as JavaScript — Vitest and Jest work natively with TypeScript. Type-level testing is also possible.

// Vitest with TypeScript (zero config)
import { describe, it, expect } from 'vitest'

function add(a: number, b: number): number {
  return a + b
}

describe('add', () => {
  it('adds two numbers', () => {
    expect(add(1, 2)).toBe(3)
  })

  it('returns a number', () => {
    const result: number = add(1, 2)
    expect(typeof result).toBe('number')
  })
})

// Type-level testing with expectTypeOf (Vitest)
import { expectTypeOf } from 'vitest'

expectTypeOf(add).toBeFunction()
expectTypeOf(add).parameter(0).toBeNumber()
expectTypeOf(add).returns.toBeNumber()

# Run tests
npx vitest           # Vitest (watch mode)
npx jest             # Jest (needs ts-jest or @swc/jest)
node --test          # Node.js built-in (with tsx loader)

# Type-check as a test step
npx tsc --noEmit

PHPUnit is the standard testing framework. Pest provides a more expressive syntax.

// PHPUnit
use PHPUnit\Framework\TestCase;

class MathTest extends TestCase
{
    public function testAddition(): void
    {
        $this->assertEquals(3, 1 + 2);
        $this->assertTrue(true);
        $this->assertCount(3, [1, 2, 3]);
    }

    public function testException(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        throw new \InvalidArgumentException('bad input');
    }
}

// Pest — expressive testing framework
test('addition works', function () {
    expect(1 + 2)->toBe(3);
});

it('handles arrays', function () {
    expect([1, 2, 3])->toContain(2)->toHaveCount(3);
});

# Run tests
./vendor/bin/phpunit
./vendor/bin/pest

# With coverage
./vendor/bin/phpunit --coverage-text
XDEBUG_MODE=coverage ./vendor/bin/pest --coverage

RSpec and Minitest are the two main testing frameworks. RSpec is more popular in the Rails community.

# RSpec
RSpec.describe 'Math' do
  it 'adds numbers' do
    expect(1 + 2).to eq(3)
  end

  it 'handles arrays' do
    expect([1, 2, 3]).to include(2)
    expect([1, 2, 3]).to have_attributes(length: 3)
  end

  context 'with negative numbers' do
    it 'returns negative sum' do
      expect(-1 + -2).to eq(-3)
    end
  end
end

# Minitest
require 'minitest/autorun'

class MathTest < Minitest::Test
  def test_addition
    assert_equal 3, 1 + 2
  end

  def test_array_includes
    assert_includes [1, 2, 3], 2
  end
end

# Run tests
bundle exec rspec                # RSpec
bundle exec rspec spec/models/   # Specific directory
ruby -Itest test/math_test.rb    # Minitest
bundle exec rails test           # Rails default (Minitest)

# With coverage
# Add simplecov gem, then: COVERAGE=true bundle exec rspec

Go has a built-in testing framework in the testing package. No external dependencies needed. testify is a popular assertion library.

// math_test.go — test files end in _test.go
package math

import "testing"

func TestAdd(t *testing.T) {
    result := Add(1, 2)
    if result != 3 {
        t.Errorf("Add(1, 2) = %d; want 3", result)
    }
}

// Table-driven tests (idiomatic Go pattern)
func TestAddTable(t *testing.T) {
    tests := []struct {
        a, b, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, tt := range tests {
        got := Add(tt.a, tt.b)
        if got != tt.want {
            t.Errorf("Add(%d, %d) = %d, want %d",
                tt.a, tt.b, got, tt.want)
        }
    }
}

// Benchmarks
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(1, 2)
    }
}

# Run tests
go test ./...           # All packages
go test -v ./...        # Verbose
go test -run TestAdd    # Specific test
go test -bench .        # Run benchmarks
go test -cover          # With coverage
go test -race ./...     # Race condition detection

Rust has built-in testing support — no external framework needed. Tests live alongside code or in a tests/ directory.

// Unit tests — in the same file as the code
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(1, 2), 3);
    }

    #[test]
    fn test_add_negative() {
        assert_eq!(add(-1, 1), 0);
    }

    #[test]
    #[should_panic(expected = "overflow")]
    fn test_overflow() {
        let _: u8 = 255u8 + 1; // panics in debug mode
    }
}

// Integration tests — in tests/ directory
// tests/integration_test.rs
use my_crate::add;

#[test]
fn it_adds() {
    assert_eq!(add(2, 3), 5);
}

# Run tests
cargo test              # All tests
cargo test test_add     # Specific test
cargo test -- --nocapture  # Show println! output
cargo test --doc        # Doc tests only
cargo bench             # Benchmarks (nightly)

No built-in testing framework. Google Test (gtest) and Catch2 are the most popular. Doctest is a lightweight alternative.

// Google Test
#include <gtest/gtest.h>

TEST(MathTest, Addition) {
    EXPECT_EQ(1 + 2, 3);
}

TEST(MathTest, Negative) {
    EXPECT_EQ(-1 + 1, 0);
    EXPECT_GT(5, 3);
    EXPECT_TRUE(true);
}

// Parameterized tests
class AddTest : public ::testing::TestWithParam<
    std::tuple<int, int, int>> {};

TEST_P(AddTest, AddsCorrectly) {
    auto [a, b, expected] = GetParam();
    EXPECT_EQ(a + b, expected);
}

INSTANTIATE_TEST_SUITE_P(Math, AddTest,
    ::testing::Values(
        std::make_tuple(1, 2, 3),
        std::make_tuple(0, 0, 0)
    ));

// Catch2 — header-only, no macros
#include <catch2/catch_test_macros.hpp>

TEST_CASE("Addition works", "[math]") {
    REQUIRE(1 + 2 == 3);

    SECTION("with negatives") {
        REQUIRE(-1 + 1 == 0);
    }
}

# Run tests (with CMake + CTest)
cmake -B build && cmake --build build
cd build && ctest --output-on-failure

Popular frameworks: xUnit (most popular), NUnit, and MSTest. FluentAssertions improves readability. Built-in dotnet test runner.

// xUnit (recommended)
using Xunit;

public class MathTests
{
    [Fact]
    public void Add_ReturnsCorrectSum()
    {
        Assert.Equal(3, 1 + 2);
    }

    [Theory]
    [InlineData(1, 2, 3)]
    [InlineData(0, 0, 0)]
    [InlineData(-1, 1, 0)]
    public void Add_WithVariousInputs(int a, int b, int expected)
    {
        Assert.Equal(expected, a + b);
    }
}

// FluentAssertions — readable assertions
using FluentAssertions;

[Fact]
public void List_Should_Contain_Item()
{
    var list = new[] { 1, 2, 3 };
    list.Should().Contain(2);
    list.Should().HaveCount(3);
}

# Run tests
dotnet test                    # All tests
dotnet test --filter "Add"     # Specific tests
dotnet test --collect:"XPlat Code Coverage"  # With coverage
dotnet test --logger "console;verbosity=detailed"

Swift has a built-in testing framework: Swift Testing (new, from Swift 5.9+) and XCTest (traditional). Both integrate with Xcode and SPM.

// Swift Testing (modern, recommended)
import Testing

@Test func addition() {
    #expect(1 + 2 == 3)
}

@Test("Addition with negatives")
func negativeAddition() {
    #expect(-1 + 1 == 0)
}

// Parameterized tests
@Test(arguments: [
    (1, 2, 3),
    (0, 0, 0),
    (-1, 1, 0),
])
func add(a: Int, b: Int, expected: Int) {
    #expect(a + b == expected)
}

// XCTest (traditional)
import XCTest

class MathTests: XCTestCase {
    func testAdd() {
        XCTAssertEqual(1 + 2, 3)
    }

    func testPerformance() {
        measure {
            // Code to benchmark
        }
    }
}

# Run tests
swift test                    # SPM projects
swift test --filter MathTests # Specific test
# In Xcode: Cmd+U to run all tests
# In Xcode: Click diamond next to test to run individually

JUnit 5 is the standard. Kotest is a Kotlin-native alternative with expressive DSLs. MockK is the preferred mocking library.

// JUnit 5 with Kotlin
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.*

class MathTest {
    @Test
    fun `adds two numbers`() {
        assertEquals(3, 1 + 2)
    }

    @Test
    fun `list contains element`() {
        val list = listOf(1, 2, 3)
        assertTrue(2 in list)
        assertEquals(3, list.size)
    }
}

// Parameterized tests
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvSource

class ParameterizedMathTest {
    @ParameterizedTest
    @CsvSource("1,2,3", "0,0,0", "-1,1,0")
    fun `adds correctly`(a: Int, b: Int, expected: Int) {
        assertEquals(expected, a + b)
    }
}

// Kotest — Kotlin-native testing framework
import io.kotest.core.spec.style.StringSpec
import io.kotest.matchers.shouldBe
import io.kotest.matchers.collections.shouldContain

class MathSpec : StringSpec({
    "addition works" {
        (1 + 2) shouldBe 3
    }

    "list contains element" {
        listOf(1, 2, 3) shouldContain 2
    }
})

# Run tests
./gradlew test                          # All tests
./gradlew test --tests "MathTest"       # Specific class
./gradlew test --tests "*adds*"         # Pattern match

pytest is the de facto standard. Python also includes unittest in the standard library. hypothesis provides property-based testing.

# pytest (recommended)
def test_addition():
    assert 1 + 2 == 3

def test_list_contains():
    assert 2 in [1, 2, 3]

# Fixtures for setup/teardown
import pytest

@pytest.fixture
def sample_list():
    return [1, 2, 3]

def test_length(sample_list):
    assert len(sample_list) == 3

# Parametrize — run test with multiple inputs
@pytest.mark.parametrize("a,b,expected", [
    (1, 2, 3),
    (0, 0, 0),
    (-1, 1, 0),
])
def test_add(a, b, expected):
    assert a + b == expected

# unittest (standard library)
import unittest

class TestMath(unittest.TestCase):
    def test_add(self):
        self.assertEqual(1 + 2, 3)

# Run tests
pytest                  # pytest (auto-discovers tests)
pytest -v               # Verbose output
pytest --cov=mypackage  # With coverage
python -m unittest      # Standard library

Chrome DevTools for browser, Node.js inspector for server. console methods and debugger statement.

// console methods
console.log('basic log')
console.error('error message')
console.warn('warning')
console.table([{ name: 'Alice', age: 30 }])
console.dir(obj, { depth: null })
console.time('op'); doWork(); console.timeEnd('op')
console.trace('call stack')
console.group('section'); /* ... */ console.groupEnd()

// debugger statement — triggers breakpoint
function processData(data) {
  debugger  // Pauses here if DevTools is open
  return data.map(transform)
}

# Node.js debugging
node --inspect app.js          # Start with inspector
node --inspect-brk app.js     # Break on first line
# Open chrome://inspect in Chrome

# VS Code — built-in debugger
# launch.json:
{
  "type": "node",
  "request": "launch",
  "program": "${workspaceFolder}/src/index.js",
  "console": "integratedTerminal"
}
# Set breakpoints by clicking gutter
# F5 to start, F10 step over, F11 step into

# Chrome DevTools
# Sources tab: breakpoints, watch, call stack
# Network tab: request/response inspection
# Console tab: live REPL in page context
# Elements tab: DOM inspection

# ndb — improved Node.js debugging
npx ndb node app.js

Same tools as JavaScript. Source maps enable debugging TypeScript directly. VS Code has first-class TS debugging support.

# Source maps — map compiled JS back to TS
# tsconfig.json: "sourceMap": true

# VS Code debugging (recommended)
# launch.json:
{
  "type": "node",
  "request": "launch",
  "program": "${workspaceFolder}/src/index.ts",
  "runtimeExecutable": "tsx",
  "console": "integratedTerminal"
}

# Or with ts-node
{
  "type": "node",
  "request": "launch",
  "runtimeArgs": ["-r", "ts-node/register"],
  "args": ["${workspaceFolder}/src/index.ts"]
}

# Chrome DevTools — works with source maps
node --inspect -r tsx/cjs src/index.ts

// Type-narrowing aids debugging
function process(input: string | number) {
  if (typeof input === 'string') {
    // TypeScript knows input is string here
    console.log(input.toUpperCase())
  }
}

// satisfies — catch type errors without changing runtime
const config = {
  port: 3000,
  host: 'localhost',
} satisfies Record<string, string | number>

// // @ts-expect-error — document expected errors
// @ts-expect-error — testing invalid input
process(null)

Xdebug is the primary debugger. Laravel has Telescope and Debugbar for web debugging.

// Basic debugging
var_dump($variable);       // Type + value
print_r($array);           // Human-readable array
echo gettype($variable);   // Type name
debug_print_backtrace();   // Stack trace

// Error reporting
error_reporting(E_ALL);
ini_set('display_errors', '1');

// Logging
error_log('Something happened');
error_log(print_r($data, true));  // Log complex data

# Xdebug — install and configure
pecl install xdebug

# php.ini configuration
zend_extension=xdebug
xdebug.mode=debug
xdebug.start_with_request=yes
xdebug.client_port=9003

# VS Code — install "PHP Debug" extension
# launch.json:
{
  "type": "php",
  "request": "launch",
  "name": "Listen for Xdebug",
  "port": 9003
}

# Laravel Telescope — request/job/query inspector
composer require laravel/telescope
php artisan telescope:install

# Laravel Debugbar
composer require barryvdh/laravel-debugbar --dev
# Automatically shows debug info in browser

debug gem (Ruby 3.1+ built-in) and Pry are the primary debugging tools.

# Built-in debug gem (Ruby 3.1+)
require 'debug'

def process(data)
  binding.break  # Breakpoint — opens debugger
  data.map { |x| x * 2 }
end

# Pry — enhanced REPL debugger
require 'pry'

def process(data)
  binding.pry  # Breakpoint — opens Pry session
  data.map { |x| x * 2 }
end

# Basic debugging
puts variable.inspect
p variable              # Shorthand for puts .inspect
pp complex_object       # Pretty print
warn "debug message"    # Print to stderr

# debug gem commands (at breakpoint)
# n / next      — step over
# s / step      — step into
# c / continue  — continue execution
# bt            — backtrace
# info          — show local variables
# eval expr     — evaluate expression

# Start script in debug mode
ruby -r debug script.rb
rdbg script.rb

# VS Code — install "Ruby LSP" extension
# launch.json:
{
  "type": "ruby_lsp",
  "request": "launch",
  "program": "${workspaceFolder}/app.rb"
}

# Byebug (older, still used)
gem install byebug
# require 'byebug'; byebug  # in code

Delve is the standard Go debugger. Built-in log and fmt for print debugging. VS Code and GoLand have GUI support.

// Print debugging
fmt.Println("debug:", value)
fmt.Printf("type: %T, value: %+v\n", obj, obj)

// log package — timestamped output
import "log"
log.Println("starting server")
log.Printf("request: %+v", req)
log.Fatal("cannot start")  // Logs then os.Exit(1)

// slog — structured logging (Go 1.21+)
import "log/slog"
slog.Info("request", "method", r.Method, "path", r.URL.Path)
slog.Error("failed", "err", err, "user_id", id)

# Delve — Go debugger
go install github.com/go-delve/delve/cmd/dlv@latest

# Start debugging
dlv debug                 # Debug current package
dlv debug ./cmd/myapp     # Debug specific package
dlv test                  # Debug tests
dlv attach <pid>          # Attach to running process

# Delve commands:
# break main.go:42  (set breakpoint)
# continue           (run to breakpoint)
# next               (step over)
# step               (step into)
# print expr         (evaluate expression)
# goroutines         (list goroutines)
# stack              (show call stack)

# VS Code — built-in Go debugging
# Install Go extension, F5 to debug
# Breakpoints, watch, goroutine inspection

# GoLand (JetBrains) — built-in debugger
# Click gutter, Shift+F9 to debug

Use LLDB or GDB for debugging. The compiler provides excellent error messages. dbg!() macro for quick inspection.

// dbg! macro — print expression + value + file:line
let x = 42;
dbg!(x);        // [src/main.rs:3] x = 42
dbg!(x * 2);    // [src/main.rs:4] x * 2 = 84

// println! for basic output
println!("value: {:?}", my_struct);   // Debug format
println!("value: {:#?}", my_struct);  // Pretty-print

// eprintln! — print to stderr
eprintln!("error: {}", msg);

// tracing — structured logging
use tracing::{info, warn, error, debug, instrument};

#[instrument]
fn process(id: u32) {
    info!(id, "processing");
    debug!(?some_value, "details");
    error!(%err, "failed");
}

# LLDB (default on macOS, works on Linux)
lldb target/debug/myapp
# b main.rs:42    (breakpoint)
# r                (run)
# n                (next)
# s                (step into)
# p variable       (print)
# bt               (backtrace)

# GDB
gdb target/debug/myapp
# Same commands but GDB syntax

# VS Code — CodeLLDB extension (recommended)
# launch.json:
{
  "type": "lldb",
  "request": "launch",
  "program": "${workspaceFolder}/target/debug/myapp",
  "args": [],
  "cwd": "${workspaceFolder}"
}
# Set breakpoints, inspect variables, view call stack

# Compiler errors are the first line of debugging
# Rust's error messages include:
# - Exact location, suggested fixes
# - Borrow checker explanations
# cargo clippy for additional warnings