Sorting algorithms are fundamental to computer science, and choosing the right one can make a significant difference in efficiency. Whether you need to sort a million integers or merge two already-ordered arrays, the algorithm’s time complexity, stability, and memory requirements all matter.

This guide covers the full spectrum of sorting: from foundational comparisons and merge sort to quicksort, heapsort, adaptive algorithms, and specialized non-comparison sorts. Each section focuses on a distinct family of algorithms, with analysis of their trade-offs and real-world applicability.

Sorting Fundamentals

• Insertion Sort vs. Bubble Sort Algorithms
• Stable Sorting Algorithms
• Counting Sort vs. Bucket Sort vs. Radix Sort
• External Sorting vs Internal Sorting
• Which Sorting Algorithm to Use?
• Worst Sorting Algorithms – What to Avoid

Merge Sort

• Merge Sort: Top-Down vs. Bottom-up
• 2-Way and K-Way Merging
• Non-Recursive Merge Sort
• Merge Two Sorted Arrays Into a Sorted Array
• In-Place Sorting With Merge Sort
• When Will the Worst Case of Merge Sort Occur?

QuickSort

• An Overview of QuickSort Algorithm
• Understanding the Randomized Quicksort
• Quicksort vs. Mergesort
• Complexity Analysis of QuickSelect
• Quicksort vs. Heapsort
• Quicksort Worst Case Time Complexity

Heapsort and Adaptive Sorts

• How Does Timsort Work?
• Tournament Sort Algorithm
• Understanding Heapsort
• Why Isn’t Heapsort Stable?
• The Complexity of Shellsort

Specialized Sorting Algorithms

• Cycle Sort Algorithm
• Binary Insertion Sort
• Cocktail Sort
• Bitonic Sort
• Radix Sort
• Gravity/Bead Sort

      

Related Stories

• Natural Language Processing (NLP) Series
• Cycle Sort Algorithm
• LaTeX Series

 

Natural Language Processing (NLP) enables computers to understand, interpret, and generate human language. From basic text preprocessing to large language models and retrieval-augmented generation, NLP covers a vast range of techniques used in search engines, chatbots, recommendation systems, and more.

This guide walks through the core areas of NLP: foundational text processing, similarity and search, word embeddings, modern language models and transformers, and practical applications like sentiment analysis and text classification.

NLP Foundations

• NLP vs. NLU vs. NLG
• Stemming vs Lemmatization
• What Exactly Is an N-Gram?
• Understanding Text Mining
• What Are Language Models in NLP?
• Differences Between Porter and Lancaster Stemming Algorithms

Text Similarity and Search

• String Similarity Metrics – Edit Distance
• How to Compute the Similarity Between Two Text Documents?
• Semantic Similarity of Two Phrases
• How Does the Google “Did You Mean?” Algorithm Work?
• Co-occurrence Matrices and Their Uses in NLP
• Natural Language Processing: Bleu Score

Word Embeddings and Vector Representations

• NLP’s word2vec: Negative Sampling Explained
• When Coherence Score Is Good or Bad in Topic Modeling?
• How To Convert a Text Sequence to a Vector
• Converting a Word to a Vector
• Word Embeddings: CBOW vs Skip-Gram
• Transformer Text Embeddings
• Dimensionality of Word Embeddings

Large Language Models and Transformers

• Introduction to Large Language Models
• From RNNs to Transformers
• Different Text Summarization Techniques Using Langchain
• How Does ChatGPT Work?
• Comparison Between BERT and GPT-3 Architectures
• What Is Retrieval-Augmented Generation (RAG)?
• Comparative Analysis of Top Large Language Models

Sentiment Analysis and Text Classification

• How Does the Amazon Recommendation System Work?
• Algorithms for Determining Text Sentiment
• Publicly Available Spam Filter Training Sets
• Automatic Keyword and Keyphrase Extraction
• Sentiment Analysis Dictionaries

      

Related Stories

• What Is Aspect-Based Sentiment Analysis?
• What Are Language Models in NLP?
• Sorting Algorithms Series

 

1. Introduction

Modern customer support chatbots are evolving beyond static FAQ bots into intelligent assistants powered by Large Language Models (LLMs). However, out-of-the-box LLMs have certain constraints. They’re only aware of the information in their training dataset.

In this tutorial, we’ll build a ChatGPT-powered support chatbot that uses Retrieval-Augmented Generation (RAG) to deliver accurate, up-to-date answers from a custom textual database. Throughout this guide, we’ll cover how to:

• ingest and index PDFs and CSVs into a FAISS (Facebook AI Similarity Search) vector store
• perform semantic retrieval of the most relevant text chunks when a user submits a query
• assemble the retrieved chunks into a context prompt tailored for ChatGPT
• run a conversational loop that grounds each response in our own data

By the end of this tutorial, we’ll have a complete end-to-end RAG pipeline that enables ChatGPT to reference and cite domain-specific materials at query time.

2. Motivation and Project Statement

Despite their impressive versatility, general-purpose language models are bound by a static training corpus and a firm knowledge cutoff. Consequently, they may deliver outdated information and, in some cases, even generate ungrounded or fabricated responses.

Simple “file upload” solutions can seem appealing at first glance. These solutions typically allow users to upload documents directly to a chatbot to be processed as a single unit without sophisticated indexing or chunking. However, this approach doesn’t provide genuine semantic search or relevance-based ranking across extensive document collections. Moreover, it can’t partition content into fine-grained, metadata-tagged segments, which makes source tracing opaque. Finally, any update to the underlying documents forces a complete re-upload.

To overcome these challenges, we adopt a Retrieval-Augmented Generation framework with vector search:

Our approach follows a systematic process: we split documents into manageable chunks and convert each chunk into vector embeddings that capture semantic meaning. When a user submits a query, we transform it into a vector representation and search for the most similar vectors in our FAISS index. We then retrieve the corresponding text chunks and inject them as context into ChatGPT’s prompt, enabling the model to generate responses grounded in our knowledge base rather than relying solely on its training data.

3. Project Setup

Now, let’s establish a Python environment, define dependencies, obtain OpenAI credentials, and centralize reusable configuration values.

3.1. Dependencies

First, we create a virtual environment and install the required libraries:

mkdir gpt4-support-bot && cd gpt4-support-bot
mkdir src docs vector_store
python -m venv venv
source venv/bin/activate   # on Windows: venv\Scripts\activate
pip install openai langchain faiss-cpu PyPDF2 pandas numpy

We use the following libraries:

• openai – official client for ChatGPT and OpenAI embedding models
• langchain – high-level abstractions for LLM orchestration, conversational memory, and vector stores
• faiss-cpu – FAISS (CPU build) enabling efficient similarity search over dense vectors
• PyPDF2 – lightweight PDF parser for ingesting documentation
• pandas – tabular data processing, particularly useful when reading CSV articles

3.2. Directory Structure

We’ll use the following project structure, where each component serves a clear purpose in the RAG pipeline:

gpt4-baeldung-support-bot/
- venv/
- vector_store/         # FAISS index after ingestion
- docs/
  - articles.csv       # metadata: title, author, pdf_name, etc.
  - baeldung.pdf
  - threading.pdf    # Threading article
  ...                # additional PDFs
- src/
  - ingest.py          # builds the index
  - chat.py            # main chatbot loop
  - cli.py             # command-line interface
  - config.py       
  - pdf_utils.py

During ingestion, the loader reads each row in articles.csv, fetches the corresponding PDF from docs/, splits it into overlapping chunks, embeds every chunk, and stores the result in vector_store/. Afterward, chat.py retrieves the TOP_K most relevant chunks for any incoming question and supplies them to the chosen GPT model.

3.3. OpenAI API Key

Next, we need an API key from the OpenAI dashboard. This key is used to make requests to the OpenAI API:

OPENAI_API_KEY="sk-..."

Instead of hardcoding the key, it is better to store it in files like an .env file or an operating-system environment variable, keeping credentials out of the source. For simplicity, we’ll store it in a constant OPENAI_API_KEY in a configuration file, config.py.

3.4. Configuration

Centralized constants in config.py clarify model names, storage directories, and text-splitting parameters:

OPENAI_API_KEY = "sk-..."
openai.api_key = OPENAI_API_KEY
GPT_MODEL = "gpt-4-0613"
EMBEDDING_MODEL = "text-embedding-ada-002"
VECTOR_DIR = "../vector_store"
CHUNK_SIZE = 1000
CHUNK_OVERLAP = 100
ARTICLES_CSV = "../docs/articles.csv"
PDF_DIR = "../docs/"

Here:

• GPT_MODEL selects the chat completion model. We opted for GPT-4-0613 in this tutorial;
• EMBEDDING_MODEL sets the vector-embedding model, which translates text into high-dimensional vectors;
• VECTOR_DIR names the folder where FAISS stores the vector index for fast retrieval;
• CHUNK_SIZE and CHUNK_OVERLAP drive the sliding-window tokenizer, ensuring that text near a boundary stays intelligible in adjacent chunks;
• PDF_DIR holds the full-text PDFs that supply rich contextual information;
• ARTICLES_CSV contains structured metadata: title, author, publication, and file name referencing those PDFs;
• TOP_K fixes the number of most-similar chunks that feed into each ChatGPT prompt, balancing context width against token limits.

4. Loading and Preparing Domain Data

