Languages & Runtimes

list of programming languages

CSS 1 💻 Introduction Dart 1 🎯 Dart Runtime Engine, JIT/AOT Compilers, and Execution Architecture HTML 1 💻 Introduction JavaScript 1 🧬 JavaScript Introduction Node.js 1 🟢 What Node.js Is and How V8 Executes JavaScript Rust 1 🦀 What Rust Is and System Programming Concepts SQL 1 🛢️ What Relational Databases Are TypeScript 1 🔷 Introduction to TypeScript CSS 2 💻 selectors and comments Dart 2 🎯 Project Setup with dart create, CLI Tools, and pubspec.yaml HTML 2 💻 Elements JavaScript 2 🧬 How to add JavaScript Node.js 2 🟢 Installing Node.js, NVM, and Setting Up the Environment Rust 2 🦀 Installing Rust, Rustup, rustc, and Cargo SQL 2 🛢️ Relational Database Management Systems (RDBMS)TypeScript 2 🔷 Setting Up the Development Environment CSS 3 💻 units Dart 3 🎯 Variables, Type Inference (var, final, const), and Compile-time Constants HTML 3 💻 Headings JavaScript 3 🧬 Comments Node.js 3 🟢 Global Objects, Process Object, and Environment Variables Rust 3 🦀 Hello World and Project Structure in Cargo SQL 3 🛢️ Tables, Rows, Columns, and Keys TypeScript 3 🔷 The TypeScript CLI and tsconfig.json CSS 4 💻 colors and color properties Dart 4 🎯 Built-in Data Types: int, double, num, String, bool HTML 4 💻 Paragraph, Preformatted text and Line Break JavaScript 4 🧬 Variables Node.js 4 🟢 CommonJS Module System (require and module.exports)Rust 4 🦀 Variables, Immutability, and the mut Keyword SQL 4 🛢️ SQL Categories: DDL, DML, DCL, TCL, and DQL TypeScript 4 🔷 Basic Types — string, number, boolean, null, undefined CSS 5 💻 background related properties Dart 5 🎯 String Manipulation, Interpolation, Multiline Literals, and Raw Strings HTML 5 💻 b, strong, i, em, mark elements Javascript 5 🧬 variable hoisting and var vs let Node.js 5 🟢 ECMAScript Modules (import and export in Node.js)Rust 5 🦀 Scalar Data Types: Integers, Floats, Booleans, and Chars SQL 5 🛢️ Installing SQL Environment and Client Tools TypeScript 5 🔷 Arrays, Tuples, and Enums CSS 6 💻 fonts and font properties Dart 6 🎯 Operators: Arithmetic, Relational, Type Test (is, as), and Bitwise HTML 6 💻 del, ins, sub, sup elements JavaScript 6 🧬 escape characters and template literals Node.js 6 🟢 Native TypeStrip Execution (--experimental-strip-types / --type-stripping)Rust 6 🦀 Compound Data Types: Tuples and Arrays SQL 6 🛢️ Creating and Dropping Databases TypeScript 6 🔷 Union and Intersection Types CSS 7 💻 line height and text decoration Dart 7 🎯 Null Safety Fundamentals: Non-nullable Types, the ? Operator, and Late Initialization (late)HTML 7 💻 blockquote, q, abbr, address, cite, dbo elements JavaScript 7 🧬 Automatic type conversion and typeof operator Node.js 7 🟢 Package Management with npm, pnpm, and yarn Rust 7 🦀 Functions, Parameters, and Return Values SQL 7 🛢️ Data Types: Numeric, Character, Date, and Boolean TypeScript 7 🔷 Type Aliases and Interfaces CSS 8 💻 text-align, letter-spacing, word-spacing and text-transform Dart 8 🎯 Null-Aware Operators: ??, ??=, ?., and Null Assertion (!)HTML 8 💻 Comments and anchor element in HTML JavaScript 8 🧬 objects Node.js 8 🟢 Understanding package.json, package-lock.json, and workspaces Rust 8 🦀 Statements vs Expressions in Rust Syntax SQL 8 🛢️ Creating Tables with CREATE TABLE TypeScript 8 🔷 Functions — Parameters, Return Types, and Overloads CSS 9 💻 text indent, vertical align, text align last, direction properties Dart 9 🎯 Control Flow: if/else, Ternary Expressions, and Guard Clauses HTML 9 💻 img, map and area elements in HTML JavaScript 9 🧬 Explicit Type Conversion Node.js 9 🟢 The Node.js Event Loop Architecture and Libuv Thread Pool Rust 9 🦀 Control Flow with if, else if, and else SQL 9 🛢️ Modifying Tables with ALTER TABLE TypeScript 9 🔷 Object Types and Optional Properties CSS 10 💻 white space, text emphasis and text shadow properties Dart 10 🎯 Switch Statements, Pattern Matching, and Switch Expressions (Dart 3+)HTML 10 💻 picture, source element and favicon JavaScript 10 🧬 Functions Node.js 10 🟢 Call Stack, Microtasks, Macrotasks, and process.nextTick Rust 10 🦀 Loops in Rust: loop, while, and for SQL 10 🛢️ Removing Tables with DROP TABLE and TRUNCATE TypeScript 10 🔷 Type Inference and Type Annotations CSS 11 💻 line break and word break properties Dart 11 🎯 Loops: for, for-in, while, do-while, and Loop Control (break, continue)HTML 11 💻 tables JavaScript 11 🧬 Control flow and Conditional execution Node.js 11 🟢 Non-Blocking Asynchronous I/O Mechanics Rust 11 🦀 Memory Layout: Stack vs Heap Storage SQL 11 🛢️ Primary Key and Foreign Key Constraints TypeScript 11 🔷 Literal Types and Const Assertions CSS 12 💻 text combine upright, text underline offset, text underline position and text overflow pro Dart 12 🎯 Functions: Named, Optional, Default Parameters, and Arrow Syntax (=>)HTML 12 💻 unordered, ordered lists, list items and description list JavaScript 12 🧬 switch statement Node.js 12 🟢 Asynchronous Control Flow with Promises and Async/Await Rust 12 🦀 Core Ownership Rules and Memory Safety Guarantee SQL 12 🛢️ NOT NULL, UNIQUE, and DEFAULT Constraints TypeScript 12 🔷 Type Assertions and Type Casting CSS 13 💻 image orientation, image rendering, object fit and object position properties Dart 13 🎯 First-Class Functions, Higher-Order Functions, and Anonymous Closures HTML 13 💻 Inline and block level elements JavaScript 13 🧬 loops part 1 Node.js 13 🟢 Legacy Callback Patterns and Error-First Conventions Rust 13 🦀 Move Semantics and Variable Scope Drop Behavior SQL 13 🛢️ CHECK Constraints TypeScript 13 🔷 Control Flow Analysis and Narrowing CSS 14 💻 box model Dart 14 🎯 Core Collections: List (Fixed vs Growable) and Spread Operators (..., ...?)HTML 14 💻 div element JavaScript 14 🧬 loops part 2 Node.js 14 🟢 The EventEmitter Class and Custom Event Handlers Rust 14 🦀 Deep Copying with Clone vs Bitwise Copy with Copy SQL 14 🛢️ Querying Data with SELECT and FROM TypeScript 14 🔷 Type Guards — typeof, instanceof, in CSS 15 💻 position property Dart 15 🎯 Collection if and Collection for Literals HTML 15 💻 iframe element JavaScript 15 🧬 Arrow functions Node.js 15 🟢 Working with the Native File System Module (node:fs)Rust 15 🦀 References and Borrowing Rules SQL 15 🛢️ Filtering Rows with WHERE TypeScript 15 🔷 User-Defined Type Guards and Predicates CSS 16 💻 display property Dart 16 🎯 Core Collections: Set for Uniqueness and Set Operations HTML 16 💻 head element JavaScript 16 🧬 Call stack Node.js 16 🟢 Synchronous vs Asynchronous vs Promise-based File Operations Rust 16 🦀 Mutable References vs Immutable References SQL 16 🛢️ Comparison Operators TypeScript 16 🔷 Discriminated Unions CSS 💻 17 - margin, padding and border properties Dart 17 🎯 Core Collections: Map Operations, Entries, and Iteration HTML 17 💻 Layout elements JavaScript 17 🧬 closure Node.js 17 🟢 File Path Parsing and Resolution with node:path Rust 17 🦀 The Aliasing XOR Mutability Rule SQL 17 🛢️ Logical Operators: AND, OR, and NOT TypeScript 17 🔷 Exhaustiveness Checking and never CSS 18 💻 Grid Layout Introduction Dart 18 🎯 Classes and Objects: Constructors (Generative, Named, Redirecting)HTML 18 💻 code, var, kbd, samp and pre elements JavaScript 18 🧬 what is recursion Node.js 18 🟢 Binary Data Manipulation with Buffers and TypedArrays Rust 18 🦀 Slice Type: String Slices (&str) and Array Slices SQL 18 🛢️ Range Filtering with BETWEEN and NOT BETWEEN TypeScript 18 🔷 Unknown, any, and never CSS 19 💻 grid-template-areas, grid-area and grid-template Dart 19 🎯 Const Constructors and Immutable Class Instances HTML 19 💻 Entities, Symbols and Emojis in HTML Javascript 19 🧬 pure functions Node.js 19 🟢 Stream Fundamentals (Readable, Writable, Duplex, Transform)Rust 19 🦀 Structs Definition and Instantiation SQL 19 🛢️ Set Filtering with IN and NOT IN TypeScript 19 🔷 Classes — Properties, Methods, and Constructors CSS 20 💻 grid-auto-columns, grid-auto-rows and grid-auto-flow properties Dart 20 🎯 Factory Constructors and Singleton Design Patterns HTML 20 💻 Forms Introduction JavaScript 20 🧬 Arrays Node.js 20 🟢 Piping Streams, Backpressure Handling, and stream/promises Rust 20 🦀 Tuple Structs and Unit-Like Structs SQL 20 🛢️ Pattern Matching with LIKE, ILIKE, and Wildcards TypeScript 20 🔷 Access Modifiers — public, private, protected, readonly CSS 21 💻 grid-row-start, grid-column-start, grid-row-end and grid-column-end properties Dart 21 🎯 Member Visibility: Private Identifiers (_) and Library Scope Rules HTML 21 💻 input and textarea elements JavaScript 21 🧬 Mutability Node.js 21 🟢 Web Streams API (ReadableStream, WritableStream, TransformStream)Rust 21 🦀 Defining Methods and Associated Functions with impl Blocks SQL 21 🛢️ Handling NULL Values with IS NULL and IS NOT NULL TypeScript 21 🔷 Abstract Classes and Interfaces CSS 22 💻 grid-row, grid-column properties Dart 22 🎯 Getters, Setters, and Computed Properties HTML 22 💻 select, option, optgroup, legend,fieldset, output elements JavaScript 22 🧬 string methods Node.js 22 🟢 Native Web Standard APIs (fetch, Headers, Request, Response)Rust 22 🦀 Enums Definition and Encoding Data in Variants SQL 22 🛢️ Sorting Results with ORDER BY TypeScript 22 🔷 Inheritance and Polymorphism CSS 23 💻 row-gap, column-gap and gap properties Dart 23 🎯 Inheritance, Method Overriding, and Super Initializer Lists HTML 23 💻 video, audio and source elements JavaScript 23 🧬 rest parameters Node.js 23 🟢 Working with FormData, Blob, File, and StructuredClone Rust 23 🦀 The Option<T> Enum and Null Prevention SQL 23 🛢️ Limiting Results with LIMIT, OFFSET, and TOP TypeScript 23 🔷 Getters, Setters, and Accessors CSS 24 💻 flexbox layout introduction Dart 24 🎯 Abstract Classes, Abstract Methods, and Interface Contracts HTML 24 💻 embed and object elements JavaScript 24 🧬 Destructuring Node.js 24 🟢 URL Parsing and Manipulation with the Web URL API (node:url)Rust 24 🦀 Control Flow Matching with the match Expression SQL 24 🛢️ Removing Duplicates with DISTINCT TypeScript 24 🔷 Static Members and Class Expressions CSS 25 💻 flex-direction and flex-wrap properties Dart 25 🎯 Implicit Interfaces and Class Implementation (implements)HTML 25 💻 svg, circle, polygon and rect JavaScript 25 🧬 Math Object Node.js 25 🟢 Managing Environment Variables natively with .env File Support Rust 25 🦀 Exhaustive Pattern Matching Rules SQL 25 🛢️ Inserting Single and Multiple Rows with INSERT INTO TypeScript 25 🔷 Generics — Functions CSS 26 💻 flex-grow, flex-shrink properties Dart 26 🎯 Mixins (mixin, with, on) and Multiple Code Reuse Architecture HTML 26 💻 ellipse, line, path and polyline JavaScript 26 🧬 JSON Node.js 26 🟢 Building Raw HTTP Servers with node:http and node:https Rust 26 🦀 Concise Control Flow with if let and while let SQL 26 🛢️ Updating Data with UPDATE and WHERE TypeScript 26 🔷 Generics — Classes and Interfaces CSS 27 💻 flex-basis, flex and flex-flow properties Dart 27 🎯 Class Modifiers (Dart 3+): base, interface, final, sealed HTML 27 💻 canvas element JavaScript 27 🧬 Higher-order functions Node.js 27 🟢 Handling HTTP Requests, Response Headers, and Status Codes Rust 27 🦀 Modules System, Privacy Rules (pub), and use Declarations SQL 27 🛢️ Deleting Data with DELETE TypeScript 27 🔷 Generic Constraints CSS 28 💻 justify-content and align-items properties Dart 28 🎯 Enums: Basic Enums, Enhanced Enums with Fields, Methods, and Interfaces HTML 28 💻 Mathematical Markup Language JavaScript 28 🧬 Encapsulation Node.js 28 🟢 Introduction to Express.js Framework Rust 28 🦀 Packages, Crates, Workspaces, and Cargo.toml SQL 28 🛢️ Column and Table Aliases with AS TypeScript 28 🔷 Default Type Parameters CSS 29 💻 align-content and align-self properties Dart 29 🎯 Extension Methods (extension on) and Static Extensions HTML 29 💻 microdata JavaScript 29 🧬 Prototype Node.js 29 🟢 Express Routing, URL Parameters, and Query Strings Rust 29 🦀 Vector Collection (Vec<T>) Operations and Storage SQL 29 🛢️ Aggregate Functions: COUNT, SUM, AVG, MIN, MAX TypeScript 29 🔷 keyof, typeof, and Indexed Access Types CSS 30 💻 media queries introduction Dart 30 🎯 Extension Types (extension type) for Zero-Cost Abstractions HTML 30 💻 Cheatsheet JavaScript 30 🧬 Classes Node.js 30 🟢 Middleware Architecture and Custom Middleware Creation in Express Rust 30 🦀 UTF-8 String Storage (String vs &str)SQL 30 🛢️ Grouping Data with GROUP BY TypeScript 30 🔷 Mapped Types CSS 31 💻 any-hover and any-pointer media features Dart 31 🎯 Generics: Generic Classes, Methods, and Type Constraints (<T extends>)HTML 31 💻 1-29 Full 💻JavaScript 31 🧬 Class notation Node.js 31 🟢 Built-in and Third-Party Express Middleware Rust 31 🦀 Key-Value HashMaps (HashMap<K, V>)SQL 31 🛢️ Filtering Grouped Data with HAVING TypeScript 31 🔷 Conditional Types CSS 32 💻 aspect-ratio and color media features Dart 32 🎯 Records (Dart 3+): Anonymous Type-Safe Aggregates and Destructuring JavaScript 32 🧬 Class getters and setters Node.js 32 🟢 Request Body Parsing (JSON, Form Data, URL-Encoded)Rust 32 🦀 Unrecoverable Errors with panic!SQL 32 🛢️ Order of Execution in SQL Queries TypeScript 32 🔷 Infer Keyword and Conditional Type Inference CSS 33 💻 color gamut, color index media features Dart 33 🎯 Pattern Matching in Assignments, Destructuring Lists, Maps, and Records JavaScript 33 🧬 Class Inheritance Node.js 33 🟢 File Upload Handling with Multer Rust 33 🦀 Recoverable Errors with the Result<T, E> Enum SQL 33 🛢️ Relational Joins Concept TypeScript 33 🔷 Template Literal Types CSS 34 💻 display-mode and dynamic-range media features Dart 34 🎯 Exception Handling: try, catch, on, finally, and Custom Exceptions JavaScript 34 🧬 Class Method Override Node.js 34 🟢 Centralized Error Handling Middleware in Express Rust 34 🦀 Propagating Errors with the ? Operator SQL 34 🛢️ Combining Data with INNER JOIN TypeScript 34 🔷 Utility Types — Partial, Required, Readonly, Pick, Omit CSS 35 💻 forced-colors and grid media features Dart 35 🎯 Functional Iteration: map, where, fold, reduce, and expand JavaScript 35 🧬 Polymorphism Node.js 35 🟢 Introduction to Fastify Framework Architecture Rust 35 🦀 Custom Error Types and the std::error::Error Trait SQL 35 🛢️ Including Unmatched Rows with LEFT JOIN TypeScript 35 🔷 Utility Types — Record, Exclude, Extract, NonNullable CSS 36 💻 height and width media features Dart 36 🎯 Asynchronous Programming Fundamentals: Future and Event Loop Execution JavaScript 36 🧬 Iterator Interface Node.js 36 🟢 Fastify Plugins, Hooks, Lifecycle, and Schema Validation Rust 36 🦀 Application Error Reporting (thiserror and anyhow)SQL 36 🛢️ Right Side Data with RIGHT JOIN TypeScript 36 🔷 Utility Types — ReturnType, Parameters, Awaited, InstanceType CSS 37 💻 hover and inverted colors media features Dart 37 🎯 Handling Futures: .then(), .catchError(), and .whenComplete()JavaScript 37 🧬 Maps Node.js 37 🟢 Introduction to NestJS Enterprise Framework Rust 37 🦀 Generic Data Types in Functions, Structs, and Enums SQL 37 🛢️ Combining All Rows with FULL OUTER JOIN TypeScript 37 🔷 Utility Types — ThisType, Uppercase, Lowercase, Capitalize CSS 38 💻 monochrome and orientation media features Dart 38 🎯 Async/Await Mechanics, Microtasks, and Event Queue Scheduling JavaScript 38 🧬 instanceof operator Node.js 38 🟢 NestJS Modules, Controllers, Services, and Dependency Injection Rust 38 🦀 Defining and Implementing Traits SQL 38 🛢️ Cartesian Products with CROSS JOIN TypeScript 38 🔷 Type Composition Patterns CSS 39 💻 overflow-block and overflow-inline media features Dart 39 🎯 Parallel Futures Execution using Future.wait and Future.any JavaScript 39 🧬 Error handling — try/catch/finally/throw Node.js 39 🟢 Connecting to PostgreSQL using the Native pg Driver Rust 39 🦀 Trait Bounds and Conditional Method Implementations SQL 39 🛢️ Joining a Table to Itself with SELF JOIN TypeScript 39 🔷 Variance and Type Compatibility CSS 40 💻 pointer and resolution media features Dart 40 🎯 Asynchronous Data Streams: Stream Fundamentals and Creation JavaScript 40 🧬 The this keyword — call/apply/bind Node.js 40 🟢 Connecting to MySQL using the mysql2 Driver Rust 40 🦀 Default Trait Implementations and Supertraits SQL 40 🛢️ Combining Query Results with UNION and UNION ALL TypeScript 40 🔷 Structural Typing vs Nominal Typing CSS 41 💻 prefers-color scheme and prefers-contrast media features Dart 41 🎯 Single-Subscription vs Broadcast Streams (StreamController)JavaScript 41 🧬 Spread operator Node.js 41 🟢 Preventing SQL Injection with Parameterized Queries Rust 41 🦀 Returning Types that Implement Traits (impl Trait)SQL 41 🛢️ Result Set Intersection with INTERSECT TypeScript 41 🔷 Covariance, Contravariance, and Bivariance CSS 42 💻 prefers-reduced-data and prefers- reduced-motion media features Dart 42 🎯 Stream Transformers (StreamTransformer) and Async Operators JavaScript 42 🧬 Promises Node.js 42 🟢 Database Connection Pooling and Lifetime Management Rust 42 🦀 Lifetimes Concepts and Preventing Dangling References SQL 42 🛢️ Finding Differences with EXCEPT and MINUS TypeScript 42 🔷 Branded Types and Nominal Typing Tricks CSS 43 💻 prefers-reduced-transparency and scan media features Dart 43 🎯 Async Generators (async*, yield) and Sync Generators (sync*, yield*)JavaScript 43 🧬 async/await Node.js 43 🟢 Connecting to MongoDB using Mongoose ODM Rust 43 🦀 Lifetime Annotations in Functions and Structs SQL 43 🛢️ Subqueries in WHERE Clauses TypeScript 43 🔷 Recursive Types CSS 44 💻 scripting, update and video-dynamic-range media features Dart 44 🎯 Package Management with pub.dev: dependencies, dev_dependencies, and Lockfiles JavaScript 44 🧬 ES Modules — import/export Node.js 44 🟢 SQL Query Building with Knex.js Rust 44 🦀 Lifetime Elision Rules SQL 44 🛢️ Subqueries in SELECT and FROM Clauses TypeScript 44 🔷 Distributive Conditional Types CSS 45 💻 transform property introduction Dart 45 🎯 File System I/O Operations (dart:io): Reading, Writing, and Streaming Files JavaScript 45 🧬 Array methods in depth Node.js 45 🟢 Modern Object-Relational Mapping (ORM) with Prisma Rust 45 🦀 Static Lifetime ('static) Mechanics SQL 45 🛢️ Correlated Subqueries TypeScript 45 🔷 Higher-Kinded Type Patterns CSS 46 💻 transform matrix and matrix3d Dart 46 🎯 HTTP Client Requests (dart:io and package:http): REST Integration JavaScript 46 🧬 Object methods in depth Node.js 46 🟢 Lightweight Type-Safe Database Querying with Drizzle ORM Rust 46 🦀 Writing Automated Unit Tests and Documentation Tests SQL 46 🛢️ Subquery Operators: EXISTS and NOT EXISTS TypeScript 46 🔷 Type-Level Programming CSS 47 💻 transform perspective, rotate and rotate3d Dart 47 🎯 JSON Serialization and Deserialization using dart:convert JavaScript 47 🧬 Sets and WeakSets Node.js 47 🟢 Executing Database Migrations via Node CLI Tools Rust 47 🦀 Integration Testing in the tests Directory SQL 47 🛢️ Subquery Operators: ANY, SOME, and ALL TypeScript 47 🔷 Builder Patterns with Types CSS 48 💻 transform rotateX, rotateY and rotateZ Dart 48 🎯 Code Generation with build_runner, json_annotation, and freezed JavaScript 48 🧬 Date and time Node.js 48 🟢 Managing SQL Database Transactions in Node.js Rust 48 🦀 Command-Line Interface Parsing (clap crate)SQL 48 🛢️ Conditional Logic with CASE WHEN Expressions TypeScript 48 🔷 Fluent Interfaces and Method Chaining CSS 49 💻 transform scale and scale3d Dart 49 🎯 Unit Testing with package:test: Grouping, Assertions, and Expectations JavaScript 49 🧬 Regular expressions Node.js 49 🟢 In-Memory Caching Strategies with Redis and Node.js Rust 49 🦀 Closure Syntax, Type Inference, and Capturing Environment SQL 49 🛢️ Handling NULLs with COALESCE and NULLIF TypeScript 49 🔷 Immutability and Readonly Deep CSS 50 💻 transform scaleX, scaleY and scaleZ Dart 50 🎯 Mocking Dependencies in Unit Tests using mockito and mocktail JavaScript 50 🧬 Numbers — Number, parseInt, parseFloat Node.js 50 🟢 Stateless Authentication with JSON Web Tokens (JWT)Rust 50 🦀 Moving Environment Variables into Closures (move keyword)SQL 50 🛢️ String Manipulation Functions TypeScript 50 🔷 Type-Safe Event Emitters CSS 51 💻 transform skew, skewX, skewY Dart 51 🎯 Dart Memory Model: Garbage Collection (Scavenger & Mark-Sweep Algorithms)JavaScript 51 🧬 BigInt Node.js 51 🟢 Password Hashing with bcrypt, Argon2, and Native Web Crypto Rust 51 🦀 Closure Traits: Fn, FnMut, and FnOnce SQL 51 🛢️ Date and Time Arithmetic Functions TypeScript 51 🔷 Type-Safe Dependency Injection CSS 52 💻 transform translate and translate3d Dart 52 🎯 Single-Threaded Concurrency Model and Microtask Queue Prioritization JavaScript 52 🧬 Symbols Node.js 52 🟢 Session-Based Authentication and Secure Cookie Management Rust 52 🦀 Iterator Trait and Consumers vs Adapters SQL 52 🛢️ Numeric and Math Functions TypeScript 52 🔷 Type-Safe State Machines CSS 53 💻 transitions Dart 53 🎯 Multithreading with Isolates: Isolate.spawn and Message Passing JavaScript 53 🧬 Generators — function*, yield Node.js 53 🟢 OAuth2, OpenID Connect, and Social Login Integrations Rust 53 🦀 Processing Collections with Iterators SQL 53 🛢️ Data Type Conversion with CAST and CONVERT TypeScript 53 🔷 Type-Safe API Clients CSS 54 💻 transition-behavior, delay, duration and property Dart 54 🎯 High-Level Concurrency with Isolate.run for CPU-Bound Calculations JavaScript 54 🧬 Event loop Node.js 54 🟢 Role-Based (RBAC) and Attribute-Based (ABAC) Access Control Rust 54 🦀 Smart Pointers: Box (Box) for Heap Allocation SQL 54 🛢️ Introduction to Window Functions and OVER Clause TypeScript 54 🔷 Type-Safe Validation with Zod and io-ts CSS 55 💻 animation property Dart 55 🎯 Bidirectional Isolate Communication via ReceivePort and SendPort JavaScript 55 🧬 null vs undefined + nullish coalescing Node.js 55 🟢 Runtime Input Validation and Sanitization with Zod Rust 55 🦀 Dereference Trait (Deref) and Implicit Deref Coercion SQL 55 🛢️ Partitioning Data with PARTITION BY TypeScript 55 🔷 Modules — import and export CSS 56 💻 animation properties part 1 Dart 56 🎯 Typed Data and Native Buffers (Uint8List, ByteData, Memory Efficiency)JavaScript 56 🧬 Optional chaining ?.Node.js 56 🟢 API Security Best Practices (Helmet, CORS, Rate Limiting, Sanitization)Rust 56 🦀 Cleanup Code Customization with the Drop Trait SQL 56 🛢️ Ranking Functions: ROW_NUMBER, RANK, DENSE_RANK TypeScript 56 🔷 Module Resolution Strategies CSS 57 💻 animation properties part 2 Dart 57 🎯 Foreign Function Interface (FFI): Calling C/C++ Libraries from Dart (dart:ffi)JavaScript 57 🧬 Logical assignment ||=, &&=, ??=Node.js 57 🟢 Native Permission Model (--permission) for File, Process, and Worker Access Rust 57 🦀 Reference Counting Smart Pointer (Rc)SQL 57 🛢️ Tile Distribution with NTILE TypeScript 57 🔷 Path Mapping and BaseUrl CSS 58 💻 Cheatsheet Dart 58 🎯 Structs, Native Memory Allocation, and Pointers in Dart FFI JavaScript 58 🧬 Proxy and Reflect Node.js 58 🟢 Cryptographic Operations with the node:crypto and Web Crypto APIs Rust 58 🦀 Interior Mutability Pattern (RefCell and Cell)SQL 58 🛢️ Value Access Functions: LAG and LEAD TypeScript 58 🔷 Namespaces and Declaration Merging CSS 59 💻 1 - 58 Full Dart 59 🎯 Foreign Function Interface (FFI) Bindings Auto-Generation using ffigen JavaScript 59 🧬 WeakRef / FinalizationRegistry Node.js 59 🟢 Low-Level Real-Time WebSockets with the ws Library Rust 59 🦀 Preventing Memory Leaks and Reference Cycles (Weak)SQL 59 🛢️ Boundary Functions: FIRST_VALUE, LAST_VALUE, NTH_VALUE TypeScript 59 🔷 Declaration Files — .d.ts Dart 60 🎯 Web Interop (dart:js_interop): Interfacing with JavaScript and WASM JavaScript 60 🧬 Class fields — public/private/static Node.js 60 🟢 Event-Driven Real-Time Applications with Socket.io Rust 60 🦀 Thread-Safe Reference Counting (Arc)SQL 60 🛢️ Aggregate Functions over Window Frames TypeScript 60 🔷 Ambient Declarations Dart 61 🎯 Compiling Dart to WebAssembly (WASM) and Modern Browser Deployment JavaScript 61 🧬 DOM manipulation Node.js 61 🟢 Push Notifications and Server-Sent Events (SSE)Rust 61 🦀 Spawning Threads and Thread Joining SQL 61 🛢️ Defining Window Frames: ROWS and RANGE TypeScript 61 🔷 Publishing Typed Packages Dart 62 🎯 Reflection vs Code Generation: dart:mirrors Limitations and Modern AOT Alternatives JavaScript 62 🧬 Events Node.js 62 🟢 Asynchronous Background Task Processing with BullMQ and Redis Rust 62 🦀 Message Passing Concurrency with Channels (mpsc)SQL 62 🛢️ Grouping Sets: ROLLUP, CUBE, and GROUPING SETS TypeScript 62 🔷 Using @types and DefinitelyTyped Dart 63 🎯 Zone Execution Contexts (Zone): Custom Error Zones and Context Binding JavaScript 63 🧬 Browser APIs — fetch, localStorage, setTimeout Node.js 63 🟢 Spawning Child Processes (exec, execFile, spawn, fork)Rust 63 🦀 Shared State Concurrency with Mutex (Mutex<T>) and RwLock SQL 63 🛢️ Common Table Expressions (CTE) with WITH TypeScript 63 🔷 Promises and Async/Await Typing Dart 64 🎯 Advanced Logging, Diagnostics, and Trace Collection via Dart Zones JavaScript 64 🧬 Design patterns Node.js 64 🟢 Parallel Processing and Multithreading with Worker Threads (node:worker_threads)Rust 64 🦀 Sync and Send Traits for Multi-Threaded Safety SQL 64 🛢️ Chaining Multiple CTEs TypeScript 64 🔷 Typing Callbacks and Higher-Order Functions Dart 65 🎯 Custom Analyzer Plugins, Linter Rules, and analysis_options.yaml Configuration JavaScript 65 🧬 Memory management / garbage collection Node.js 65 🟢 Multi-Core Scaling and Process Load Balancing with the Cluster Module Rust 65 🦀 Trait Objects (dyn Trait) and Dynamic Dispatch SQL 65 🛢️ Recursive CTEs for Hierarchical Data TypeScript 65 🔷 Typing Event Handlers and DOM Dart 66 🎯 Writing Custom Static Analysis Rules with AST (Abstract Syntax Tree) Visitors JavaScript 66 🧬 Performance — debounce/throttle Node.js 66 🟢 Production Process Management and Monitoring with PM2 Rust 66 🦀 Object Safety Rules for Trait Objects SQL 66 🛢️ Creating and Managing Views TypeScript 66 🔷 Typing Node.js APIs Dart 67 🎯 Macros Framework (Dart 3.x+): Metaprogramming and Compile-Time Code Augmentation JavaScript 67 🧬 Testing Node.js 67 🟢 Structured Logging Strategies with Pino and Winston Rust 67 🦀 Advanced Pattern Matching: Guards and @ Bindings SQL 67 🛢️ Materialized Views and Refresh Strategies TypeScript 67 🔷 Typing Third-Party Libraries Without Types Dart 68 🎯 Immutability Architecture: Value Objects, Equatable, and Freezed Union Types JavaScript 68 🧬 Node.js basics Node.js 68 🟢 OpenTelemetry Integration for Distributed Tracing and Observability Rust 68 🦀 Associated Types vs Generic Parameters in Traits SQL 68 🛢️ Database Transactions and ACID Properties TypeScript 68 🔷 Error Handling and Typed Errors Dart 69 🎯 Clean Architecture in Pure Dart: Entities, Use Cases, and Repositories JavaScript 69 🧬 package.json + npm/yarn/pnpm Node.js 69 🟢 Application Performance Metrics Exporting with Prometheus Rust 69 🦀 Fully Qualified Syntax for Method Calls (Type::method)SQL 69 🛢️ Transaction Control: BEGIN, COMMIT, and ROLLBACK TypeScript 69 🔷 Result Types and Either Patterns Dart 70 🎯 Dependency Injection Patterns in Pure Dart (get_it, injectable)JavaScript 70 🧬 Modern ES2022+ methods Node.js 70 🟢 Native Test Runner (node:test) and Assertion Library (node:assert)Rust 70 🦀 Orphan Rule and Implementing External Traits on External Types SQL 70 🛢️ Savepoints in Transactions TypeScript 70 🔷 Typing JSON and Unknown Data Dart 71 🎯 Reactive State Management with Streams, BehaviorSubject, and RxDart JavaScript 71 🧬 Numeric separators Node.js 71 🟢 Mocking, Spying, and Timers in node:test Rust 71 🦀 Operator Overloading via std::ops Traits SQL 71 🛢️ Transaction Isolation Levels and Concurrency Anomalies TypeScript 71 🔷 Strict Mode — All Flags Explained Dart 72 🎯 Functional Programming in Dart: Monads, Either, and Option Types using fpdart JavaScript 72 🧬 Top-level await Node.js 72 🟢 Unit Testing Node.js Applications with Jest and Vitest Rust 72 🦀 Type Sizing: Sized vs Unsized Types (?Sized Bound)SQL 72 🛢️ Database Indexes Concepts TypeScript 72 🔷 Compiler Options in Depth Dart 73 🎯 Writing Command-Line Interfaces (CLIs) with package:args JavaScript 73 🧬 Cheatsheet Node.js 73 🟢 Integration and End-to-End API Testing with Supertest Rust 73 🦀 Advanced Lifetimes: Lifetime Subtyping and Bounds SQL 73 🛢️ B-Tree, Hash, and Bitmap Indexes TypeScript 73 🔷 Project References and Composite Projects Dart 74 🎯 Building Production Web Servers in Dart using package:shelf Node.js 74 🟢 Mocking External APIs and Services with MSW Rust 74 🦀 Function Pointers (fn) vs Closure Types SQL 74 🛢️ Composite, Unique, and Partial Indexes TypeScript 74 🔷 Incremental Builds and Performance Dart 75 🎯 Middleware Pipeline Design in Shelf-based Backend Services Node.js 75 🟢 Application Debugging using V8 Inspector and Chrome DevTools Rust 75 🦀 Declarative Macros (macro_rules!) Syntax SQL 75 🛢️ Index Maintenance, Overhead, and Unused Indexes TypeScript 75 🔷 Type-Only Imports and Exports Dart 76 🎯 WebSockets Implementation in Pure Dart Client and Server Applications Node.js 76 🟢 Memory Leak Detection, Heap Profiling, and Heap Snapshots Rust 76 🦀 Procedural Macros: Derive Macros (#[derive])SQL 76 🛢️ Execution Plans and Query Optimization TypeScript 76 🔷 Isolated Modules and verbatimModuleSyntax Dart 77 🎯 Microservices and gRPC Services Implementation in Dart (package:grpc)Node.js 77 🟢 Profiling Event Loop Lag, CPU Spikes, and Async Hooks Rust 77 🦀 Attribute-Like Macros and Function-Like Macros SQL 77 🛢️ Table Scans vs Index Scans and Index Seeks TypeScript 77 🔷 Decorators — Legacy Experimental Dart 78 🎯 Protocol Buffers (Protobuf) Compilation and Type Mapping Node.js 78 🟢 Containerizing Node.js Applications with Docker Rust 78 🦀 Abstract Syntax Tree Manipulation (syn and quote crates)SQL 78 🛢️ Database Normalization: 1NF, 2NF, and 3NF TypeScript 78 🔷 Decorators — Stage 3 Standard Dart 79 🎯 Object-Relational Mapping (ORM) and Database Connectors in Pure Dart Node.js 79 🟢 Multi-Stage Docker Builds, Image Minimization, and Non-Root Execution Rust 79 🦀 Data Serialization and Deserialization (serde)SQL 79 🛢️ Advanced Normalization: BCNF, 4NF, and 5NF TypeScript 79 🔷 Decorators in Angular Dart 80 🎯 Native C Extensions vs Dart FFI Performance Benchmarks Node.js 80 🟢 Signal Handling (SIGTERM, SIGINT) and Graceful Shutdown Patterns Rust 80 🦀 Asynchronous Programming Concepts (Future Trait)SQL 80 🛢️ Denormalization Strategies for Performance TypeScript 80 🔷 Decorators in NestJS Dart 81 🎯 Profiling Dart Applications with DevTools: CPU Profiler and Memory Snapshots Node.js 81 🟢 CI/CD Automated Pipelines for Testing and Deploying Node.js Apps Rust 81 🦀 Async/Await Syntax and Execution Flow SQL 81 🛢️ Entity-Relationship Modeling and Cardinality TypeScript 81 🔷 Mixins and Class Composition Dart 82 🎯 Memory Leak Detection and Tracking Uncollected Objects Node.js 82 🟢 Single Executable Applications (SEA) to Package Apps as Native Binaries Rust 82 🦀 Async Runtimes Architecture (Tokio and async-std)SQL 82 🛢️ User-Defined Functions (Scalar and Table-Valued)TypeScript 82 🔷 The this Type and Polymorphic this Dart 83 🎯 Optimizing Tree Shaking and Reducing AOT Binary Snapshot Size Node.js 83 🟢 Building Custom Command-Line Tools (CLIs) in Node.js Rust 83 🦀 Asynchronous I/O Operations and File System Handling SQL 83 🛢️ Stored Procedures Creation and Execution TypeScript 83 🔷 Function Overloads in Depth Dart 84 🎯 Security Best Practices: Obfuscation, Cryptography, and Key Storage Node.js 84 🟢 Native C++ Addons and High-Performance Native API (Node-API / N-API)Rust 84 🦀 Streams API for Asynchronous Data Sequences (FuturesUnordered)SQL 84 🛢️ Stored Procedure Input and Output Parameters TypeScript 84 🔷 Assertion Functions and asserts Dart 85 🎯 Secure Data Hashing and Encryption using package:crypto and package:encrypt Node.js 85 🟢 Cheatsheet Rust 85 🦀 High-Performance REST API Servers (axum and actix-web)SQL 85 🛢️ Conditional Flow and Loops in Procedural SQL TypeScript 85 🔷 Satisfies Operator Dart 86 🎯 Writing Dynamic Code Evaluators and Parsers in Dart Rust 86 🦀 Asynchronous SQL Database Drivers (sqlx and diesel)SQL 86 🛢️ Error Handling and Exception Control TypeScript 86 🔷 Const Type Parameters Dart 87 🎯 Monorepo Management for Dart Packages using melos Rust 87 🦀 Building Command-Line Terminal Interfaces (ratatui)SQL 87 🛢️ Database Triggers: BEFORE, AFTER, and INSTEAD OF TypeScript 87 🔷 The using Keyword and Disposable Dart 88 🎯 Continuous Integration pipelines for Dart Codebase Quality Gates Rust 88 🦀 Cross-Platform GUI Development (iced and egui)SQL 88 🛢️ Cursors and Iterative Processing TypeScript 88 🔷 TypeScript with React Dart 89 🎯 Publishing Open-Source Dart Packages to pub.dev with Automated Workflows Rust 89 🦀 Desktop Web Hybrid Applications (Tauri)SQL 89 🛢️ Sequences and Auto-Increment Mechanisms TypeScript 89 🔷 TypeScript with Vue Dart 90 🎯 Internal Architecture: Dart VM Architecture, Kernel AST, and IL Optimizations Rust 90 🦀 Unsafe Rust Capabilities and the unsafe Keyword SQL 90 🛢️ User Access Control: GRANT and REVOKE TypeScript 90 🔷 TypeScript with Angular Dart 91 🎯 Internal Architecture: Class Table Layout, Object Headers, and Smi Mechanics Rust 91 🦀 Raw Pointers (*const T and *mut T) Dereferencing SQL 91 🛢️ Roles, Permissions, and Data Security TypeScript 91 🔷 TypeScript with Node and Express Dart 92 🎯 Internal Architecture: Inline Caches (IC) and Polymorphic Call Sites Rust 92 🦀 Calling Unsafe Functions and External C Libraries (FFI)SQL 92 🛢️ Preventing SQL Injection Vulnerabilities TypeScript 92 🔷 TypeScript with Deno and Bun Dart 93 🎯 Internal Architecture: Garbage Collector Safepoints and Mutator Pauses Rust 93 🦀 Foreign Function Interface (bindgen and cbindgen)SQL 93 🛢️ Row-Level Security and Data Masking TypeScript 93 🔷 TypeScript with Testing — Jest and Vitest Dart 94 🎯 Internal Architecture: Deep Dive into Dart AOT Snapshot Binary Format Rust 94 🦀 Accessing or Modifying Mutable Static State SQL 94 🛢️ Working with JSON Data in Relational Databases TypeScript 94 🔷 TypeScript with ESLint and Prettier Dart 95 🎯 Internal Architecture: How Async/Await Desugars into State Machines Rust 95 🦀 Implementing Unsafe Traits SQL 95 🛢️ Full-Text Search and Indexing TypeScript 95 🔷 TypeScript with Bundlers — Vite, esbuild, webpack Dart 96 🎯 Internal Architecture: Dart Web Compilers (dart2js vs dart2wasm) Architecture Rust 96 🦀 Inline Assembly (asm!) for Architecture-Specific Optimization SQL 96 🛢️ Table Partitioning: Range, List, and Hash TypeScript 96 🔷 Migrating JavaScript to TypeScript Dart 97 🎯 Building a Custom Transpiler Engine or DSL Parser in Pure Dart Rust 97 🦀 Pinning Memory (Pin<P> and Unpin)SQL 97 🛢️ Database Locks, Deadlocks, and Blocking Resolution TypeScript 97 🔷 Migrating Between TypeScript Versions Dart 98 🎯 Porting Node.js or Python Utilities to Cross-Platform Standalone Dart Binaries Rust 98 🦀 Memory Layouts: #[repr(C)], Alignment, and Structure Packing SQL 98 🛢️ Upsert Patterns: MERGE, ON CONFLICT, and ON DUPLICATE KEY TypeScript 98 🔷 TypeScript Compiler Internals — Overview Dart 99 🎯 Native Dockerization Strategies for Dart Standalone Backend Services Rust 99 🦀 PhantomData (PhantomData<T>) for Unused Type Parameters SQL 99 🛢️ Database Sharding and Read Replicas TypeScript 99 🔷 Writing Custom TypeScript Transformers Dart 100 🎯 Dart Internals Master Class: Hand-Tracing Memory Lifecycle from Allocator to GC Sweeper Rust 100 🦀 Interior Mutability Mechanics and UnsafeCell (UnsafeCell<T>)SQL 100 🛢️ Backup, Restore, and Disaster Recovery Strategies TypeScript 100 🔷 Language Server Protocol and Editor Integration Dart 101 🎯 Cheatsheet Rust 101 🦀 Lock-Free Data Structures and Atomic Operations (std::sync::atomic)SQL 101 🛢️ Storage Engines Architecture and Page Layouts TypeScript 101 🔷 Performance — Type Checking at Scale Rust 102 🦀 Memory Ordering Guarantees (SeqCst, Acquire, Release, Relaxed)SQL 102 🛢️ Write-Ahead Logging (WAL) and Redo/Undo Logs TypeScript 102 🔷 Monorepos with TypeScript Rust 103 🦀 WebAssembly (Wasm) Compilation and Interoperability (wasm-bindgen)SQL 103 🛢️ Buffer Pool Management and Page Replacement Algorithms TypeScript 103 🔷 Publishing Libraries with Types Rust 104 🦀 Embedded Rust: no_std Environment and Bare-Metal Executables SQL 104 🛢️ Multi-Version Concurrency Control (MVCC) Internals TypeScript 104 🔷 TypeScript Style Guide and Best Practices Rust 105 🦀 Custom Memory Allocators (#[global_allocator])SQL 105 🛢️ Lock Escalation, Latching, and Two-Phase Locking (2PL)TypeScript 105 🔷 Real-World Architecture Patterns SQL 106 🛢️ Cost-Based Optimizer (CBO) Statistics and Histograms TypeScript 106 🔷 Capstone — Full Type-Safe Application SQL 107 🛢️ Join Algorithms: Nested Loop, Hash Join, and Merge Join TypeScript 107 🔷 Cheatsheet SQL 108 🛢️ Query Execution Engine: Volcano Iterator Model vs Vectorized Execution SQL 109 🛢️ Specialized Index Structures: GiST, GIN, BRIN, and R-Trees SQL 110 🛢️ Spatial Data Processing and PostGIS / Geospatial Extensions SQL 111 🛢️ Temporal Tables and System-Versioned Data History SQL 112 🛢️ Graph Queries in Relational Databases (Recursive & Native Graph Extensions)SQL 113 🛢️ Columnar Storage vs Row Storage for OLAP SQL 114 🛢️ Data Warehousing Concepts: Star Schema and Snowflake Schema SQL 115 🛢️ Data Vault 2.0 Modeling Mechanics SQL 116 🛢️ Slowly Changing Dimensions (SCD Types 1, 2, 3, and 6)SQL 117 🛢️ Massively Parallel Processing (MPP) Architecture SQL 118 🛢️ Distributed SQL Engines (CockroachDB, YugabyteDB, Spanner)SQL 119 🛢️ Two-Phase Commit (2PC) in Distributed Transactions SQL 120 🛢️ Consensus Protocols in Distributed Databases (Raft and Paxos)SQL 121 🛢️ Querying Unstructured Data with XML and XPath SQL 122 🛢️ Vector Search and Embeddings in SQL (pgvector, HNSW indexes)SQL 123 🛢️ Change Data Capture (CDC) with Debezium and Database Triggers SQL 124 🛢️ Foreign Data Wrappers (FDW) and Federated Queries SQL 125 🛢️ Dynamic SQL and SQL Injection Hazards in Procedural Code SQL 126 🛢️ Database Auditing, Compliance Logging, and Event Tracking SQL 127 🛢️ Cross-Database Migration Strategies and Schema Evolution SQL 128 🛢️ Database Unit Testing Frameworks (pgTAP, tSQLt)SQL 129 🛢️ Benchmarking SQL Performance (sysbench, TPC-C, TPC-H)SQL 130 🛢️ Database Driver Mechanics and Wire Protocols (PostgreSQL Protocol, MySQL Protocol)SQL 131 🛢️ Cheatsheet

Programming | Languages & Runtimes | SQL

SQL 130 🛢️ Database Driver Mechanics and Wire Protocols (PostgreSQL Protocol, MySQL Protocol)
ByKandZ October 22, 2026October 22, 2026

A database driver is a translator. The application speaks in function calls and typed objects; the database speaks in a binary protocol over a socket. The wire protocol is the contract between them: a sequence of messages with defined framing, a startup handshake that negotiates capabilities and authenticates the user, and a query phase that…

Read More SQL 130 🛢️ Database Driver Mechanics and Wire Protocols (PostgreSQL Protocol, MySQL Protocol)
Programming | Languages & Runtimes | SQL

SQL 131 🛢️ Cheatsheet
ByKandZ October 22, 2026October 22, 2026

A quick-reference for SQL syntax, functions, and behavior across PostgreSQL, MySQL, and SQL Server. Organized for lookup, not for reading. SELECT Clause Order Clause Purpose Evaluated SELECT Columns to return 5th FROM Tables to query 1st JOIN Combine tables 2nd WHERE Filter rows 3rd GROUP BY Group rows 4th HAVING Filter groups 6th ORDER BY…

Read More SQL 131 🛢️ Cheatsheet