SVG stands for Scalable Vector Graphics. It's an XML-based file format used to describe 2D graphics. SVG allows for the display of vector images that can be scaled to any size without losing quality. It's widely used in web design because it offers high resolution at any size and integrates easily into web pages.

Here are some key features of SVG:

• Vector-based: SVG graphics are made up of lines, curves, and shapes defined mathematically, unlike raster images (like JPEG or PNG), which are made of pixels.

• Scalability: Since SVG is vector-based, it can be resized to any dimension without losing image quality, making it ideal for responsive designs.

• Interactivity and Animation: SVG supports interactivity (e.g., via JavaScript) and animation (e.g., via CSS or SMIL).

• Search engine friendly: SVG content is text-based and can be indexed by search engines, offering SEO benefits.

• Compatibility: SVG files are supported by most modern web browsers and are great for logos, icons, charts, and other graphics.

SLD (Styled Layer Descriptor) is an XML-based standard developed by the Open Geospatial Consortium (OGC). It is used to define the styling of geospatial data in web mapping services like WMS (Web Map Service).

What does SLD do?

SLD describes how certain geospatial features should be rendered on a map — meaning it defines colors, lines, symbols, labels, and more. With SLD, you can specify things like:

• Roads should appear red.

• Water bodies in blue, with a certain transparency.

• Points should have symbols that vary depending on attribute values (e.g., population).

• Text labels over features.

Technically:

• SLD is an XML file with a defined structure.

• It can be read by WMS servers like GeoServer or MapServer.

• The file includes Rules, Filters, and Symbolizers like LineSymbolizer, PolygonSymbolizer, or TextSymbolizer.

Example of a simple SLD snippet:

<Rule>
  <Name>Water Bodies</Name>
  <PolygonSymbolizer>
    <Fill>
      <CssParameter name="fill">#0000FF</CssParameter>
    </Fill>
  </PolygonSymbolizer>
</Rule>

Why is it useful?

• To create custom-styled maps (e.g., thematic maps).

• To define styling server-side, so the map is rendered correctly regardless of the client.

• For interactive web GIS applications that react to attribute values.

If you're working with geospatial data — for example in QGIS or GeoServer — you'll likely come across SLD when you need fine-grained control over how your maps look.

The SLD (Second-Level Domain) is the part of a domain name that appears directly to the left of the Top-Level Domain (TLD).

Example:

In the domain
👉 example.com

• .com is the TLD (Top-Level Domain)

• example is the SLD (Second-Level Domain)

Domain Structure (from right to left):

More Examples:

Why it matters:

The SLD is usually the custom, chosen part of the domain—often representing a company name, brand, or project. It's the most recognizable and memorable part of a domain name.

A hyperscaler is a company that provides cloud services on a massive scale — offering IT infrastructure such as computing power, storage, and networking that is flexible, highly available, and globally scalable. Common examples of hyperscalers include:

• Amazon Web Services (AWS)

• Microsoft Azure

• Google Cloud Platform (GCP)

• Alibaba Cloud

• IBM Cloud (on a somewhat smaller scale)

Key characteristics of hyperscalers:

1. Massive scalability
   They can scale their services virtually without limits, depending on the customer's needs.

2. Global infrastructure
   Their data centers are distributed worldwide, enabling high availability, low latency, and redundancy.

3. Automation & standardization
   Many operations are automated (e.g., provisioning, monitoring, billing), making services more efficient and cost-effective.

4. Self-service & pay-as-you-go
   Customers usually access services via web portals or APIs and pay only for what they actually use.

5. Innovation platform
   Hyperscalers offer not only infrastructure (IaaS), but also platform services (PaaS), as well as tools for AI, big data, or IoT.

What are hyperscalers used for?

• Hosting websites or web applications

• Data storage (e.g., backups, archives)

• Big data analytics

• Machine learning / AI

• Streaming services

• Corporate IT infrastructure

Vite is a modern build tool and development server for web applications, created by Evan You, the creator of Vue.js. It is designed to make the development and build processes faster and more efficient. The name "Vite" comes from the French word for "fast," reflecting the primary goal of the tool: a lightning-fast development environment.

The main features of Vite are:

1. Fast Development Server: Vite uses modern ES modules (ESM), providing an ultra-fast development server. It only loads the latest module, making the initial startup much faster than traditional bundlers.

2. Hot Module Replacement (HMR): HMR works extremely fast by updating only the changed modules, without needing to reload the entire application.

3. Modern Build System: Vite uses Rollup under the hood to bundle the final production build, enabling optimized and efficient builds.

4. Zero Configuration: Vite is very user-friendly and doesn’t require extensive configuration. It works immediately with the default settings, supporting many common web technologies out-of-the-box (e.g., Vue.js, React, TypeScript, CSS preprocessors, etc.).

5. Optimized Production: For production builds, Rollup is used, which is known for creating efficient and optimized bundles.