Now, we’re ready for data ingestion, vector indexing, and prompt-answering logic.
We use both CSV and PDF files to demonstrate multi-source RAG capabilities: the CSV provides structured metadata (titles, categories, reading times) for quick filtering and categorization, while PDFs contain the full article content for detailed technical explanations.

4.1. Loading Structured Data

First, we transform CSV entries (articles.csv) into text chunks:

raw_chunks: list[str] = []
metas: list[dict] = []
art_df = pd.read_csv(cfg.ARTICLES_CSV)
for _, row in art_df.iterrows():
    payload = (
        f"Article ID: {row['article_id']}\n"
        f"Title: {row['title']}\n"
        f"Category: {row['category']}\n"
        f"Reading time: {row['reading_time_minutes']} min\n"
        f"Summary: {row['summary']}"
    )
    raw_chunks.append(payload)
    metas.append({"source": "articles.csv", "article_id": row['article_id']})

Rather than embedding raw CSV rows, we reformat structured data into narrative mini-paragraphs. This transformation enhances semantic matching by providing natural language context that embedding models can better understand. Each record maintains metadata references to enable source attribution in the chatbot’s responses.

4.2. Incorporating Unstructured Content

Next, we process PDF documents:

for pdf_path in Path(cfg.PDF_DIR).glob("*.pdf"):
    text = pdf_to_text(pdf_path)
    raw_chunks.append(text)
    metas.append({"source": pdf_path.name})

The pdf_to_text utility extracts raw text from every page of a PDF, ensuring we capture all relevant content. This function leverages PyPDF2 to handle the extraction.

By joining the extracted text with newlines, we maintain logical separation between pages while creating a consolidated document that can be further processed.

4.3. Semantic Chunking Strategy

To facilitate effective retrieval, we need to break large documents into smaller, semantically cohesive parts:

splitter = RecursiveCharacterTextSplitter(
    chunk_size = cfg.CHUNK_SIZE,
    chunk_overlap = cfg.CHUNK_OVERLAP
)
chunks, chunk_meta = [], []
for txt, meta in zip(raw_chunks, metas, strict=True):
    pieces = splitter.split_text(txt)
    chunks.extend(pieces)
    chunk_meta.extend([meta] * len(pieces))

Here, we employ LangChain’s RecursiveCharacterTextSplitter with the following configuration:

• CHUNK_SIZE = 1000 (characters) is a target guideline rather than a hard limit. The RecursiveCharacterTextSplitter attempts to break text at natural boundaries (paragraphs, sentences, then words) while staying close to this target. If a single sentence exceeds 1000 characters, it will be kept intact to preserve semantic meaning, potentially creating a chunk larger than the target size.
• CHUNK_OVERLAP = 100 means adjacent chunks will have overlapping content, where the last 100 characters of one chunk are the first 100 characters of the next one. This overlap ensures that sentences or concepts spanning chunk boundaries aren’t lost, maintaining semantic continuity across the dataset.

The splitter’s recursive nature means it tries multiple splitting strategies in order of preference: first by paragraphs, then by sentences, then by words, and finally by characters if necessary. This approach prioritizes semantic coherence over strict size limits, ensuring chunks remain meaningful and contextually complete.

For every chunk, we maintain its corresponding metadata, establishing the links between vector embeddings and their sources.

5. Embeddings and Vector Indexing with FAISS

Effective RAG relies on accurate and fast information retrieval. We achieve this by converting textual information into numerical vector representations called embeddings. Then, we search the vector database to find the best-matching vectors for our query.

In this tutorial, we’ll use FAISS to perform semantic searches rapidly.

5.1. Generating Embeddings

Embeddings translate textual content into dense vectors that capture the semantic meaning of the text.

In the ideal case, semantically related pieces of text produce embeddings close to each other in vector space.

We use OpenAI’s text-embedding-ada-002 model because it is efficient and suitable for generating precise embeddings that aid in accurate semantic search.

Here’s how we generate embeddings from textual chunks:

embeds = []
for piece in chunks:
    embedding_response = client.embeddings.create(
        model=cfg.EMBEDDING_MODEL,
        input=piece
    )
    embeds.append(embedding_response.data[0].embedding)
embeds_np = np.array(embeds, dtype="float32")

Each embedding vector has 1,536 dimensions, which is a balance between capturing a rich variety of semantic nuances and remaining computationally efficient. Each of those 1,536 slots represents a learned feature of the text (e.g., topic, tone, entities), so semantically similar chunks end up as nearby points in this high-dimensional space.

5.2. Building and Persisting the FAISS Index

Once we have embeddings for our document chunks, the next step is constructing a FAISS vector index. FAISS allows rapid searching of these high-dimensional embedding vectors, efficiently finding semantically similar content.

Here’s how we create and save the FAISS index:

index = faiss.IndexFlatL2(len(embeds_np[0]))
index.add(embeds_np)
Path(cfg.VECTOR_DIR).mkdir(parents=True, exist_ok=True)
faiss.write_index(index, os.path.join(cfg.VECTOR_DIR, "baeldung.idx"))
with open(os.path.join(cfg.VECTOR_DIR, "chunks.pkl"), "wb") as f:
    pickle.dump({"texts": chunks, "meta": chunk_meta}, f)

The above ingestion process must be completed before running the chatbot. So, we first execute python src/ingest.py to build the FAISS index and process all documents in our knowledge base. This creates the baeldung.idx file and chunks.pkl metadata that the chat_round() function depends on.

6. Retrieving Context with Semantic Search

Upon receiving a user query, the chatbot retrieves relevant context from the indexed embeddings. We do this by transforming the query into an embedding vector and searching for semantically similar document chunks using FAISS.

Here’s our implementation:

def retrieve_context(question, k=3):
    q_emb = client.embeddings.create(
        model=cfg.EMBEDDING_MODEL,
        input=question
    ).data[0].embedding
    D, I = index.search(np.array([q_emb], dtype="float32"), k)
    relevant_chunks = []
    for i in I[0]:
        if i == -1:
            continue
        relevant_chunks.append({"text": all_texts[i], "meta": all_meta[i]})
    return relevant_chunks

This function embeds the query, performs a similarity search against the FAISS index, and returns the most relevant chunks along with their metadata:

• k=3: The number of most similar chunks to retrieve. This parameter controls how much context we provide to ChatGPT – too few chunks might miss relevant information, while too many could exceed token limits or introduce noise
• D, I = index.search(): FAISS returns two arrays: D contains the distances (similarity scores) between the query and each retrieved chunk, while I contains the indices of the most similar chunks in our original dataset. Lower distances indicate higher similarity
• np.array([q_emb], dtype=”float32″): The query embedding must be converted to a NumPy array with float32 precision to match the data type used when building the FAISS index. The embedding is wrapped in brackets [q_emb] because FAISS expects a 2D array where each row represents a query vector, even when searching with a single query
• if i == -1: FAISS returns -1 when fewer than k similar items are found, which we skip to avoid indexing errors

The results provide the context for the chosen GPT model, enabling the chatbot to answer user queries accurately, even if the topic wasn’t explicitly covered in ChatGPT’s training data.

While FAISS is efficient and effective for smaller datasets, larger or dynamically updated datasets might benefit from a persistent vector database such as Pinecone, Weaviate, or Chroma. They are suitable for production-level deployments.

In a Java-based context, Spring AI integrates with these vector databases, providing similar retrieval capabilities tailored to enterprise applications.

7. Processing User’s Query

Finally, we send the chunks and their metadata to ChatGPT for a textual answer.

Let’s define our main function chat_round, which will handle a query step by step:

def chat_round(user_question: str, history: Optional[list[dict]] = None) -> str:
    history = history or []
    relevant_chunks = retrieve_context(user_question)
    context_text = ""
    for chunk in relevant_chunks:
        meta = chunk["meta"]
        source = meta.get("source", "Unknown")
        article_id = meta.get("article_id", "")
        context_text += f"[Source: {source}"
        if article_id:
            context_text += f", Article ID: {article_id}]"
        else:
            context_text += "]"
        context_text += f"\n{chunk['text']}\n\n"
    system_content = (
        "You are customer-support assistant. Answer questions about "
        "Spring, Java, and web development. Use the following articles "
        "as context for your answer.\n\n"
        f"Knowledge Base Context:\n{context_text}\n\n"
        "If the context doesn't contain relevant information, use your general knowledge "
        "but prioritize the context's perspective."
    )
    system_msg = {"role": "system", "content": system_content}
    history_msgs = history.copy()
    history_msgs.insert(0, system_msg)
    history_msgs.append({"role": "user", "content": user_question})
    
    resp = client.chat.completions.create(
        model=cfg.GPT_MODEL,
        messages=history_msgs,
        temperature=0
    )
    return resp.choices[0].message.content

When a user asks a question, our system retrieves relevant articles and documentation from our knowledge base. This information is injected into the prompt as context, allowing the model to ground its responses in accurate, domain-specific knowledge.

7.1. Using the Chat Function

Once the FAISS index is built and the chat function is defined, we can use our RAG-powered chatbot. Here’s an interactive loop:

def main():
    print("Technical Support Chat (type 'quit' to exit)")
    conversation_history = []
    
    while True:
        user_input = input("\nUser: ").strip()
        if user_input.lower() == 'quit':
            break
            
        response = chat_round(user_input, conversation_history)
        print(f"Support: {response}")
        
        # Maintain conversation history
        conversation_history.append({"role": "user", "content": user_input})
        conversation_history.append({"role": "assistant", "content": response})
