What is the R reference?

The R reference on SyntaxStudy lists all 0 R elements, properties, and methods with syntax explanations and working code examples. It is a complete, beginner-friendly cheat sheet for R developers.

Is this R reference free?

Yes. The entire R reference on SyntaxStudy is completely free. No account or payment is required to browse all 0 entries.

The best way to learn R is to start with the free R tutorial on SyntaxStudy. Each lesson includes a hands-on code example you can run in the browser, followed by a short quiz. After completing the tutorial, use this reference page to look up syntax whenever you need it.

SyntaxStudy

Tutorials

Reference Pages

HTML CSS JavaScript PHP Python MySQL Bootstrap jQuery TypeScript React Vue.js Node.js

All References →

Exercises How-Tos Challenges Colors ☕ Support Us

HTML CSS JavaScript PHP Python MySQL Bootstrap jQuery

Search tutorials

Login Sign Up

Tutorials References Exercises Challenges

Search tutorials

What is HTML? HTML Document Structure HTML Attributes HTML Comments & Special Characters HTML Headings & Paragraphs HTML Colors

HTML Headings HTML Text Formatting HTML Links HTML Images HTML Lists HTML Tables

HTML Form Basics HTML Input Types Select, Textarea & Datalist Checkboxes & Radio Buttons Form Validation Attributes The Button Element

HTML Images In-Depth HTML Audio HTML Video HTML iframes HTML Canvas HTML SVG

HTML Headings HTML Paragraphs Bold and Italic Text HTML Quotations Abbreviations and Addresses Preformatted Text and Code

Anchor Tag Basics Link Targets Link Colors and States Image Links Mailto and Tel Links Bookmark Links

Table Basics Table Headers Column and Row Spanning Table Styling Table Caption and Summary Advanced Tables

Unordered Lists Ordered Lists Description Lists Nested Lists Styling Lists with CSS Custom List Counters

Introduction to Semantic HTML Header, Nav, and Main Article, Section, and Aside Footer and Address Figure and Figcaption Time, Mark, and Details

The HTML Head Element Meta Charset and Viewport Meta Tags for SEO Open Graph Meta Tags Link Tags in HTML Head The Base Element

CSS Color Names Hexadecimal Colors RGB and RGBA Colors HSL and HSLA Colors Applying Color to HTML Elements Using Color Pickers and Tools

Inline Styles Internal CSS with the style Tag Linking External CSS Files Styling with CSS Classes Styling with CSS IDs Multiple CSS Classes on One Element Understanding the CSS Cascade CSS Specificity Rules CSS Property Inheritance Adding Media Queries to HTML CSS Custom Properties (Variables) The @import Rule CSS Reset and Normalize Strategies Print Stylesheets CSS Best Practices in HTML Projects

The HTML Script Tag External JavaScript Files Inline JavaScript The async Attribute The defer Attribute Script in Head vs Body The noscript Element HTML Event Attributes HTML Data Attributes Basic DOM Manipulation The Window Object Browser Console Methods ES Module Scripts in HTML JavaScript Loading Order JavaScript Performance in HTML

The Viewport Meta Tag Fluid Width Layouts Responsive Images with CSS CSS Media Queries Choosing Responsive Breakpoints Mobile-First Design Approach CSS Grid for Responsive Design Flexbox for Responsive Layouts Responsive Typography Responsive HTML Tables The HTML Picture Element The srcset and sizes Attributes Responsive Navigation Patterns The CSS calc() Function CSS Container Queries

Introduction to HTML iframes Common iframe Attributes Embedding YouTube Videos Embedding Google Maps Making iframes Responsive The iframe sandbox Attribute The iframe allow Attribute iframe Security Considerations Cross-Frame Communication with postMessage Lazy Loading iframes Controlling iframe Scrolling Accessible iframes Dynamic iframe Height Same-Origin Policy and iframes iframe vs object vs embed Elements

Introduction to HTML Canvas Getting the 2D Rendering Context Drawing Rectangles on Canvas Drawing Paths and Lines Drawing Circles and Arcs Drawing Text on Canvas Drawing Images on Canvas Canvas Gradients Drop Shadows in Canvas Canvas Transformations Canvas Compositing Operations Canvas Animation with requestAnimationFrame Mouse Interaction on Canvas Saving and Restoring Canvas State Canvas vs SVG

Introduction to SVG SVG Basic Shapes SVG Path Element SVG Text Styling SVG with CSS SVG Gradients Animating SVG with CSS viewBox and Responsive SVG SVG Icon Sprites SVG Clip Paths SVG Drop Shadow Filter Accessible SVG SVG and JavaScript DOM Inline SVG vs img Tag SVG Summary

Geolocation API Drag and Drop API Web Storage API Canvas API Fetch API History API Intersection Observer API Web Workers Notification API Clipboard API File API Broadcast Channel API ResizeObserver API MutationObserver API HTML APIs Summary

What is Web Accessibility? Image Alt Text Semantic HTML for Accessibility Accessible Form Labels Keyboard Navigation Color Contrast ARIA Roles ARIA States and Properties Skip Navigation Links Focus Management Accessible Tables Accessible Form Error Messages Complex Images and Figures Responsive Accessibility Accessibility Summary

HTML5 Semantic Elements HTML5 Input Types HTML5 Form Validation datalist — Autocomplete Suggestions details and summary The dialog Element Responsive Images with picture HTML5 Video HTML5 Audio progress and meter Elements template Element Custom Data Attributes Microdata and Schema.org Essential HTML5 Meta Tags HTML5 Features Summary

What is CSS? CSS Selectors CSS Colors & Backgrounds CSS Text & Fonts CSS Specificity & Cascade CSS Units

The CSS Box Model Margin & Padding CSS Borders Width, Height & Overflow Display & Visibility CSS Shadows & Opacity

Flexbox Introduction flex-direction & flex-wrap justify-content & align-items flex-grow, flex-shrink & flex-basis Flexbox Layouts in Practice align-self & order

CSS Grid Introduction grid-template-columns & rows Grid Placement & Spanning CSS Grid Areas Grid Alignment Responsive Grid with Media Queries

Basic CSS Selectors Combinator Selectors Attribute Selectors Pseudo-Class Selectors Pseudo-Element Selectors Grouping & the :is() / :where() Selectors

CSS Color Values Opacity & Transparency currentColor & inherit Modern CSS Color Functions color-mix() Function Color Accessibility & Contrast

Background Color Background Image Background Repeat & Position Background Size & Cover Multiple Backgrounds Background Shorthand

Font Family & Font Stacks Font Size & CSS Units Font Weight & Style Line Height & Text Spacing Text Decoration & Transform Using Google Fonts

Border Basics Border Radius Individual Border Sides Border Image Outline vs Border box-sizing Explained

Box Shadow Basics Multiple Box Shadows Text Shadow filter: drop-shadow() Inset Shadows Neumorphism with CSS

2D Translate Transform 2D Rotate & Scale Skew Transform transform-origin 3D Transforms Transform Matrix

Introduction to CSS Transitions The transition-property Transition Duration Transition Timing Functions Transition Delay The transition Shorthand Animating Multiple Properties Hover Transition Patterns Transitioning Colors Transitioning CSS Transforms Transitioning Opacity Transitioning Width and Height Box Shadow Transitions CSS Transition Performance CSS Transition Events in JavaScript

Introduction to CSS Animations CSS @keyframes Rules animation-name Property animation-duration Property animation-timing-function animation-delay Property animation-iteration-count animation-direction Property animation-fill-mode Property animation-play-state Property The animation Shorthand Multiple Animations on One Element Step-Based Animations with steps() Controlling CSS Animations with JavaScript CSS Animation Performance Tips

Introduction to CSS Pseudo-Classes :hover and :focus Pseudo-Classes :nth-child() Pseudo-Class :nth-of-type() Pseudo-Class :first-child and :last-child The :not() Pseudo-Class :checked and :disabled Pseudo-Classes :link, :visited, and :active :focus-visible Pseudo-Class :empty Pseudo-Class The :root Pseudo-Class :is() and :where() Pseudo-Classes The :has() Pseudo-Class :lang() and :dir() Pseudo-Classes Pseudo-Class Specificity

Introduction to CSS Pseudo-Elements ::before and ::after Pseudo-Elements The content Property Creating Decorative Shapes with Pseudo-Elements ::first-line Pseudo-Element ::first-letter Drop Cap ::selection Pseudo-Element ::placeholder Pseudo-Element ::marker Pseudo-Element ::backdrop Pseudo-Element Icon Techniques with Pseudo-Elements CSS Tooltip with Pseudo-Elements Clearfix with ::after Progress Indicators with Pseudo-Elements Pseudo-Elements vs Pseudo-Classes

Introduction to CSS Positioning position: relative position: absolute position: fixed position: sticky CSS z-index and Stacking Order top, right, bottom, left Offsets Positioning Context and Containing Blocks Centering with Absolute Positioning CSS Overlay Patterns Building a Fixed Header Sticky Sidebar Pattern Stacking Contexts in CSS Building a Modal with CSS Positioning CSS Positioning Practical Examples

