Code Snippets

Sort a Python dictionary by its values in descending order.

Chain map, filter, reduce, find, some, and every on arrays.

Define a Rust struct and implement methods with self and Self.

Manipulate strings with split, join, substring, and StringBuilder in Java.

Filter, sort, and limit rows with SELECT, WHERE, and ORDER BY in SQL.

Build an accessible HTML form with labels, inputs, select, and checkbox.

Structure tabular data with thead, tbody, tfoot, and caption in HTML.

Embed responsive images with srcset, video, audio, and figure in HTML.

Create internal, external, anchor, email, phone, and download links in HTML.

Center elements horizontally and vertically using Flexbox, Grid, and absolute positioning.

Target elements with pseudo-classes, pseudo-elements, and attribute selectors.

Build a controlled React form with inline validation and error messages.

Handle events and render dynamic lists with keys in React.

Add, change, and interact with remote repositories in Git.

Browse, filter, and format commit history with git log options.

Assign variables, use command substitution, and work with arrays in Bash.

Create indexed, associative, and multidimensional arrays with map and filter.

Manipulate strings with substr, replace, explode, and sprintf in PHP.

Read, write, append, and iterate files with PHP filesystem functions.

Connect and run prepared statements safely with PDO in PHP.

Store user data across requests with sessions and cookies in PHP.

Define classes with constructors, visibility, and inheritance in PHP.

Deduplicate an array using Set.

Deep clone objects, supporting common data types.

Wait a period of time after an event triggers before executing; reset the timer if triggered again during the wait.

Limit a function to execute at most once within a time interval.

A Promise executor with concurrency limit.

Wrap async functions to uniformly catch exceptions.

Wrap fetch with timeout, error handling, and JSON parsing.

Wrap localStorage with expiration time and JSON support.

Wrap Cookie read, write, and delete operations.

Parse URL query string into an object.

Format a date into a specified string.

Format a number as a thousands-separated money string.

Generate random numbers and random strings within a range.

Convert between RGB and HEX colors.

Generate a unique identifier compliant with UUID v4.

Truncate a string and append an ellipsis.

Flatten a multi-dimensional array into one dimension.

Deeply merge multiple objects.

Precisely determine JavaScript data types.

Implement event delegation via event bubbling.

Dynamically create and manipulate DOM elements.

A collection of common form validation rules.

Wrap file upload with progress and chunking support.

Implement image lazy loading with IntersectionObserver.

A cross-browser clipboard copy method.

Wrap browser fullscreen operations.

Get user geolocation information.

Create a Web Worker to run time-consuming tasks.

Register a Service Worker for offline caching.

Wrap IndexedDB CRUD operations.

Basic Canvas drawing example.

Quickly generate lists using list comprehensions.

Multiple ways to merge dictionaries.

Various ways to read and write files.

Read and write CSV files using the csv module.

JSON serialization and deserialization.

Perform regex matching using the re module.

Handle dates and times with datetime.

Define and use decorators.

Save memory using generators.

Custom context managers.

Complete exception handling mechanism.

Class inheritance and method overriding.

Implement multithreading using the threading module.

Achieve true parallelism with multiprocessing.

Implement asynchronous concurrency with asyncio.

TCP Socket server and client.

Send HTTP requests using the requests library.

Operate on databases using sqlite3.

Create and manage Python virtual environments.

Common pip package management commands.

Read and set environment variables.

Configure and use the logging module.

Write unit tests using unittest.

Improve code readability with type annotations.

Simplify class definitions with dataclass.

Define enum types using Enum.

Control attribute access with property.

Common magic method examples.

Custom iterator implementation.

Basic usage of coroutines.

Define and use generic functions.

Select types based on conditions.

Construct new types from existing ones.

TypeScript built-in utility types.

Custom type guard functions.

Define function overload signatures.

Class and method decorators.

Numeric, string, and const enums.

Interface inheritance and implementation.

Define abstract classes and abstract methods.

Organize code using namespaces.

Write type declarations for JS libraries.

Merge multiple declarations with the same name.

Safely access deep properties.

Use a default value only for null/undefined.

TypeScript automatically infers types.

Narrow types using as const.