if __name__ == "__main__":
    main()

Let’s run the cli.py file to start our chatbot in an interactive mode. We can query it with some information about our domain  to get a response:

User: What is a green thread ?

We’ll get the following or a similar response:

A green thread refers to a type of thread that is scheduled by a runtime library or virtual machine (VM) instead of natively by the underlying operating system. Green threads emulate multithreaded environments without relying on any native OS capabilities, and they are managed in user space instead of kernel space, allowing for more threads to be created as compared to native system threads. Java used green threads in its early days, but modern versions of Java use native OS threads instead.

While the implementation above provides a solid foundation, several optimization strategies can significantly enhance accuracy and performance.

We can combine semantic vector search with traditional keyword-based retrieval methods using BM25 (Best Matching 25). This hybrid approach captures both semantic similarity and exact keyword matches, which is particularly valuable for technical queries with precise terminology. Libraries like Elasticsearch or Weaviate provide built-in hybrid search capabilities, while custom implementations can use rank-bm25 alongside our existing FAISS index.

Another option is a two-stage retrieval process with reranking. After retrieving initial candidates, we can apply cross-encoder models like sentence-transformers/ms-marco-MiniLM-L-6-v2 to rerank results based on query-document relevance scores.

Additionally, query expansion techniques can broaden retrieval coverage by leveraging ChatGPT to generate multiple query variations, then retrieving context for each variation and deduplicating results. Combined, these approaches often yield 10-20% improvement in retrieval accuracy and double the likelihood of finding relevant context for complex user questions.

8. Conclusion

In this article, we built a ChatGPT-powered chatbot that can answer questions using a custom knowledge base. We walked through ingesting documents, generating embeddings, and storing them in a FAISS vector index. Using Retrieval Augmented Generation (RAG), our chatbot finds relevant context for each query and uses ChatGPT to produce a grounded answer.

This approach provides a blueprint for building AI assistants specific to custom data. We can extend it by adding more document types, implementing memory for conversations, history summary, and other features to improve and tailor the assistant. As usual, all code is available over on GitHub.

     

Related Stories

• The Mixture-of-Experts ML Approach
• Download a Hugging Face Model
• Different Text Summarization Techniques Using Langchain

 

1. Introduction

Voice over Internet Protocol (VoIP) allows voice calls over the internet, offering flexibility and cost savings for businesses. However, this convenience comes with security risks. VoIP systems are frequent targets for hackers aiming to intercept calls, commit fraud, or disrupt services.

In this tutorial, we’ll outline the most common types of VoIP attacks and provide practical countermeasures to help protect the communications infrastructure.

2. How VoIP Works

VoIP transforms traditional voice communication by converting sound signals into digital data packets. When someone speaks into a VoIP device or application, their voice is digitized and organized into packets. These packets are then transmitted over the Internet or private IP networks to the recipient, where they are reassembled and converted back into audio:

While VoIP offers cost savings and flexibility, it introduces security challenges.

Because VoIP relies on open internet protocols and often travels across public networks, it’s vulnerable to packet interception, identity spoofing, and service disruption. Without strong encryption and authentication, voice data and signaling information can be intercepted or altered. So, it’s essential to secure each component and communication channel.

3. Common Types of VoIP Hacking

VoIP systems are vulnerable to various cyberattacks due to their use of open standards and Internet-based protocols. So, below are the most prevalent attack types, including newer threats like SPIT and TDoS.

3.1. Eavesdropping

Eavesdropping occurs when attackers intercept voice packets traveling across the network. This is especially problematic on shared or public networks. If these packets are unencrypted, anyone with access to the network can capture and listen to calls using tools like Wireshark or specialized VoIP sniffers:

In VoIP systems, the lack of encryption for both SIP signaling and RTP audio streams leaves conversations exposed. Attackers can gather sensitive information such as login credentials, business plans, or customer data. This type of attack is typically passive, making it hard to detect without constant monitoring.

3.2. SIP Registration Hijacking

SIP (Session Initiation Protocol) handles the signaling required to establish and manage VoIP calls. Attackers can hijack SIP registration by sending a spoofed registration request to the SIP server using stolen or guessed credentials.

Once registered, the attacker can impersonate a legitimate user, receiving incoming calls and making outgoing calls on their behalf. This allows attackers to conduct fraud, intercept conversations, or manipulate call routing, potentially causing reputational and financial damage.

3.3. Call Redirection

Call redirection exploits vulnerabilities in VoIP systems to silently reroute calls through unauthorized or malicious intermediaries. The attacker can configure the system to forward calls to a server under their control.

Attackers can record, modify, or redirect these calls to other destinations. Victims usually remain unaware of the redirection, which makes this a particularly insidious form of surveillance or fraud. Attackers often combine it with spoofing techniques to further conceal their involvement.

3.4. Toll Fraud

Toll fraud targets VoIP systems by exploiting weaknesses to make unauthorized premium-rate or international calls. Attackers often gain access through unsecured interfaces, weak credentials, or compromised voicemail systems.

After gaining access, attackers program the system to auto-dial costly numbers, often during non-business hours, to avoid detection. The financial impact can be significant, with victims discovering the breach only after receiving inflated bills.

3.5. Voicemail Hacking

Voicemail systems are often overlooked in security planning. Many users fail to change default PINs or use weak passwords, making voicemail accounts easy targets for attackers.

By exploiting these weaknesses, attackers can listen to sensitive messages, reset user passwords, or use voicemail to impersonate the target. Also, since voicemail systems are typically less monitored than live traffic, breaches can persist for extended periods without detection.

3.6. Caller ID Spoofing

In caller ID spoofing, attackers manipulate the information that appears on the recipient’s caller ID display. Phishing attacks commonly use this tactic, allowing attackers to impersonate banks, companies, or trusted contacts.

Spoofing is easy in VoIP due to weak verification mechanisms in SIP headers. Attackers exploit this by launching social engineering campaigns that deceive users into revealing sensitive information or performing risky actions, such as transferring funds or clicking malicious links.

3.7. Man-in-the-Middle (MitM) Attacks

MitM attacks involve intercepting communication between two parties without their knowledge. In VoIP, this usually occurs when unencrypted traffic passes through shared or public networks.

Attackers can listen, record, or even modify conversations in real-time. By placing themselves between endpoints, they can alter call content or inject commands, causing reputational and operational harm. This is particularly dangerous in environments lacking TLS and SRTP protections.

3.8. SPIT

SPIT is the VoIP equivalent of email spam. Attackers flood systems with unwanted prerecorded calls, often pushing advertising or scams. Unlike email, voice spam is more disruptive due to its real-time and attention-demanding nature.

Excessive SPIT can overwhelm voicemail boxes, tie up lines, and degrade user experience. Attackers use auto-dialers and botnets to initiate thousands of calls, exploiting the openness of SIP endpoints that lack rate limiting or CAPTCHA protections.

3.9. TDoS

TDoS attacks aim to overwhelm VoIP servers or phone lines with traffic to disrupt voice services. This can render entire systems unusable, affecting customer support, emergency services, and internal communication.

Attackers typically use automated tools to flood SIP endpoints or call queues with fake traffic, consuming system resources. Sometimes, TDoS is used as a diversion for larger attacks or extortion schemes, where attackers demand ransom to stop the attack.

4. VoIP Security Best Practices and Countermeasures

VoIP security requires a multi-layered approach to protect against threats like eavesdropping, spoofing, and fraud. Key areas include encryption, authentication, access control, network defenses, and ongoing monitoring.

4.1. Encryption and Protocol Security

TLS (Transport Layer Security) should be used to encrypt SIP signaling, while SRTP (Secure Real-Time Transport Protocol) secures voice streams. These protocols prevent interception and tampering of both call setup and audio data.

Encryption uses specialized algorithms to perform cryptographic operations on plaintext data, applying an encryption key to transform it into a secure format.

All VoIP components must support and enforce encrypted communication. Certificates and encryption settings should be properly managed to avoid configuration issues and ensure protocol integrity.

4.2. Authentication and Access Control

Strong, regularly updated credentials reduce the risk of SIP hijacking and unauthorized access. Moreover, multi-factor authentication adds further protection, especially for administrative interfaces and voicemail systems.

Features not required for operations, such as international dialing or call forwarding, should be disabled. Access control policies must be based on roles, with users granted only the permissions necessary for their tasks.

4.3. STIR/SHAKEN and Caller ID Protection

The STIR/SHAKEN protocol helps verify caller identity using digital certificates, mitigating caller ID spoofing and supporting trust in inbound communications.

Adoption of this framework by service providers enhances call validation. Thus, additional protections, including caller reputation databases and filtering tools, can reduce exposure to fraudulent calls.

4.4. Network and Perimeter Security

Segmenting VoIP traffic using VLANs or dedicated subnets enhances security by isolating voice data from other services. This limits lateral movement in the event of a breach.

SIP-aware firewalls and Session Border Controllers (SBCs) provide inspection, policy enforcement, and threat filtering at the network edge. These tools also help obscure internal infrastructure from external entities.

4.5. Monitoring and Maintenance

Continuous monitoring of logs, call patterns, and access events supports early detection of suspicious activity. Alerts and analytics tools assist in identifying anomalies in real time.

