1
2

// main.swift
print("hello from swift")

1
2
3
4
5
6
7

package main

import "fmt"

func main() {
    fmt.Println("hello from go")
}

1
2
3
4
5

def main() -> None:
    print("hello from python")

if __name__ == "__main__":
    main()

1
2
3

fun main() {
    println("hello from kotlin")
}

1
2
3

void main() {                       // JDK 25+ 的紧凑源文件写法
    System.out.println("hello from java");
}

1
2
3
4
5

#include <print>

int main() {
    std::println("hello from c++");
}

1
2
3
4
5
6

#include <stdio.h>

int main(void) {
    puts("hello from c");
    return 0;
}

1
2
3
4
5

function main()
    println("hello from julia")
end

main()

1
2

// app.cs（.NET 10 文件级应用，可加 #:package 指令）
Console.WriteLine("hello from c#");

1
2
3

void main() {
    print('hello from dart');
}

1
2
3
4
5

main <- function() {
  cat("hello from R\n")
}

main()

1
2
3
4
5

const std = @import("std");

pub fn main() !void {
    std.debug.print("hello from zig\n", .{});
}

1
2
3
4
5

local function main()
  print("hello from lua")
end

main()

1
2
3
4

function main(): void {
  console.log("hello from typescript");
}
main();

1
2
3
4

function main() {
  console.log("hello from javascript");
}
main();

1
2
3
4
5
6

<?php
function main(): void {
    echo "hello from php\n";
}

main();

1
2
3
4
5

def main
  puts "hello from ruby"
end

main if __FILE__ == $0

1
2
3
4
5
6

swift main.swift                       # 解释执行，适合脚本
swiftc -O main.swift -o app && ./app    # 编译成原生可执行文件

swift package init --type executable    # 生成 Package.swift 与 Sources/
swift build -c release                  # 产物在 .build/release/
swift run                               # 编译并运行

1
2
3
4
5
6
7

go mod init example.com/demo     # 初始化模块（生成 go.mod）
go run main.go                   # 临时编译并运行
go build -o app .                # 生成二进制
./app

GOOS=windows GOARCH=amd64 go build -o app.exe .   # 一条命令交叉编译
go test -race ./...                                # 竞态检测

1
2
3
4
5
6
7

python3 main.py
python3 -m venv .venv && source .venv/bin/activate   # 虚拟环境
python3 -m pip install -r requirements.txt

python3 -O main.py            # __debug__ 变为 False，断言被移除
python3 -m compileall .        # 生成 __pycache__/*.pyc
python3 -X importtime main.py  # 看导入耗时

1
2
3
4
5
6
7
8

kotlinc main.kt -include-runtime -d app.jar   # 单文件 → 可执行 JAR
java -jar app.jar

kotlin script.kts                              # .kts 脚本直接运行

gradle init --type kotlin-application          # 生成 Gradle 项目
./gradlew run                                  # 运行
./gradlew build                                # 构建（含测试）

1
2
3
4
5
6
7
8
9

javac -d out src/Main.java
java -cp out Main

java Main.java                 # 源码模式：JVM 内部编译并运行

jar --create --file app.jar --main-class Main -C out .
java -jar app.jar

javac --release 25 -d out src/Main.java   # 按指定 Java 版本编译

1
2
3
4
5

g++ -std=c++23 -O2 -Wall -Wextra main.cpp -o app
./app

clang++ -std=c++23 -O2 -flto main.cpp -o app     # LTO 链接期优化
clang++ -g -O1 -fsanitize=address,undefined main.cpp -o app   # 调试 + 消毒器

1
2
3
4
5

gcc -std=c23 -O2 -Wall -Wextra main.c -o app
./app

gcc -std=c23 -c main.c util.c          # 分别编译成 .o
gcc main.o util.o -lm -o app           # 链接（注意 -l 的顺序）

1
2
3
4
5
6
7
8

julia main.jl
julia -e 'println(sum(1:10))'

julia --project=. -e 'using Pkg; Pkg.instantiate()'   # 按 Manifest.toml 装依赖
julia --project=. main.jl

julia --threads=auto main.jl        # 多线程
julia -O3 main.jl                    # 提高优化等级（默认 -O2）

1
2
3
4
5
6
7
8

dotnet run app.cs                     # 单文件脚本（.NET 10 文件级应用）

dotnet new console -o demo && cd demo
dotnet run                            # 开发运行
dotnet publish -c Release -o out      # 发布（依赖目标机器有 .NET）