Type-check while preserving the narrowest type.

Extract types within conditional types.

Construct types based on strings.

Implement concurrency using goroutines.

Communicate between goroutines using channels.

Multiplex channels using select.

Protect shared data using sync.Mutex.

Usage and execution order of defer.

Go's error handling pattern.

Define and implement interfaces.

Implement composition via embedding.

Using generics in Go 1.18+.

Control timeout and cancellation using context.

Read and write file operations.

Create an HTTP server.

Send HTTP requests.

Convert between structs and JSON.

Common operations in the strings package.

Common slice operations.

CRUD operations on map.

Common operations in the time package.

Using the regexp package.

Write unit tests.

Process collections using the Stream API.

Simplify code with Lambda expressions.

Handle null values elegantly.

Common operations on List, Set, and Map.

try-catch-finally and custom exceptions.

Read and write file operations.

Create and manage threads.

Common utilities in the concurrency package.

Custom annotations and usage.

Generic classes and methods.

Get class information at runtime.

Object serialization and deserialization.

Java 8+ Date-Time API.

Pattern and Matcher.

Database connection and operations.

Java 11+ HTTP client.

Java 14+ record classes.

instanceof pattern matching.

Java 17+ sealed classes.

Java 15+ multi-line strings.

Multi-table join queries.

Nested queries.

Ranking and aggregate window functions.

GROUP BY and HAVING.

Common Table Expressions.

Query hierarchical data with recursive CTE.

Create and manage indexes.

Transaction control and isolation levels.

Create stored procedures and functions.

Automatically executing triggers.

Create and manage views.

Materialized views and refresh.

Table partitioning strategies.

Data backup, import, and export.

Query performance analysis and optimization.

PostgreSQL JSON/JSONB operations.

PostgreSQL full-text search.

PIVOT and Crosstab.

Date and time operations.

LIMIT/OFFSET and cursor pagination.

Rust ownership system.

References and mutable borrows.

Explicit lifetime annotations.

Define and implement traits.

Generic functions and structs.

Enums and Option.

match and destructuring.

Result and the ? operator.

Iterator adapters and consumers.

Closures and Fn traits.

Modules, paths, and visibility.

Threads and channels.

Box, Rc, RefCell.

Declarative and procedural macros.

Unsafe operations.

unique_ptr, shared_ptr, weak_ptr.

Resource Acquisition Is Initialization.

Rvalue references and move constructors.

Lambda and captures.

Function templates and class templates.

Common container operations.

Common algorithm functions.

Iterator types and usage.

try-catch and custom exceptions.

thread, mutex, condition_variable.

File read and write operations.

std::string operations.

std::regex matching and replacement.

auto, decltype, template deduction.

Compile-time constants and computation.

HTML5 semantic structure.

HTML5 form validation.

Grid layout.

Flexible box layout.

CSS keyframe animations.

CSS transition effects.

Custom properties.

Responsive breakpoints.

Pseudo-classes and pseudo-elements.

Responsive layout techniques.

Dark theme switching.

Style scrollbars.

Linear and radial gradients.

box-shadow and text-shadow.

CSS filter effects.

2D/3D transforms.

Scalable Vector Graphics.

Canvas drawing.

Custom elements and Shadow DOM.

ARIA and accessibility.

State management Hook.

Side-effect Hook.

Shared state via context.

Complex state management.

Memoize computation results.

Memoize callback functions.

Reference DOM and mutable values.

Extract reusable logic.

Parent-child and sibling component communication.

Catch component errors.

Code splitting and lazy loading.

Render to DOM nodes outside the component.

Component enhancement pattern.

Render props pattern.

React performance optimization tips.

File and directory management.

Text processing with grep, sed, awk.

for and while loops.

if and case conditional statements.

Function definition and parameters.

Bash array operations.

Bash string processing.

Basic Git operations.

Branch management and operations.

Merging and conflict resolution.

Undo commits and revert.

Version tag management.

Stash working directory changes.

Selectively merge commits.

Binary search to locate problem commits.

Make elements draggable with axis, containment, and event callbacks.

Create drop targets that accept draggable elements with hover and drop events.

Add resize handles with min/max constraints and aspect ratio lock.

