⚡ Dev Shortcuts & Cheat Sheets

Production Reference Manual for Enterprise Infrastructure and Language Architectures

Repository Archive Access:
git clone https://github.com/CosmicViraj/the-dev-pocket-guide.git

Global Architecture Matrix

Resource Context Target	Advanced Structural Deep-Dive Scope	Local PDF Mapping Artifact
Docker Architecture	Multi-Stage Scratch Runtimes, BuildKit Cache Mounts, Kernel Cap Isolation, Namespace Sandboxing.	`docker_cheat_sheet.pdf`
Python Optimization	Pattern Matching (3.10+), Walrus Evaluation Loop, Recursive Autovivification, Memory Views, IDE Keymaps.	`python_cheat_sheet.pdf`
Java Architecture	Enhanced Type Switch (17+), Immutable Records, Unmodifiable Streams API, IntelliJ Postfix Macros.	`java_cheat_sheet.pdf`

1. Docker: Enterprise Infrastructure & Runtime Optimization

Multi-Stage Decoupling & Minimal Runtimes

Decouple bulky compiler suites entirely from runtime artifacts utilizing static compilation over a pure, empty zero-byte base container image footprint.

# --- COMPILATION MATRIX STAGE ---
FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
# Strip debugging symbol markers (-w -s) via low-level linker flags
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-w -s" -o server .

# --- IMMUTABLE SYSTEM RUNTIME STAGE ---
FROM scratch
COPY --from=builder /app/server /server
USER 10001:10001
ENTRYPOINT ["/server"]

BuildKit Mounting Cache Primitives

Route build layers through local persistent storage cache volumes or secure memory paths without embedding variables inside image structural layer histories.

# Bind persistent host system cache paths directly to compiler
RUN --mount=type=cache,target=/root/.cache/go-build go build -o server .

# Extract private API tokens out of a secure in-memory tmpfs mount
RUN --mount=type=secret,id=api_key \
    TOKEN=$(cat /run/secrets/api_key) && \
    curl -H "Authorization: Bearer $TOKEN" https://internal.api.net/deploy

Distributed Network Sandboxing Patterns

Leverage software-defined Multi-Host Swarm Overlay networks configured with native kernel-level IPsec encryption (AES-GCM).

# Instantiate secure encrypted VXLAN data lanes
docker network create --driver overlay --opt encrypted prod-net

# Attach a diagnostic network toolbox straight into an app's namespace
docker run -it --rm --network=container:production_api_app nicolaka/netshoot tcpdump -nnvv -i any

Security Hardening & Completely Fair Scheduler Boundaries

Strip operational kernel capabilities by default, force strict read-only execution locks, and limit computing resources to completely eliminate noisy-neighbor issues.

docker run --cap-drop=ALL \
  --cap-add=NET_BIND_SERVICE \
  --read-only --tmpfs /tmp \
  --security-opt=no-new-privileges:true \
  --cpus="2.5" --cpuset-cpus="0,2" \
  --memory-swap="512m" --oom-score-adj=-1000 \
  nginx:alpine

2. Python: Advanced Syntactic Patterns & Performance Hacks

Structural Pattern Matching & Inline Assignments (Python 3.10+)

Implement single-pass structural parsing execution loops that simultaneously read data streams, evaluate structures, and extract items directly into bound memory references.

def process_telemetry(payload):
    match payload:
        # Evaluate specific map properties and unbox list elements
        {"type": "sensor", "id": device_id, "data": [x, y, *rest]}:
            return f"Device {device_id} dynamic matrix coordinates: ({x}, {y}) Buffer: {rest}"
        # Execute type parsing and instance field attribute checking
        User(role="admin", is_active=True, email=email):
            return f"Spawning privileged secure shell protocol instance for: {email}"
        _:
            raise ValueError("Malformed packet stream execution token signature")

# Single-Pass inline variable processing loop (The Walrus Operator)
while chunk := network_socket.read(4096):
    process_data_matrix(chunk)

Recursive Autovivification Trees

Build recursive dictionary branches dynamically without encountering lookup errors or needing manual path structure checks.

from collections import defaultdict

# Define an infinitely nesting lookup tree node factory
tree = lambda: defaultdict(tree)
root = tree()

# Direct assignment maps elements without prior initialization
root["infra"]["us_east"]["rack_14"]["node_01"]["ip"] = "10.0.12.5"

Zero-Copy Slicing with Memory Views

Directly access and slice binary logs or socket buffers at the C-level scale to eliminate memory allocation penalties.