CSS Custom Properties Variable Fallback Values Variable Scoping Dark Mode with Variables Variables and JavaScript Variables in calc() HSL Color System Spacing Scale Component-Level Variables Responsive Variables Variables in Animations Typography Variables State-Based Variables Variable Inheritance and Reset CSS Variables Summary

Viewport Meta Tag Media Query Basics Mobile-First Strategy Fluid Typography with clamp() Fluid Layouts Responsive CSS Grid Responsive Flexbox Patterns Responsive Images with CSS Showing and Hiding at Breakpoints Container Queries Responsive Navigation Responsive Tables Aspect Ratio Print Stylesheets Responsive CSS Summary

Linear Gradients Radial Gradients Conic Gradients Gradient Text Gradient Borders Gradient Overlays Animating Gradients Color Stops and Hints CSS Gradient Patterns Gradient Buttons Gradient Dividers Mesh Gradients Gradient Progress Bars Gradient Accessibility CSS Gradients Summary

What Is CSS Specificity? Calculating Specificity The CSS Cascade !important and When to Use It Cascade Layers (@layer) Inheritance vs Specificity Low-Specificity Selectors BEM and Flat Specificity Selector Performance Debugging Specificity Specificity in Component Systems Overriding Specificity Safely Common Specificity Bugs Utility Classes and Specificity Specificity Summary

What is JavaScript? JS Output Methods JS Syntax & Comments Data Types Operators Type Conversion

var, let & const Strings Numbers & Math Arrays Objects Conditionals

Function Declarations Arrow Functions Scope & Closures Array HOFs Loops Error Handling

Selecting DOM Elements Changing HTML & CSS Creating & Removing Elements Event Listeners Event Delegation Fetch API

Creating Strings in JavaScript String Methods: length, charAt, indexOf, includes String Methods: slice, substring, replace, split Template Literals In Depth Searching Strings with Regex Padding, Trimming, and Formatting Strings

Number Basics: Integers, Floats, NaN, Infinity Number Methods: toFixed, parseInt, parseFloat, Number The Math Object Number Formats: Binary, Hex, Octal, Scientific BigInt: Arbitrary-Precision Integers Floating-Point Precision and Solutions

Mutating Array Methods Non-Mutating Array Methods Spread and Rest with Arrays Array Destructuring flat() and flatMap() Array.from() and Array.of()

Creating Objects with Literals Object Methods and the this Keyword Object Spread and Object.assign() Object Destructuring Object.keys(), values(), and entries() The Prototype Chain

Event Basics: addEventListener and removeEventListener Mouse Events Keyboard Events Form Events: submit, change, input, focus, blur Event Bubbling and Capturing Custom Events

Synchronous vs Asynchronous JavaScript Callback Functions Introduction to Promises async/await Basics Error Handling with async/await Promise.all(), race(), allSettled(), any()

Class Basics: constructor and Methods Class Inheritance: extends and super Static Methods and Properties Getters and Setters Private Class Fields and Methods Mixins and Composition Patterns

Introduction to ES Modules Named Exports Default Exports Importing Named Exports Importing Default Exports Importing All Exports Dynamic import() Module Scope and Privacy Re-exporting from Modules Circular Imports import.meta in Modules CommonJS vs ES Modules Tree Shaking and Dead Code Elimination Module Design Patterns Module Bundlers Overview

Introduction to Regular Expressions String and RegExp Methods Character Classes in Regex Regex Quantifiers Regex Anchors Capturing Groups in Regex Regex Flags Lookahead and Lookbehind Replace with a Function String split() with Regex Named Capture Groups String matchAll() for All Matches Regex Performance Tips Common Regex Patterns Regex Best Practices

JavaScript Date and Time Overview Creating Date Objects Date Getter Methods Date Setter Methods Date Formatting Methods Intl.DateTimeFormat for Localization Date Arithmetic Comparing Dates Unix Timestamps in JavaScript Timezones in JavaScript Parsing Date Strings Building a Countdown Timer Relative Time Formatting The Temporal API (Modern Dates) Date and Time Best Practices

Introduction to JSON JSON.stringify() JSON.parse() JSON for Deep Cloning JSON.stringify() Replacer JSON.parse() Reviver JSON in API Responses JSON with localStorage JSON Handling of null and undefined Circular References in JSON Custom toJSON() Method JSON Schema Validation Streaming JSON Parsing JSON Security Considerations JSON Best Practices

Web Storage APIs Overview localStorage Basics sessionStorage Basics Storing Objects with JSON The storage Event Storage Capacity and Limits Cookies vs Web Storage IndexedDB Introduction The Cache API Storage Security Best Practices Common Storage Patterns Storage Data Migration Storage with React (useState + useEffect) Private Storage with Encryption Web Storage Best Practices

ES6+ Overview let and const Arrow Functions Template Literals Default Parameters Rest and Spread Classes ES Modules Symbols Generators Optional Chaining and Nullish Coalescing Map and Set Proxy and Reflect Logical Assignment Operators ES6+ Summary

Destructuring Introduction Array Destructuring Object Destructuring Nested Destructuring Destructuring in Function Parameters Destructuring in Loops Renaming Destructured Variables Default Values in Destructuring Destructuring with Imports Destructuring API Responses Variable Swapping Computed Property Destructuring Destructuring Iterables Destructuring Design Patterns Destructuring Summary

Introduction to Promises Promise Chaining async/await Promise.all and Promise.allSettled Promise.race and Promise.any Async Error Handling Creating Promises Async Iteration Microtasks and Event Loop Concurrency Limiting AbortController Common Async Patterns Async Anti-Patterns Testing Async Code Promises Summary

The Fetch API POST Requests with Fetch Fetch Headers Fetch Error Handling Query Parameters with URLSearchParams Cancelling Fetch Requests Uploading Files with FormData Reading Response Bodies CORS and Credentials Building a Fetch Wrapper Streaming Responses Fetch Caching Server-Sent Events Fetching GraphQL APIs Fetch API Summary

What is PHP? PHP Variables & Echo PHP Data Types PHP Comments PHP Operators PHP Conditionals & Loops

Variable Scope & Constants PHP String Functions PHP Math Functions Type Juggling & Casting Null & Null-Safe Operators PHP Superglobals

PHP Arrays Introduction Array Functions Array Sorting Multidimensional Arrays array_map, filter & reduce Array Destructuring & Spread

Functions in PHP Anonymous Functions & Closures Recursion Built-in Functions Overview PHP OOP Basics Namespaces & Autoloading

Core String Functions Searching & Trimming Strings Formatting Strings & Numbers Advanced Search & Replace Heredoc & Nowdoc Syntax Multibyte String Handling

Date & Time Basics The DateTime Class Date Differences & Intervals Timezone Handling Parsing Dates with strtotime Date Formatting & Localization

GET vs POST Methods Form Validation Basics Sanitizing User Input Server-Side Validation Patterns CSRF Protection Basics File Upload Handling

Session Basics Session Security Cookie Basics Cookie Security Flash Messages "Remember Me" Pattern

Reading Files Writing Files File System Operations Directory Operations CSV File Handling JSON File Handling

Classes & Objects Constructors & Destructors Access Modifiers Static Methods & Properties Constants & Final Classes Magic Methods

Class Inheritance Abstract Classes Traits Basics Trait Conflict Resolution Interfaces Late Static Binding

Introduction to PHP Interfaces Interface Syntax and Rules Implementing an Interface Implementing Multiple Interfaces Extending Interfaces Abstract Classes in PHP Abstract Classes vs Interfaces Interfaces as Type Hints Interface Constants Interfaces and Dependency Inversion Interface Segregation Principle Fluent Interfaces (Method Chaining) PHP Standard Library Interfaces Testing with Interface Mocks Interface Best Practices

PHP Exception Handling Introduction try, catch, finally Blocks Throwing Exceptions Exception Messages and Codes Multiple and Union Catch Blocks Custom Exception Classes Exception Chaining SPL Exception Classes Global Exception Handler PHP Errors vs Exceptions Rethrowing Exceptions Logging Exceptions First-Class Exception Context Testing Exception Behavior Exception Best Practices

Introduction to PHP PDO PDO Connection with Error Handling Running Simple Queries Prepared Statements Fetching Results Inserting Data with PDO UPDATE and DELETE with PDO PDO Transactions bindParam and bindValue PDO Error Handling PDO lastInsertId() PDO Fetch Modes PDO DSN and Connection Options rowCount() and Affected Rows PDO Best Practices

json_encode() in PHP json_decode() in PHP JSON Error Handling Building JSON API Responses SimpleXML for Parsing XML Loading XML from Files and URLs DOMDocument for Complex XML XPath Queries in PHP JSON vs XML in PHP Consuming REST APIs in PHP Generating XML in PHP SOAP Web Services in PHP JSON Web Tokens (JWT) in PHP Parsing RSS Feeds with PHP JSON and XML Best Practices in PHP

preg_match() in PHP preg_match_all() for Multiple Matches preg_replace() for String Replacement preg_replace_callback() for Dynamic Replacements preg_split() for Complex Splitting Common PHP Regex Patterns PCRE Character Classes PHP Regex Modifiers Named Capture Groups in PHP Lookahead and Lookbehind in PHP Form Validation with Regex Advanced preg_replace Techniques PHP Regex Performance Unicode Regex in PHP PHP Regex Best Practices

