// databases

What Is SQLite?

SQLite is a lightweight relational database system that stores an entire database in a file. Unlike many database systems, it does not require a separate database server running in the background.

// definition

SQLite is an embedded relational database

SQLite is a relational database management system designed to be embedded directly inside applications.

A complete SQLite database is commonly stored in a single file on disk.

Applications interact with that file using SQL commands such as SELECT, INSERT, UPDATE and DELETE.

// simple idea

A database can be just one file

A SQLite database might look like this:

customers.db

Inside that file could be several tables:

customers orders products payments

The application can open the database file and query those tables directly.

// serverless

SQLite does not need a separate database server

Systems such as MySQL and PostgreSQL normally run as separate database server processes.

Applications connect to those servers over a local connection or network connection.

SQLite works differently.

Application ↓ SQLite library ↓ database.db

The application accesses the database through the SQLite library rather than contacting a separate database server.

// sql

SQLite uses SQL

SQL stands for Structured Query Language.

SQL is used to create, read, update and delete data stored in relational databases.

SELECT * FROM customers;

This query asks SQLite to return all rows from the customers table.

// tables

SQLite stores data in tables

A customer table might contain:

id	name	email
1	Alice	alice@example.com
2	Ben	ben@example.com
3	Carla	carla@example.com

Each row represents a record, while each column represents a particular type of information.

// create table

Tables can be created with SQL

CREATE TABLE customers ( id INTEGER PRIMARY KEY, name TEXT NOT NULL, email TEXT );

This creates a table containing three columns:

id name email

// insert

Data can be inserted

INSERT INTO customers ( name, email ) VALUES ( 'Alice', 'alice@example.com' );

This adds a new row to the customers table.

// select

Data can be retrieved

SELECT name, email FROM customers;

A condition can also be added:

SELECT * FROM customers WHERE id = 1;

This retrieves the customer whose ID is 1.

// update

Existing data can be changed

UPDATE customers SET email = 'alice.new@example.com' WHERE id = 1;

This changes the email address associated with the selected row.

// delete

Rows can be deleted

DELETE FROM customers WHERE id = 1;

The matching row is removed from the table.

// crud

These operations are often called CRUD

Create

Add new records to the database.

Read

Retrieve existing information.

Update

Change existing records.

Delete

Remove records from the database.

// relational

SQLite is a relational database

Relational databases can connect information stored across different tables.

For example:

customers id | name 1 | Alice orders id | customer_id | total 1001 | 1 | 49.99 1002 | 1 | 18.50

The customer_id value connects the orders to Alice's customer record.

// joins

SQL can combine related tables

SELECT customers.name, orders.total FROM customers JOIN orders ON customers.id = orders.customer_id;

The database can use the relationship between the tables to combine the relevant information.

// files

SQLite databases can use different file extensions

You may encounter files such as:

data.db database.sqlite app.sqlite3 customers.db

The extension does not fundamentally determine whether the file is a SQLite database. It is mainly a naming convention.

// storage classes

SQLite can store several kinds of values

Storage class	Purpose
NULL	No value
INTEGER	Whole numbers
REAL	Floating-point numbers
TEXT	Text strings
BLOB	Binary data

// embedded

SQLite is often embedded inside applications

Software can include SQLite as part of the application itself.

The user may never even realise that a SQLite database is being used.

Desktop Apps Mobile Apps Browsers Local Tools Development Testing

// portable

SQLite databases are highly portable

Because a database can be stored in a single file, it can be straightforward to copy, back up or move.

project/ │ ├── app.py ├── database.db └── settings.json

The database can sit directly alongside the application files.

// sqlite vs csv

SQLite is very different from CSV

CSV	SQLite
Plain-text file	Database file
Usually one table	Can contain many tables
No SQL engine	Supports SQL queries
Limited relationships	Relational structure
Simple data exchange	Application data storage

// sqlite vs mysql

SQLite and MySQL use different architectures

SQLite	MySQL
Embedded database	Database server
Database commonly stored in one file	Server manages database storage
No separate server required	Requires database server software
Excellent for local and embedded use	Common for networked applications

// sqlite vs server database

SQLite is not designed for every database workload

SQLite is extremely useful when simplicity and local storage are important.

A dedicated database server such as PostgreSQL or MySQL may be more appropriate when an application requires many simultaneous writers, centralised access, extensive server administration or large multi-user workloads.

