DEV Community: Anurag-Rj

Protocol Buffers

Anurag-Rj — Sun, 12 Jul 2026 15:34:33 +0000

Protocol Buffers are language-neutral, platform-neutral extensible mechanisms for serializing structured data.

How it looks: (filed number + wiretype)(value) = ( field number << 3 | wiretype)(value) precise view.

There are three terms here:

Serializing structured data:

Suppose you have an object in Java:

classUser {
intid=101;
Stringname="Anurag";
}

Computers cannot directly send Java objects over a network.

So we convert the object into a format that can be transmitted or stored.

This conversion process is called S*erialization*.

Example:

{
  "id":101,
  "name":"Anurag"
}

Protocol Buffers serialize the same data into a compact binary format instead of JSON.

Language-neutral:

You define the data structure once in a .proto file:

message User {
  int32 id = 1;
  string name = 2;
}

From this single file, Protocol Buffers can generate classes for:

Java
Python
Go
C++
C#
JavaScript
Kotlin

So a Java service and a Python service can communicate using the same contract.

One definition → many programming languages.

Protocol buffers binary encoding

Let’s suppose:

message User {
   int32 age = 1;
}

And suppose the value of age that is send is : 25

What protobuf actually sends

Instead of sending

{
    "age":"25"
}

protobuf sends:

08 19

Only 2 bytes!

Let's understand where they come from.

Part 1: Field number - It is the just the numbering/ordering of fields that is set in “.proto” file. Like as age is at 1 then the field number is 1.
Part 2: Wire Type - A wire type tells protobuf what kind of data follows.

Data Type	Wire Type
int32, int64, bool	0
string	2
embedded message	2

For:

int32 age = 1;

wire type =

because it's an integer.

Part 3: Combine Field Number + Wire Type

Protobuf stores them together:

Formula:

(field_number << 3) | wire_type

For our example:

field_number = 1
wire_type = 0

1 << 3 | 0 = ( 1 * 2 ^ 3 ) | 0 = 8 | 0 = 1000 | 0 = 1000 = 8
So, the decimal we get is 8 we need to get it Hexadecimal representation: 08.

Part 4: Encode Value

Value:

25 in hexadecimal:

So protobuf stores:

Final Payload

Combine both parts:

08 19

Interpretation:

08 -> Field #1, Integer
19 -> Value 25

Understanding the Difference Between LLM, SLM, and FM

Anurag-Rj — Sat, 02 May 2026 18:27:54 +0000

In today’s AI-driven world, terms like LLM, SLM, and FM are often used interchangeably—but they represent different concepts with distinct roles. Let’s break them down in a simple and practical way 👇

🧠 1. Large Language Models (LLMs)

LLMs are AI models trained on massive datasets to understand and generate human-like text.

Key Characteristics:

Trained on billions/trillions of tokens
Strong at reasoning, conversation, and content generation
Examples: GPT models, Claude

Use Cases:

Chatbots
Code generation
Content writing

👉 Think of LLMs as general-purpose brains for language tasks

⚡ 2. Small Language Models (SLMs)

SLMs are lightweight versions of LLMs, designed for efficiency rather than scale.

Key Characteristics:

Smaller in size → faster and cheaper
Can run locally or on edge devices
More focused, less generalized

Use Cases:

Mobile AI apps
On-device assistants
Low-latency systems

👉 Think of SLMs as compact, efficient versions of LLMs

🏗️ 3. Foundation Models (FMs)

Foundation Models are a broader category that includes models trained on large-scale data and can be adapted for multiple tasks.

Key Characteristics:

Pretrained on diverse datasets (text, images, etc.)
Can be fine-tuned for specific applications
Includes LLMs as a subset

Use Cases:

Multimodal AI (text + image + audio)
Domain-specific fine-tuning
Enterprise AI solutions

👉 Think of FMs as the base layer on which specialized AI systems are built

🧩 Quick Comparison

Feature	LLM	SLM	FM
Size	Very Large	Small	Large (varies)
Scope	Language-focused	Language-focused	Broad (multi-domain)
Flexibility	High	Medium	Very High
Performance	High	Optimized efficiency	Depends on fine-tuning

🚀 Final Takeaway

LLMs → Powerful, general-purpose language models
SLMs → Lightweight, efficient alternatives
FMs → The bigger umbrella that includes LLMs and beyond

Understanding these differences helps you choose the right model based on scale, performance, and use-case requirements.

AI #MachineLearning #LLM #SLM #FoundationModels #TechExplained #ArtificialIntelligence