Reorder list items via drag-and-drop and persist the new order.

Collapsible content panels with only one section expanded at a time.

Calendar widget with date range limits, formatting, and inline mode.

Modal window with buttons, animations, and dynamic open/close.

Tabbed content panels with AJAX loading and event-driven switching.

Multi-page template with header, content, and footer roles.

Apply slide, pop, flip, and fade transitions between pages.

Fixed header and footer bars with fullscreen tap-to-toggle mode.

Persistent icon-based navigation bars in the footer.

Filterable, grouped lists with thumbnails, icons, and count bubbles.

Enhanced inputs including sliders, switches, and grouped controls.

Themed, iconified, and grouped buttons from links and inputs.

Modal popups, dialogs, and tooltips with positioning control.

Vertical bar chart with custom colors and rounded corners.

Smooth line chart with fill, tension, and hover styling.

Pie chart with per-slice colors and legend positioning.

Doughnut chart with cutout control and centered title.

Multi-series radar chart for comparing entities across dimensions.

Chart that fills its container with maintainAspectRatio disabled.

Title, legend, axis formatting, animations, and live updates.

Custom-styled tooltips with title, label, and footer callbacks.

Category bar chart with axis tooltip and styled bars.

Smooth multi-series line chart with area fill.

Donut-style pie with emphasis effect and percentage labels.

Scatter plot with point size encoded by a third dimension.

Radar with multiple indicators and overlaid value series.

Dataset-driven multi-series chart with grid and legend config.

Custom HTML tooltip with crosshair axis pointer.

Resize chart on window and container changes, with cleanup.

Define a module and a controller with scope methods.

Prototypal scope inheritance between parent and child controllers.

Attribute directive and element directive with isolated scope.

Factory and service singletons for shared state and logic.

Configure routes with templates, controllers, and resolve guards.

Chainable filters for formatting values in templates.

Form with required, minlength, email validation, and disabled submit.

Promise-based HTTP requests with config object and error handling.

Define an Angular component with selector, template, and styles.

Interpolation, property, event, and two-way binding in Angular templates.

Use *ngIf, *ngFor, ngClass, and ngStyle to shape the DOM.

Transform template values with built-in and custom pipes.

Create an injectable service and consume it in a component.

Define routes with params, lazy loading, and redirects.

Build a typed reactive form with FormBuilder and validators.

Perform typed HTTP requests with HttpClient and Observables.

Define a Vue 3 component with script setup, template, and scoped styles.

Organize reactive state, computed, and lifecycle logic by feature.

Choose between ref and reactive for reactive state.

Derive values with computed and react to changes with watch.

Declare inputs and events, and implement v-model on a component.

Register lifecycle callbacks as composable functions.

Distribute content with default, named, and scoped slots.

Extract reusable reactive logic into a useMouse composable.

Select elements by id, class, attribute, and pseudo-filters.

Bind handlers with on(), support delegation and namespaced removal.

Get/set text, html, attributes, classes, and insert nodes.

Use $.ajax, $.get, $.post, and load with promises.

Show, hide, fade, slide, and animate elements.

Navigate relatives and filter the matched set.

Iterate, merge, and filter with jQuery helpers.

Chain jQuery methods and use end() to restore context.

Lay out pages with the 12-column responsive grid.

Show, hide, and reorder elements per breakpoint.

Build a responsive collapsing navbar with brand and links.

Compose a card with image, body, list, and footer.

Trigger and structure a Bootstrap modal dialog.

Build a responsive form with validation feedback.

Use button variants, sizes, states, and groups.

Display contextual messages with dismissible alerts.

Structure a page with header, nav, main, article, and footer.

Use native HTML5 input types, validation, and datalist.

Draw shapes, lines, and text on a 2D canvas.

Embed media with multiple sources and control playback.

Persist data in the browser with the Web Storage API.

Get the user's position and watch for changes.

Accept dropped files with the Drag and Drop API.

Run heavy computation on a background thread.

Align and distribute items along one axis with flexbox.

Build two-dimensional layouts with grid-template-areas.

Define keyframes and apply reusable animations.

Smoothly interpolate properties on state change.