SQLite is not simply a smaller MySQL. Its architecture is deliberately different. It is designed to provide a database engine directly inside an application.

// transactions

SQLite supports transactions

A transaction allows several database operations to be treated as one logical unit.

BEGIN; UPDATE accounts SET balance = balance - 50 WHERE id = 1; UPDATE accounts SET balance = balance + 50 WHERE id = 2; COMMIT;

Transactions help protect data from being left in an incomplete state if an operation fails.

// reliability

SQLite supports ACID transactions

Atomicity

A transaction is completed as a unit or rolled back.

Consistency

Database rules can help preserve valid states.

Isolation

Transactions are managed to avoid unsafe interference.

Durability

Committed changes are designed to survive failures.

// indexes

Indexes can improve query performance

CREATE INDEX idx_customer_email ON customers(email);

An index can allow the database to find certain values more efficiently instead of examining every row.

// programming

Many programming languages can use SQLite

Python PHP JavaScript C C++ Java C# Swift

// example with python

SQLite can be used from application code

For example, Python includes support for SQLite:

import sqlite3 connection = sqlite3.connect("customers.db") cursor = connection.cursor() cursor.execute( "SELECT * FROM customers" ) rows = cursor.fetchall() connection.close()

The program opens the database file, executes a query and retrieves the results.

// uses

What is SQLite used for?

Mobile Apps Desktop Software Local Data Application Settings Prototypes Testing Small Websites Data Analysis Embedded Systems Offline Applications

// advantages

Why is SQLite useful?

Simple

No separate database server needs to be configured.

Portable

An entire database can commonly be stored in one file.

Lightweight

The database engine can be embedded directly inside an application.

Powerful

It still provides SQL, transactions, indexes, relationships and many database features.

// important distinction

A SQLite database is more than an ordinary data file

A CSV file stores rows of text.

A JSON file stores structured text.

A SQLite file contains a database managed by an actual database engine.

CSV → data file JSON → structured data file SQLite → database stored in a file

That distinction is important.

// summary

A database inside one file.

SQLite is an embedded relational database system that provides SQL, tables, relationships, transactions and indexes without requiring a separate database server. Its simplicity and portability make it useful for mobile apps, desktop software, local tools, prototypes and many other applications.

// server-side programming

What Is PHP?

PHP is a programming language widely used for server-side web development. It can generate web pages, process forms, communicate with databases, manage sessions and build dynamic websites and applications.

// definition

PHP is a server-side scripting language

PHP is a general-purpose programming language particularly suited to web development.

PHP code commonly runs on a web server rather than directly inside the user's browser.

The server executes the PHP code and sends the resulting output, often HTML, back to the browser.

// name

What does PHP stand for?

PHP is officially described using the recursive acronym:

PHP: Hypertext Preprocessor

The name reflects PHP's long association with generating and processing web content.

// example

What does PHP look like?

<?php echo "Hello, world!"; ?>

The echo statement sends text to the output.

In a web application, that output can become part of the HTML returned to the browser.

// server

PHP usually runs before the page reaches the browser

Browser requests page ↓ Web server receives request ↓ PHP code executes ↓ PHP generates output ↓ Server sends response ↓ Browser displays page

The browser usually receives the output generated by PHP rather than the original PHP source code.

// php + html

PHP can be embedded inside HTML

<h1>Welcome</h1> <p> Today is <?php echo date("d F Y"); ?> </p>

PHP executes on the server and inserts the generated value into the document before it is sent to the user.

// variables

PHP can store information in variables

<?php $name = "Alice"; $orders = 4; echo $name; echo $orders; ?>

PHP variable names normally begin with a $ symbol.

// data types

PHP supports different kinds of data

Type	Example
String	"Freelance Coder"
Integer	42
Float	19.99
Boolean	true
Array	["HTML", "CSS", "PHP"]
Null	null
Object	new Customer()

// arrays

PHP arrays can store collections of data

<?php $skills = [ "HTML", "CSS", "JavaScript", "PHP" ]; echo $skills[0]; ?>

This outputs:

HTML

// associative arrays

PHP arrays can also use named keys

<?php $customer = [ "name" => "Alice", "orders" => 4, "active" => true ]; echo $customer["name"]; ?>