PHP Security Overview SQL Injection Prevention Cross-Site Scripting (XSS) CSRF Protection Password Hashing Secure File Uploads Session Security Input Validation Security Headers Rate Limiting Directory Traversal Prevention Dependency Security Secure Cookie Settings Secure Error Handling PHP Security Summary

Introduction to Composer composer.json Structure Version Constraints PSR-4 Autoloading Essential Composer Commands Composer Scripts Private Packages and Repositories Creating a Composer Package The Lock File Composer Plugins Platform Requirements Monorepo with Composer Composer in CI/CD Classmap Autoloading Composer Summary

Building REST APIs in PHP JSON Responses Laravel API Resources API Authentication with Sanctum API Request Validation API Versioning API Pagination Consistent Error Responses API Rate Limiting API Response Caching CORS in PHP APIs API Documentation with OpenAPI Testing APIs in Laravel Sending and Receiving Webhooks PHP API Summary

Introduction to PHP Testing Writing Unit Tests PHPUnit Assertions Mocking with PHPUnit Database Testing Feature Tests in Laravel Test Doubles: Fakes, Stubs, Spies Data Providers Code Coverage Testing Exceptions Testing Events and Queues Mocking HTTP Calls Test Performance Tips Test-Driven Development in PHP PHP Testing Summary

What is Python? Python Syntax Python Variables Python Data Types Python Operators Control Flow

String Methods Number Operations Type Casting Input and Output Scope and Globals Constants and Walrus Operator

Lists Introduction List Methods List Comprehensions Tuples and Sets Dictionaries Slicing and Unpacking

Functions Introduction Lambda Functions Decorators Generators Error Handling OOP Basics

String Creation & Indexing String Methods — Part 1 String Methods — Part 2 String Formatting Multiline & Raw Strings String Encoding

Tuple Basics Tuple Methods & Uses Set Basics Set Operations Frozensets Named Tuples

Dictionary Basics Dictionary Methods Dictionary Comprehensions Nested Dictionaries defaultdict & Counter Merging Dicts & Walrus Operator

Reading Files Writing Files File Modes & Encoding CSV Reading & Writing JSON File Handling pathlib & os.path

Importing Modules Standard Library Overview Creating Your Own Modules Packages & __init__.py pip & Package Management Virtual Environments

Classes & Objects Class vs Instance Variables __str__, __repr__ & Magic Methods Properties & Decorators Class Methods & Static Methods __slots__ & Dataclasses

Single Inheritance Method Overriding Multiple Inheritance & MRO Abstract Classes & ABC Duck Typing & Protocols Composition vs Inheritance

Try/Except Basics Catching Multiple Exceptions Else and Finally Clauses Raising Exceptions Custom Exception Classes Exception Chaining Context Managers and Exceptions Exception Groups (Python 3.11+) Suppressing Exceptions The Traceback Module Assertions Logging Exceptions Built-in Exception Hierarchy Re-raising Exceptions Exception Best Practices

List Comprehension Basics Filtering with Comprehensions Nested Comprehensions Dictionary Comprehensions Set Comprehensions Generator Expressions Inline If/Else in Comprehensions Walrus Operator in Comprehensions Comprehensions vs map/filter Comprehension Performance Multiple Conditions in Comprehensions Flattening Nested Lists Readability and When Not to Use Comprehensions Using zip() in Comprehensions Using enumerate() in Comprehensions

Iterables vs Iterators The Iterator Protocol Generator Functions yield from itertools.chain itertools.islice itertools.product itertools.groupby Infinite Iterators Custom Iterable Classes Sending Values to Generators throw() and close() Lazy Evaluation with Iterators Lazy Built-ins: zip, map, filter Combinations and Permutations

Decorator Basics Preserving Metadata with functools.wraps Decorators with Arguments Class-Based Decorators Stacking Multiple Decorators The @property Decorator @staticmethod and @classmethod Memoization with Decorators Timing Decorator Retry Decorator @dataclass Decorator @singledispatch Abstract Methods with @abstractmethod @contextmanager Decorator Decorator Patterns Summary

Introduction to Regex in Python re.match vs re.search re.findall Capturing Groups Named Capturing Groups re.sub — Substitution Regex Flags Compiled Patterns Lookahead and Lookbehind Non-Greedy Quantifiers re.split Character Classes Anchors re.finditer Verbose Mode for Complex Patterns

Python datetime Module Formatting and Parsing Dates timedelta Arithmetic Timezones with zoneinfo Comparing Dates Unix Timestamps calendar Module dateutil for Advanced Parsing Business Day Calculations Datetime in Pandas Date Intervals and Ranges Datetime Performance Tips Serialising Datetimes Recurring Events Python datetime Summary

Python json Module JSON File I/O JSON Type Mapping Custom JSON Encoder Custom JSON Decoder JSON Error Handling JSON with Requests Library JSON Validation with Pydantic JSON with dataclasses Streaming Large JSON JSON Schema Validation JSON Performance with orjson Working with Nested JSON Configuration with JSON Python JSON Summary

Introduction to Python Testing pytest Basics pytest Fixtures Parametrized Tests Mocking with unittest.mock Test Marks and Categories Testing Exceptions Code Coverage with pytest-cov Testing Django Applications Testing FastAPI Applications Property-Based Testing with Hypothesis Snapshot Testing Testing Async Code TDD in Python Python Testing Summary

Metaclasses Descriptors Custom Context Managers Abstract Base Classes functools Module Advanced Dataclasses Advanced Type Hints Concurrency: Threads, Processes, Async __slots__ and Memory Optimisation Garbage Collection and Memory AST and Code Introspection Python Performance with C Extensions Packaging and Distribution Design Patterns in Python Advanced Python Summary

What is MySQL? MySQL Setup and Connection Creating Tables MySQL Data Types Basic Queries Constraints

SELECT and Filtering ORDER BY and LIMIT Aggregate Functions String and Date Functions Subqueries Indexes

INSERT Data UPDATE and DELETE Transactions Stored Procedures Views

INNER JOIN LEFT and RIGHT JOIN Self Join and UNION Advanced Query Patterns Query Optimization

SQL UPDATE Syntax UPDATE Multiple Columns UPDATE with WHERE Clause UPDATE with JOIN UPDATE with Subquery UPDATE Best Practices

SQL DELETE Syntax DELETE with WHERE Clause DELETE with JOIN DELETE with Subquery TRUNCATE vs DELETE DELETE Best Practices

Introduction to SQL Functions String Functions in MySQL Numeric Functions in MySQL Date and Time Functions Aggregate Functions Control Flow Functions

Introduction to Stored Procedures Stored Procedure Parameters Variables and Control Flow in Procedures Cursors in Stored Procedures Error Handling in Stored Procedures Managing Stored Procedures

Introduction to MySQL Triggers BEFORE INSERT and AFTER INSERT Triggers BEFORE UPDATE and AFTER UPDATE Triggers BEFORE DELETE and AFTER DELETE Triggers Trigger Limitations and Gotchas Practical Trigger: Audit Log

MySQL User Accounts and Authentication Privileges and GRANT Statement Preventing SQL Injection MySQL SSL/TLS Connections MySQL Roles (MySQL 8.0+) MySQL Security Hardening Checklist

Introduction to MySQL Backup Strategies Using mysqldump Restoring from a mysqldump Backup Binary Log and Point-in-Time Recovery Automated Backup Scripts MySQL Replication as a Backup Strategy

Understanding Query Execution Plans Index Types in MySQL Composite Index Strategy Covering Indexes Slow Query Log Buffer Pool and InnoDB Caching Avoiding SELECT * Optimizing Pagination The N+1 Query Problem Indexing Foreign Keys Query Rewriting for Performance Connection Pooling Table Partitioning Temporary Tables Performance Schema Read Replicas for Scaling Query Hints ANALYZE and OPTIMIZE TABLE MySQL Performance Checklist

JSON Column Type Extracting JSON Values Filtering on JSON Values Indexing JSON with Generated Columns Modifying JSON Values Removing JSON Keys JSON Array Operations JSON Object Functions JSON_TABLE — Shredding JSON into Rows Aggregating Data into JSON JSONPath Syntax Reference JSON Column vs TEXT Storage Searching JSON with JSON_SEARCH JSON_OVERLAPS and JSON_CONTAINS_PATH JSON_SCHEMA_VALID JSON Column Best Practices Migrating TEXT JSON to JSON Column Working with JSON Columns in Laravel MySQL JSON — Summary

Full-Text Index Introduction MATCH ... AGAINST Syntax Natural Language Mode Boolean Mode Query Expansion Stop Words Minimum Word Length Relevance Ranking Multi-Column Full-Text Search Full-Text Search in Laravel Full-Text vs LIKE When to Use External Search Engines Full-Text Index Maintenance Paginating Full-Text Results N-gram Parser for CJK Languages Tuning Relevance Scores Combining Full-Text with Regular Filters Dropping and Rebuilding Full-Text Indexes Full-Text Search Summary