dotnet publish -c Release -r linux-x64 --self-contained -p:PublishSingleFile=true
dotnet publish -c Release -r linux-x64 -p:PublishAot=true     # Native AOT

1
2
3
4
5
6

dart run main.dart                       # 开发：JIT，可配合热重载
dart compile exe main.dart -o app         # 发布：AOT 原生可执行
./app

dart compile js -O2 main.dart -o out/main.js   # Web（dart2js）
dart pub get && dart analyze               # 拉依赖 + 静态检查

1
2
3
4
5
6

Rscript main.R
Rscript -e 'print(sum(1:10))'

R CMD build mypkg && R CMD check mypkg_0.1.0.tar.gz   # 打包 + 检查
R CMD INSTALL mypkg                                   # 本地安装
Rscript -e 'renv::restore()'                           # 按 renv.lock 还原依赖

1
2
3
4
5
6
7

zig run main.zig                       # 编译 + 立即运行
zig build-exe main.zig                 # 生成 ./main
./main

zig build-exe -O ReleaseFast -fstrip main.zig   # 优化 + 去符号
zig build -Doptimize=ReleaseSafe                 # 项目级构建
zig test main.zig                                 # 运行测试

1
2
3
4
5
6

lua main.lua
lua -e 'print(("hello"):upper())'

luac -o main.luac main.lua     # 预编译
lua main.luac                   # 直接跑字节码（跳过解析与编译）
luac -l main.luac               # 反汇编字节码（调试用）

1
2
3
4
5
6
7
8

npx tsc main.ts                 # 输出 main.js
node main.js

npx tsc --noEmit                # 只检查类型，常用于 CI
npx tsc --init                  # 生成 tsconfig.json

node main.ts                    # Node 26：类型剥离，直接跑 .ts
npx tsx main.ts                 # 或用 tsx/ts-node 做完整转换

1
2
3
4
5
6

node main.js
node --check main.js          # 只做语法检查，不执行
node --watch main.js          # 文件变化自动重启（Node 18.11+）

npm init -y && npm run start   # package.json 里的 scripts.start
node --experimental-sea-config sea-config.json   # 生成单文件可执行程序

1
2
3
4
5
6

php main.php
php -l main.php                  # 只做语法检查（lint）
php -S localhost:8000 -t public   # 开发用内置服务器

php -d opcache.enable_cli=1 main.php   # CLI 下也启用 OPcache
composer install                        # 安装依赖（读 composer.lock）

1
2
3
4
5
6
7

ruby main.rb
ruby -c main.rb            # 语法检查
ruby --yjit main.rb         # 启用 YJIT

bundle install              # 读 Gemfile.lock 安装依赖
bundle exec ruby main.rb     # 在 bundle 环境下运行
gem build mygem.gemspec      # 打包成 .gem

1
2
3
4
5
6

// Package.swift 片段
let package = Package(
    name: "demo",
    dependencies: [.package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.5.0")],
    targets: [.executableTarget(name: "demo", dependencies: ["ArgumentParser"])]
)

1
2
3
4

swift package init --type executable
swift package resolve            # 解析并写 Package.resolved
swift build -c release
swift test

1
2
3
4
5
6

go mod init example.com/demo    # 初始化
go get github.com/gin-gonic/gin@latest   # 加依赖
go mod tidy                      # 清理未用依赖并补齐缺失
go mod download                  # 预下载到模块缓存
go mod vendor                    # 复制到 vendor/（离线构建）
go work init ./a ./b             # 多模块工作区（go.work）

1
2
3
4
5
6

python3 -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"          # 可编辑安装 + 开发依赖
pip freeze > requirements.txt     # 导出（粗暴但常见）

uv sync                          # 用 uv.lock 安装（快）
python -m build                  # 生成 wheel 与 sdist

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// build.gradle.kts 片段
plugins {
    kotlin("jvm") version "2.4.0"
    application
}
dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
    testImplementation(kotlin("test"))
}
application { mainClass.set("MainKt") }

1
2
3

./gradlew run            # 运行
./gradlew build          # 构建 + 测试
./gradlew dependencies    # 查看依赖树

1
2
3
4
5
6
7
8

<!-- pom.xml 片段 -->
<dependencies>
  <dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.4.0-jre</version>
  </dependency>
</dependencies>

1
2
3
4

mvn -q package           # 打包
mvn test                  # 测试
mvn dependency:tree       # 依赖树
mvn versions:display-dependency-updates

