Decentraland: Migrating Profile Requests For Efficiency

In the vibrant and ever-evolving world of Decentraland, ensuring a smooth and responsive user experience is paramount. One critical aspect of this is how user profiles are fetched and displayed. Currently, the client spawns numerous individual requests to fetch profiles by wallet ID, leading to inefficiencies. This article delves into the problem, the proposed solution of migrating GET /profiles/id requests to POST /profiles, and the benefits of this approach.

The Problem: Inefficient Profile Fetching

The current method of fetching user profiles in Decentraland relies on individual GET requests for each wallet ID. While seemingly straightforward, this approach can lead to several issues that impact performance and cost-effectiveness. Let's break down the core issues:

• Elevated Costs: Each individual request incurs costs at various levels, including DNS resolution, transport overhead, and transmission fees. When multiplied by a large number of requests, these costs can quickly add up, making the system less economical.
• Reduced Throughput: The sheer volume of individual requests can overwhelm the system, reducing the overall throughput of web requests. This means the application becomes less responsive, leading to a degraded user experience.
• Increased Latency: Sending multiple individual requests introduces latency. Users may experience delays in seeing profiles load, which can be frustrating and detract from the immersive nature of Decentraland.

Think of it this way: Imagine a bustling restaurant where each customer orders individually with a separate ticket. The kitchen staff would be overwhelmed by the sheer number of orders, leading to delays and potentially higher costs. A more efficient system would be to batch orders together, allowing the kitchen to fulfill multiple requests simultaneously.

In the context of Decentraland, these issues highlight the need for a more streamlined and efficient approach to profile fetching. By reducing the number of individual requests, we can significantly improve performance, reduce costs, and enhance the user experience.

The Solution: Batching Profile Requests with POST

To address the challenges of individual GET requests, a solution is proposed: migrating to a batched POST request system. This involves collecting individual requests and sending them as a single POST request, significantly reducing overhead and improving efficiency. Here's a detailed look at the proposed solution:

• Centralizing the Request Source: Currently, LambdasProfilesProvider is the primary source for POST requests. The proposal suggests unifying this with RealmProfileRepository. Consolidating these sources will streamline the process and simplify maintenance.
• Throttling Individual Requests: To create batches, individual requests will be throttled within a specified time frame (either a number of frames or milliseconds). This experimental phase will help determine the optimal value for balancing responsiveness and batch size. By throttling requests, we can gather them into groups for efficient processing.
• Cache Utilization: If a profile ID is already present in the cache, it should be served immediately without being added to a batch. This ensures that frequently accessed profiles are delivered with minimal latency, further enhancing the user experience. Caching is a crucial aspect of this solution, as it prevents unnecessary requests and reduces the load on the server.
• Ignoring Profile Version: The profile version is client-specific and doesn't need to be part of the request. This simplifies the process and reduces the amount of data transmitted.
• Batching with Forced Lambda URL Awareness: Batching should consider the forced lambda URL, which originates from the Remote Peer Metadata. This ensures that requests are routed correctly and efficiently.
• Excluding Self Profile: The user's own profile should never be batched. This ensures that the user's profile information is always readily available and up-to-date.

Let's revisit the restaurant analogy: The batched POST request system is akin to a waiter collecting orders from multiple tables before submitting them to the kitchen. This reduces the number of trips the waiter needs to make and allows the kitchen to work more efficiently.

By implementing this solution, Decentraland can significantly reduce the number of requests, leading to improved performance, lower costs, and a better overall experience for users.

Benefits of the Migration

The migration from individual GET requests to batched POST requests offers a multitude of benefits for Decentraland and its users. These advantages span across performance, cost-effectiveness, and user experience.

• Improved Performance: By reducing the number of individual requests, the system experiences a significant performance boost. Batching reduces overhead associated with DNS resolution, transport, and transmission. This results in faster loading times for profiles, making the application more responsive and fluid.
• Reduced Costs: The decrease in individual requests directly translates to lower costs. Each request incurs expenses, and by consolidating them into batches, Decentraland can optimize resource utilization and reduce operational costs. This is particularly crucial for a platform with a large and growing user base.
• Enhanced User Experience: Faster loading times and improved responsiveness contribute to a better overall user experience. Users will spend less time waiting for profiles to load and more time engaging with the Decentraland world. This leads to increased user satisfaction and retention.
• Scalability: Batching profile requests makes the system more scalable. As Decentraland's user base grows, the batched system can handle the increased load more efficiently than the individual request model. This ensures that the platform can continue to perform optimally even with a large number of concurrent users.