What is Database Normalization? First Normal Form (1NF) Second Normal Form (2NF) Third Normal Form (3NF) Boyce-Codd Normal Form (BCNF) Denormalization for Performance Normalizing Many-to-Many Relationships Functional Dependencies Normalizing a Table Step by Step Primary Key Design Surrogate vs Natural Keys Referential Integrity with Foreign Keys Normalization vs Performance Trade-offs Fourth and Fifth Normal Forms Normalization Cheat Sheet EAV Pattern and Its Pitfalls Normalization in Real-World Projects Schema Review Checklist Normalization — Summary

MySQL Transactions ACID Properties COMMIT and ROLLBACK autocommit Mode Isolation Levels Deadlocks Row Locking with SELECT FOR UPDATE Optimistic Locking Transactions in PHP (PDO) Nested Transactions and Savepoints InnoDB Redo and Undo Logs MVCC (Multi-Version Concurrency Control) Transaction Best Practices XA Distributed Transactions Monitoring Transactions Common Transaction Patterns Transactions in Laravel Testing with Transactions Gap Locks and Next-Key Locks MySQL Transactions Summary

MySQL Replication Overview Binary Log (binlog) Setting Up Primary-Replica Replication GTID-Based Replication Replication Lag Read/Write Splitting Group Replication InnoDB Cluster and MySQL Shell Replication Filtering Monitoring Replication Health Failover and Promotion Delayed Replication Semi-Synchronous Replication Replication Consistency and Drift Replication in the Cloud Backups via Replication ProxySQL for Load Balancing Replication Troubleshooting Point-in-Time Recovery with Binlog MySQL Replication Summary

MySQL Events Overview Creating Events Event Body and BEGIN...END Altering and Dropping Events Event Privileges Event Error Handling Events vs. Cron Jobs Automated Data Archiving Rolling Aggregations Session and Cache Cleanup Automated Partition Management Updating Table Statistics Events and Replication Event Performance Considerations Monitoring and Auditing Events Token Expiry with Events Event-Driven Queue Processing Automated Leaderboard Reset Scheduled Report Generation MySQL Events Summary

What is Bootstrap? Typography and Colors Spacing Utilities Buttons and Badges Alerts and Cards Forms and Inputs

Grid System Flexbox Utilities Navbar Modals and Offcanvas

Tables and Pagination Accordion and Tabs Carousel and Tooltips

Bootstrap Display Utilities Bootstrap Flex Utilities Bootstrap Text Utilities Bootstrap Overflow and Position Utilities Bootstrap Sizing Utilities Bootstrap Shadow and Border Utilities

Bootstrap Margin and Padding Basics Responsive Spacing in Bootstrap Bootstrap Gap Utilities Bootstrap Negative Margins Bootstrap Spacing Scale Reference Auto Margin Centering Techniques

Bootstrap Typography Basics Display Headings Bootstrap Text Color Utilities Blockquotes and Lists Typography Bootstrap Font Weight and Style Bootstrap Monospace and Code Styling

Bootstrap Color Palette Overview Bootstrap Background Color Utilities Bootstrap Theme Color Customization Bootstrap Dark Mode Colors Using CSS Custom Properties from Bootstrap Bootstrap Gradient Backgrounds

Bootstrap Button Variants Bootstrap Button Sizes Button States and Disabled Buttons Bootstrap Button Groups Bootstrap Toggle Buttons Bootstrap Link and Close Buttons

Bootstrap Form Controls Bootstrap Form Validation Bootstrap Input Groups Bootstrap Checkboxes and Radios Bootstrap Select and Range Inputs Bootstrap Floating Labels

Bootstrap Navbar Basics Bootstrap Navbar with Dropdowns Bootstrap Tabs and Pills Bootstrap Breadcrumbs Bootstrap Pagination Bootstrap Offcanvas Navigation

List Group Basics Active and Disabled Items Linked and Button List Groups Contextual Color Variants List Groups with Badges Custom Content in List Groups List Groups with Checkboxes and Radios Flush List Group Horizontal List Group Numbered List Group List Group as Tab Navigation List Groups with Icons Sortable List Groups with JavaScript Filtering List Group Items Dynamic List Groups from AJAX List Group Accessibility Building a Sidebar with List Groups Responsive List Group Patterns List Groups — Summary

Responsive Images with img-fluid Thumbnail Images Rounded and Circle Images Image Alignment Images with Captions Image Grid Gallery Aspect Ratio Boxes Lazy Loading Images Images in Cards Image Overlay Cards Object-Fit Utilities Avatar Patterns Image Hover Effects Lightbox for Images Responsive Images with srcset Image Placeholders Image with Badge Overlay Brand Logo in Navbar Bootstrap Images — Summary

Border Spinner Grow Spinner Spinner Colors Spinner Sizing Spinner Inside a Button Full-Page Centered Spinner Spinner Inside a Card Toggling Spinners with JavaScript Spinner Overlay Multiple Grow Spinners Table Loading State Form Submit Loading State Skeleton Screen Alternative Spinner Accessibility Custom Spinner Animations Progress Bar vs Spinner Spinner Inside a Modal Spinner with Status Text Bootstrap Spinners — Summary

Toast Component Basics Showing Toasts with JavaScript Toast Container and Positioning Auto-Dismiss and Delay Colored Toasts Stacking Multiple Toasts Dynamically Creating Toasts Toast Events Toasts with Icons Toast with Progress Bar Toast Accessibility Building a Notification Center Flash Messages as Toasts in Laravel Toast Position Variants Dismissing All Toasts Toast vs Alert — When to Use Which Custom Toast Animation Toast Queue and Limits Bootstrap Toasts — Summary

Bootstrap Icons Overview Icon Sizing Icon Colors Icons in Buttons Icons in Navigation Icons in Form Inputs Icons in Badges and Alerts Inline SVG Icons SVG Sprite Usage Animated Icons Feature Cards with Icons Searching Bootstrap Icons Bootstrap Icons in React and Vue Icon Accessibility Icons via npm and Build Tools Admin Sidebar with Icons Star Rating Component Bootstrap Icons Summary

Bootstrap Collapse Component Default Open Collapse Multiple Triggers for One Collapse One Trigger for Multiple Collapses Accordion Component Flush and Always-Open Accordions Collapse JavaScript API Customising Collapse Animation Horizontal Collapse Rotating Icons on Collapse Read More / Show Less Pattern Collapsible Filter Panels Responsive Navbar Collapse Nested Collapses FAQ Page with Accordion getOrCreateInstance Pattern Lazy Loading with Collapse Collapse and Accordion Summary

Customising Bootstrap Custom Colour Palette Custom Typography Custom Spacing Scale Customising Components Utilities API Dark Mode Support Partial Bootstrap Import Bootstrap with Vite Bootstrap Sass Maps RTL Support Overriding Component CSS Variables Multiple Themes Print Customisation Using Bootstrap Sass Mixins Removing Unused CSS Design Tokens with Bootstrap Bootstrap Customisation Summary

Bootstrap Responsive System Responsive Grid Layouts Responsive Display Utilities Responsive Flexbox Utilities Responsive Typography Responsive Navbar Responsive Tables Responsive Images and Embeds Responsive Spacing Offcanvas Sidebar Responsive Forms Responsive Card Grids Container Types Reordering Elements Responsively Responsive Modals Responsive Footer Testing Responsive Layouts Bootstrap Responsive Summary

What is jQuery? jQuery Selectors DOM Manipulation jQuery Events jQuery Effects jQuery AJAX

DOM Traversal Chaining and Each

Advanced Event Handling Deferred and Promises Writing jQuery Plugins jQuery UI Overview

jQuery CSS Manipulation jQuery CSS Classes jQuery Inline Styles jQuery Dimensions jQuery Position and Offset jQuery CSS Variables and Custom Properties

jQuery DOM Manipulation Basics jQuery DOM Insertion jQuery DOM Removal and Replacement jQuery DOM Attributes and Properties jQuery DOM Cloning jQuery DOM Data Storage

jQuery AJAX Introduction jQuery $.get() and $.post() jQuery $.getJSON() and JSON APIs jQuery AJAX Form Submission jQuery AJAX Error Handling jQuery AJAX and REST APIs

jQuery Show, Hide, and Toggle jQuery Fade Effects jQuery Slide Effects jQuery animate() jQuery Animation Queue and Callbacks jQuery CSS Transitions vs jQuery Animate

jQuery DOM Traversal Introduction jQuery Parent and Ancestor Traversal jQuery Children and Descendant Traversal jQuery Sibling Traversal jQuery Traversal Chaining and .end() jQuery .each() and Iteration

jQuery Filtering Introduction jQuery .filter() with Functions jQuery .not() and Exclusion Filtering jQuery :first, :last, :even, :odd Filters jQuery .is() for Testing jQuery .map() and Transforming Sets

jQuery Utility Functions Overview jQuery $.extend() — Object Merging jQuery $.grep() — Array Filtering jQuery $.proxy() and Context Binding jQuery $.parseJSON() and Data Utilities jQuery $.noConflict() and the $ Alias

Preventing Default Form Submission Serializing Form Data AJAX Form Submission Basic Client-Side Validation Input Events: change, input, keyup Conditional Form Fields Adding and Removing Dynamic Fields Dependent Dropdowns File Upload with AJAX Resetting Forms Multi-Step Form Autocomplete Input Debouncing Input Events Select All Checkboxes Character Counter Password Visibility Toggle Image Preview on File Select Range Slider with Live Value jQuery Forms — Summary

