The Curious One
From Object to Data and Back: Understanding Serialization and Deserialization

From Object to Data and Back: Understanding Serialization and Deserialization

Yogita Agarwal's photo
Yogita Agarwal
·

9 min read

While working on a task, I had to write a model with toJson and fromJson methods. I quickly tried to open JSONLintto help me out, but then here comes the company firewall. The IT department was busy, and it felt like too much trouble to raise a ticket just for this which i needed immediately.

I knew how these methods worked, but I forgot the syntax when I needed it — 😔. This made me realize how easy it is to depend on tools like JSONLint. But the real value comes from understanding why we need these methods in the first place. That moment made me dig deeper into why serialization is important and how it helps data move smoothly between different systems.

When building software, whether it’s a web app or a mobile app, data exchange between the client (frontend) and the server (backend) is a core functionality. Data is requested from the backend (usually via an API), and the frontend processes or displays that data in a user-friendly manner and this is the megical part that all front end dev loves to see the data fit inside the code that is building an amazing ui. 😁However, before any data can be used, serialization plays a critical role in the process.

Let’s break down the “how” and “why” of data serialization 🏃🏻‍♀️‍➡️🏃🏻‍♀️‍➡️🏃🏻Imagine you want to send a letter to your friend who lives far away. You’ve written a beautiful message, but there’s one big problem: you need to make sure your friend can read it, no matter where they are or what language they speak.

Step 1: Different Languages & Formats
Now, imagine you write your letter in a secret code that only you and your close friends understand. But when your friend receives it, they’re confused because they don’t know the code! The letter is full of strange symbols that don’t make sense to anyone but you.

This is similar to how data works in computers. Data can come in many different formats. Some systems or programs might store data in ways that others can’t understand. This can cause big problems when you want to share that data between systems, like from a server to a website or mobile app.

Serialization is like writing that letter in a universal language that everyone can read, no matter where they are. Instead of using a secret code, you write it in a format like English (or another common language). In the world of computers, this universal language is often JSON or XML — formats that all systems can understand.

Step 2: Sending the Letter (Making the Data Compact and Efficient)
Now that your letter is written clearly, you need to send it through the post office. But the letter is too big! If you try to mail it as-is, it could cost a lot of money, and the post office might take forever to deliver it.

Serialization makes your letter smaller and more efficient to send. Imagine you fold the letter neatly and put it in a small envelope. This is like compressing your data into a compact format. When you serialize data, you’re making sure it’s small, easy to send, and quick to deliver. This means your letter — or your data — gets to its destination much faster and doesn’t waste space.

In the world of computers, this means you’re sending the data in a lightweight format like JSON, which is easy to transport over the internet. This helps your app or website load faster, without waiting for huge chunks of data to travel slowly across the network.

Step 3: Reading the Letter (Making Data Understandable)
When your friend gets the letter, they need to understand it. If the letter is clear and written in a language they know, they can read it easily. But if it’s full of confusing words or symbols, they won’t know how to interpret it.Serialization ensures that when your friend (or a computer system) gets the data, it can easily understand it. The process of deserialization is when your friend reads the letter and turns the text back into something meaningful — like a story or an instruction.

In computer terms, this means that once the serialized data reaches the frontend (like a website or app), it can be converted back into usable information. For example, a web app might receive a serialized JSON response with the user’s details (like name, email, etc.), and then use that data to display the user’s profile on the screen.

Step 4: Keeping the Letter Safe (Data Integrity)
What if you send your letter, but along the way, it gets torn or ruined? Your friend might not be able to read it anymore! Maybe some words are missing or it’s hard to understand the message because the letter got messed up.

Serialization ensures that the data sent is safe and intact. Just like you would put your letter in an envelope to protect it, serialization “protects” your data. It flattens everything into a safe, standard format that won’t get messed up during the journey. This way, when your data arrives, it’s in the same condition as when it was sent. There’s no corruption or loss of information, and your app or website can use the data just as it was intended.

Step 5: Sending the Letter Over Time (Versioning and Compatibility)
Sometimes, you might want to update the way you write your letters. Maybe you add some new sections or change the way you structure your message. But what if your friend is used to receiving your letters in the old format, and now your new letters don’t look like they used to?

Serialization helps with this too! It ensures that even if you change the structure of your data — like adding new fields or information — your friend can still read the old version of the letter without getting confused. Serialization formats, like JSON, allow you to version your data, meaning that older systems can still understand the data while newer systems can use the new format. This makes your system future-proof and avoids breaking things if you need to update your data structure in the future.

Why Is Serialization So Important?
Think of serialization like sending a letter to your friend. If the letter is clear, neat, and in a language everyone can understand, it’s easy to read, efficient to send, and safe to travel. Serialization helps computers do the same thing with data.

