Protocol Buffer aka (Protobuf)

Protocol Buffers is a data serialization system developed by Google for efficiently exchanging structured information between different systems. It uses a message definition language (.proto file) to describe the structure of the data and generates code in various programming languages to facilitate the serialization and deserialization of data based on that structure.

Protocol Buffers (Protobuf) was developed by Google in the year 2001. To be more specific by a Google team led by Kenton Varda. It was created as an efficient way to exchange and store structured data, especially in distributed and high-performance environments.

The initial version of Protocol Buffers was internally used at Google for various applications. Subsequently, in July 2008, Google publicly released Protocol Buffers as an open-source technology and made it available to the general public.

Since then, Protocol Buffers has gained popularity in the software development community due to its efficiency, flexibility, and ability to generate code in multiple programming languages.

Protobuf and JSON are both popular formas for data serialization, and each one has its own advantages and disadvantages, which one is better, well depends on the scenario of your specific project requirements.

Let’s review every point.

Advantages

• Data Size Efficiency: Protocol Buffers tends to generate more compact messages compared to JSON. This reduces the size of transmitted or stored data, resulting in better bandwidth utilization and lower storage consumption.
• Faster Serialization and Deserialization: Due to its binary format and predefined structure, Protocol Buffers can serialize and deserialize data faster than JSON. This is especially beneficial in applications that require high-performance data transmission or processing.
• Schema Validation: Protocol Buffers uses a schema defined in the .proto file, allowing for stricter verification of data structure and types. This helps prevent errors and ensures higher data integrity during communication.

Disadvantages

• Human Readability: JSON is a human-readable format, making it easier to understand and debug data. On the other hand, Protocol Buffers messages are encoded in binary, making it less directly interpretable by humans.
• Interoperability with Other Systems: JSON is widely supported across a variety of programming languages and platforms. While Protocol Buffers also has support in multiple languages, some systems or tools may not have native implementations for working with Protocol Buffers.
• Flexibility in Data Structure: JSON allows for greater flexibility in data structure, as it can contain nested objects, dynamic objects, and additional properties. In contrast, Protocol Buffers requires a strict definition of the data schema in the .proto file, which can limit flexibility in certain cases.

Overall, Protocol Buffers excels in terms of size and speed efficiency, as well as schema validation capabilities. However, JSON is more human-readable and has broader compatibility. The choice between Protocol Buffers and JSON again depends on specific project requirements, such as performance, data size, interoperability, and ease of use.

If you want to use and try Protobuf you can download from https://github.com/protocolbuffers/protobuf and their documentation can be found on protpbuf.dev

I will not explain at detail, but the idea of protobuf as is mentioned above, is to serialize structured data using the .proto files.

Using these files protobuf generates a generated class (in the case of java) to persist data.

For example you have the next person.proto file:

[gist https://gist.github.com/CesarPasillas/a33ba0f8566d4f6c5942250a7571f7e1]

Then when we execute the below command in the terminal, (of cpourse after you have installed protobuf):

protoc --proto_path=src --java_out=build/gen src/person.proto

The option --java_out=build/gen src/person.proto means that the generated classes will be on the directory build/gen, and the src/person.proto means that is the .proto file will be processed. After execute the command the generated class will be like:

[gist https://gist.github.com/CesarPasillas/82dc29776904840c338fe2bd7bd2dff4]

In conclusion it looks a great way to serialize Strucutred Data, and of course they have some best practices that allows to give a better format in the generated java classes, and this is only for demostration purposes, if you can try for your self you can download our project from Github protobuf-example.

What do you think about this serialization option?, let’s us know your thoughs, comments and opinion.

Thanks for reading and Happy Learning!!!