jQuery .data() Method Reading HTML data-* Attributes .data() vs .attr() Storing Objects and Arrays with .data() Using .data() in Event Handlers Element-Level State Management Infinite Scroll with .data() Caching API Responses with .data() Plugin Options via .data() Memory Management with .data() Toggle Buttons with .data() Tracking Original Form Values .data() in Drag and Drop Pagination State with .data() Dynamic Tooltip Content via .data() Reading All .data() Keys .data() vs localStorage Tracking Sort Order with .data() jQuery .data() — Summary

Introduction to jQuery Deferred Deferred.promise() $.when() for Parallel Requests Chaining with .then() Progress Notifications AJAX Returns a Deferred resolve() and reject() Deferred vs Native Promise Sequential Async Queue Deferred in Animations Error Handling in Deferred Chains Cancellable Deferred Racing Deferreds Transforming Results with .then() .always() for Cleanup Checking Deferred State Retry Logic with Deferred $.when() with Dynamic Arrays jQuery Deferred — Summary

jQuery Plugin Basics Plugin Options with $.extend IIFE Plugin Wrapper Plugin with Multiple Methods Storing Plugin Instances with .data() Plugin Custom Events Plugin Destroy / Cleanup Using Select2 Plugin Using DataTables Plugin SweetAlert2 for Dialogs lightGallery Plugin Typeahead / Autocomplete Plugin jQuery Validate Plugin Plugin Namespacing Best Practices Documenting Your Plugin Testing jQuery Plugins Publishing a Plugin to npm Popular jQuery Plugins jQuery Plugins — Summary

jQuery on Mobile Touch Events Swipe Navigation Eliminating 300ms Click Delay Smooth Scrolling on Mobile Mobile Navigation Menu Lazy Loading Images on Mobile Pinch and Multi-Touch Viewport and Breakpoint Detection Mobile Form Optimisation Handling Orientation Changes Mobile-Optimised AJAX Service Workers and jQuery Input Masking on Mobile Bottom Navigation Bar Pull-to-Refresh Offline Detection jQuery Mobile Summary

jQuery Performance Overview Caching Selectors Efficient DOM Manipulation Event Delegation Performance Throttle and Debounce Selector Performance Ajax Performance Tuning detach() for DOM Manipulation Animation Performance Virtualised Lists Avoiding Memory Leaks jQuery Slim and Module Builds Profiling jQuery Code requestAnimationFrame with jQuery Read-Write DOM Batching Async Loading jQuery Replacing jQuery with Vanilla JS jQuery Performance Summary

Drag and Drop Infinite Scroll Sticky Header on Scroll Smooth Scroll to Anchor Typeahead / Autocomplete Scroll Spy Navigation Image Lightbox Animated Number Counter Character Counter for Inputs Password Strength Meter Copy to Clipboard Multi-Step Form Color Picker Integration Toggle Text and State File Drop Zone Progress Notifications Keyboard Shortcuts UI Interactions Summary

Tab Component Custom Modal Dialog Custom Tooltip Widget Date Picker Range Slider Interactive Star Rating Custom Carousel Toast Notification System Custom Select Dropdown Custom Accordion Widget Sortable Data Table Tree View / Folder Structure Theme Switcher Widget Pagination Widget Cookie Consent Banner Live Badge Notifications Step Wizard Widget jQuery UI Widgets Summary

Introduction to TypeScript What Is TypeScript and Why Use It Setting Up TypeScript with tsconfig.json TypeScript Compilation and the Type System

Primitive and Special Types Arrays, Tuples, and Union Types Literal Types and Type Narrowing

Defining and Implementing Interfaces Interface Inheritance and Extension Callable and Constructable Interfaces

Type Aliases vs Interfaces Recursive and Self-Referential Type Aliases Template Literal Type Aliases

TypeScript Functions Function Types, Overloads, and Optional Parameters Generic Functions and Constraints Higher-Order Functions and this Typing

Classes, Access Modifiers, and Parameter Properties Generics in Classes and Static Members Getters, Setters, and the Singleton Pattern

Generic Types, Interfaces, and Constraints Generics in TypeScript Conditional Types and Infer Mapped Types and Key Remapping

Numeric and String Enums Const Enums and Enum Patterns Exhaustiveness Checking with Enums

Partial, Required, Readonly, and Record Pick, Omit, Exclude, Extract, and NonNullable Awaited, Template Literal Utilities, and Custom Utilities

typeof, instanceof, and in Guards User-Defined Type Guards with is Discriminated Unions and Exhaustive Narrowing

ES Modules: Import, Export, and Re-export Module Augmentation and Ambient Declarations Path Aliases and Barrel Files

Class and Method Decorators Property and Parameter Decorators Decorator Factories and Composition

Conditional Types and Mapped Types Deep Dive Variance, Covariance, and Contravariance Branded Types and Opaque Types

Typing React Components and Props Typing Hooks: useState, useRef, useReducer Generic Components, Custom Hooks, and Context

What Is React and the Virtual DOM What is React? Setting Up a React Project with Vite JSX Syntax React Component Tree and Rendering Lifecycle

JSX Syntax and Transformation JSX Expressions and Dynamic Content JSX Fragments, Comments, and Whitespace

Functional Components React Components Component Composition and the Children Prop Splitting Components and File Organisation

Passing and Receiving Props Destructuring Props and Default Values PropTypes for Runtime Type Checking

useState Hook Basics State with Objects and Arrays Lifting State Up

Handling onClick and Synthetic Events Controlled Inputs with onChange Keyboard, Focus, and Other Event Types

Conditional Rendering with Ternary and && Early Returns and if/else in Components Rendering Nothing and Toggling Visibility

Rendering Lists with .map() and the key Prop Dynamic Lists with State: Add, Remove, Reorder Nested Lists and Keyed Fragments

Introduction to useEffect useEffect Cleanup and Event Listeners Synchronising with External Systems

useRef for DOM Access and Persisting Values useMemo and useCallback for Memoisation React.memo for Component Memoisation

Creating and Providing Context useContext and Custom Context Hooks Context with useReducer for Complex State

React Router v6 Basics Dynamic Routes with useParams and useNavigate Protected Routes and Navigation Guards

Controlled Forms with useState Form Submission and Async Validation Checkbox, Radio, and Select Inputs

Building Custom Hooks useFetch: Data Fetching as a Custom Hook Advanced Custom Hooks: usePrevious and useOnClickOutside

Code Splitting with React.lazy and Suspense Profiling and Avoiding Unnecessary Re-renders Virtualisation for Long Lists

Data Fetching with useEffect and fetch TanStack Query: Caching and Background Refetching Pagination and Infinite Scroll with TanStack Query

What is Vue.js? What Is Vue.js? Vue vs React vs Angular Creating a Vue App with Vite Options API vs Composition API

Vue Template Syntax Text Interpolation and Attribute Binding Event Handling with v-on Dynamic Templates and v-html

Vue Single File Components Single-File Components (SFCs) Global and Local Component Registration Slots: Default, Named, and Scoped

Defining and Validating Props Emitting Custom Events with defineEmits Provide / Inject for Deep Prop Passing

ref and reactive Fundamentals Watchers: watch vs watchEffect Shallow Refs and Advanced Reactivity Utilities

Vue Directives v-if, v-else-if, v-else and v-show v-for List Rendering v-model Two-Way Binding and Custom Directives

Computed Properties Basics Computed vs Methods vs Watchers Computed Properties with Complex Data

Component Lifecycle Hooks Overview onMounted and Template Refs onUnmounted and Cleanup Patterns

Setting Up Vue Router 4 RouterLink, RouterView and Programmatic Navigation Navigation Guards and Route Meta

Introduction to Pinia Stores storeToRefs and $patch Async Actions and Store Composition

The setup() Function and script setup Building Reusable Composables Advanced Composable Patterns

Fetching Data with the Fetch API in onMounted Using Axios in Vue 3 POST, PUT, DELETE and Form Submission

Introduction to Node.js The Event Loop and Your First Server Installing Node.js and nvm

Node.js Modules CommonJS Modules (require / exports) ES Modules (import / export) Built-in Node.js Modules

npm Basics: init, install, and package.json npm Scripts and npx

Reading and Writing Files Directories, readdir, and File Watching Streams in the fs Module

Creating an HTTP Server Request Headers and Status Codes

Setting Up an Express Server Route Handlers and Response Methods

Express Router and Route Parameters Route Groups and Nested Routers

Understanding Middleware and next() Third-Party Middleware: cors, helmet, morgan

Callbacks and Promises async/await and Error Handling

process.env and dotenv Config Management and NODE_ENV

Password Hashing with bcrypt JWT Authentication

Connecting to PostgreSQL with pg MongoDB with Mongoose

Building a REST API with Express Response Format and Error Handling

Readable and Writable Streams Piping and File Streaming

PM2 Process Manager Nginx Reverse Proxy and Docker Basics

Introduction to Git Installing Git and First-Time Configuration

git init, git clone, and .gitignore SSH Keys Setup for GitHub