Translate, rotate, and scale elements with GPU-friendly transforms.

Apply responsive, print, and preference-based styles.

Define and reuse CSS variables with live updates.

Select elements by state and structural position.

Store colors, spacing, and breakpoints in Sass variables.

Mirror HTML structure and use the parent selector with &.

Create reusable style groups with arguments and defaults.

Share styles across selectors with @extend and %placeholders.

Split stylesheets into partials and load them with @use.

Define custom functions that return computed values.

Generate styles with @for, @each, and @if.

Use arithmetic, relational, and equality operators in Sass.

Compose a button and card from atomic utilities.

Apply per-breakpoint utilities with sm:, md:, and lg: prefixes.

Style interactive states and group-hover with variant prefixes.

Center, distribute, and grid layouts with utilities.

Use the default palette, opacity modifiers, and gradients.

Apply padding, margin, gap, and width/height from one scale.

Extend the theme with custom colors, fonts, and animations.

Toggle themes with the dark: variant and class strategy.

Run, list, stop, and remove Docker containers.

Build an image from a Dockerfile with multi-instruction layers.

Pull, list, tag, push, and prune images.

Persist data with named volumes, anonymous volumes, and bind mounts.

Create networks, attach containers, and expose ports.

Define and run multi-container apps with compose.

Build artifacts in one stage and copy them into a slim final image.

Run commands inside running containers and inspect logs.

Define a standalone Pod with a container, env, and probe.

Manage a replicated, rolling-updated workload.

Expose Pods via ClusterIP, NodePort, and LoadBalancer services.

Inject configuration and sensitive data into containers.

Route external HTTP traffic to services by host and path.

Tag resources and query them with selectors.

Common kubectl commands for everyday operations.

Partition a cluster into isolated virtual clusters.

Insert documents and query a collection.

Use comparison, logical, array, and regex operators.

Build multi-stage pipelines for analytics.

Create single, compound, and text indexes for performance.

Modify and remove documents with update operators.

Manage collections, validators, and capped collections.

Configure a replica set for high availability.

Distribute data across shards by a shard key.

Combine rows from multiple tables using JOINs.

Use scalar, IN, EXISTS, and derived-table subqueries.

Create single, composite, unique, and fulltext indexes.

Use BEGIN, COMMIT, ROLLBACK, and isolation levels.

Define reusable procedural routines with parameters.

Run logic automatically on INSERT, UPDATE, or DELETE.

Create virtual tables to simplify and secure queries.

Diagnose and optimize slow queries with EXPLAIN and indexes.

Use INNER, LEFT, and LATERAL joins in PostgreSQL.

Store, query, and index JSONB documents.

Compute rankings, running totals, and moving averages.

Use CTEs and recursive CTEs for readable queries.

Create B-tree, GIN, GiST, and partial indexes.

Search text using tsvector, tsquery, and ranking.

Control transactions, savepoints, and isolation levels.

Store and query arrays of scalar values.

Set, get, increment, and expire string values.

Build queues and stacks with list operations.

Store object fields and values efficiently.

Manage unique collections and compute intersections.

Rank items by score for leaderboards and scheduling.

Broadcast messages to subscribed clients.

Configure RDB snapshots and AOF append logs.

Set TTL, scan keys, and inspect the keyspace.

Configure a virtual host with root, index, and try_files.

Forward requests to upstream HTTP services.

Distribute traffic across multiple upstream servers.

Terminate TLS with certificates and HTTP/2.

Match request URIs with prefix, regex, and exact locations.

Rewrite URIs and issue HTTP redirects.

Compress text responses to reduce bandwidth.

Cache upstream responses to reduce backend load.

Copy, move, link, and search files efficiently.

Manage read/write/execute bits with chmod and chown.

List, signal, and monitor running processes.

Inspect interfaces, ports, connections, and DNS.

Install, update, and search packages on Debian and RHEL.

Filter, transform, and summarize text streams.

Inspect filesystems, large directories, and inodes.

Create users, manage groups, and grant sudo access.

Define tables with constraints and autoincrement keys.

Insert rows and query with parameterized statements.

Combine tables and aggregate grouped rows.

Create indexes and inspect query plans.