Associative arrays are useful for representing structured information using named keys and values.

// conditions

PHP can make decisions

<?php $loggedIn = true; if ($loggedIn) { echo "Welcome back."; } else { echo "Please sign in."; } ?>

Conditional statements allow different code to run depending on the state of the application.

// functions

PHP functions package reusable logic

<?php function greet($name) { return "Hello, " . $name; } echo greet("Alice"); ?>

The full stop operator joins strings together in PHP.

// loops

PHP can repeat tasks

<?php for ($i = 1; $i <= 5; $i++) { echo $i; } ?>

Loops are useful when the same operation must be repeated several times.

// foreach

foreach is useful for collections

<?php $skills = [ "HTML", "CSS", "PHP" ]; foreach ($skills as $skill) { echo $skill; } ?>

The loop processes each item in the array one at a time.

// forms

PHP can process form submissions

A website might contain a form:

<form method="post"> <input type="text" name="name" > <button type="submit"> Send </button> </form>

PHP can receive the submitted data:

<?php if ($_SERVER["REQUEST_METHOD"] === "POST") { $name = $_POST["name"] ?? ""; } ?>

User input should be validated and handled safely. Real applications should never assume that submitted information is automatically trustworthy.

// databases

PHP can communicate with databases

PHP is commonly used with relational databases such as MySQL and PostgreSQL.

An application might use a database to store:

Users Products Orders Blog Posts Settings Transactions

// database connection

PHP provides database interfaces

One common approach is PHP Data Objects, or PDO.

<?php $pdo = new PDO( "mysql:host=localhost;dbname=shop;charset=utf8mb4", $username, $password ); ?>

Applications can then execute database queries through the connection.

// sql safety

Prepared statements are important

<?php $stmt = $pdo->prepare( "SELECT * FROM users WHERE email = ?" ); $stmt->execute([$email]); $user = $stmt->fetch(); ?>

Prepared statements allow values to be supplied separately from the SQL structure and are an important defence against SQL injection.

// sessions

PHP can maintain session data

<?php session_start(); $_SESSION["user_id"] = 123; ?>

Sessions allow a server to associate information with a user across multiple requests.

They are commonly used for login systems and other stateful website features.

// cookies

PHP can also work with cookies

<?php setcookie( "theme", "light", time() + 3600 ); ?>

Cookies are stored by the browser and can later be sent back to the server with requests.

// json

PHP works with JSON

PHP can convert arrays and objects into JSON:

<?php $data = [ "name" => "Alice", "orders" => 4 ]; echo json_encode($data); ?>

It can also convert JSON into PHP data:

<?php $data = json_decode( $json, true ); ?>

This makes PHP useful for building and consuming APIs.

// APIs

PHP can power APIs

Instead of returning an HTML page, a PHP application can return structured data.

<?php header( "Content-Type: application/json" ); echo json_encode([ "status" => "success", "message" => "Data received" ]); ?>

Another application can then consume the JSON response.

// php vs javascript

PHP and JavaScript often work together

PHP

Commonly runs on the server and handles server-side application logic.

JavaScript

Commonly runs in the browser and handles interactive client-side behaviour.

PHP Output

Can generate HTML or JSON that is sent to the browser.

JavaScript Requests

Can send requests to PHP-powered APIs and process their responses.

// web application

A PHP web application might work like this

User ↓ Browser ↓ HTTP request ↓ Web server ↓ PHP application ↓ Database ↓ PHP generates response ↓ HTML or JSON ↓ Browser

PHP often acts as the server-side layer connecting users, application logic and stored data.

// wordpress

WordPress is built with PHP

PHP has played a major role in the development of content management systems.

WordPress uses PHP extensively for themes, plugins, templates, database interaction and server-side logic.

<?php the_title(); the_content(); ?>

WordPress-specific PHP functions can dynamically retrieve and display website content.

// .php files

PHP code is commonly stored in .php files

index.php contact.php login.php api.php functions.php

A web server configured for PHP can execute the PHP code when one of these files is requested.

// security

Server-side code must handle data carefully

PHP applications often process passwords, form inputs, database queries, cookies and uploaded files.

Secure applications therefore need appropriate validation, escaping, authentication and database practices.

Never trust input simply because it came from your own website. Server-side code should validate data and apply the correct security controls for how that data will be used.

// frameworks