git status, add, and commit git log and git diff

The Staging Area and git add -p Unstaging and Restoring Files

Branching and Merging Creating and Switching Branches Detached HEAD State

git merge: Fast-Forward and 3-Way Merge Resolving Merge Conflicts

git remote, push, and pull Tracking Branches

Fork, Clone, and Pull Requests GitHub Actions: Basic CI Workflow

git revert and git reset git reflog: Your Safety Net

git stash: Temporarily Save Work Advanced Stash: Branch from Stash

git rebase: Moving Commits Interactive Rebase: Squash and Reorder

Creating and Pushing Tags Semantic Versioning

Git Flow and GitHub Flow Commit Message Conventions Trunk-Based Development

Introduction to Linux & Bash What Is Linux and How It Works Linux Distributions and Choosing the Right One The Linux Shell and Terminal Basics

Understanding the Linux Filesystem Hierarchy Listing and Inspecting Files with ls and tree Navigating with cd, pwd, and Shortcuts

File & Directory Management Creating, Copying, and Moving Files Viewing and Editing File Content Links, Archives, and Disk Usage

Understanding Linux File Permissions Changing Permissions with chmod and Ownership with chown Special Bits: umask, SUID, SGID, and Sticky Bit

Searching Text with grep Stream Editing with sed and Field Processing with awk Cutting, Sorting, and Deduplication with cut, sort, and uniq

Pipes and Standard Streams Advanced Redirection and tee xargs and Command Substitution

Viewing and Managing Processes with ps and top Signals, kill, and Process Priorities Background Jobs: jobs, bg, fg, and nohup

Bash Scripting Bash Script Basics: Variables and Arguments Bash Control Flow: if, for, and while Bash Functions, Error Handling, and Best Practices

Environment Variables and the Shell Environment The PATH Variable and source Aliases, Shell Options, and Dotfiles

Network Configuration with ip and ifconfig Inspecting Connections with netstat, ss, and curl Firewall Management with ufw and iptables

SSH Key Generation and Password-less Login SSH Config, Tunnels, and Port Forwarding File Transfer with scp and rsync

Crontab Syntax and Scheduling Jobs System Cron Directories and Logging Systemd Timers as a Modern Cron Alternative

What is MongoDB? Introduction to MongoDB Collections and Documents Installing and Connecting to MongoDB

BSON Data Types Document Validation with JSON Schema Embedded Documents vs References

Insert Operations MongoDB CRUD Operations Update Operations Find and Delete Operations

Comparison and Logical Operators Array and Element Operators Cursors, Sort, Skip, and Limit

Aggregation Pipeline Basics $lookup and $unwind Advanced Pipeline Stages

Single Field and Compound Indexes Text and Geospatial Indexes Index Strategies and EXPLAIN

Schema Design Patterns One-to-Many Relationships Many-to-Many and Tree Structures

Population with $lookup Transactions and Multi-Document Atomicity Change Streams

Getting Started with MongoDB Atlas Atlas Search Atlas Triggers and Functions

Mongoose Schemas and Models Mongoose Queries and Populate Mongoose Middleware and Instance Methods

Introduction to Docker What Is Docker and Why Use It Docker Architecture and Key Concepts Docker vs Virtual Machines

Pulling, Tagging, and Inspecting Images Building Images with docker build Pushing Images to Docker Hub

Running and Managing Containers Container Logs and Debugging Resource Limits and Container Security

Writing a Dockerfile Core Dockerfile Instructions Layer Caching and Build Optimisation ARG, ENV, and HEALTHCHECK

Named Volumes vs Bind Mounts Volume Drivers and Sharing Data Between Containers Persisting Database Data with Volumes

Docker Network Types and Bridge Networking Host Networking and Port Publishing Container DNS and Network Aliases

Docker Compose Introduction to Docker Compose Docker Compose for Development Workflows Compose Profiles and Scaling Services

Docker Hub and Private Registries Image Tagging Strategies Vulnerability Scanning and Image Security

Multi-Stage Builds Explained Targeting Build Stages with --target Multi-Stage Builds for Go Static Binaries

Production Hardening Checklist CI/CD Pipeline with Docker Monitoring and Observability for Docker

Introduction to Java What Is Java and Setting Up the JDK Understanding the Java Compilation Model and the JVM Java Program Structure and Basic I/O

Primitive Data Types and Literals Wrapper Classes and Autoboxing Strings, StringBuilder, and Variable Scope

if, else if, else and the Switch Statement for, while, do-while, and the Enhanced for Loop Exception Handling with try-catch-finally

Defining Methods, Return Types, and Parameters Method Overloading Varargs, Recursion, and Method Best Practices

OOP in Java Encapsulation and Data Hiding Abstraction and Polymorphism The Object Class, equals, hashCode, and toString

Class Design: Constructors, Fields, and Getters/Setters Static Members, Inner Classes, and Enums Records, Sealed Classes, and Class Design Patterns

Extending Classes and the super Keyword Abstract Classes vs Concrete Classes final Classes, final Methods, and Preventing Inheritance

Defining and Implementing Interfaces Default and Static Interface Methods Multiple Interface Implementation and Functional Interfaces

Java Collections Framework ArrayList and LinkedList HashMap and HashSet TreeMap and Sorting Collections

Generic Classes and Methods Bounded Type Parameters Generic Interfaces: Comparable and Comparator

Checked vs Unchecked Exceptions try-catch-finally Blocks try-with-resources

Stream filter, map, and collect Stream reduce and Advanced Collectors Optional and Stream Terminal Operations

Reading Files with Files and BufferedReader Writing Files and Path Operations Walking Directory Trees with Files.walk

Thread and Runnable ExecutorService and Thread Pools CompletableFuture for Async Programming

Maven Basics and pom.xml Gradle Basics and build.gradle Multi-module Builds and Dependency Management

What Is C and Why Learn It? Introduction to C Compiling C with GCC The Structure of a C Program

Fundamental Data Types and sizeof Constants, Scope, and Storage Classes Type Conversions and Casting

Arithmetic and Assignment Operators Bitwise Operators Logical and Relational Operators

if, else, and switch Statements for, while, and do-while Loops goto and Structured Error Handling

Declaring and Defining Functions Pass-by-Value and Pass-by-Pointer Function Pointers and Callbacks

Arrays and Pointer Arithmetic C Strings and <string.h> String Formatting and Parsing

Pointer Basics: &, *, and Null Pointers in C malloc, realloc, and free void Pointers and Pointer Casting

Defining Structs and typedef Nested Structs and Arrays of Structs Linked Lists with Structs

Stack vs Heap Memory Memory Leaks and Valgrind Dynamic Data Structures and Arena Allocation

fopen, fclose, and Text File I/O Binary Files: fread and fwrite Error Handling and File Utilities

#define, #include, and Object-Like Macros Function-Like Macros and Pitfalls Conditional Compilation: #ifdef, #if, and #pragma

Introduction to C++ Compilation, Namespaces, and the C++ Toolchain References, Pointers, and Value Semantics Functions, Overloading, and Default Arguments

Encapsulation and Access Specifiers Constructors, Destructors, and the Rule of Three Operator Overloading

Classes and Objects in C++ Class Design: Constructors and Member Initialiser Lists Static Members and the Singleton Pattern Move Semantics and the Rule of Five

Single Inheritance and Base Class Constructors Multiple Inheritance and the Diamond Problem Slicing, Upcasting, and Downcasting

Virtual Functions and the vtable Pure Virtual Functions and Abstract Classes Compile-Time Polymorphism with CRTP

Function Templates and Template Argument Deduction Class Templates and Template Specialisation Variadic Templates and Parameter Packs

Sequence Containers: vector, array, and deque Associative Containers: map, set, unordered_map STL Algorithms and Iterators

Stack vs Heap and RAII Dynamic Allocation: new, delete, and Placement new Memory Leaks, Valgrind, and Address Sanitizer

throw, try, and catch Custom Exception Classes and Exception Hierarchies Exception Safety Guarantees and noexcept

C++11 Essentials: auto, Range-for, and Initialiser Lists Lambdas, std::function, and Closures C++17/20 Features: Structured Bindings, if constexpr, Concepts

unique_ptr: Exclusive Ownership shared_ptr and Reference Counting weak_ptr: Breaking Cycles and Observing Ownership

Introduction to C# What Is C# and the .NET Platform Creating and Running a .NET 8 Console Project C# Type System Overview

Declaring Variables and Constants Value Types vs Reference Types in Depth Nullable Types and Null Safety

If Statements and Switch Expressions Loops and Iteration Pattern Matching

Method Declarations and Overloading Optional Parameters and Named Arguments Out, Ref, and In Parameters

Classes, Properties, and Constructors Inheritance and Polymorphism Static Members, Enums, and Records

Defining and Implementing Interfaces Explicit Interface Implementation Generic Interfaces and Covariance

LINQ in C# LINQ Basics: Where, Select, and ToList GroupBy and Aggregation LINQ Join and Advanced Queries

Async and Await Fundamentals CancellationToken and Timeouts Async Streams and Channels

Try, Catch, and Finally Custom Exceptions Global Error Handling in ASP.NET Core