Wrap statements in atomic units with savepoints.

Configure SQLite behavior and inspect the database.

Query across multiple database files in one connection.

Dump databases to SQL and restore from dumps.

Read, write, and watch files with promises and callbacks.

Build an HTTP server with the http module and routing.

Pipe, transform, and consume streams efficiently.

Emit and listen for custom events.

Join, resolve, and parse file paths cross-platform.

Work with binary data using Buffer and TypedArrays.

Spawn, exec, and fork external processes.

Run promises in parallel, sequentially, and with limits.

Define a Django model with field types and meta options.

Filter, exclude, annotate and chain QuerySets.

Use generic class-based views for common CRUD flows.

Wire URLs to views with path converters and includes.

Build forms from models with validation and widgets.

Use built-in tags and filters in Django templates.

Customize the Django admin with list_display and actions.

Login, logout, and protect views with auth decorators.

Define routes with methods and dynamic parameters.

Access request data and build custom responses.

Render templates with context and template inheritance.

Organize an app into modular blueprints.

Store per-user data in signed session cookies.

Register custom error handlers for HTTP exceptions.

Define models and query them with Flask-SQLAlchemy.

Build decorators to gate or augment view functions.

Capture typed path segments with validation.

Parse query strings with defaults and validation.

Validate JSON bodies with Pydantic models.

Share logic via Depends and yield-based dependencies.

Shape and filter responses with response_model.

Issue and verify JSON Web Tokens with OAuth2.

Define async handlers and run blocking work in a thread.

Add CORS, timing, and custom middleware.

Create arrays from lists and built-in constructors.

Slice arrays and index with boolean masks.

Combine arrays of compatible shapes without copying.

Apply element-wise math and reductions.

Solve systems, factorize, and compute eigenvalues.

Sample from distributions with a Generator.

Reshape, transpose, and stack arrays.

Persist arrays with .npy, .npz, and text formats.

Build DataFrames from dicts, lists, and files.

Select rows and columns with loc, iloc, and masks.

Split, aggregate, and transform with groupby.

Combine frames with merge and concat.

Reshape data with pivot, melt, and pivot_table.

Resample, shift, and roll windows over time data.

Detect, fill, and drop NaN values.

Read and write CSV, Excel, Parquet, and SQL.

Plot lines with markers, colors, and styles.

Draw vertical, horizontal, and grouped bars.

Visualize relationships with size and color encodings.

Arrange multiple axes with subplots and GridSpec.

Annotate plots with text, arrows, and legend options.

Apply built-in styles and customize rcParams.

Export figures to PNG, PDF, and SVG with DPI control.

Render surfaces and scatter in 3D.

Load, display, and save images in various formats.

Resize with interpolation and crop regions of interest.

Convert between BGR, RGB, HSV, and grayscale.

Smooth and sharpen images with kernels.

Detect edges with Canny, Sobel, and Laplacian.

Find, draw, and measure contours.

Detect faces with a Haar cascade classifier.

Apply binary, adaptive, and Otsu thresholding.

Create, index, and operate on tensors.

Compute gradients automatically with backward().

Build custom datasets and batch them with DataLoader.

Define models with nn.Module and Sequential.

Run a full train-eval loop with loss and optimizer.

Move models and tensors to GPU and handle availability.

Checkpoint models, optimizer state, and weights.

Fine-tune a pretrained torchvision model.

Create and operate on TensorFlow tensors.

Build models with Sequential and the functional API.

Use core layers and build a custom one.

Compile, fit, and evaluate a Keras model.

Step through batches with GradientTape.

Monitor and control training with callbacks.

Persist models in SavedModel and Keras formats.

Build efficient input pipelines with tf.data.

Scale, encode, and impute features with sklearn.

Split data into training and evaluation sets.

Train and predict with common classifiers.

Fit regressors and evaluate with RMSE and R2.

Cluster with KMeans and DBSCAN.

Evaluate classifiers with confusion matrix and reports.

Chain preprocessing and modeling with Pipeline.

Estimate performance with k-fold and grid search.

Tokenize text with NLTK, spaCy, and regex.

Remove common words with NLTK and spaCy.