data_buffer = bytearray(b"SYS_RAW_FRAME_PACKET_STREAM_PAYLOAD_EOF")
view = memoryview(data_buffer)

# Slice the internal byte array references without copying memory
payload_segment = view[19:35]
payload_segment[0:3] = b"XYZ"  # Mutates data_buffer natively

Python Environment Cross-Platform Productivity Keymaps

Contextual Code Manipulation Action	PyCharm (Windows / Linux)	PyCharm (macOS)	VS Code (Windows / Linux)
Intelligent Context Intent Actions / Quick-Fix Fixes	`Alt + Enter`	`Option + Enter`	`Ctrl + .`
Extract Block Highlighted Selection into Clean Method	`Ctrl + Alt + M`	`Cmd + Option + M`	Command Palette
Tether Simultaneous Multi-Cursor Line Hooks	`Alt + Shift + Click`	`Option + Shift + Click`	`Ctrl + Alt + ↑ / ↓`
Trace Underlying Structural Variable Definition	`Ctrl + B` / `Click`	`Cmd + B` / `Click`	`F12`
Reformat Active File Workspace (PEP 8 Alignment)	`Ctrl + Alt + L`	`Cmd + Option + L`	`Shift + Alt + F`

3. Java: Architectural Design Primitives & IDE Automation

Enhanced Switch Expressions & Type Pattern Matching (Java 17+)

Transform standard choice trees into clear evaluation engines that automatically handle type checking, structural boundaries, and drop explicit manual class-casting requirements.

public String processDataEngine(Object stateNode) {
    return switch (stateNode) {
        # Safely cast and evaluate length boundary conditions within a single operation
        case String s && s.length() > 500 -> "Large volume trace anomaly. Initializing sample protocols.";
        case String s -> "Clean string structure processed: " + s;
        # Evaluate structured objects directly via class typing signatures
        case LocalDate date -> "Chronological boundary system confirmation step: " + date.getYear();
        case TransactionTx tx -> "Financial node execution trace matched uuid token: " + tx.getUuid();
        case null -> "Bypass fallback intercept execution trigger initialized";
        default -> "Generic unknown data layout structure mapped";
    };
}

Boilerplate Erasure via Java Records

Instantly generate highly compact Data Transfer Objects (DTOs) with immutable backing fields, complete parameter constructors, and structural string conversions on a single line.

// Auto-generates fields, constructors, equals(), and hashCode()
public record AccountRecord(UUID txId, String routingToken, double balance) {}

Functional Unmodifiable Pipeline Aggregations

Reconstruct traditional loops into clean declarative sequence paths that natively build unmodifiable target data sets.

List<String> staffAddresses = corporateDirectory.stream()
    .filter(emp -> "INFRASTRUCTURE".equals(emp.getDepartment()))
    .filter(Employee::isClearanceVerified)  // Method syntax reference hook
    .map(Employee::getEmailAddress)
    .toList(); // Instant Java 16+ immutable list collection allocation

IntelliJ IDEA Java Power-User Postfix & Shortcuts Engine

Advanced Postfix Automation Systems: Type the target core data structure first, append a dot selector config, and execute contextual shortcuts: myList.for + Tab auto-synthesizes an enhanced loop statement; instance.null + Tab auto-spawns a safe null-intercept conditional wrapper.

Advanced Compilation & Workspace Context Objective	IntelliJ IDEA (Windows / Linux)	IntelliJ IDEA (macOS)
Omnipresent Global Project Index Query (Search Everywhere)	`Double Shift`	`Double Shift`
Display Local Context Intent Actions / Generate Fix Code Blocks	`Alt + Enter`	`Option + Enter`
Find and Map All Object References across Total App Scope	`Alt + F7`	`Option + F7`
Jump straight from Interface down to Concrete Class Implementations	`Ctrl + Alt + B`	`Cmd + Option + B`
Launch Total Workspace Refactoring Matrix Menu (Safe Rename/Move)	`Ctrl + Alt + Shift + T`	`Ctrl + T`
Extract Highlighted Expression into a Local Memory Variable Location	`Ctrl + Alt + V`	`Cmd + Option + V`
Synthesize Complete Current Statement (Appends braces/semicolons)	`Ctrl + Shift + Enter`	`Cmd + Shift + Enter`
Generate Volatile Isolated Local Testing Workspace File (Scratch)	`Ctrl + Alt + Shift + Insert`	`Cmd + Option + Shift + N`