PHP has a large software ecosystem

Developers can use frameworks and content management systems rather than building every component from scratch.

Laravel Symfony WordPress Composer PHPUnit

// uses

What is PHP used for?

Dynamic Websites WordPress APIs Databases Forms Authentication E-commerce Web Applications Server-Side Logic Automation

// summary

The server does the work.

PHP is a programming language widely used for server-side web development. It can generate HTML, process forms, manage sessions, communicate with databases, work with JSON and APIs, and power dynamic websites and applications such as WordPress.

// programming

What Is JavaScript?

JavaScript is a programming language used extensively on the web. It allows websites to respond to users, manipulate page content, communicate with servers, process data and perform tasks dynamically.

// definition

JavaScript adds logic and behaviour

JavaScript is a high-level programming language used in web browsers, servers and many other software environments.

On a web page, JavaScript can react to user actions, change HTML content, modify CSS styles, process data and communicate with APIs.

It is one of the core technologies of modern web development alongside HTML and CSS.

// example

What does JavaScript look like?

A very simple JavaScript statement might be:

console.log("Hello, world!");

This tells JavaScript to send the text Hello, world! to the developer console.

// variables

JavaScript can store information

Variables allow programs to store values for later use.

let name = "Alice"; let orders = 4; console.log(name); console.log(orders);

Here, one variable stores text and another stores a number.

// let + const

Values can be declared with let and const

let score = 10; score = 20; const siteName = "Freelance Coder";

let is commonly used when a variable may later be assigned another value.

const creates a binding that cannot later be reassigned.

// data types

JavaScript works with different kinds of data

Type	Example
String	"Freelance Coder"
Number	42
Boolean	true
Undefined	undefined
Null	null
Object	{ name: "Alice" }
BigInt	123n
Symbol	Symbol("id")

// arrays

Arrays store collections of values

const skills = [ "HTML", "CSS", "JavaScript", "PHP" ];

Individual values can be accessed by their position.

console.log(skills[0]);

This produces:

HTML

JavaScript array indexes begin at 0. The first item therefore has index 0 rather than 1.

// objects

Objects group related information

const customer = { name: "Alice", orders: 4, active: true };

The object's properties can then be accessed:

console.log(customer.name);

This produces:

Alice

// operators

JavaScript can perform calculations

let a = 10; let b = 5; let total = a + b; console.log(total);

The result is:

15

+ - * / % **

// conditions

Programs can make decisions

Conditional statements allow code to behave differently depending on whether a condition is true or false.

const loggedIn = true; if (loggedIn) { console.log("Welcome back."); } else { console.log("Please sign in."); }

// functions

Functions package reusable behaviour

function greet(name) { return "Hello, " + name; } console.log(greet("Alice"));

The function receives a value, performs some logic and returns a result.

This makes code easier to organise and reuse.

// arrow functions

JavaScript also has arrow functions

const add = (a, b) => { return a + b; }; console.log(add(3, 4));

This outputs:

7

// loops

JavaScript can repeat tasks

for (let i = 1; i <= 5; i++) { console.log(i); }

This repeats the same instruction while the loop condition remains true.

// dom

JavaScript can change a web page

In a browser, JavaScript can interact with the Document Object Model, usually called the DOM.

Suppose the HTML contains:

<h1 id="title">Old Title</h1>

JavaScript could change it:

document.getElementById("title").textContent = "New Title";

The visible heading can change without loading an entirely new HTML document.

// events

JavaScript can respond to users

Browsers generate events when users click buttons, type into forms, move the mouse and perform other actions.

const button = document.getElementById("button"); button.addEventListener("click", function () { alert("Button clicked!"); });

JavaScript waits for the click event and then runs the function.

// html + css + javascript

The three core web technologies have different roles

HTML

Defines the structure and meaning of the page.

CSS

Controls presentation, layout and visual design.

JavaScript

Adds logic, behaviour and interactivity.

Together

They form the foundation of much of modern front-end web development.

// example

HTML, CSS and JavaScript working together

HTML:

<button id="helloButton"> Say Hello </button>

CSS:

#helloButton { background: #001eff; color: white; padding: 12px 18px; }

JavaScript:

document .getElementById("helloButton") .addEventListener("click", function () { alert("Hello!"); });

HTML creates the button, CSS styles it and JavaScript gives it behaviour.