Reduce words to roots with Porter, Snowball, and lemmatizers.

Vectorize text with TF-IDF and n-grams.

Train and use word embeddings with gensim.

Extract entities with spaCy and transformers.

Score text polarity with VADER and transformers.

Train a TF-IDF + LogisticRegression text classifier.

Declare pointers, dereference, and walk an array with pointer arithmetic.

Allocate, resize, and free heap memory with malloc, realloc, and free.

Use string.h helpers for length, copy, concat, compare, and tokenize.

Open, read, write, and close files using the stdio FILE API.

Group related fields with typedef and pass by pointer for mutation.

Store function addresses for callbacks and dispatch tables.

Define object-like and function-like macros with conditional compilation.

Set, clear, toggle, and test bits with bitwise operators and flags.

Filter, project, sort, group, and aggregate sequences with LINQ.

Run I/O concurrently with async methods, await, and Task.WhenAll.

Encapsulate state with auto, computed, validated, and init-only properties.

Write type-parameterized methods and classes with constraints.

Define delegate types and publish events with safe subscription.

Inspect type metadata and invoke members at runtime via System.Reflection.

Use List, Dictionary, HashSet, Queue, Stack, and read-only views.

Read, write, append, copy, and JSON-serialize files with File and streams.

Use optional binding, nil-coalescing, chaining, and guard for safe unwrapping.

Define closure expressions, capture state, and pass escaping callbacks.

Define contracts, conform with structs, and add default behavior via extensions.

Write type-parameterized functions and types with protocol constraints.

Compare value-type structs with reference-type classes and inheritance.

Throw and catch typed errors with do-catch, try?, try!, and rethrows.

Run async functions, parallelize with async let, and fan out with task groups.

Trim, split, join, replace, and index strings using Swift's Unicode API.

Use blocks with yield, Procs, lambdas, and the & operator.

Define classes with inheritance, mix in modules, and add class methods.

Use each, map, select, reduce, group_by, and lazy enumerators.

Interpolate, trim, split, replace, and pattern-match strings.

Build, default, transform, merge, and group with Hash.

Define methods dynamically, intercept with method_missing, and build DSLs.

Raise and rescue typed exceptions with ensure and retry.

Read, write, append, traverse directories, and process CSV files.

Use nullable types, safe calls, Elvis, and smart casts for null-safe code.

Model immutable data with auto-generated equals, copy, and destructuring.

Use launch, async, await, and structured concurrency with supervisorScope.

Add methods to existing types with extensions and infix operators.

Model closed hierarchies and UI state with sealed classes and when.

Branch on values, ranges, and types with when as statement or expression.

Filter, map, group, partition, and chunk with functional operators.

Delegate interfaces, lazy properties, observables, and custom delegates.

Create, inspect, filter, mutate, sort, aggregate, and merge data frames.

Build atomic vectors, apply vectorized ops, index, and recycle.

Build layered plots with geoms, facets, and themes using the grammar of graphics.

Chain mutate, filter, group_by, summarise, and joins with the native pipe.

Compute summaries, run t-tests, linear models, ANOVA, and use distributions.

Apply functions over arrays, lists, and groups with apply, lapply, sapply, tapply.

Read and write CSV, TSV, RDS, RData, and text files with base R.

Define functions with defaults, variadic args, closures, and higher-order use.

Six levels of ATX and Setext headings.

Inline, reference, and auto links plus images.

Fenced, indented, and inline code.

GFM tables with column alignment.

Ordered, unordered, and nested lists.

Single, multi-line, and nested quotes.

Italic, bold, strikethrough, and escaping.

GFM checkboxes for to-do items.

The seven JSON value types.

Objects within objects for hierarchical data.

Lists of mixed and homogeneous values.

Validate structure with JSON Schema.

Query expressions for locating nodes.

Partially update JSON documents.

Address a specific value by path.

Newline-delimited JSON for streaming.

Strings, numbers, booleans, null, and dates.

Lists and key-value maps.

Reuse nodes with anchors, aliases, and merge keys.

Several documents in one stream.

Explicit type tags for custom resolution.

Inline JSON-like sequences and mappings.

Indentation-based nesting.

How YAML 1.1 and 1.2 resolve scalars.