Routine patching of VoIP software and firmware is essential to address known vulnerabilities. Security audits, permission reviews, and incident response testing contribute to a resilient environment.

5. Case Studies and Real-World Examples

One significant example involves toll fraud in VoIP systems, where attackers gained unauthorized access to a private branch exchange (PBX) and routed international and premium-rate calls through it. Victims were billed heavily for these calls, often only discovering the fraud after receiving exorbitant phone bills. This type of exploitation typifies how weak authentication and voicemail misconfiguration can be leveraged for financial gain.

This case highlights why enforcing strong credentials, restricting outbound calling, and monitoring call patterns are crucial. Moreover, inadequate safeguards in VoIP systems expose organizations to severe financial loss and operational disruption, particularly when attackers exploit voicemail or management interfaces to launch automated outbound dialing campaigns.

6. AI and VoIP

As VoIP use expands, threats also increase, ranging from traditional risks like vishing and insecure mobile apps to new dangers brought by AI. Additionally, cloud-based systems and remote work widen the attack surface, which demands updated security strategies.

6.1. How AI Enhances Security

AI strengthens VoIP defenses by enabling smarter detection and response. For example, machine learning models analyze call patterns, identify anomalies, and flag suspicious behavior in real time. Moreover, AI systems detect spoofed traffic, block spam calls, and adapt to evolving threats faster than static rule-based systems. Behavioral analysis adds another layer by learning how users typically communicate, which helps detect impersonation or unauthorized use more easily.

Additionally, AI improves monitoring efficiency by reducing the workload on human analysts while increasing accuracy. Consequently, these capabilities enable organizations to respond quickly to fraud attempts and system misuse.

6.2. How AI Increases Risk

While AI defends, it also arms attackers with powerful tools. Deepfake voice technology can clone speech patterns and tones, allowing malicious actors to impersonate executives, colleagues, or service providers with alarming realism. These synthetic voices can bypass voice authentication systems and manipulate targets during calls.

Additionally, AI-driven phishing bots can conduct large-scale phishing campaigns using lifelike speech, tailored responses, and context-aware dialogue, making scams more convincing and harder to filter. Combined with caller ID spoofing, these tactics undermine trust in voice communication.

As VoIP systems evolve, security teams must prepare for attacks that are not only technical but also psychological, driven by AI’s ability to mimic human behavior.

7. Conclusion

In this article, we explored the common types of VoIP attacks alongside practical countermeasures like encryption, strong authentication, and network segmentation.

VoIP technology revolutionizes communication by enabling voice calls over the internet, offering flexibility and cost savings. However, it also introduces security risks such as eavesdropping, toll fraud, and session hijacking.

     

Related Stories

• Introduction to Differential Privacy in Deep Learning Models
• What Is CSRF?
• Network Time Protocol: Security and Authentication

 

1. Introduction

In training deep learning models, we use vast amounts of available data, including sensitive information, such as contact details and other personal data. We can mask the sensitive data with traditional anonymization techniques. However, these methods aren’t foolproof, as hackers can decipher anonymized data using linkage attacks.

Differential privacy is an emerging technique that solves this problem without the bottlenecks of traditional anonymization methods.

In this tutorial, we’ll introduce differential privacy, explain how it works, and explore its applications in training deep learning models.

2. Problem Statement

Let’s say we record calls to an emergency response unit. During a routine day, we receive hundreds of calls, collect data, and reroute this information to the emergency services. At the end of the workday, we have a dataset of hundreds of rows.

Now, let’s say we want to build a deep learning model to analyze why certain types of emergencies were recorded in that region within a specific period. This model will access our callers’ records, including Personally Identifiable Information (PII). PII can include our callers’ names, addresses, hospital records, and ages. Traditionally, we’d anonymize this information by obscuring sensitive information or removing the fields entirely.

However, traditional anonymization isn’t enough. Attackers can cross-reference anonymized records with external, publicly available data to identify our callers.

Differential privacy protects against this kind of privacy breach by ensuring that an attacker analyzing our trained model can’t determine whether or not a specific individual’s data was included in our training set. As a result, the attacker can’t reliably infer sensitive information about any targeted person by reverse-engineering the model’s behavior.

With differential privacy, we split the dataset among several models and introduce controlled noise to the models’ training process. The controlled noise during the training obscures the sensitive data. This method of privacy ensures that our model’s analysis remains unchanged even if we add or remove a single record.

3. How Does Differential Privacy Work?

Differential privacy protects individuals’ sensitive data in a dataset by ensuring that the output of any model analysis does not significantly change if one data point is added or removed. We achieve this by introducing controlled noise or randomness into the model’s training process.

Continuing our previous example, we can obscure sensitive data by passing our recorded responses through an algorithm that adds a controlled measure of noise. For instance, we can slightly alter the field that holds the patients’ ages or substitute the addresses with a fictional street or number. Introducing such noise ensures that any record has a negligible impact during training.

In doing so, we can still utilize this data to train our model without compromising security or relevance. Think of differential privacy on data as tuning a device. If we tune to the exact frequency of a radio station, we hear the sounds and music clearly. However, if we add a bit of static noise, we can still hear the sound, but we can’t distinguish any one instrument or identify which person is talking.

3.1. How Is Differential Privacy Calculated?

Generally, the idea behind differential privacy is that the probability distribution of a model’s output should remain nearly the same even if we add or remove an individual’s record from the dataset.

Before going to the formula, let’s define the terms:

• : the mechanism or algorithm (such as a noise-adding function) including the training plus noise

• : contains all the data, including the individual’s record

• : dataset with all the data except the individual’s record (one record missing)

• : a possible set of outputs from the mechanism. This refers to all possible models or outputs when the trained model is given a specific input, which can be used to test whether an individual’s data was included in the training set. For example, an attacker might input a record and observe the model’s output prediction, expecting the output to differ if the record was part of the training data

• : the probability that applying the mechanism to dataset results in an output within

• : the privacy parameter (also called the privacy budget), controlling the trade-off between privacy and accuracy

Mathematically, we say provides the -differential privacy if:

This means that the likelihood of output doesn’t change much whether we add or remove a single individual’s data. The smaller is, the stronger the privacy guarantee (due to larger noise), although this typically means our model may have reduced accuracy.

An -privacy has an additional parameter, :

It’s the probability of violating the privacy guarantee. So, if we set , we get the so-called pure differential privacy.

4. Challenges With Differential Privacy

One of the major challenges we face when implementing differential privacy is the loss of accuracy, which occurs when we introduce too much noise to protect privacy, thereby compromising the accuracy of the student model.

A higher privacy budget results in lower noise. However, the trade-off is weaker privacy. A lower privacy budget results in high noise levels and stronger privacy, but it also leads to misclassification more often.

Another challenge is the computational overhead due to noise.

Then, there’s the challenge of tuning . Typically, industries that handle highly sensitive data, such as healthcare and finance, use stricter privacy budgets.

To address these issues, we can:

• Use larger datasets to offset the impact of noise

• Optimize batch sizes and gradient clipping parameters to improve efficiency

• Employ techniques such as transfer learning, where we first train models on publicly available data before fine-tuning them with differential privacy

5. Implementing a Differential Privacy Framework: the PATE Example

Let’s examine a real-world example where we train models using the Private Aggregation of Teacher Ensembles (PATE) framework. The PATE framework is one of the ways we can implement differential privacy in training ML models. It works well in distributed training systems.

Suppose we have healthcare data shared among different hospitals in a city. The data involves diagnoses based on patient information from various doctors. Here’s an illustration of the PATE framework for this scenario:

PATE splits the dataset into non-overlapping subsets. Then, the independent teacher models learns directly from these data subsets.

When we want to label a new data point during training, the teacher models vote, and controlled noise is added to each vote. Then, we label the data point with the noisy majority vote, which is then used to train the student model. This way, the student model doesn’t interact with the sensitive data.

5.1. The Teacher Models

In the PATE framework, we always split the sensitive data into non-overlapping chunks and assign them to teacher models. Each teacher model fits its slice learning patterns without access to the complete set.

Looking back at our healthcare scenario, let’s say we have 3,000 X-ray images of lung cancer patients from two hospitals: 1,500 from Hospital A and 1,500 from Hospital B. Using the PATE framework, we shuffle the images and then split them into three non-overlapping groups of 1,000 images each. We train Teacher 1 using the first 1,000 images as input data, Teacher 2 on the following 1,000 images, and Teacher 3 on the final 1,000 images. Shuffling before splitting should make each group representative.

5.2. Introducing Noise

Now, it’s time to get the teachers’ outputs. Each teacher model makes a prediction when we need to label a new data point (such as a new X-ray image). The teacher models vote on the correct label. For example, if two out of our three teacher models vote “cancer” and the third votes “healthy,” the majority vote is “cancer.”

Before the votes are used to label data for the student model, we add noise to the votes through our function. This noise prevents anyone from deducing which teacher model, and by extension, which subset of data, influenced the outcome. The label decided by the noisy majority vote becomes the training label for the student model.

If we have a collection of teacher vote counts for each of the possible labels, then, for each , we sample noise from a chosen noise distribution, which can either be Laplace or Gaussian (calibrated to the privacy budget), and add it to . Then, the noisy version of that vote, , is:

For example, we can sample from a Laplace distribution calibrated to :

The output with the highest noisy count () is selected as the label.

5.3. Our Public Student Models