// APIs

JavaScript can communicate with APIs

JavaScript can request data from another service over the web.

fetch("https://api.example.com/products") .then(response => response.json()) .then(data => { console.log(data); });

This example requests information from an API and converts the response into JavaScript data.

// javascript + json

JavaScript works naturally with JSON

JSON was derived from JavaScript object notation and is widely used to exchange structured information.

{ "name": "Alice", "orders": 4 }

JavaScript can parse JSON text:

const customer = JSON.parse(jsonText);

It can also convert JavaScript values into JSON:

const json = JSON.stringify(customer);

// asynchronous code

JavaScript can handle asynchronous tasks

Some operations take time, such as requesting information from a server.

JavaScript provides mechanisms such as promises and async/await for working with these tasks.

async function getData() { const response = await fetch("/api/data"); const data = await response.json(); console.log(data); }

// runtime

JavaScript is not limited to browsers

JavaScript originally became popular as a browser language, but it can now run in many other environments.

Web Browsers Servers Node.js Web Apps Desktop Apps Automation Cloud Functions

// node.js

Node.js allows JavaScript to run outside the browser

Node.js is a JavaScript runtime commonly used for server-side programming, command-line tools and automation.

console.log( "JavaScript running with Node.js" );

This means the same language can be used for both browser-based and server-side development.

// javascript vs java

JavaScript is not Java

JavaScript and Java are different programming languages. Despite the similarity in their names, they have different histories, syntax, ecosystems and execution models.

// dynamic typing

JavaScript is dynamically typed

A variable can hold values of different types at different times.

let value = 10; value = "Hello"; value = true;

The variable itself is not permanently restricted to one of these types.

// modules

JavaScript code can be divided into modules

Larger applications can separate functionality into reusable files.

export function add(a, b) { return a + b; }

Another JavaScript file can import that function:

import { add } from "./math.js"; console.log(add(2, 3));

// uses

What is JavaScript used for?

Interactive Websites Web Applications APIs Data Processing Automation Servers Forms Animations AI Interfaces Browser Tools

// summary

Structure and design become interactive.

JavaScript is a programming language used to add logic, behaviour and interactivity to websites and applications. It can manipulate HTML, change CSS, process data, respond to users, communicate with APIs and run on both browsers and servers.

// web development

What Is CSS?

CSS is the language used to control the appearance and layout of web pages. HTML describes the structure of the content, while CSS determines how that content should look.

// definition

CSS means Cascading Style Sheets

CSS stands for Cascading Style Sheets.

It is a stylesheet language used to describe the presentation of HTML and other structured documents.

CSS can control colours, fonts, spacing, borders, positioning, page layout, animations and how a website adapts to different screen sizes.

// example

What does CSS look like?

Suppose a web page contains this HTML:

<h1>Freelance Coder</h1>

We could style that heading using CSS:

h1 { color: blue; font-size: 40px; text-align: center; }

The HTML identifies the content as a heading. The CSS controls how that heading is displayed.

// css rule

CSS is written as rules