1
2
3
4
5
6

# CMakeLists.txt 片段
cmake_minimum_required(VERSION 3.28)
project(demo CXX)
set(CMAKE_CXX_STANDARD 23)
add_executable(app main.cpp)
target_compile_options(app PRIVATE -Wall -Wextra)

1
2
3

cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j
./build/app

1
2
3
4
5

# Makefile 片段
CC = cc
CFLAGS = -std=c23 -O2 -Wall -Wextra
app: main.o util.o
	$(CC) $^ -o $@

1
2
3
4
5

make            # 增量构建
make clean
cc $(pkg-config --cflags --libs libcurl) main.c -o app

cmake -S . -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build -j

1
2
3
4
5
6

using Pkg
Pkg.activate(".")          # 激活当前目录为项目环境
Pkg.add("DataFrames")       # 加依赖（写 Project.toml 与 Manifest.toml）
Pkg.instantiate()           # 按 Manifest.toml 精确还原
Pkg.status()                # 查看当前依赖
Pkg.update()                # 升级

1
2

julia --project=. -e 'using Pkg; Pkg.instantiate()'
julia --project=. main.jl

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

<!-- demo.csproj 片段 -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Serilog" Version="4.2.0" />
  </ItemGroup>
</Project>

1
2
3
4
5
6

dotnet new console -o demo
dotnet add demo package Serilog     # 加依赖
dotnet restore                       # 还原 NuGet 包
dotnet build -c Release
dotnet test
dotnet list package --outdated       # 检查可升级的包

1
2
3
4
5
6
7
8

# pubspec.yaml 片段
name: demo
environment:
  sdk: ^3.13.0
dependencies:
  http: ^1.2.0
dev_dependencies:
  test: ^1.25.0

1
2
3
4
5
6

dart pub get          # 安装依赖（写 pubspec.lock）
dart pub upgrade       # 升级到允许范围内的最新版
dart pub outdated      # 查看可升级项
dart analyze           # 静态分析
dart test              # 跑测试
dart pub publish --dry-run   # 发布前检查

1
2
3
4

# 包开发常用（devtools）
devtools::load_all()      # 载入当前包（开发态）
devtools::check()          # 跑 R CMD check
devtools::document()       # 生成 man/ 文档

1
2
3
4
5

R CMD build mypkg           # 生成源码包 .tar.gz
R CMD check mypkg_0.1.0.tar.gz
R CMD INSTALL mypkg          # 本地安装
Rscript -e 'renv::init()'    # 为项目建立 renv.lock
Rscript -e 'renv::restore()' # 按锁文件还原

1
2
3
4
5
6
7
8
9

// build.zig.zon 片段
.{
    .name = .demo,
    .version = "0.1.0",
    .dependencies = .{
        .zap = .{ .url = "https://github.com/zigzap/zap/archive/refs/tags/v0.10.0.tar.gz", .hash = "..." },
    },
    .paths = .{""},
}

1
2
3
4
5

zig init                 # 生成 build.zig 与 build.zig.zon
zig build                # 构建（产物在 zig-out/）
zig build run            # 构建并运行
zig build test            # 跑测试
zig fetch --save <url>    # 加依赖并写入哈希

1
2
3
4

luarocks install luafilesystem     # 安装一个 rock
luarocks install --local busted     # 装到用户目录
luarocks make                       # 用当前目录的 rockspec 构建安装
luarocks list                       # 已安装列表

1
2
3

-- 在代码里 require 已安装的模块
local lfs = require("lfs")
print(lfs.currentdir())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// tsconfig.json 片段
{
  "compilerOptions": {
    "target": "es2022",
    "module": "nodenext",
    "strict": true,
    "noEmit": true,          // 由打包器产出 JS
    "declaration": true       // 需要发 .d.ts 时
  },
  "include": ["src"]
}

1
2
3
4

npm install -D typescript esbuild
npx tsc --noEmit             # 只做类型检查
npx esbuild src/main.ts --bundle --minify --outfile=dist/main.js
npx tsc --build              # 项目引用（monorepo）增量构建

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// package.json 片段
{
  "name": "demo",
  "type": "module",
  "scripts": {
    "start": "node src/main.js",
    "build": "esbuild src/main.js --bundle --minify --outfile=dist/main.js",
    "test": "node --test"
  }
}

1
2
3
4

npm ci                 # 按 lockfile 精确安装（CI 推荐）
npm install <pkg>       # 加依赖
npm run build           # 跑脚本
npm audit fix            # 安全修复