Our student model, which will eventually be deployed publicly, learns from public, non-sensitive data labeled by noisy votes.

This method is effective because our student model doesn’t have direct access to patient data, resulting in a privacy-compliant and accurate model.

6. When to Use Differential Privacy?

Although differential privacy is rapidly being adopted in the data ecosystem, here are the use cases where it is particularly important:

Protecting sensitive data is becoming increasingly important as companies and organizations collect more user information. Differential privacy offers a more effective approach to achieving this than traditional anonymization methods.

Other frameworks are also gaining traction or are widely adopted, such as Differentially Private Stochastic Gradient Descent (DP-SGD), which is supported in libraries like TensorFlow Privacy and PyTorch Opacus. These frameworks offer different approaches to implementing differential privacy, especially in large-scale deep learning models.

7. Conclusion

In this article, we explained differential privacy as a new and improved method for protecting sensitive data during model training. We also discussed how it works, focusing on the PATE framework. Lastly, we explored the challenges of differential privacy and its various use cases.

Differential privacy is a framework that ensures our data remains safe even when it is used to train machine learning models.

     

Related Stories

• Types of VoIP Hacking and Countermeasures
• What Is the Gradient Norm?
• What’s the Difference Between ‘transform’ and ‘fit_transform’ in sklearn?

 

1. Introduction

Deep learning has opened up new possibilities in the world of creativity by enabling computers to recognize images and generate art. One of the techniques in this space is the neural style transfer, a deep learning technique, allowing creators and users to blend the content of an image with the artistic style of another.

In this tutorial, we’ll learn how to transfer an artist’s style to an image using TensorFlow and a pretrained VGG16 model. We’ll extract content and style features from an Expressionism painting style called “Scream” by Edvard Munch, define a loss function that guides stylization, and optimize the image to transfer style to the image of an owl.

2. Configuration and Setup

Let’s begin by defining the key parameters for the style transfer process, including the image dimensions, style and content weight, and number of iterations.

#import libraries and modules
from __future__ import print_function
import time
from PIL import Image
import numpy as np
from keras import backend
from keras.models import Model
from keras.applications.vgg16 import VGG16
from scipy.optimize import fmin_l_bfgs_b
import imageio
#define parameters
CONTENT_IMAGE_PATH = './image_to_style.jpg'
STYLE_IMAGE_PATH = './artistic_image.jpg'
IMG_HEIGHT = 512
IMG_WIDTH = 512
STYLE_WEIGHT = 1e2  
CONTENT_WEIGHT = 1e3
TOTAL_VARIATION_WEIGHT = 1e-6
NUM_ITERATIONS = 50

Let’s discuss the key parameters:

• STYLE_WEIGHT: defines how strongly the artistic style is applied to the image
• CONTENT_WEIGHT: establishes how much of the original image structure is preserved
• TOTAL_VARIATION_WEIGHT: adds smoothness, reduces noise

3. Image Preprocessing

Before passing images to our model, we need to ensure that we convert them into the right format that the model will understand. The following functions help with loading the image, preprocessing based on the VGG16 requirements, and postprocessing to display output:

3.1. Load and Process Image

The function below loads the image from the input file path using the PIL library and resizes the image to fit the dimensions as specified in the configuration above. This is because VGG16 requires a fixed input size:

def load_and_process_image(path):
    img = Image.open(path).resize((IMG_WIDTH, IMG_HEIGHT))
    img = tf.keras.preprocessing.image.img_to_array(img)
    img = np.expand_dims(img, axis=0)
    return vgg16.preprocess_input(img)

The load_and_process_image() function returns the resized image, formatted as a batch, which is now ready to be passed into the model.

3.2. Deprocess Image and Show Image

The deprocess function reverses the preprocessing we applied to the image before feeding it to the model by adding back the pixel value and converting it into a displayable format:

def deprocess_image(img):
    img = img.reshape((IMG_HEIGHT, IMG_WIDTH, 3))
    img[:, :, 0] += 103.939
    img[:, :, 1] += 116.779
    img[:, :, 2] += 123.68
    img = img[:, :, ::-1]
    return np.clip(img, 0, 255).astype('uint8')
def show_image(img):
    plt.imshow(img)
    plt.axis('off')
    plt.show()

The deprocess_image() function reverses the preprocessing previously applied by the load_and_preprocess_image() function. It first reshapes the image into standard height format, restores the pixel values, and clips all the pixel values to a valid range, converting the array to uint8 type, making it displayable. On the other hand, the show_image() function displays the deprocessed image.

Here’s a sample of our input image:

Here’s a sample of our artistic image:

4. Building the Feature Extraction Model

As mentioned earlier, the VGG16 model, which is pre-trained on ImageNet, is used for the style transfer. We selectively extract features from intermediate layers for capturing content and style:

def get_model():
    vgg = vgg16.VGG16(include_top=False, weights='imagenet')
    vgg.trainable = False
    style_layers = ['block1_conv1', 'block2_conv1', 'block3_conv1', 'block4_conv1']
    content_layers = ['block4_conv2']
    outputs = [vgg.get_layer(name).output for name in (style_layers + content_layers)]
    return Model(inputs=vgg.input, outputs=outputs), style_layers, content_layers

In the above function, we defined the model object. Convolutional layers like block1_conv1 to block4_conv1 capture the texture and brushstroke patterns, and the content layer block4_conv2 preserves the spatial structure. These layers combine into a new model to display the required output.

5. Style and Content Representations

Now, that we’ve built the model, the next step is to extract the style and content representation from the respective images. Let’s compute the Gram matrix for the style to capture the correlations between feature maps and summarize the texture:

def gram_matrix(tensor):
    result = tf.linalg.einsum('bijc,bijd->bcd', tensor, tensor)
    input_shape = tf.shape(tensor)
    num_locations = tf.cast(input_shape[1] * input_shape[2], tf.float32)
    return result / num_locations
def get_feature_representations(model, content_image, style_image, style_layers, content_layers):
    style_outputs = model(style_image)
    content_outputs = model(content_image)
    style_features = [gram_matrix(output) for output in style_outputs[:len(style_layers)]]
    content_features = [output for output in content_outputs[len(style_layers):]]
    return style_features, content_features

We use the gram_matrix() in the get_feature_representation() function to extract and store both the style and content features from the input images.

6. Defining the Loss Function

The loss function is the heart of style transfer. It ensures that the generated image mimics the texture of the artistic image. It also ensures that it preserves the structure of the content image and regularizes the image to reduce noise and artifacts:

def compute_loss(model, loss_weights, init_image,
  gram_style_features, content_features, style_layers, content_layers):
    style_weight, content_weight = loss_weights
    model_outputs = model(init_image)
    style_output_features = model_outputs[:len(style_layers)]
    content_output_features = model_outputs[len(style_layers):]
    style_score = 0
    content_score = 0
    for target_style, comb_style in zip(gram_style_features, style_output_features):
        style_score += tf.reduce_mean(tf.square(gram_matrix(comb_style) - target_style))
    for target_content, comb_content in zip(content_features, content_output_features):
        content_score += tf.reduce_mean(tf.square(comb_content - target_content))
    style_score *= style_weight / len(style_layers)
    content_score *= content_weight / len(content_layers)
    total_variation = tf.image.total_variation(init_image) * TOTAL_VARIATION_WEIGHT
    loss = style_score + content_score + total_variation
    return loss, style_score, content_score, total_variation

The compute_loss() function evaluates how well the current image (init_image()) balances the desired style and content features. First, it passes the init_image() through the model to extract style and content features, and then it calculates the style loss by comparing the Gram matrices of the current image style features with that of the target image.

The output of the compute_loss() function returns:

• style_score: this measures how much the generated image imitates the texture of the style image
• content_score: this measures how much the generated image preserves the structure of the content image
• total_variation_score: this regularizes the image to reduce noise

7. Optimization and Stylization

Now that we have computed the loss and have a good score across the compute_loss() output, let’s define an optimization loop that iteratively updates the input image and minimizes the combined loss. Here we use TensorFlow’s GradientTape() to compute gradients and apply changes using the Adam’s optimizer:

@tf.function()
def compute_grads(cfg):
    with tf.GradientTape() as tape:
        loss = compute_loss(**cfg)[0]
    return tape.gradient(loss, cfg['init_image']), loss

Here’s a breakdown of the compute_grade() function:

• @tf.function: compiles the function below it into a TensorFlow graph for faster execution.
• compute_loss(): computes the gradient loss based on the input image

Now, we write the function to perform the artistic transfer. This function combines all the previous functions we’ve written, accepts the input and styled image, and transfers the artist’s style to the image based on a certain number of iterations:

def run_style_transfer(content_path, style_path, iterations=NUM_ITERATIONS):
    model, style_layers, content_layers = get_model()
    content_image = load_and_process_image(content_path)
    style_image = load_and_process_image(style_path)
    gram_style_features, content_features = get_feature_representations(
        model, content_image, style_image, style_layers, content_layers)
    init_image = tf.Variable(content_image, dtype=tf.float32)
    opt = tf.optimizers.Adam(learning_rate=5.0)
    best_loss, best_img = float('inf'), None
    cfg = {
        'model': model,
        'loss_weights': (STYLE_WEIGHT, CONTENT_WEIGHT),
        'init_image': init_image,
        'gram_style_features': gram_style_features,
        'content_features': content_features,
        'style_layers': style_layers,
        'content_layers': content_layers
    }
    print("Starting style transfer...")
    for i in range(iterations):
        grads, loss = compute_grads(cfg)
        opt.apply_gradients([(grads, init_image)])
        clipped = tf.clip_by_value(init_image, -127.5, 127.5)
        init_image.assign(clipped)
        if loss < best_loss:
            best_loss = loss
            best_img = init_image.numpy()
        print("Iteration {}, loss: {:.2e}".format(i + 1, loss.numpy().item()))
    final_img = deprocess_image(best_img)
    show_image(final_img)
    return final_img

