Languages

For developers who use Python as their scripting and data-processing workhorse: covers venv/pip environments, built-in containers, list comprehensions, file and JSON I/O, exception handling, and common built-ins, ready to apply to real projects.

An ES6+ syntax reference for frontend and full-stack developers: let/const, arrow functions, destructuring, template literals, higher-order array methods, and Promise/async-await — the patterns used most in everyday React/Vue and Node code, ready to reuse.

For Go developers building backend services, cloud-native tooling, and CLIs: covers variables & types, control flow, functions and defer, structs & methods, interfaces, goroutine/channel concurrency, and error handling, organized by the coding scenarios you hit in practice.

For Python developers doing data analysis, numerical computing, and scientific simulation: covers array creation, indexing & slicing, shape manipulation, math & statistics, random numbers, and the often-misunderstood broadcasting rule, arranged from creating an array to saving it to disk.

For Java backend and ops developers: covers compiling, running and packaging with javac/java/jar, Maven/Gradle build flows, JVM heap and GC tuning flags, and online troubleshooting with jps/jstack/jmap/jstat, organized in a build → run → tune → debug sequence you can copy.

For PHP developers and the ops people deploying PHP apps: covers running scripts and the built-in dev server, Composer dependency management, extension and ini config checks, php -l linting and phpinfo diagnostics, grouped by the real dev workflow.

For Rust developers, from beginners in the borrow checker to maintainers of production crates: covers Cargo project scaffolding, build and run, testing, docs, Clippy lints, rustfmt, and cross-compilation, following the actual release workflow.

For Kotlin developers, especially Android and JVM-backend engineers: covers kotlinc compilation and scripting, Gradle builds, null-safety idioms, the standard collection operators, and coroutines, arranged around the code you write every day.

For Swift developers shipping iOS/macOS apps or server code: covers swift/swiftc compilation and running, Xcode command-line builds and simctl, Swift Package Manager workflows, and common syntax idioms, arranged by the real build-and-debug cycle.

For Laravel developers making CRUD apps and the ops people behind them: covers project scaffolding, artisan generators, migrations, routing and cache optimization, queued jobs, and testing — the Artisan commands used around every feature and deploy.

For Node developers building REST APIs and web apps on Express: covers app and router setup, route definition (params/query/Router chains), request and response objects, the middleware ecosystem (json, static, cors, helmet, morgan, compression), EJS rendering, JWT auth, and async error handling.

A focused ES2015+ reference for JavaScript developers modernizing their code: let/const and block scoping, arrow functions, destructuring, template literals, Promise/async, modules, classes, Map/Set and iterators — the language features that changed how everyday JS is written.

For developers maintaining legacy sites or jQuery-heavy frontends: covers selectors, DOM manipulation, event binding and delegation, Ajax requests, animations, and the plugin pattern — the API you reach for when modernizing or maintaining jQuery code.

For developers designing or consuming GraphQL APIs: covers query and mutation syntax, subscriptions, the schema type system, fragments, directives, and pagination — the vocabulary shared by GraphQL clients and servers.

For developers writing C for embedded, systems, or performance-critical code: covers data types, control flow, pointers and arrays, functions, manual memory management, file/syscalls, and the preprocessor — with the bytes and lifetimes that demand care in C.

For C++ developers working on applications, games, or libraries: covers classes and objects, the STL containers, smart pointers, lambdas, templates, and exceptions — emphasizing the modern idioms that avoid manual lifetime bugs.

For .NET developers building apps, services, or games: covers classes and interfaces, LINQ querying over collections, async/await, generics and delegates, properties and events, with the C# idioms that differ from other mainstream languages.

For Dart developers building Flutter apps and backend services: covers variables and null-safety types, functions and closures, classes and mixins, and Future/async programming — the syntax that shapes everyday Dart.

For Node and Express developers rendering server-side HTML: covers the EJS tag syntax, escaped and raw output, conditionals and loops over locals, includes, layout inheritance, and wiring EJS into an Express app.

Learn to process data the MATLAB way: build matrices, run linear-algebra solves, visualize trends, read/write files, and do signal processing. 80+ commands grouped by scenario, copy and run.

For JS devs adding static types to a codebase: from basic types, interfaces and union types, to generic constraints and utility types like Partial/Pick/Omit — explained with copyable examples.

A Lodash quick reference for writing safer, shorter JS without hand-rolling helpers: array transforms, safe nested property access, deep clone & merge, debounce/throttle, and handy math utilities. Copy and run.

A Vue 3 reference for building reactive UIs with the Composition API: ref/reactive/computed/watch, lifecycle hooks, props-emits-provide-inject communication, router, Pinia state, and template/render optimization. Copy and run.

A React 18 reference for building component UIs with Hooks: state and effects, advanced Hooks like useReducer/Context, component patterns, controlled forms, and performance tweaks (memo, lazy, Suspense). Copy and run.

A Promise async reference for JavaScript: creating and consuming promises, static combinators like all/race/allSettled, chaining, the async/await syntax, plus concurrency control, timeouts, retries, and abort via AbortController. Copy and run.

A Redux Toolkit reference for predictable app state: configureStore, createSlice with auto-generated actions, async thunks, middleware, useSelector/useDispatch, and normalized entities — the idiomatic way to wire Redux into React. Copy and run.

A React Router v6 (and v6.4+ data APIs) reference: declarative routes and nested layouts, Link/NavLink/useNavigate navigation, URL and search params, guarded routes, and lazy loading. Copy and run.

A Chai.js assertion reference covering all three styles — expect and should (BDD) and assert (TDD): equality, deep comparison, types, inclusion, thrown errors, numeric bounds, plus async and HTTP helpers via plugins. Copy and run.

A Sinon.js test-double reference: spies that observe calls, stubs that replace behavior with returns/throws/resolves, strict mocks, fake timers, sandboxes, and assertion helpers — the tools for isolating units under test. Copy and run.

A Moment.js date-time reference: creating and formatting dates, add/subtract and startOf/endOf operations, comparisons, relative time like fromNow, timezones via moment-timezone, and Duration math. Copy and run.

A Ruby syntax reference for newcomers and Rails devs: variables, symbols, arrays/hashes, control flow, methods and blocks, classes & modules (include/extend/attr_accessor), and exception handling — with the idiomatic Ruby way of writing each. Copy directly.

PM2 process-management commands across start/stop/restart and zero-downtime reload, log management and rotation, cluster mode, monitoring, boot-start and deployment — with key flags explained. For running and keeping Node.js services alive in production.

npm commands across project init/scaffolding, install/update/remove, version management and lockfiles, script running and npx, dependency inspection and auditing, publishing, and config/cache. For running a Node.js project's full lifecycle without leaving the terminal.

Webpack configuration covering entry/output, Loaders for assets, Plugins, the dev server and HMR, code splitting and bundle optimization, and mode/environment. For assembling a frontend build pipeline and fixing slow or bloated builds.

Jest testing APIs covering test cases and grouping (describe/it), matchers and assertions, async testing, mock functions and module mocking, snapshot tests, and coverage reports. For writing JavaScript unit tests that fail for the right reason.