1
2
3
4
5
6

// composer.json 片段
{
  "require": { "php": "^8.5", "monolog/monolog": "^3.0" },
  "require-dev": { "phpunit/phpunit": "^11.0" },
  "autoload": { "psr-4": { "App\\": "src/" } }
}

1
2
3
4
5

composer install          # 按 composer.lock 安装（CI 用这个）
composer update            # 升级依赖并更新锁文件
composer require guzzlehttp/guzzle
composer dump-autoload --optimize    # 生成并优化自动加载
composer validate          # 校验 composer.json

1
2
3
4
5
6

# Gemfile 片段
source "https://rubygems.org"
gem "rails", "~> 8.0"
group :development, :test do
  gem "rspec"
end

1
2
3
4
5
6

bundle install             # 安装并写 Gemfile.lock
bundle update rails         # 升级指定 gem
bundle exec rspec           # 在锁定环境下运行
gem build mygem.gemspec     # 打包 gem
gem install mygem-0.1.0.gem
rake build                  # 项目里的 Rake 任务

1
2
3

swiftc -O main.swift -o app -g          # 带调试信息
swiftc -emit-sil main.swift              # Swift 中间语言 SIL
swiftc -emit-ir main.swift               # LLVM IR

1
2
3

go build -o app .
go build -gcflags=-S main.go > main.s     # 查看汇编
go tool objdump -s main.main app           # 反汇编指定函数

1
2
3

python3 -m compileall -q .          # 生成 .pyc
python3 -m dis main.py               # 反汇编字节码
python3 -m zipapp mypkg -o app.pyz    # 打包成可执行 zip

1
2
3

kotlinc main.kt -include-runtime -d app.jar
jar tf app.jar | head                  # 查看 JAR 内容
javap -c -p MainKt                      # 反汇编字节码

1
2
3
4
5

javac -d out src/Main.java
javap -c -p out/Main.class             # 反汇编
jar --create --file app.jar --main-class Main -C out .
java -XX:ArchiveClassesAtExit=app.jsa -cp out Main   # 生成 CDS 归档
jlink --add-modules java.base --output runtime        # 定制运行时

1
2
3
4

g++ -std=c++23 -c main.cpp -o main.o
g++ -std=c++23 -S main.cpp -o main.s       # 汇编
g++ -std=c++23 -shared -fPIC lib.cpp -o lib.so
nm -C app | head                            # 查看符号

1
2
3
4

gcc -E main.c -o main.i        # 预处理结果
gcc -S main.c -o main.s        # 汇编
gcc -c main.c -o main.o        # 目标文件
gcc main.o -o app              # 链接

1
2
3
4

@code_lowered f(1)   # 降级后的 IR
@code_typed f(1)       # 类型推断结果
@code_llvm f(1)         # LLVM IR
@code_native f(1)       # 本机汇编

1
2

julia -e 'using Pkg; Pkg.precompile()'
julia -e 'using PackageCompiler; create_sysimage(["DataFrames"])'

1
2
3

dotnet build -c Release                 # bin/Release/net10.0/
dotnet publish -c Release -o out
dotnet publish -c Release -r linux-x64 -p:PublishAot=true -p:StripSymbols=true

1
2
3
4

dart compile kernel main.dart -o main.dill
dart compile exe main.dart -o app
dart compile js -O2 main.dart -o out/main.js
dart compile wasm main.dart -o out/main.wasm

1
2

saveRDS(model, "model.rds")
readRDS("model.rds")

1

R CMD INSTALL --byte-compile mypkg     # 安装时预编译字节码

1
2
3
4

zig build-exe main.zig
zig build-lib -dynamic lib.zig
zig build-exe -femit-asm=main.s main.zig
zig build-exe -femit-llvm-ir=main.ll main.zig

1
2
3

luac -o main.luac main.lua
luac -l main.luac              # 反汇编（带调试信息时）
luac -s -o main.luac main.lua   # 去掉调试信息

1
2
3

npx tsc --declaration --sourceMap
npx tsc --incremental
npx tsc --noEmit

1
2

npx esbuild src/main.js --bundle --minify --sourcemap --outfile=dist/main.js
node --build-snapshot -e 'require("./heavy.js")'

1
2
3

php -d opcache.enable_cli=1 -d opcache.file_cache=/tmp/opcache main.php
php -d opcache.jit=tracing -d opcache.jit_buffer_size=64M main.php
php -d phar.readonly=0 build.php     # 打包 .phar