Here’s what the function does:

• loads the VGG16 model and selects the relevant layer
• calls load_and_preprocess() to preprocess the content and style images
• captures the style and content details from the original images
• sets up the optimizer to adjust the image pixels
• repeatedly apply gradients to image to minimize loss
• tracks the best version of the image based on loss
• calls deprocess() to deprocess the image and display the final stylized image

Now let’s take a look at our stylized image output. Let’s run the next function to transfer the style of the Scream painting to our owl image:

stylized = run_style_transfer(CONTENT_IMAGE_PATH, STYLE_IMAGE_PATH)

Output image:

The above code performs neural style transfer by optimizing the input image to one image’s content with the style of another. At each step, the image is refined to match the desired style and content. The final stylized image is displayed after all iterations.

8. Conclusion

This article demonstrates the walkthrough of building an art style transfer program using deep learning techniques and tools like TensorFlow and the VGG16 model. We defined each step by breaking them down into functions from loading and preprocessing, feature extraction, computing loss, and style optimization loop.

The next step is to experiment further by trying out different layers, like realistic or vintage, adjusting the weights and iterations, and improvising on the output.

      

1. Introduction

In this tutorial, we’ll explore the concepts of gradient, divergence, and curl, learn the underlying math, and learn about their real-world applications.

2. Scalars, Vectors, Fields, and the Cartesian Coordinate System

In physics and math, quantities fall into scalars and vectors.

A scalar has only its magnitude (like time, mass, or temperature) while a vector includes both magnitude and direction, e.g., velocity or force.

Extending these to space, a field assigns values to every point in a region. Scalar fields provide a single value per point (e.g., room temperature), whereas vector fields assign direction and magnitude: imagine electromagnetic waves moving through the air.

To describe fields mathematically, we often use the Cartesian Coordinate System (CCS), which represents a 2D or 3D space with coordinates ( and in 2D and , , and in 3D). Vector fields are defined using unit vectors , , , corresponding to , , and directions:

3. The Del Operator in Vector Calculus

To analyze scalar and vector fields, we use a mathematical tool called the Del operator, denoted as (nabla). It acts like a vector differential operator.

In a Cartesian system, the Del operator is defined as:

This means that operates on functions by taking their partial derivatives with respect to , and . Depending on how we apply it, we get different insights into scalar and vector fields:

• Gradient measures the rate and direction of change in a scalar field
• Divergence tells us how much a vector field spreads out from or converges to a point.
• Curl captures the rotational tendency of a vector field .

4. The Concept of Gradient in a Scalar Field

Say you’re in a large building, looking for the strongest Wi-Fi signal. Since signal strength varies by location, it forms a scalar field, assigning a value (but not a direction) to every point.

Here’s the key question: how do we know which direction to walk in to get the strongest signal as quickly as possible? This is where the gradient comes in. It reveals two things: the direction in which the signal increases most rapidly, and how quickly that happens in that direction.

So, if at a spot with a weak signal, we should walk in the direction pointed to by the gradient of the signal.

4.1. Mathematical Formulation Using the Wi-Fi Analogy

Using the log-distance path loss model, we calculate how signal strength changes across space, and from there, compute the gradient to find the best direction for a stronger connection.

We begin with the formula for the signal strength at distance from the router:

Here, is the signal strength at reference distance , and is the path loss exponent (typically 2 to 4).

To understand how Wi-Fi signal strength varies across space, we calculate the gradient of the signal strength function :

Since the signal strength depends on distance , and depends on spatial coordinates , we apply the chain rule.

First, we compute the derivative of with respect to distance :

Since depends on , and on , we’ll need partial derivatives of w.r.t. for the chain rule:

.

By combining these, we get:

4.2. Worked Example

Suppose the router is at the origin (0, 0, 0), and we measure the signal at point (3, 4, 5). Given dBm, meter, and , we first find the distance:

Next, using the signal strength model:

We compute the spatial gradient to examine how the signal strength changes with respect to position. First, we calculate the partial derivative of with respect to :

Using the same method, we compute the and components of the gradient as well:

Let’s interpret these results.

4.3. Interpretation

Negative values mean the signal strength weakens as we move away from the origin, whereas positive values mean the signal strengthens as we approach the origin.

In our example, all the values are negative, and the most rapid drop occurs along the z-axis, indicating that vertical shifts affect the signal strength the most. To improve the connection, we should move toward the origin of the router.

Here’s a 3D figure showing the scalar field of the signal strength:

The corresponding gradient vectors are pointing towards the router:

The gradient of a scalar field points in the direction of steepest increase, and moving in the opposite direction leads to the fastest decrease. This is the idea behind the gradient descent algorithm (GDA), a key method in machine learning used to minimize loss functions.

5. Divergence in a Vector Field

Let’s imagine this: drop a positive charge in space, and electric field lines instantly radiate outward like invisible arrows bursting from a source. With a negative charge, those arrows collapse inward toward it. That’s divergence at play.

Divergence reveals how much a vector field, such as an electric field, spreads from a point (a source) or converges into it (a sink).

The following figure illustrates this behavior:

Mathematically, for a vector field , the divergence is given by:

This expression is the dot product of the del operator and the vector field in CCS.

When the divergence at a point is positive, the vector field behaves like a source at that specific location. If it’s negative, the point acts like a sink. And when the divergence is zero, the field is locally balanced there.

Let’s illustrate this concept.

5.1. A Smooth Polynomial Field Vector

Let’s consider a vector field . Let’s find the divergence at the point (1, -2, 3).

We apply the divergence formula component-wise:

Let’s compute each term:

Now plug in the point :

So, the divergence at this point is 2, which means the field is acting like a source there.

6. The Curl of a Vector Field

Let’s say we’re beside a river and place a small paddlewheel in the water. If the water pushes evenly from all directions, the wheel stays still. However, if one side experiences a stronger flow, the wheel spins. That spin reflects the curl: it measures how much a vector field “swirls” around a point.

Mathematically, curl captures the field’s local rotation. For a vector field , the curl is defined as:

Expanding this determinant, we get:

A zero curl means no rotation, i.e., the flow is smooth and straight. In contrast, a nonzero curl reveals spinning around the corresponding axis.

To determine the direction of that curl vector, we apply the right-hand rule. We point the fingers of our right hand in the direction of the flow that’s curving around, and the thumb will point in the direction of the curl:

The curl’s magnitude tells us the rotation speed. The larger the magnitude, the faster the field swirls around that axis. If the curl is zero at a point, there’s no local spinning, just smooth, straight flow.

Let’s apply what we’ve just learned.

6.1. Case 1: A Field with No Curl

Consider the vector field:

To compute the curl, we evaluate:

As a result, every component of the curl vanishes:

This means the field has no rotational effect. While the flow exists, it’s entirely non-rotational. So, placing a paddlewheel anywhere in this field leaves it motionless:

In this field, the arrows neither swirl nor form loops around any axis. Using the right-hand rule, we cannot establish a definite circular path. This tells us the field is irrotational, meaning its curl is zero.

6.2. Case 2: A Rotating Field

Now, let’s tweak the field to introduce rotation:

Computing the curl yields:

So, we get:

Clearly, the field rotates about the z-axis, much like a whirlpool swirling on a lake’s surface.

The next figure shows this in action:

When we apply the right-hand rule, our thumb points upward along the Z-axis.

7. Conclusion

In this article, we explored the meaning behind three core vector calculus tools: the gradient, curl, and divergence.

The gradient points in the direction of the steepest increase of a scalar field, the divergence tells us how much a vector field spreads out from or converges to a point, and the curl measures the local rotation of a field.

     

Related Stories

• What Is the Gradient Norm?
• The Method of Lagrange Multipliers
• How to Find the Maximum Value in Relational Algebra

 

1. Introduction

Nature often works through simple laws, yet gives rise to unpredictable complexity. Conway’s Game of Life is a computational example of this principle. Developed in 1970 by British mathematician John Conway, this simulation game runs on a grid of cells. Each cell follows basic rules such as live, die, or stay the same based on its neighbors.

Despite this simplicity, astonishing patterns emerge. Stable shapes, repeating cycles, and seemingly intelligent movements evolve from random starting points. The system displays lifelike qualities such as reproduction, mobility, and even interaction between patterns.

In this tutorial, we’ll learn how simple rules can lead to complex, lifelike behaviors through Conway’s Game of Life. This classic simulation is as a foundational example in the study of emergent systems, chaos theory, and artificial life.

2. Cellular Automata

Cellular automata are mathematical models made up of grids of cells. Each cell changes state over time according to a set of rules based on neighboring cells. These models simulate processes in which local actions drive global behavior.

Each cell can have a finite number of states, but there are typically just two: alive and dead. Time advances in discrete steps, and the rule set determines how cells evolve from one step to the next. Each cell’s future state depends only on its current state and the state of its immediate neighbors.