p { color: #20262d; font-size: 18px; }

A CSS rule contains a selector and one or more declarations.

Selector

Identifies which HTML elements should receive the styling.

Declaration

Specifies the property that should change and the value it should receive.

// property + value

Properties and values control the design

color: blue;

In this declaration:

Part	Meaning
color	The CSS property
blue	The value assigned to the property

A colon separates the property from the value, and declarations normally end with a semicolon.

// selectors

CSS selectors choose what to style

CSS provides several ways to target HTML elements.

/* Every paragraph */ p { color: black; } /* Elements with class="button" */ .button { background: blue; } /* Element with id="header" */ #header { padding: 20px; }

Element Selector Class Selector ID Selector Attribute Selector Pseudo-class

// classes

Classes make styles reusable

An HTML element can be given a class:

<a class="button">Contact Me</a>

CSS can then target that class:

.button { background: #001eff; color: white; padding: 10px 18px; border-radius: 6px; }

The same class can be applied to multiple elements, allowing the styling to be reused.

// colours

CSS controls colour

Colours can be represented in several ways.

color: blue; color: #001eff; color: rgb(0, 30, 255); color: rgba(0, 30, 255, 0.5);

Your Freelance Coder site, for example, uses:

Normal link: #001eff Hover: #00d719 Visited link: #5b3fd6

// typography

CSS controls text appearance

p { font-family: Arial, sans-serif; font-size: 18px; font-weight: 400; line-height: 1.7; }

CSS can control the typeface, size, weight, spacing and alignment of text.

// box model

HTML elements are treated like boxes

One of the most important CSS concepts is the box model.

An element can have:

Content

The text, image or other content inside the element.

Padding

Space between the content and the border.

Border

A line surrounding the element and its padding.

Margin

Space outside the element separating it from surrounding elements.

.card { padding: 20px; border: 1px solid #e3e8ee; margin: 20px; }

// dimensions

CSS controls dimensions

.container { width: 100%; max-width: 720px; min-height: 300px; }

Widths and heights can be expressed using pixels, percentages, viewport units and other CSS units.

// flexbox

CSS can arrange elements with Flexbox

.container { display: flex; gap: 20px; align-items: center; justify-content: space-between; }

Flexbox is useful for arranging elements along a row or column and controlling their alignment and spacing.

// grid

CSS Grid can create page layouts

.services { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; }

This creates two equal-width columns.

CSS Grid is particularly useful for layouts involving rows and columns.

// responsive design

CSS can adapt a website to different screens

Media queries allow styles to change depending on properties such as the width of the screen.

@media (max-width: 600px) { .services { grid-template-columns: 1fr; } }

A two-column desktop layout could therefore become a single-column layout on a phone.

// interaction

CSS can respond to user interaction

Pseudo-classes such as :hover can apply styles when a user interacts with an element.

a { color: #001eff; } a:hover { color: #00d719; }

This is the same basic idea behind the green hover effects used throughout Freelance Coder.

// transitions

CSS can create smooth transitions

a { color: #001eff; transition: color 0.25s ease; } a:hover { color: #00d719; }

Instead of the colour changing instantly, the browser transitions smoothly between the two colours.

// animation

CSS can also create animations

@keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } } .card { animation: fadeIn 0.6s ease; }

CSS animations can change properties over time without requiring JavaScript for every visual effect.

// cascade

Why is it called "Cascading" Style Sheets?

More than one CSS rule can potentially apply to the same element.

The browser must therefore determine which declaration wins.

The result depends on factors including:

Origin Importance Specificity Scope Source Order

The cascade is a core part of CSS. It provides a defined system for resolving competing style declarations.

// inheritance

Some CSS properties are inherited

Certain properties can pass from a parent element to its descendants.

body { color: #20262d; font-family: Arial, sans-serif; }

Text inside many child elements may inherit these properties automatically unless another rule overrides them.

// adding css

CSS can be added in several ways

Method	Example
External stylesheet	styles.css
Internal stylesheet	<style> ... </style>
Inline style	style="color: blue;"

Larger websites usually benefit from reusable stylesheets rather than repeating styles directly inside individual HTML elements.

// external stylesheet

CSS can live in its own file

A stylesheet might be saved as:

styles.css

HTML can then load it using:

<link rel="stylesheet" href="styles.css" >

This separation allows one stylesheet to control the appearance of many pages.

// html + css + javascript

HTML, CSS and JavaScript have different roles

HTML

Defines the structure and meaning of the content.

CSS

Defines the presentation, design and layout.

JavaScript

Adds programming logic, behaviour and interactivity.

Together

They form the core technologies behind much of modern front-end web development.

// separation

Structure and presentation can be separated

HTML might contain:

<button class="contact-button"> Contact Me </button>

CSS can separately define how it looks:

.contact-button { background: #001eff; color: white; padding: 12px 18px; border: 0; border-radius: 8px; } .contact-button:hover { background: #00d719; }

The HTML describes the button. CSS controls its presentation.

// css vs html

CSS does not replace HTML

CSS normally styles an existing document structure.

Without HTML or another document language providing the content and structure, there is little for ordinary CSS to style.

HTML describes what the content is. CSS describes how that content should be presented.

// uses

What is CSS used for?

Colours Typography Layouts Spacing Responsive Design Hover Effects Animations Navigation Forms Web Design

// summary

Structure becomes design.

CSS is the stylesheet language used to control how web content is presented. It works alongside HTML to control colours, typography, spacing, dimensions, layouts, responsive behaviour, hover effects and animations, making it one of the fundamental technologies of the modern web.