1
2
3
4

iseq = RubyVM::InstructionSequence.compile("1 + 2")
puts iseq.disasm                  # 反汇编字节码
binary = iseq.to_binary           # 导出字节码
RubyVM::InstructionSequence.load_from_binary(binary).eval

1

ruby --yjit -e 'p RubyVM::YJIT.enabled?'

1
2
3
4

swift build -c release
swiftc -O -whole-module-optimization main.swift -o app
swiftc -g -sanitize=address main.swift -o app-debug
lldb ./app

1
2
3
4
5
6

go build -trimpath -ldflags="-s -w" -o app .
CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -o app .

go test -race -cover ./...
go test -bench=. -benchmem ./...
go build -gcflags="-m" . 2>&1 | grep escapes | head

1
2
3
4
5
6

python3 -O main.py
PYTHON_JIT=1 python3 main.py          # 3.14 官方构建的实验 JIT

python3 -m cProfile -s cumtime main.py | head -20
python3 -m pdb main.py
mypy . && ruff check .

1
2
3

./gradlew build
./gradlew linkReleaseExecutableMacosArm64    # Kotlin/Native 原生可执行
java -XX:+UseZGC -jar app.jar

1
2
3
4

java -XX:+UseZGC -Xmx2g -jar app.jar
java -XX:AOTCache=app.aot -XX:AOTMode=create -cp out Main   # JDK 24+ AOT 缓存
jlink --add-modules java.base,java.sql --output runtime
jpackage --input out --main-jar app.jar --type dmg

1
2
3
4

g++ -std=c++23 -O2 -DNDEBUG -flto -s main.cpp -o app
clang++ -g -O1 -fsanitize=address,undefined main.cpp -o app-san
valgrind --leak-check=full ./app-debug
perf record ./app && perf report

1
2
3

gcc -std=c23 -O2 -DNDEBUG main.c -o app
gcc -g -O1 -fsanitize=address,undefined main.c -o app-san
gcc -fanalyzer -Wall main.c        # 编译期静态分析

1
2

julia -O3 --threads=auto main.jl
julia -e 'using Profile; @profile f(); Profile.print()'

1

@code_warntype slow_function(1)    # 找类型不稳定

1
2
3

dotnet publish -c Release -r linux-x64 --self-contained \
  -p:PublishSingleFile=true -p:PublishTrimmed=true -p:PublishReadyToRun=true
dotnet-counters monitor -p <pid>

1
2
3

dart compile exe --obfuscate --split-debug-info=out main.dart -o app
dart compile js -O4 --minify main.dart -o out/main.js
dart run --enable-asserts main.dart

1
2
3
4
5

Rprof("prof.out"); f(); Rprof(NULL)
summaryRprof("prof.out")

options(error = recover)      # 出错时进入交互式调试
browser()                      # 在函数里打断点

1

Rscript --vanilla main.R        # 不加载用户配置，CI 友好

1
2
3
4

zig build -Doptimize=ReleaseFast
zig build-exe -O ReleaseSmall -fstrip main.zig
zig test main.zig
zig build test -Doptimize=ReleaseSafe

1
2
3

luac -s -o app.luac main.lua
lua app.luac
luajit -jv main.lua          # LuaJIT 的 JIT 日志（-jv）

1
2
3

local ok, err = xpcall(work, function(e)
  return debug.traceback(e, 2)      -- 带堆栈的错误信息
end)

1
2
3

npx tsc --noEmit
npx esbuild src/main.ts --bundle --minify --sourcemap --target=es2022 --outfile=dist/main.js
node --enable-source-maps dist/main.js

1
2
3
4

node --inspect-brk main.js            # 断点调试
node --cpu-prof main.js                # 生成 .cpuprofile
node --max-old-space-size=4096 main.js  # 调大堆上限
npx esbuild main.js --bundle --minify --sourcemap --outfile=dist/main.js

1
2
3

php -d opcache.enable=1 -d opcache.jit=tracing -d opcache.jit_buffer_size=64M -S localhost:8000
composer dump-autoload -o --classmap-authoritative
php -d zend_extension=xdebug -d xdebug.mode=debug main.php

1
2
3
4

ruby --yjit main.rb
RUBY_YJIT_ENABLE=1 ruby main.rb
ruby -w main.rb                  # 打开警告
stackprof --text profile.dump     # 火焰图/文本报告