This setup mirrors real-world systems: neurons firing, chemical reactions spreading, and population dynamics evolving. It provides a digital playground to explore how complexity arises from simplicity.

Conway’s Game of Life is the most famous cellular automaton. Others, such as Rule 30 or Langton’s Ant, also demonstrate unique forms of emergent behavior. 

3. Conway’s Game of Life Explained

Conway’s Game of Life is a zero-player game that simulates cellular evolution on a two-dimensional grid. Each cell on the grid is either alive or dead, e.g.:

At every time step, cells update based on the number of alive neighbors. The entire system evolves based on just four rules, creating surprising and complex behaviors.

3.1. The Basic Rules of Conway’s Game of Life

Each cell interacts with its eight surrounding neighbors (horizontally, vertically, and diagonally):

• Underpopulation: A live cell with fewer than two live neighbors dies.
• Survival: A live cell with two or three live neighbors lives on.
• Overpopulation: A live cell with more than three live neighbors dies.
• Reproduction: A dead cell with exactly three live neighbors becomes alive.

These rules run simultaneously for every cell at each time step. The state of the entire grid changes in waves, evolving into new patterns with every iteration.

Some patterns are famous for their unique behaviors. These structures demonstrate that the system can store information, transmit signals, and simulate logic gates.

3.2. Still Lives

“Still lives” patterns don’t change over time. Examples are Block, Boat, and Beehive:

Block:	Boat:	Beehive:

These are called “still lives” because all live cells survive (they have 2 or 3 neighbors) and no new cells are born (no dead cell has exactly three neighbors). These patterns are in perfect equilibrium under Conway’s Game of Life rules.

3.3. Oscillators

Oscillators repeat a cycle of states. The simplest is the Blinker, which flips between vertical and horizontal lines:

In the horizontal state, the middle cell survives because it has two neighbors, whereas the outer cells have one neighbor each, so they die. The new births occur above and below the center, which flips the pattern to the vertical state. The vertical state then reverts to horizontal using the same logic.

Another example is Toad, which cycles between the extended and compressed shapes:

The 6-cell toad structure creates unstable edge conditions, where cells on the edges die and new ones form between the two rows. Each generation alternates the structure’s position. One generation compresses it, the next stretches it.

In a similar way, Beacon alternates between “Corner on” and “Corner off”:

Each of the two sub-blocks (which would be stable alone) interferes with the corner cells of the other. The interaction causes the corner cells to die or be born, flipping between two states. Most of the structure stays the same, only one corner “flashes.”

3.4. Spaceships

Spaceships move across the grid. The most iconic is the Glider, which travels diagonally in a looping motion:

A glider’s arrangement of live cells changes slightly each generation. Over a four-step cycle, the glider returns to its original shape but is shifted diagonally by one cell. This means the pattern is not identical every generation but periodic. It repeats in a loop, just in a new location.

In general, a spaceship doesn’t have to look identical in every step. Instead, it must return to its original shape after a fixed number of steps, but displaced by a specific vector, like one cell right or diagonally.

3.5. Guns

Guns generate other patterns. The most well-known is the Gosper Glider Gun, which produces a stream of Gliders at regular intervals. It was the first known pattern that creates an infinite stream of Gliders, small moving shapes that travel diagonally across the grid:

The structure itself is large and stable. Inside it, oscillating cells interact in cycles. Every 30 generations, these interactions release a Glider, effectively turning the system into a repeating pattern generator.

This Gosper Glider Gun is important because it proves that the Game of Life can support patterns with unbounded growth. Before its discovery, all known structures either stabilized or vanished at some point.

This is what we have after a few cycles:

After several more cycles, we see there’s an infinite stream of gliders:

The glider gun also enables advanced computation. Since Gliders can carry information and interact, multiple guns can simulate logic gates. This leads to the realization that the Game of Life is Turing complete, capable of universal computation using only cell updates. In fact, it’s been proven that the Game of Life is capable of universal computation with the right setup, thus it is Turing complete.

4. Key Learnings From Conway’s Game of Life

Conway’s Game of Life teaches several foundational ideas in computation and complexity science. One of the most important is emergent behavior. With only four rules, the system creates rich dynamics.

Another is sensitivity to initial conditions. Tiny changes in the starting grid can lead to completely different outcomes. For example, a glider gun may fail if just one cell is removed, preventing the emission of gliders.

The game also illustrates how local interactions lead to global patterns. Each cell only “knows” about its neighbors, yet large-scale patterns can emerge. This insight applies to urban planning, neural networks, and swarm intelligence.

5. Conclusion

In this article, we learned how Conway’s Game of Life uses simple rules to simulate complex, lifelike systems. 

The game demonstrates how simple, local rules can lead to unexpected global complexity and how systems can self-organize and evolve. Cell patterns offer glimpses into foundational concepts in artificial life, computation, and complexity theory.

     

Related Stories

• How to Find the Complexity of an Algorithm
• Raft Consensus Algorithm
• Gale-Shapley Algorithm

 

1. Overview

A linter is a tool that analyzes source code to find potential problems such as syntax and logic errors, inconsistent formatting, and violations of the adopted coding style. This term is derived from lint, small bits of fiber shed by clothing, and was used in computing to describe tiny code faults.

In this tutorial, we’ll examine linting in software development, how it works, its importance, and the most common linting tools for various programming languages.

2. Why Linters Are Useful

Linters often catch issues that manual reviews miss. Without a linter, we can encounter inconsistent code formatting or logical mistakes that only become obvious during runtime or testing.

In addition, by utilizing a linter, we add a layer of automatic quality control, as linters can enforce uniform style guidelines like indentation, naming conventions, and spacing. As a result, we prevent future problems and improve our code’s readability and comprehension.

Also, linters help us cut review time while maintaining a higher level of code quality throughout our applications.

3. How Does a Linter Work?

A linter operates in several phases to evaluate source code and report any issues:

To understand the internal workings of a linter, we’ll look at a JavaScript code example and walk through how it’s processed in phases:

function greet() {
  console.log(message);
  var message = "Hello, world!"
}

In this example, the greet function logs a variable message before declaring it. Although variable hoisting allows JavaScript to permit this, it displays undefined instead of the “Hello, world!” string. This isn’t a syntax error, but linters are designed to detect typical semantic errors such as this one.

3.1. Parsing

A linter converts raw source code into an abstract syntax tree (AST), a structured representation of the code’s logic and syntax. An AST enables the linter to process the code’s logic, scope, expressions, and control flow rather than depend solely on text matching. It allows linting tools to detect both syntactic and logical errors.

Here’s the AST of the previous JavaScript code:

Program
|- FunctionDeclaration (id: greet)
   |- Identifier (greet)
   |- BlockStatement
      |- ExpressionStatement
         |- CallExpression
            |- MemberExpression (object: console, property: log)
            |- Identifier (message)
      |- VariableDeclaration (kind: var)
         |- VariableDeclarator
            |- Identified (message)
            |- Literal ("Hello, world!")

In this example, each code element corresponds to a node in the tree. The root node (Program) has a function declaration. The function’s body (BlockStatement) contains two children: an expression statement that logs a value and a variable declaration that defines the message.

Parsing enables the linter to reason about variable usage and identify errors and issues such as undefined variables, unreachable code, or incorrect function usage.

3.2. Applying Rules

After parsing the source code into an AST, the linter executes the rules step. In this phase, the linter traverses the AST and evaluates it using a set of predefined or user-configured rules.

The rules can be syntactic, semantic, and stylistic.

Syntactic rules check if the code has a proper structure. For instance, if the function keyword were absent from a function declaration in JavaScript, the linter wouldn’t build a FunctionDeclaration node and would indicate a syntactic issue immediately. Semantic rules enforce a well-defined logic, such as using a variable only after it’s defined. Finally, stylistic rules enforce formatting (proper indentation, spacing, etc.).

In our code example, two rules have been violated:

Program
|- FunctionDeclaration (id: greet)
   |- Identifier (greet)
   |- BlockStatement
      |- ExpressionStatement
         |- CallExpression
            |- MemberExpression (object: console, property: log)
            |- Identifier (message) # Semantic rule violation: no-use-before-define
      |- VariableDeclaration (kind: var)
         |- VariableDeclarator
            |- Identifier (message)
            |- Literal ("Hello, world!") # Stylistic rule violation: missing semicolon

The message Identifier is a child of CallExpression. However, the VariableDeclarator isn’t on its path from the root. That isn’t a syntax error but a semantic one. Similarly, there’s no semicolon after “Hello, world” which is a stylistic error. Although JavaScript automatically inserts semicolons in such cases, enabling “semi”: [“error”, “always”] in our linter configuration treats this as an error to enforce consistent style.

3.3. Reporting

After applying the rules and detecting problems, the linter enters the reporting phase and displays the summary of all the issues it has discovered in the code. An issue report usually includes the file name, line number, column, the issue nature, and a brief note detailing the problem.

Linters support various kinds of reporting documents, including text output in the console, formatted summaries in IDEs, and JSON and XML reports for CI/CD integration. This is what we get with ESLint when we apply it to our code example:

greet.js 
2:15 error 'message' was used before it was defined no-use-before-define
3:37 error Missing semicolon semi 
2 problems (2 errors, 0 warnings)