Vite is mainly aimed at modern web applications and is particularly popular with developers working with frameworks like Vue, React, or Svelte.

Memcached is a distributed in-memory caching system commonly used to speed up web applications. It temporarily stores frequently requested data in RAM to avoid expensive database queries or API calls.

Key Features of Memcached:

• Key-Value Store: Data is stored as key-value pairs.

• In-Memory: Runs entirely in RAM, making it extremely fast.

• Distributed: Supports multiple servers (clusters) to distribute load.

• Simple API: Provides basic operations like set, get, and delete.

• Eviction Policy: Uses LRU (Least Recently Used) to remove old data when memory is full.

Common Use Cases:

• Caching Database Queries: Reduces load on databases like MySQL or PostgreSQL.

• Session Management: Stores user sessions in scalable web applications.

• Temporary Data Storage: Useful for API rate limiting or short-lived data caching.

Memcached vs. Redis:

• Memcached: Faster for simple key-value caching, scales well horizontally.

• Redis: Offers more features like persistence, lists, hashes, sets, and pub/sub messaging.

Installation & Usage (Example for Linux):

sudo apt update && sudo apt install memcached
sudo systemctl start memcached

It can be used with PHP or Python via appropriate libraries.

A spider (also called a web crawler or bot) is an automated program that browses the internet to index web pages. These programs are often used by search engines like Google, Bing, or Yahoo to discover and update content in their search index.

How a Spider Works:

1. Starting Point: The spider begins with a list of URLs to crawl.

2. Analysis: It fetches the HTML code of a webpage and analyzes its content, links, and metadata.

3. Following Links: It follows the links found on the page to discover new pages.

4. Storage: The collected data is sent to the search engine’s database for indexing.

5. Repetition: The process is repeated regularly to keep the index up to date.

Uses of Spiders:

• Search engine optimization (SEO)

• Price comparison websites

• Web archiving (e.g., Wayback Machine)

• Automated content analysis for AI models

Some websites use a robots.txt file to specify which areas can or cannot be crawled by a spider.

A crawler (also known as a web crawler, spider, or bot) is an automated program that browses the internet and analyzes web pages. It follows links from page to page and collects information.

Uses of Crawlers:

1. Search Engines (e.g., Google's Googlebot) – Index web pages so they appear in search engine results.

2. Price Comparison Websites – Scan online stores for the latest prices and products.

3. SEO Tools – Analyze websites for technical errors or optimization potential.

4. Data Analysis & Monitoring – Track website content for market research or competitor analysis.

5. Archiving – Save web pages for future reference (e.g., Internet Archive).

How a Crawler Works:

1. Starts with a list of URLs.

2. Fetches web pages and stores content (text, metadata, links).

3. Follows links on the page and repeats the process.

4. Saves or processes the collected data depending on its purpose.

Many websites use a robots.txt file to control which content crawlers can visit or ignore.

The Fetch API is a modern JavaScript interface for retrieving resources over the network, such as making HTTP requests to an API or loading data from a server. It largely replaces the older XMLHttpRequest method and provides a simpler, more flexible, and more powerful way to handle network requests.

Basic Functionality

• The Fetch API is based on Promises, making asynchronous operations easier.
• It allows fetching data in various formats like JSON, text, or Blob.
• By default, Fetch uses the GET method but also supports POST, PUT, DELETE, and other HTTP methods.

Simple Example

fetch('https://jsonplaceholder.typicode.com/posts/1')
  .then(response => response.json()) // Convert response to JSON
  .then(data => console.log(data)) // Log the data
  .catch(error => console.error('Error:', error)); // Handle errors

Making a POST Request

fetch('https://jsonplaceholder.typicode.com/posts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ title: 'New Post', body: 'Post content', userId: 1 })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

Advantages of the Fetch API

✅ Simpler syntax compared to XMLHttpRequest
✅ Supports async/await for better readability
✅ Flexible request and response handling
✅ Better error management using Promises

The Fetch API is now supported in all modern browsers and is an essential technique for web development.

A Single Page Application (SPA) is a web application that runs entirely within a single HTML page. Instead of reloading the entire page for each interaction, it dynamically updates the content using JavaScript, providing a smooth, app-like user experience.

Key Features of an SPA:

• Dynamic Content Loading: New content is fetched via AJAX or the Fetch API without a full page reload.
• Client-Side Routing: Navigation is handled by JavaScript (e.g., React Router or Vue Router).
• State Management: SPAs often use libraries like Redux, Vuex, or Zustand to manage application state.
• Separation of Frontend & Backend: The backend typically serves as an API (e.g., REST or GraphQL).

Advantages:

✅ Faster interactions after the initial load
✅ Improved user experience (no full page reloads)
✅ Offline functionality possible via Service Workers

Disadvantages:

❌ Initial load time can be slow (large JavaScript bundle)
❌ SEO challenges (since content is often loaded dynamically)
❌ More complex implementation, especially for security and routing

Popular frameworks for SPAs include React, Angular, and Vue.js.