Declare and use XML namespaces.

Path expressions for selecting nodes.

Document Type Definition for validation.

Two models for reading XML.

Name-value pairs on elements.

Escape blocks of literal text.

Transform XML into other formats.

Rules every parser enforces.

Rect, circle, ellipse, line, polygon, polyline.

Draw arbitrary curves via the d attribute.

Linear and radial color blends.

Translate, rotate, scale, and skew groups.

Styled text and tspans.

Blur, shadow, and other effects.

SMIL animate, transform, and opacity.

Tileable fills defined in defs.

Match sets and ranges of characters.

Control how many times a token repeats.

Capture, non-capture, and named groups.

Zero-width assertions around a position.

Match one of several branches.

Match positions instead of characters.

Reuse a previously captured group.

Practical patterns for everyday validation.

Define types, enums, and scalars.

Read data with selection sets.

Write data and return the result.

Receive pushed updates over a stream.

Reusable selection sets.

Parameterize operations dynamically.

Conditionally include or skip fields.

Functions that fulfill each field.

GET, POST, PUT, and DELETE requests.

Set and inspect request and response headers.

Basic, bearer, and OAuth credentials.

Send, save, and reuse cookies.

Transfer files to and from a server.

Route requests through HTTP or SOCKS proxies.

Chase 3xx responses automatically.

Trace requests, timing, and transfers.

Core HTTP request methods.

Five classes of response codes.

Common request and response headers.

Cache-Control, ETag, and conditional requests.

Set, send, and expire cookies.

Basic, Bearer, and challenge responses.

Negotiate representation with Accept headers.

Cross-origin preflight and responses.

Compile and instantiate a .wasm module.

Shared, growable byte buffer.

Function references for indirect calls.

Exchange functions, memory, and globals.

Pass strings through shared memory.

Human-readable WebAssembly.

Benchmark and parallelize WASM workloads.

Inspect modules and handle traps.

Destructure values and match cases in Scala.

Immutable data classes with auto-generated equals/hashCode/toString.

Functional collection operations: map, filter, fold, groupBy.

Compose behaviors using traits with default implementations.

Asynchronous computation with Future and ExecutionContext.

Type-class derivation and context passing via implicits.

Message-passing concurrency with the actor model.

Ad-hoc polymorphism via type classes.

Create and operate on matrices in MATLAB.

Create line plots with labels, legends, and styling.

Define functions in separate files or at end of scripts.

Heterogeneous data containers in MATLAB.

Read and write .mat, .csv, and text files.

Solve ordinary differential equations with ode45.

Compute and visualize the FFT of a signal.

Work with struct arrays and modern table data type.

Declare variables with Dim and type inference.

For, For Each, While, and Do loops in VB.

Define Sub (no return) and Function (returns value).

Create a simple WinForms application.

Read/write text files and use My.Computer.FileSystem.

Structured exception handling in VB.

Generic collections in VB.NET.

Query data with VB LINQ syntax.

Define units with interface and implementation sections.

Create a form with event handlers in Delphi VCL.

Define properties and event handlers in Delphi.

Type-safe containers with generics in Delphi.

Define interfaces with automatic reference counting.

Try/Except/Finally in Delphi.

Inspect types and properties at runtime.

Query SQL databases with FireDAC.

Create and operate on arrays in modern Fortran.

Define reusable procedures in Fortran.

Organize code with modules and OOP-style types.

Read/write files with formatted output.

Parallelize loops with OpenMP directives.

Call BLAS/LAPACK for matrix operations.

Custom types with allocatable components and pointers.

Dynamic memory allocation in Fortran.

Tables are Lua's only data structure — used as arrays and maps.

Implement OOP and operator overloading via metatables.

Cooperative multitasking with coroutines.

Create reusable modules in Lua.

Pattern matching and string functions in Lua.

Read and write files in Lua.

Implement class inheritance using metatables.

Protected calls and error handling in Lua.

Pattern matching is core to Elixir — used everywhere.

Chain function calls with the |> pipe operator.

Spawn lightweight processes and send messages.

Build stateful server processes with GenServer behaviour.

Build fault-tolerant supervision trees.