Imagine the impact on the restaurant: With batched orders, the kitchen runs smoother, the waiters are more efficient, and customers receive their meals faster. This leads to happier customers and a more successful restaurant.

In Decentraland, the migration to batched POST requests will have a similar positive impact, paving the way for a more efficient, scalable, and user-friendly platform.

Areas Benefiting from Batching

The implementation of batched profile requests will positively impact various areas within Decentraland. Identifying these key areas helps prioritize the migration and maximize its benefits. Here are some specific examples:

• Remote Profiles: Fetching profiles of users in the same scene or interaction radius can be optimized through batching. Instead of sending individual requests for each remote profile, a single batched request can retrieve multiple profiles simultaneously.
• Friends: Loading the friend list often involves fetching multiple profiles. Batching these requests will significantly reduce the time it takes to display the user's friends, enhancing social interaction within Decentraland.
• Context Menu: When a user interacts with another avatar, the context menu displays information about that user. Batching the profile request for the context menu ensures a quick and responsive display.
• Profile Widget: The profile widget, which displays detailed information about a user, can benefit from batched requests. Whether the profile is loaded from a remote source or a local cache, batching optimizes the fetching process.
• JS API: The JavaScript API, which allows developers to interact with Decentraland's features, can leverage batching to efficiently fetch multiple profiles when needed. This enhances the performance of Decentraland applications and experiences.
• LoadTextureSystem - Avatar Picture Case: Loading avatar pictures often involves fetching profile information. Batching these requests can reduce the number of individual image loads, leading to a smoother visual experience.

Think of these areas as individual departments in the restaurant: Each department (kitchen, waiting staff, bar) benefits from the efficient ordering system. Similarly, each area in Decentraland will experience performance gains from batched profile requests.

By focusing on these key areas, the migration to batched POST requests can deliver significant improvements across the Decentraland platform.

Potential Challenges and Considerations

While the migration to batched POST requests offers numerous benefits, it's crucial to acknowledge potential challenges and considerations. Addressing these proactively ensures a smooth and successful transition.

• Non-Batchable Areas: Some areas within Decentraland might not be suitable for batching due to their specific requirements or limitations. Identifying these areas requires careful evaluation and alternative solutions.
• Throttling Optimization: Finding the optimal throttling value (the time frame for collecting requests) is crucial. A too-short time frame might result in small batches, negating the benefits of batching. A too-long time frame might introduce noticeable delays. Experimentation and monitoring are essential to determine the best value.
• Cache Management: Effective cache management is crucial for the success of batching. Ensuring that the cache is up-to-date and efficiently utilized is vital for minimizing requests to the server.
• Error Handling: Robust error handling is necessary to address potential issues during batch processing. Clear error messages and appropriate fallback mechanisms should be implemented to prevent disruptions to the user experience.

Back to the restaurant: Even with the efficient ordering system, challenges can arise. A waiter might mishear an order, or the kitchen might run out of a specific ingredient. Having contingency plans and clear communication channels ensures smooth operations.

In Decentraland, addressing these potential challenges will ensure that the migration to batched POST requests is successful and delivers the intended benefits.

Conclusion: A More Efficient Decentraland

The migration from GET /profiles/id to POST /profiles with batching represents a significant step towards a more efficient and user-friendly Decentraland. By addressing the inefficiencies of individual profile requests, this solution offers improved performance, reduced costs, and an enhanced user experience. The benefits extend across various areas of the platform, from remote profiles and friend lists to context menus and the JS API.

While potential challenges exist, a proactive approach to addressing them will ensure a smooth transition and the realization of the full benefits of batching. As Decentraland continues to grow and evolve, optimizations like this are crucial for maintaining a vibrant and engaging metaverse experience.

For more information on best practices for web performance optimization, check out Google's Web Fundamentals. They offer great resources and guidelines to make your web applications faster and more efficient.