File and Directory Operations StreamReader, StreamWriter, and Binary Streams Working with JSON and CSV Files

ASP.NET Core Minimal APIs Dependency Injection in .NET Configuration and appsettings.json

Unit Testing with xUnit Unit Testing with NUnit Mocking with Moq and Integration Testing

Introduction to Go What Is Go and Why Use It Setting Up a Go Module The Go Toolchain

Variable Declaration and Zero Values Basic Types and Type Conversions Pointers, Slices, and Maps

Function Basics and Multiple Return Values First-Class Functions and Closures Defer, Panic, and Recover

Defining Structs and Methods Struct Embedding and Composition Struct Tags and JSON Serialisation

Interfaces and Duck Typing Common Standard Library Interfaces Interface Composition and nil Interfaces

Goroutines & Concurrency Starting Goroutines Goroutines with sync.WaitGroup and sync.Mutex Context for Cancellation and Timeouts

Unbuffered and Buffered Channels Select Statement and Channel Patterns Worker Pools with Channels

Error Handling Fundamentals Error Wrapping, Unwrapping, and Sentinel Errors Idiomatic Error Handling Patterns

Organising Code with Packages Working with Go Modules and Dependencies The init Function and Package Initialisation

Building an HTTP Server with net/http Middleware and Handler Chains Graceful Shutdown and HTTP Client

Writing Tests with the testing Package Benchmarks, Examples, and Coverage Testing HTTP Handlers with httptest

Introduction to Rust What Is Rust and Why Use It Installing Rust and Using Rustup Data Types and Control Flow

Ownership in Rust The Ownership Rules Move Semantics in Depth Scope, Drop, and the Drop Trait

Immutable and Mutable References Lifetime Annotations Slices and the Borrow Checker

Defining and Instantiating Structs Methods and Associated Functions with impl Struct Visibility and Encapsulation

Defining Enums and Match Expressions Option<T> and if let Custom Enums with Data and Methods

Result<T, E> and Error Handling The ? Operator and Error Propagation Custom Error Types and the thiserror Crate

Defining and Implementing Traits Trait Bounds and Static Dispatch Standard Library Traits: From, Into, Iterator

Generic Functions and Structs Generic Bounds, where Clauses, and Associated Types Const Generics and Phantom Types

Closures: Syntax and Capturing Fn, FnMut, and FnOnce Traits Iterator Adapters and Closures

Threads and the Send and Sync Traits Shared State with Arc<Mutex<T>> Message Passing with Channels

Creating and Building Projects with Cargo Managing Dependencies in Cargo.toml Testing, Workspaces, and cargo publish

What Is Kotlin? Introduction to Kotlin Kotlin vs Java: Key Differences Kotlin Compilation and Tooling

val, var and Type Inference Nullable Types and the Safe-Call Operator Destructuring and Range Expressions

Function Basics and Default Parameters Higher-Order Functions and Lambdas Inline Functions and Scope Functions

Classes, Constructors and Properties Inheritance and Interfaces Object Declarations and Companion Objects

The Kotlin Type System and Null Null Safety in Kotlin Safe Casts and Smart Casts Platform Types and Java Interop Nullability

Lists, Sets and Maps Sequences for Lazy Evaluation Sorting, Searching and Aggregating

Coroutine Basics with launch and runBlocking async/await and Parallel Decomposition Flows for Asynchronous Streams

Extension Functions Extension Properties and Members Building DSLs with Extension Lambdas

Data Classes Fundamentals Sealed Classes and Algebraic Data Types Value Classes and Inline Classes

Android with Kotlin: Activities and ViewBinding ViewModel and StateFlow Jetpack Compose Basics

What Is Swift Introduction to Swift Swift Playground and Toolchain Swift vs Objective-C

Constants, Variables, and Type Inference Basic Types and Collections Enumerations

Conditionals and Loops Pattern Matching Error Handling with do-catch

Function Basics and Labels Higher-Order Functions inout Parameters and Generic Functions

Classes and Structs Inheritance and Initializers Properties and Access Control

Protocol Basics Codable and Standard Protocols Generics and Protocol Constraints

Optionals in Swift Optionals Fundamentals Optional Chaining and Map Implicitly Unwrapped and Result Type

Closure Syntax Async/Await Combine Framework Basics

Error Protocol and Custom Errors Multiple Error Types and Typed Throws Testing and Assertions

SwiftUI Basics Navigation and Data Flow Animations and Custom Views

Introduction to SASS What Is SASS and Why Use It Setting Up SASS in a Project SCSS vs SASS Indented Syntax

SASS Variables Declaring and Using SASS Variables Variable Scope and the !default Flag SASS Variables vs CSS Custom Properties

SASS Nesting Basic Nesting and the Parent Selector Nested Properties and Combinator Selectors The & Selector in Advanced Patterns

Creating and Importing Partials The @use Rule and Namespaces The @forward Rule for Library Authors

SASS Mixins Defining and Including Mixins Mixins with @content for Block Passing Variable Arguments and Mixin Best Practices

The @extend Directive and Selector Inheritance Placeholder Selectors with % @extend vs @mixin — Choosing the Right Tool

Writing Custom @function Definitions Built-in SASS Functions for Color and Math String, List, and Selector Functions

@if, @else if, and @else Directives @for and @while Loops @each for Iterating Lists and Maps

Creating and Accessing SASS Maps Merging and Manipulating Maps Maps as Design Token Systems

Modern SASS Modules: sass:color and color.adjust() The sass:math Module and Division Namespaced Imports, sass:meta, and Modern Best Practices

What is Tailwind CSS? What Is Tailwind CSS and the Utility-First Philosophy Installing Tailwind CSS v3 in a Project Understanding the Tailwind Class Naming Convention

Core Utility Classes Core Layout and Display Utilities Background, Border, and Shadow Utilities Transition, Animation, and Transform Utilities

Responsive Design with Tailwind Mobile-First Responsive Design with Breakpoint Prefixes Responsive Navigation and Header Patterns Responsive Images and Media Handling

Flexbox & Grid in Tailwind Flexbox Fundamentals with Tailwind CSS Grid Layout with Tailwind Advanced Alignment, Gap, and Order Utilities

Font Size, Weight, and Line Height Utilities Text Alignment, Decoration, and Transform Utilities Using the Official Tailwind Typography Plugin (@tailwindcss/typography)

Tailwind Color Palette and How to Use It Spacing Scale: Padding, Margin, and Gap Sizing Utilities: Width, Height, Min/Max Constraints

Dark Mode in Tailwind Enabling and Using the dark: Variant Designing Consistent Dark Mode Color Pairs Dark Mode with Forms, Tables, and Charts

Extracting Components with @apply Building a Card Component System Modal, Dropdown, and Overlay Patterns

Extending the Default Theme in tailwind.config.js Adding Custom Utilities and Components in CSS Layers Configuring Content Paths, Safelist, and Prefix

Writing a Custom Tailwind Plugin Official Tailwind CSS Plugins Overview Community Plugins and Plugin Configuration

Understanding the JIT Engine and Arbitrary Values Arbitrary Properties, Variants, and Dynamic Classes Performance, Build Optimisation, and Production Setup

What Is Django and Why Use It Introduction to Django Django Project and App Structure The Django Request-Response Cycle

Defining Django Models and Fields Django Models Django ORM Queries and Managers Model Relationships and Meta Options

Function-Based Views (FBV) Django Views Class-Based Views (CBV) Mixins, Context Data, and View Customisation

Django Template Language Basics Template Inheritance with extends and block Custom Template Tags and Filters

URL Patterns and path() vs re_path() Namespaces and include() Custom Path Converters and URL Best Practices

Django Forms and Form Validation ModelForms and Saving to the Database Rendering Forms and Handling File Uploads

Login, Logout, and Built-in Auth Views User Registration and Custom User Models Permissions and Groups

Registering Models and Basic Admin Configuration Admin Actions and Inlines Customising the Admin Site and Overriding Templates

Django REST Framework: Serializers APIView and Generic Views in DRF ModelViewSet, Routers, and DRF Authentication

Preparing Django for Production Gunicorn and Nginx Configuration PostgreSQL, Environment Variables, and CI/CD

Introduction to Next.js What Is Next.js and Why Use It App Router Directory Structure Next.js Configuration with next.config.js

File-based Routing File-System Routing in the App Router Layouts, Templates, and Nested Routing Loading UI, Error Boundaries, and Not Found

Creating Pages with page.tsx Pages Router: getStaticProps and getServerSideProps Client Components vs Server Components in Pages

Data Fetching in Next.js Fetching Data in Server Components Caching, Revalidation, and Streaming Mutations with Server Actions

Understanding React Server Components The use client Directive and Client Component Patterns Context, Hooks, and Sharing Data Across the Server

Route Handlers in the App Router Middleware for Auth, Redirects, and Edge Logic Handling Forms, Validation, and CORS in Route Handlers

Static Site Generation with generateStaticParams Server-Side Rendering and Dynamic Routes Incremental Static Regeneration (ISR) Deep Dive

Optimising Images with next/image Image Formats, Quality, and the Blur Placeholder next/font for Optimised Web Fonts

Static and Dynamic Metadata with the Metadata API Sitemap, Robots.txt, and Open Graph Images Icons, Manifest, and Structured Data