Polymorphism via protocols and the Enum module.

Functional collection operations in Elixir.

Write code that writes code at compile time.

Define algebraic data types and type classes.

Use Maybe for safety and IO for side effects.

Generate lists with comprehensions and leverage laziness.

The three core abstraction type classes.

Side-effectful programming in Haskell.

Organize code with modules and control exports.

Understand lazy evaluation and when to be strict.

Apply functions in a context with less power than Monad.

Define classes with named and factory constructors.

Asynchronous programming with Future and async/await.

Work with collections and functional operations.

Sound null safety with ? and ! operators.

Type-safe reusable classes and methods.

Compose behaviors without inheritance.

Work with single and multiple async values.

Run code in separate isolates for CPU-bound work.

Perl's three main data types with sigils.

Perl is famous for its powerful regex support.

Define subs and use references for complex data.

Build nested structures with references.

Create reusable modules with package keyword.

Read and write files with filehandles.

Modern object-oriented programming in Perl.

Common Perl one-liners for text processing.

Define a basic smart contract with state and functions.

Function visibility, payable, and return values.

Reuse validation logic with modifiers.

Emit events for off-chain listeners.

Group related data with structs and look it up by key with mappings.

Reuse logic via inheritance; define contracts with abstract and interface.

Receive ETH via payable functions and the receive/fallback hooks.

Harden contracts against the most common smart-contract attack.

Edit multiple files with buffers, split windows, and tab pages.

Find text with / and replace with :s, leveraging regex and ranges.

Store yanks/deletes in named registers and paste from them.

Jump back to positions in a file or across files with marks.

Record a sequence of keys and replay it to automate repetitive edits.

Hide regions of code to focus on structure with fold methods.

Install, configure and discover plugins with vim-plug / packer / lazy.

Get IDE features (autocomplete, go-to-definition, diagnostics) via LSP.

Store and retrieve values by key with expiration and flags.

Conditional writes and in-place string concatenation.

Optimistic locking: update a key only if it hasn't changed since you read it.

Inspect memory, hit rate, evictions and per-slab allocation.

Logically invalidate all keys instantly (lazy deletion).

Choose TTLs wisely and understand how Memcached evicts under pressure.

Pick the right protocol and shard across servers without reshuffling.

Apply Memcached to common application caching problems.

Connect to standalone, TLS, authenticated, or non-default DB indexes.

Navigate the REPL, discover commands, and introspect the server.

Queue commands atomically and use optimistic locking with WATCH.

Fan-out messaging with channels and pattern subscriptions.

Watch every command in real time and find slow queries.

Run atomic server-side Lua scripts; load and call functions.

Trigger snapshots, manage AOF rewrite, and capture a safe backup.

Manage ACL users, redis-check tools, and cluster resharding.

Apply a function element-wise over arrays with dot syntax and @.

Select methods by the runtime types of all arguments, not just the receiver.

Define generic, type-stable containers that compile to specialized code.

Manipulate Julia syntax trees as first-class data via :expr and macro.

Parallelize loops with @threads and offload tasks with @spawn / pmap.

Filter, transform, group, and join tabular data with DataFrames.jl.

Write Julia that runs at C speed by removing bounds checks, avoiding allocations, and using views.

Define and numerically solve an initial-value ODE with adaptive stepping.

A freestanding x86-64 program that prints and exits using only kernel syscalls.

Pass args in registers, preserve callee-saved regs, keep rsp 16-byte aligned.

Sum integers 1..N with a counted loop using dec/jnz.

Compute C-string length by scanning memory until a zero byte.

Use the rep movsb string instruction for a tight memory copy.

Use BMI/ABM instructions for branchless bit operations.

open/read/write/close a file using only Linux syscalls.

Implement factorial(n) recursively with a proper stack frame.

Two processes pass messages back and forth using spawn and receive.

Build a stateful server with the gen_server behaviour.

Define a supervisor that starts workers and restarts them on crash.

Match a specific reply out of many messages using a unique reference.

Use link and trap_exit to detect process death and recover.

Hold mutable state in a process by threading it through recursive calls.

Apply a function to each list element in parallel across processes.

Reload a module's code without stopping the running system.