In this example, the report reveals two issues: the absence of a semicolon following the string “Hello, world!” and a semantic error for using the variable message before it was declared. In our ESLint configuration, we tell the linter to interpret missing semicolons as actual errors by setting the “semi”: [“error”, “always”] rule.

4. Auto Fixes

Modern linters can automatically fix certain issues using a feature called auto-fixing. However, not all issues are safe for auto-fix. Linters don’t automatically resolve logic issues such as undefined variables, unneeded function parameters, or questionable control flows. These require the insight of a developer.

In our previous example, the linter can fix a missing semicolon but it shouldn’t fix an undeclared variable.

5. Linter Configuration

We can configure linters to follow our project’s style, structure, and requirements

A linter configuration specifies which coding standards to apply, the severity of specific rules, and which files or folders to exclude from examination.

Here’s how we can customize ESLint:

{
  "env": {
    "browser": true,
    "es2021": true
  },
  "extends": "eslint:recommended",
  "rules": {
    "no-unused-vars": "warn",
    "no-console": "off",
    "semi": ["error", "always"]
  }
}

We create an ESLint configuration for the greet() function. Using JavaScript Object Notation, we notify ESLint that our code is designed to run in a browser and supports contemporary JavaScript syntax up to ES2021. The extends field loads a list of preset best-practice guidelines.

We set no-unneeded-vars to “warn”, which indicates unused variables but doesn’t fail the build. Then, we entirely disable no-console, which would otherwise complain about console.log() calls. We also require semicolons at the end of every statement using “semi”: [“error”, “always”].

Configuration significantly determines the effectiveness of lining. Without it, linters can generate too many irrelevant mistakes, creating frustration and leading developers to abandon the tool entirely.

6. Linting Tools

In conclusion, every programming language has linting tools that detect language-specific errors and enforce best practices.

Choosing and setting the linter allows us to produce cleaner, safer, and more consistent code.

7. Conclusion

In this article, we discussed linting and how it can improve code quality.

Linting catches syntax and some logic problems, enforces coding standards, and maintains code uniformity.

     

Related Stories

• How to Start Building an Operating System
• Raft Consensus Algorithm
• What Is a Monad?

 

1. Overview

Before we dive into operating system development, it’s essential to pause and ask ourselves: Why are we embarking on this path?

Are we aiming to deepen our understanding of a programming language by creating something complex from scratch? Or do we want to explore how hardware operates, how to start a machine, work with a specific CPU architecture, manage memory, and handle interrupts? Perhaps our goal is to understand core components of an operating system, such as the memory manager, task scheduler, or file system.

Alternatively, we might want to build something that controls the hardware. Even a simple, functioning kernel can be pretty satisfying. Clarifying our objectives early on helps us narrow down the extensive list of tutorials and guides available. This, in turn, minimizes planning paralysis and accelerates our progress toward writing working code.

Of course, our motivations are personal. As a result, an article shaped by one person’s ambitions may not resonate with others who have different goals. Instead, we will focus on the “how.”

First, we’ll examine resources that apply to all operating system development endeavors, and then we’ll explore learning paths based on specific operating system concepts and programming languages.

2. Common Tools for OS Development

Before we start coding, it’s essential to have the right environment. Unlike regular applications, we cannot rely on an existing operating system to run, test, and debug our code. Therefore, we must set up specific tools to safely test and execute our code.

First, we need to choose an emulator. The most popular choice is QEMU, which is fast, flexible, and well-documented. Starting with a practical guide for Linux kernel development can be very beneficial.

Alternatively, Bochs offers detailed CPU-level debugging, although it is slower and limited to the i386 architecture.

VirtualBox is another user-friendly option that comes with a graphical user interface. It is popular and has extensive documentation available.

Next, we must select a bootloader. A common choice is GRUB, as it simplifies the kernel loading process. We can get started with GRUB by following the “Bare Bones” tutorial.

For debugging, we can combine QEMU with GDB. This combination allows us to step through kernel code, inspect memory, and examine CPU registers interactively.

Additionally, practicing booting a minimal operating system can be very beneficial. For instance, booting a minimal Linux kernel will help you gain experience using the emulator and provide insight into how an operating system boots a computer.

3. Academic Resources for OS Concepts and Development

Developing an operating system is an inherently iterative process. We begin by learning concepts and then writing code to solidify our understanding.

In this section, we’ll explore resources that support this cycle. We’ll start with guides on how to build an operating system from existing code, followed by academic resources that explain theoretical concepts and provide exercises to help us master them.

3.1. Linux From Scratch

We’ll begin by creating a complete Linux system entirely from source. This hands-on approach will help us understand how everything fits together as we compile the toolchain, kernel, and userland tools. Through this process, we’ll gain insights into bootloaders, drivers, libraries, and how the system initialises.

3.2. UIUC CS 241: System Programming

This repository is a clone of the 2019 edition of the “System Programming” course from the University of Illinois at Urbana-Champaign. It includes lecture slides, lab exercises such as “Lovable Linux,” and programming assignments focused on threads, I/O buffering, and concurrency. Engaging with these materials will provide us with a solid foundation in low-level system behavior.

3.3. EGOS-2000

This resource allows us to explore a minimal educational operating system that demonstrates memory management, scheduling, and file systems. Each chapter includes clear theoretical explanations from a free online book, accompanied by modular code available on GitHub. For those interested in working with hardware, RISC-V boards such as the Allwinner D1 or the Sipeed Lichee RV64 Nezha are available for purchase.

3.4. Operating Systems: Three Easy Pieces

In this online textbook, we’ll learn about virtualization, concurrency, and persistence. Each chapter includes interactive labs and simulations that reinforce the concepts, making it an excellent resource for iterative learning.

3.5. Other Resources

Other valuable resources include the OSDev Wiki, which allows us to explore topics such as Memory Management, Scheduling, and Interrupts. Additionally, BrokenThorn’s OS series discusses bootloaders, multitasking, and device drivers for the x86 architecture.

4. OS Development Resources by Programming Language

One of the most effective ways to master a programming language is by using it in a challenging project. Writing an operating system is one of the most demanding tasks we can take on. This process requires us to gain an in-depth understanding of the language, encompassing everything from hardware interaction and memory management to the structuring of large-scale software.

4.1. C

C continues to be a popular choice for operating system (OS) development. Several resources can help us enhance our practical understanding of this language.

This well-structured tutorial by Carlos Fenollosa guides us step-by-step from creating a minimal bootloader to developing a functional kernel. It covers essential topics such as interrupts, memory management, and drivers.

The Little OS Book is a concise and beginner-friendly guide that takes us through the process of creating a minimal operating system. It addresses key OS concepts such as booting, interrupts, and memory management, using small and practical examples in C to illustrate each topic.

This practical tutorial on Medium provides clear explanations and code snippets that help us understand how to structure and implement a bare OS kernel in C.

4.2. C++

One of the most notable operating systems written in C++ is BeOS. An open-source clone of this OS, named Haiku, allows us to explore how C++ can be successfully utilized for large-scale system development.

Using C++ for operating system development is both powerful and challenging. On one hand, the language offers modern abstractions, strong type safety, and resource management through RAII (Resource Acquisition Is Initialization). However, many of its features, such as exceptions and dynamic memory allocation, require runtime support, which is often unavailable when writing the low-level code needed for an operating system.

This C++ OS template provides a straightforward and well-organized starting point for building a kernel in modern C++. It demonstrates how to structure early-stage boot code and create a minimal runtime environment that does not rely on the standard library.

Thor OS is written entirely in C++ with the specific goal of learning about operating systems. Although it is not actively maintained, it remains a valuable resource for studying concepts such as threading, memory management, and device drivers.

4.3. Emerging Programming Languages

Rust, Zig, and Nim are a trio of emerging systems programming languages, with Rust being the most established among them. Rust code may soon be integrated into the Linux Kernel. Each of these languages offers innovative approaches to prevent common errors in memory management while ensuring the correctness and security of the software written in them.

In the Rust community on GitHub, we can find numerous practical examples, bootloaders, and kernel libraries. These resources enhance our understanding of Rust’s strong type system and unique ownership model.

Zen is an experimental operating system written in Zig that clearly and succinctly demonstrates basic OS concepts, memory management, and hardware interaction. This OS can be used to explore the application of meta-programming in OS development.

Fusion OS, a small educational operating system written in Nim, allows us to examine how Nim’s deterministic memory management and move semantics could revolutionize OS development.

4.4. Go

The gokrazy project showcases the use of Go in a minimal OS environment, demonstrating how Go interacts directly with hardware and challenging our assumptions about the capabilities of high-level languages.

5. Conclusion

In this article, we explored various paths to enter the field of operating system development. We examined tools to help get started, resources for understanding Operating System concepts, and projects that can enhance our skills in specific programming languages.

The endeavor allows us to learn how computers operate and to master the tools and languages used in the development process.

To this end, we can follow academic materials to deepen our understanding of the theory behind each feature, and get our hands dirty with practical tasks such as building, booting, and debugging an OS from scratch.

Through this process, we develop clear thinking, strengthen our debugging skills, and gain insight into how software interacts with hardware.

     

Related Stories

• How to Make a Bare-Metal Program With UEFI (No OS Required) - Enclosure
• How to Make a Bare-Metal Program With UEFI (No OS Required)
• How Bootstrapping Works in Machine Learning