Deploying to Vercel Self-Hosting with Node.js and Docker Environment Variables, CI/CD, and Production Checklist

What Is Laravel and Why Use It Introduction to Laravel Laravel Directory Structure and Artisan CLI Service Container and Service Providers

Basic Routing with Route Facades Laravel Routing Route Groups and Middleware Resourceful Routes and Route Model Binding

Creating and Using Controllers Form Requests and Validation Middleware in Controllers and Responses

Eloquent ORM Basics and Models Eloquent ORM Eloquent Relationships: hasMany, belongsTo, belongsToMany Query Builder and Advanced Eloquent

Blade Templating Basics Blade Layouts and Components Blade Directives and Service Injection

Database Migrations and Schema Builder Altering Tables and Running Migrations Seeders, Factories, and Fake Data

Laravel Breeze and Starter Kits Laravel Sanctum for API Token Authentication Authorization with Policies and Gates

Introduction to Laravel Queues and Jobs Queue Workers, Redis, and Horizon Job Chaining, Batching, and Rate Limiting

Building REST APIs with Laravel API Versioning and Error Handling API Authentication and Rate Limiting

Feature Testing with PHPUnit in Laravel Testing with actingAs, Mocking, and Fakes API Testing and JSON Assertions

Introduction to GraphQL What is GraphQL? GraphQL vs REST: Key Differences Setting Up a GraphQL Server with Apollo

SDL: Defining Types and Fields Input Types and Custom Scalars Schema Stitching and Modular SDL

GraphQL Queries Arguments, Aliases, and Variables Fragments and Inline Fragments Pagination with Connections

GraphQL Mutations Writing Mutations with Input Types Error Handling in Mutations Optimistic UI and Cache Updates with Apollo Client

GraphQL Subscriptions and WebSockets Filtering Subscription Events Production Subscriptions with Redis PubSub

Resolver Function Anatomy The N+1 Problem and DataLoader Resolver Middleware with graphql-middleware

JWT Authentication with Apollo Server Refresh Tokens and Secure Token Storage Role-Based Access Control in GraphQL

Apollo Client: Queries and Mutations Apollo Client Cache Policies and Local State Apollo Federation: Building a Supergraph

Introduction to REST APIs What is REST? Resource Naming and URL Design HATEOAS and Richardson Maturity Model

HTTP Methods in REST GET, POST, PUT, PATCH, DELETE Idempotency and Safe Methods Batch Operations and Custom Actions

Designing RESTful Endpoints Filtering, Sorting, and Pagination API Response Envelopes and JSON:API

HTTP Headers: Content Negotiation Request Validation and Error Responses HTTP Caching with ETags and Cache-Control

2xx and 3xx Status Codes 4xx Client Error Status Codes 5xx Server Error Status Codes

JWT Authentication in REST APIs OAuth 2.0 Authorization Code Flow API Keys and Rate Limiting

URL, Header, and Query String Versioning Semantic Versioning and Change Management Backward-Compatible API Evolution

OpenAPI 3.1 Specification Generating Docs with Swagger UI and Redoc API Changelog and SDK Generation

Testing REST APIs with Postman Automated API Testing with PHPUnit and Laravel Contract Testing with Pact

Getting Started with R R Data Types and Type Coercion Working with Packages and the R Environment

Atomic Vectors and Vector Operations Vector Recycling, Lists, and Factors Vector Utility Functions and String Vectors

Creating and Inspecting Data Frames Subsetting Data Frames Merging, Reshaping, and Applying Functions to Data Frames

Defining and Calling Functions Functional Programming with Apply and purrr Error Handling and Defensive Programming

Conditionals: if, else, ifelse, and switch Loops: for, while, and repeat Vectorised Alternatives and Performance Considerations

Introduction to ggplot2 and the Grammar of Graphics Bar Charts, Histograms, Boxplots, and Facets Scales, Themes, and Customisation

Core dplyr Verbs: filter, select, mutate, arrange Grouping, Summarising, and Joins Window Functions, Rowwise Operations, and tidyr

Descriptive Statistics and Hypothesis Tests Linear Regression with lm() ANOVA, Logistic Regression, and Model Evaluation

Introduction to R Markdown Documents Tables, Figures, and Cross-References Parameterised Reports and Output Formats

What Is XML and Why It Matters Introduction to XML The XML Prolog and Declaration Well-Formed vs Valid XML Documents

Elements, Attributes, and Text Nodes XML Syntax Rules CDATA Sections and Comments Entity References and Special Characters

Element Content Models Element Naming Rules and Best Practices Attributes vs Child Elements — Design Decisions

Understanding XML Namespaces Default and Prefixed Namespace Declarations Namespace-Aware Parsing in Practice

Introduction to Document Type Definitions DTD Attribute Types and Defaults External DTDs and Entity Declarations

XML Schema (XSD) Basics XSD Simple Types and Facets XSD Complex Types, Keys, and References

XPath Syntax and Location Paths XPath Axes and Node Tests XPath Functions and Expressions

Introduction to XSLT Templates XSLT Control Structures and Variables XSLT Identity Transform and Modes

DOM Parsing with Python xml.etree.ElementTree SAX Parsing with Python xml.sax XML Parsing in Java: DOM and SAX

Introduction to Web Security The CIA Triad: Confidentiality, Integrity, and Availability Threat Modeling: Identifying and Prioritising Risks Defence in Depth and the Principle of Least Privilege

How TLS Works: Handshake and Certificate Chains HTTP Strict Transport Security (HSTS) Mixed Content, Certificate Pinning, and HTTPS Best Practices

SQL Injection Understanding SQL Injection Attacks Parameterised Queries and Prepared Statements ORM Usage, Stored Procedures, and Defence Layers

Cross-Site Scripting (XSS) Stored, Reflected, and DOM-Based XSS Output Encoding and Sanitisation to Prevent XSS Content Security Policy (CSP) as an XSS Defence Layer

How CSRF Attacks Work CSRF Tokens and the Synchroniser Token Pattern SameSite Cookies: Browser-Enforced CSRF Protection

Secure Password Storage with bcrypt and Argon2 Multi-Factor Authentication (MFA) Implementation JWT Security: Pitfalls and Best Practices

Same-Origin Policy and Why CORS Exists Configuring Access-Control Headers Securely CORS Pitfalls, Null Origin, and Private Network Access

X-Frame-Options and Clickjacking Prevention X-Content-Type-Options and Referrer-Policy Security Header Auditing and Grading

OWASP Top 10 2021: A01–A04 with Examples OWASP Top 10 2021: A05–A08 with Examples OWASP Top 10 2021: A09–A10 and Remediation Strategies

What is PostgreSQL? Introduction to PostgreSQL Creating Databases, Schemas, and Tables Roles, Permissions, and Security

Numeric and String Types Date, Time, UUID, and Array Types JSONB and Other Special Types

INSERT and RETURNING UPDATE and DELETE Transactions and Savepoints

SELECT, Filtering, and Sorting Advanced PostgreSQL Queries Aggregate Functions and GROUP BY CTEs and Subqueries

INNER, LEFT, RIGHT, and FULL JOIN Window Functions LATERAL Joins and Set Operations

B-tree, Hash, and Partial Indexes Full-Text Search Index Maintenance and Monitoring

Creating SQL and PL/pgSQL Functions Stored Procedures and Triggers Table-Returning Functions and Views

JSONB Storage and Operators JSONB Path Queries and Manipulation Building JSON Responses

EXPLAIN and Query Planning Partitioning and Table Design Connection Pooling and Configuration Tuning

Introduction to Express.js What Is Express.js The Application and Request-Response Cycle Project Structure and Best Practices

Express Routing Basic Routing with app.get and app.post Express Router for Modular Routes Route Parameters, Wildcards, and app.route()

Express Middleware Writing and Registering Middleware The Middleware Chain and next() Built-in and Third-Party Middleware

The Request Object The Response Object Streaming Responses and res.locals

Setting Up a Template Engine Layouts and Partials with EJS Pug Templates in Depth

Designing a RESTful API with Express Input Validation with express-validator Pagination, Filtering, and Sorting

JWT Authentication with jsonwebtoken Refresh Tokens and Secure Cookie Storage Role-Based Access Control (RBAC)

Centralised Error Handling Middleware Async Error Handling Patterns Validation Errors and HTTP Status Codes

Running Express in Production with PM2 Environment Configuration and Health Checks Reverse Proxy with Nginx and HTTPS

Login Sign Up

Home R Reference

R Reference

0 entries — click any item for full details and examples

No results found. Try a different search term.

SyntaxStudy

Free, beginner-friendly tutorials for web development. Learn at your own pace, anywhere.

Tutorials

HTML CSS JavaScript PHP Python MySQL Bootstrap jQuery TypeScript React Vue.js Node.js Git Linux / Bash MongoDB Docker Java C C++ C# Go Rust Kotlin Swift SASS / SCSS Tailwind CSS Django Next.js Laravel GraphQL REST API R XML Web Security PostgreSQL Express.js

Tools

Code Editor
Search
Create Account

Company

About
Contact
Privacy Policy
Sitemap
☕ Support Us

Privacy Policy Contact About