It allows different systems, different devices, and different programming languages to understand the same information. Whether it’s a mobile app, a website, or a database, serialization makes sure that data can be shared quickly, clearly, and without any mistakes.

Without serialization, it would be like trying to send a messy, incomprehensible letter to a friend who can’t read it — and the data would get lost or misunderstood.

Serialization keeps things simple, fast, and safe — just like sending a well-written letter that your friend can read and understand, no matter where they are!

  • Data Transfer: Serialized data is easy to transfer over the network as a string (e.g., JSON). This is critical when you’re sending or receiving data from the backend server.

  • Efficiency: Serializing and deserializing data allows you to easily structure it in a format that can be interpreted by other systems, especially when working with multiple platforms (e.g., mobile and backend).

Serialization is the process of converting data (usually an object or a complex data structure) into a format that can be easily transmitted over a network or stored. The data format is typically JSON, XML, Protobuf, or another standardized format.

It is like putting your message into a clear, readable envelope, making sure it gets to your friend safely and in the best format possible. It helps data travel quickly, be understood by anyone, and stay intact along the way. Just like sending a letter, serialization makes everything smooth and efficient!

Steps Involved in Serialization in Dart

Serialization in Dart typically involves converting a data object (like a class instance) into a format that can be easily transmitted over a network, such as JSON. Deserialization is the reverse process, where the data (usually JSON) is converted back into an object that can be used in the application.

Here are the basic steps involved in serialization and deserialization in Dart, along with an example:

  1. Define the Model Class: You define a Dart class that represents the data structure.

  2. Implement toJson() Method: The class needs a method to convert the object to a JSON format.

  3. Implement fromJson() Method: The class also needs a method to create an object from a JSON string.

  4. Serialize: Convert the object to JSON using the toJson() method.

  5. Deserialize: Convert JSON data back into a Dart object using the fromJson() method.

Example Dart Code

Step 1: Define the Model Class

Let’s start by defining a simple class called User, which has fields like id, name, and email.

class User {
  int id;
  String name;
  String email;
// Constructor
  User({required this.id, required this.name, required this.email});
 // Method to convert Dart object to JSON (Serialization)
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'name': name,
      'email': email,
    };
  }
 // Method to create a Dart object from JSON (Deserialization)
  static User fromJson(Map<String, dynamic> json) {
    return User(
      id: json['id'],
      name: json['name'],
      email: json['email'],
    );
  }
}

Step 2: Serialize and Deserialize Data

Now, let’s see how to serialize a User object into JSON and deserialize JSON data back into a User object.

import 'dart:convert';
void main() {
  // Create an instance of User
  User user = User(id: 1, name: 'John Doe', email: 'john.doe@example.com');
 // Serialize the User object to JSON (Serialization)
  String jsonString = jsonEncode(user.toJson());
  print('Serialized JSON: $jsonString');
 // Deserialize the JSON back to a User object (Deserialization)
  Map<String, dynamic> jsonResponse = jsonDecode(jsonString);
  User newUser = User.fromJson(jsonResponse);
  print('Deserialized User: ${newUser.name}, ${newUser.email}');
}

Explanation of the Code:

1. User Class:

  • toJson(): Converts the User object into a JSON-compatible format (a Map<String, dynamic>).

  • fromJson(): Converts the given JSON (Map) back into a User object. This is done by extracting the values from the map and passing them to the User constructor.

2. Serialization:

  • The toJson() method of the User class is used to convert the object into a map (JSON-like structure).

  • We then use jsonEncode() to convert the map into a JSON string.

3. Deserialization:

  • The jsonDecode() function converts the JSON string back into a map (Map<String, dynamic>).

  • Then, we use the fromJson() method to create a new User object from that map.

Running the Code

When you run the above code, the following output will be printed:

Serialized JSON: {"id":1,"name":"John Doe","email":"john.doe@example.com"}
Deserialized User: John Doe, john.doe@example.com

Learn More About freezed Serialization

If you’re interested in learning more about freezed, a package that simplifies the creation of immutable data models and automatic serialization in Dart and Flutter, you can check out my detailed blog post here:

Exploring Freezed in Dart: Immutable Data Models Made Easy
Hello there! 👋 let’s talk about a cool package /tool called Freezed in Dart. If you’re working with Flutter, Freezed…theweirdyoyo.medium.com

Conclusion:

I hope this article gave you a clear understanding of Serialization and its importance in Dart and Flutter development and in general development. If you think it could help someone else, don’t hesitate to share it with your friends or colleagues!

Have any feedback or noticed something I missed? Drop your thoughts in the comments — I’m always eager to learn and improve. After all, growth is what keeps us going as developers! 😎
❤ ❤ Thanks for reading this article ❤❤
じゃあね ✌️