Frontend Code That Lasts 1 (opens in new tab)

Toss Payments evolved its Payment SDK to solve the inherent complexities of integrating payment systems, where developers must navigate UI implementation, security flows, and exception handling. By transitioning from V1 to V2, the team moved beyond simply providing a library to building a robust, architecture-driven system that ensures stability and scalability across diverse merchant environments. The core conclusion is that a successful SDK must be treated as a critical infrastructure layer, relying on modular design and deep observability to handle the unpredictable nature of third-party runtimes. ## The Unique Challenges of SDK Development * SDK code lives within the merchant's runtime environment, meaning it shares the same lifecycle and performance constraints as the merchant’s own code. * Internal logging can inadvertently create bottlenecks; for instance, adding network logs to a frequently called method can lead to "self-DDoS" scenarios that crash the merchant's payment page. * Type safety is a major hurdle, as merchants may pass unexpected data types (e.g., a number instead of a string), causing fatal runtime errors like `startsWith is not a function`. * The SDK acts as a bridge for technical communication, requiring it to function as both an API consumer for internal systems and an API provider for external developers. ## Ensuring Stability through Observability * To manage the unpredictable ways merchants use the SDK, Toss implemented over 300 unit tests and 500 E2E integration tests based on real-world use cases. * The team utilizes a "Global Trace ID" to track a single payment journey across both the frontend and backend, allowing for seamless debugging across the entire system. * A custom Monitoring CLI was developed to compare payment success rates before and after deployments, categorized by merchant and runtime environment (e.g., PC Chrome vs. Android WebView). * This observability infrastructure enables the team to quickly identify edge-case failures—such as a specific merchant's checkout failing only on mobile WebViews—which are often missed by standard QA processes. ## Scaling with Modular Architecture * To avoid "if-statement hell" caused by merchant-specific requirements (e.g., fixing installment months or custom validation for a specific store), Toss moved to a "Lego-block" architecture. * The SDK is organized into three distinct layers based on the "reason for change" principle: * **Public Interface Layer:** Manages the contract with the merchant, validating inputs and translating them into internal domain models. * **Domain Layer:** Encapsulates core business logic and payment policies, keeping them isolated from external changes. * **External Service Layer:** Handles dependencies like Server APIs and Web APIs, ensuring technical shifts don't leak into the business logic. * This separation allows the team to implement custom merchant logic by swapping specific blocks without modifying the core codebase, reducing the risk of regressions and lowering maintenance costs. For developers building SDKs or integration tools, the shift from monolithic logic to a layered, observable architecture is essential. Prioritizing the separation of domain logic from public interfaces and investing in environment-specific monitoring allows for a highly flexible product that remains stable even as the client-side environment grows increasingly complex.

Pushsphere: The Secret to Fast and (opens in new tab)

LINE developed Pushsphere to overcome the inherent instability and rate-limiting challenges of delivering high-volume push notifications via providers like APNs and FCM. By implementing a sophisticated gateway architecture rather than relying on naive retry logic, the system ensures reliable delivery even during massive traffic spikes or regional emergencies. This approach has successfully stabilized the messaging pipeline, drastically reducing operational overhead and system-wide failures. ## Limitations of Standard Push Architectures * External push providers are frequently unstable, exhibiting misbehaving instances, sudden disconnections, and unpredictable timeouts. * Naive retry strategies often lead to "retry storms," which quickly exhaust rate-limit quotas and result in HTTP 429 (Too Many Requests) errors. * At massive scales, manual management of hundreds of server connections becomes impossible, necessitating automated decisions on when to abandon or switch between faulty nodes. ## Unified Gateway Design and High-Performance Transport * Pushsphere provides a single entry point for all push platforms, abstracting the complexities of mTLS for Apple and OAuth 2.0 for Firebase. * The system is built on the Armeria microservice framework and utilizes Netty for high-performance, non-blocking communication within the Java Virtual Machine. * The architecture includes a client library and gateway server that support zone-aware routing, ensuring low latency and efficient traffic distribution across data centers. ## Intelligent Retry and Load Balancing Strategies * The "retry-aware" load balancer uses a Round Robin base strategy but is designed to skip previously attempted endpoints during a retry cycle to avoid repeated failures on faulty nodes. * Quota-aware logic monitors rate limits in real-time, preventing the system from retrying endpoints that are nearing their capacity. * These smarter traffic distribution rules balance high delivery success rates with the preservation of provider quotas, preventing service-wide blocking. ## Resilient Endpoint Management via Circuit Breakers * Pushsphere assigns a dedicated circuit breaker to every endpoint to report success and failure rates continuously. * When a circuit opens due to frequent failures, the unhealthy endpoint is immediately removed from the active pool and replaced with a fresh candidate from a DNS-refreshed pool. * This automated replacement mechanism maintains a consistent pool of healthy endpoints, allowing the system to remain stable without manual intervention during hardware or network degradations. Pushsphere has transformed LINE's notification infrastructure, reducing annual on-call alerts from over 30 to just four, despite implementing stricter monitoring thresholds. For developers managing high-volume messaging services, adopting a gateway-based approach with automated circuit breaking and quota awareness is a proven path to achieving carrier-grade reliability.

A new quantum toolkit for optimization (opens in new tab)

Researchers at Google Quantum AI have introduced Decoded Quantum Interferometry (DQI), a new quantum algorithm designed to tackle optimization problems that remain intractable for classical supercomputers. By leveraging the wavelike nature of quantum mechanics to create specific interference patterns, the algorithm converts complex optimization tasks into high-dimensional lattice decoding problems. This breakthrough provides a theoretical framework where large-scale, error-corrected quantum computers could eventually outperform classical methods by several orders of magnitude on commercially relevant tasks. ### Linking Optimization to Lattice Decoding * The DQI algorithm functions by mapping the cost landscape of an optimization problem onto a periodic lattice structure. * The "decoding" aspect involves identifying the nearest lattice element to a specific point in space, a task that becomes exponentially difficult for classical computers as dimensions increase into the hundreds or thousands. * By using quantum interference to bridge these fields, researchers can apply decades of sophisticated classical decoding research—originally developed for data storage and transmission—to solve optimization challenges. * This approach is unique because it requires a quantum computer to leverage these classical decoding algorithms in a way that conventional hardware cannot. ### Solving the Optimal Polynomial Intersection (OPI) Problem * The most significant application of DQI is for the OPI problem, where the goal is to find a low-degree polynomial that intersects the maximum number of given target points. * OPI is a foundational task in data science (polynomial regression), cryptography, and digital error correction, yet it remains "hopelessly difficult" for classical algorithms in many scenarios. * DQI transforms the OPI problem into a task of decoding Reed-Solomon codes, a family of codes widely used in technologies like QR codes and DVDs. * Technical analysis indicates a massive performance gap: certain OPI instances could be solved by a quantum computer in approximately a few million operations, while the most efficient classical algorithms would require over $10^{23}$ (one hundred sextillion) operations. ### Practical Conclusion As quantum hardware moves toward the era of error correction, Decoded Quantum Interferometry identifies a specific class of "NP-hard" problems where quantum machines can provide a clear win. Researchers and industries focusing on cryptography and complex data regression should monitor DQI as a primary candidate for demonstrating the first generation of commercially viable quantum advantage in optimization.

Separating natural forests from other tree cover with AI for deforestation-free supply chains (opens in new tab)

Researchers from Google DeepMind and Google Research have developed "Natural Forests of the World 2020," an AI-powered global map that distinguishes natural ecosystems from commercial tree plantations. By utilizing high-resolution satellite data and machine learning, the project provides a critical 10-meter resolution baseline to support deforestation-free supply chain regulations like the EUDR. This tool enables governments and companies to monitor biodiversity-rich areas with unprecedented accuracy, ensuring that natural forests are protected from industrial degradation. **The Limitation of Traditional Tree Cover Maps** * Existing maps frequently conflate all woody vegetation into a generic "tree cover" category, leading to "apples-to-oranges" comparisons between different land types. * This lack of distinction makes it difficult to differentiate between the harvesting of short-term plantations and the permanent loss of ancient, biodiversity-rich natural forests. * Precise mapping is now a legal necessity due to regulations like the European Union Regulation on Deforestation-free Products (EUDR), which bans products from land deforested or degraded after December 31, 2020. **The MTSViT Modeling Approach** * To accurately identify forest types, researchers developed the Multi-modal Temporal-Spatial Vision Transformer (MTSViT). * Rather than relying on a single snapshot, the AI "observes" 1280 x 1280 meter patches over the course of a year to identify seasonal, spectral, and textural signatures. * The model integrates multi-modal data, including Sentinel-2 satellite imagery, topographical information (such as elevation and slope), and specific geographical coordinates. * This temporal-spatial analysis allows the AI to recognize the complex patterns of natural forests that distinguish them from the uniform, fast-growing structures of commercial plantations. **Dataset Scale and Global Validation** * The model was trained on a massive dataset comprising over 1.2 million global patches at 10-meter resolution. * The final map provides seamless global coverage, achieving a best-in-class validation accuracy of 92.2% against an independent global dataset. * The research was a collaborative effort involving the World Resources Institute and the International Institute for Applied Systems Analysis to ensure scientific rigor and practical utility. The "Natural Forests of the World 2020" dataset is publicly available via Google Earth Engine and other open repositories. Organizations should leverage this high-resolution baseline to conduct environmental due diligence, support government monitoring, and target conservation efforts in preparation for global climate milestones like COP30.

Differentially private machine learning at scale with JAX-Privacy (opens in new tab)

Google DeepMind and Google Research have announced the release of JAX-Privacy 1.0, a high-performance library designed to scale differentially private (DP) machine learning. By leveraging JAX’s native parallelization and functional programming model, the toolkit enables researchers to train large-scale foundation models while maintaining rigorous privacy guarantees. This version introduces modular components for advanced algorithms and empirical auditing, making private training both computationally efficient and verifiable across distributed environments. ### Scaling Differential Privacy with JAX * The library is built directly on the JAX ecosystem, integrating seamlessly with Flax for neural network architectures and Optax for optimization. * It utilizes JAX’s `vmap` for automatic vectorization and `shard_map` for single-program multiple-data (SPMD) parallelization, allowing DP primitives to scale across multiple accelerators. * By using just-in-time (JIT) compilation, the library mitigates the traditional performance overhead associated with per-example gradient clipping and noise addition. ### Core Components and Advanced Algorithms * The toolkit provides fundamental building blocks for implementing standard DP algorithms like DP-SGD and DP-FTRL, including specialized modules for data batch construction. * It supports state-of-the-art methods such as DP matrix factorization, which improves performance by injecting correlated noise across training iterations. * Features like micro-batching and padding are included to handle the massive, variable-sized batches often required to achieve an optimal balance between privacy and model utility. ### Verification and Privacy Auditing * JAX-Privacy incorporates rigorous privacy accounting based on Rényi Differential Privacy to provide precise tracking of privacy budgets. * The library includes tools for empirical auditing, allowing developers to validate their privacy guarantees through techniques like membership inference attacks and data poisoning. * The design ensures correctness in distributed settings, specifically focusing on consistent noise generation and gradient synchronization across clusters. JAX-Privacy 1.0 is a robust solution for researchers and engineers who need to deploy production-grade private models. Its modular architecture and integration with high-performance computing primitives make it a primary choice for training foundation models on sensitive datasets without compromising on scalability or security.

Figma Opens a New Hub in India | Figma Blog (opens in new tab)

Figma opens a new hub in India to support our growing community of builders Inside Figma News With our new hub in Bengaluru, we’re investing in India’s fast-growing product development community. The map above shows active Figma users across India’s official states and union ter…

Create new monetization opportunities with Stripe Billing’s recent upgrades (opens in new tab)

Atlassian, Figma, Instacart, and fast-growing AI companies such as OpenAI, Anthropic, and NVIDIA use Stripe Billing to power diverse and complex revenue models. We’ve worked closely with these users to make Billing a complete, configurable platform for all business types—ensurin…

Code Quality Improvement Techniques Part 22: To equal, or not to equal (opens in new tab)

The post argues that developers should avoid overriding the `equals` method to compare only a subset of an object’s properties, as this violates the fundamental principles of identity and structural equivalence. Implementing "partial equality" often leads to subtle, hard-to-trace bugs in reactive programming environments where UI updates depend on detecting changes through equality checks. To ensure system reliability, `equals` must strictly represent either referential identity or total structural equivalence. ### Risks of Partial Equality in Reactive UI * Reactive frameworks such as Kotlin’s `StateFlow`, `Flow`, and Android’s `LiveData` utilize `distinctUntilChanged` logic to optimize performance. * These "observable" patterns compare the new object instance with the previous one using `equals`; if the result is `true`, the update is ignored to prevent unnecessary re-rendering. * If a `UserProfileViewData` object only compares a `userId` field, the UI will fail to reflect changes to a user's nickname or profile image because the framework incorrectly assumes the data has not changed. * To avoid this, any comparison logic that only checks specific fields should be moved to a uniquely named function, such as `hasSameIdWith()`, instead of hijacking the standard `equals` method. ### Defining Identity vs. Equivalence * **Identity (Referential Equality):** This indicates that two references point to the exact same object instance, which is the default behavior of `Object.equals()` in Java or `Any.equals()` in Kotlin. * **Equivalence (Structural Equality):** This indicates that two objects are logically the same because all their properties match. In Kotlin, `data class` implementations provide this by default for all parameters defined in the primary constructor. * Proper implementation of equivalence requires that all fields within the object also have clearly defined equality logic. ### Nuances and Implementation Exceptions * **Kotlin Data Class Limitations:** Only properties declared in the primary constructor are included in the compiler-generated `equals` and `hashCode` methods; properties declared in the class body are ignored by default. * **Calculated Caches:** It is acceptable to exclude certain fields from an equality check if they do not change the logical state of the object, such as a `cachedValue` used to store the results of a heavy mathematical operation. * **Context-Dependent Equality:** The definition of equality can change based on the model's purpose. For example, a mathematical model might treat 1/2 and 2/4 as equal, whereas a UI display model might treat them as different because they represent different strings of text. When implementing `equals`, prioritize full structural equivalence to prevent data-stale bugs in reactive systems. If you only need to compare a unique identifier, create a dedicated method instead of repurposing the standard equality check.

Introducing Nested Learning: A new ML paradigm for continual learning (opens in new tab)

Google Research has introduced Nested Learning, a paradigm that treats machine learning models as systems of interconnected, multi-level optimization problems rather than separate architectures and training rules. By unifying structure and optimization through varying update frequencies, this approach aims to mitigate "catastrophic forgetting," the tendency for models to lose old knowledge when acquiring new skills. The researchers validated this framework through "Hope," a self-modifying architecture that outperforms current state-of-the-art models in long-context memory and language modeling. ### The Nested Learning Paradigm This framework shifts the view of machine learning from a single continuous process to a set of coherent, nested optimization problems. Each component within a model is characterized by its own "context flow"—the specific set of information it learns from—and its own update frequency. * The paradigm argues that architecture (structure) and optimization (training rules) are fundamentally the same concept, differing only by their level of computational depth and update rates. * Associative memory is used as a core illustrative concept, where the training process (backpropagation) is modeled as a system mapping data points to local error values. * By defining an update frequency rate for each component, researchers can order these problems into "levels," allowing for a more unified and efficient learning system inspired by the human brain's neuroplasticity. ### Deep Optimizers and Refined Objectives Nested Learning provides a principled way to improve standard optimization algorithms by viewing them through the lens of associative memory modules. * Existing momentum-based optimizers often rely on simple dot-product similarity, which fails to account for how different data samples relate to one another. * By replacing these simple similarities with standard loss metrics, such as L2 regression loss, the researchers derived new formulations for momentum that are more resilient to imperfect or noisy data. * This approach turns the optimizer itself into a deeper learning component with its own internal optimization objective. ### Continuum Memory Systems and the "Hope" Architecture The paradigm addresses the limitations of Large Language Models (LLMs), which are often restricted to either their immediate input window or static pre-trained knowledge. * The researchers developed "Hope," a proof-of-concept architecture that utilizes multi-time-scale updates for its internal components. * While standard Transformers act primarily as short-term memory, the Nested Learning approach allows for "continuum memory" that manages long-context information more effectively. * Experimental results show that this self-modifying architecture achieves superior performance in language modeling compared to existing state-of-the-art models. By recognizing that every part of a model is essentially an optimizer operating at a different frequency, Nested Learning offers a path toward AI that can adapt to new experiences in real-time. This structural shift moves away from the "static pre-training" bottleneck and toward systems capable of true human-like neuroplasticity and lifelong learning.

During October, Treat a Friend to Nitro and Trick Out Your Profile for Halloween 🎃 (opens in new tab)

Discord is launching a seasonal Halloween event that invites users to participate in a themed conflict between "tricks" and "treats." By interacting with the platform's interface, users can select a side and influence their digital presence throughout the holiday period. This update integrates atmospheric elements directly into the user experience, transforming standard notifications into part of a broader community-driven narrative. **Aesthetic and Interface Enhancements** * The event is framed within the context of the Onyx client theme, providing a dark, high-contrast visual foundation for the seasonal content. * Thematic sensory cues, such as specialized notification sounds and candy-corn-themed imagery, are used to signal event milestones and updates. * Interface shifts are designed to build immersion as the user navigates through the client during the spooky season. **Faction Selection and Social Influence** * Users are presented with a definitive choice between two fates: embracing "treacherous tricks" or opting for "treats." * Once a faction is selected, the platform allows users to display their allegiance publicly to the rest of the world. * The event includes social mechanics that allow users to help pull others toward their chosen side, fostering community competition. This Halloween update emphasizes user agency and social signaling, providing a gamified layer to the Discord client that encourages interaction through seasonal factions.

Creating the worst experience at Toss (opens in new tab)

Toss designer Lee Hyeon-jeong argues that business goals and user experience are not mutually exclusive, even when integrating controversial elements like advertising. By identifying the intersection between monetization and usability, her team transformed intrusive ads into value-driven features that maintain user trust while driving significant revenue. The ultimate conclusion is that transparency and appropriate rewards can mitigate negative feedback and even increase user engagement. ### Reducing Friction through Predictability and Placement * Addressed "surprise" ads by introducing clear labeling, such as "Watch Ad" buttons or specifying ad durations (e.g., "30-second ad"), which reduced negative sentiment without decreasing revenue. * Discovered that when users are given a choice and clear expectations, their anxiety decreases and their willingness to engage with the content increases. * Eliminated "flow-breaking" ads that mimicked functional UI elements, such as banners placed inside transaction histories that users frequently mistook for personal bank records. * Established a design principle to place advertisements only in areas that do not interfere with information discovery or core user navigation tasks. ### Transforming Advertisements into User Benefits * Developed a dedicated B2B ad platform to scale the variety of available advertisements, ensuring that users receive ads relevant to their specific life stages, such as car insurance or new credit cards. * Shifted the internal perception of ads from "noise" to "benefits" by focusing on the right timing and high-quality matching between the advertiser and the user's needs. * Institutionalized regular "creative ideation sessions" to explore interactive formats, including advertisements that respond to phone movement (gyroscope), quizzes, and mini-games. * Leveraged long-term internal experiments to ensure that even if an idea cannot be implemented immediately, it remains in the team's "creative bank" for future product opportunities. ### Optimizing Value Exchange through Rewards * Conducted over a year of A/B testing on reward thresholds, comparing small cash amounts (1 KRW to 200 KRW), non-monetary items (gifticons), and high-stakes lottery-style prizes. * Analyzed the "labor intensity" of ads by adjusting lengths (10 to 30 seconds) to find the psychological tipping point where users felt the reward was worth their time. * Implemented a high-value lottery system within the Toss Pedometer service, which successfully transitioned a loss-making feature into a profitable revenue stream. * Maintained user activity and satisfaction levels despite the increased presence of ads by ensuring the "worst-case experience"—viewing ads for no gain—was entirely avoided. Product teams should stop viewing business requirements and UX as a zero-sum game. By focusing on user psychology—specifically transparency, non-disruption, and fair value exchange—it is possible to achieve aggressive business targets while maintaining a sustainable and trusted user environment.

Build better software to build software better (opens in new tab)

Streamlining Security Investigations with Agents

Issue No.13: All Systems Go | Figma Blog (opens in new tab)

Issue no.12: New roles, new rules Working Well The Long & Short of It

ServiceNow and Figma Launch Strategic Collaboration to Turn Design Vision Into Enterprise Transformation | Figma Blog (opens in new tab)

ServiceNow and Figma launch strategic collaboration to turn design vision into enterprise transformation Inside Figma News Today, ServiceNow, the AI platform for business transformation, and Figma announced a strategic collaboration to turn design vision into enterprise transfor…

DS-STAR: A state-of-the-art versatile data science agent (opens in new tab)

DS-STAR is an advanced autonomous data science agent developed to handle the complexity and heterogeneity of real-world data tasks, ranging from statistical analysis to visualization. By integrating a specialized file analysis module with an iterative planning and verification loop, the system can interpret unstructured data and refine its reasoning steps dynamically based on execution feedback. This architecture allows DS-STAR to achieve state-of-the-art performance on major industry benchmarks, effectively bridging the gap between natural language queries and executable, verified code. ## Comprehensive Data File Analysis The framework addresses a major limitation of current agents—the over-reliance on structured CSV files—by implementing a dedicated analysis stage for diverse data formats. * The system automatically scans a directory to extract context from heterogeneous formats, including JSON, unstructured text, and markdown files. * A Python-based analysis script generates a textual summary of the data structure and content, which serves as the foundational context for the planning phase. * This module ensures the agent can navigate complex, multi-file environments where critical information is often spread across non-relational sources. ## Iterative Planning and Verification Architecture DS-STAR utilizes a sophisticated loop involving four specialized roles to mimic the workflow of a human expert conducting sequential analysis. * **Planner and Coder:** A Planner agent establishes high-level objectives, which a Coder agent سپس translates into executable Python scripts. * **LLM-based Verification:** A Verifier agent acts as a judge, assessing whether the generated code and its output are sufficient to solve the problem or if the reasoning is flawed. * **Dynamic Routing:** If the Verifier identifies gaps, a Router agent guides the refinement process by adding new steps or correcting errors, allowing the cycle to repeat for up to 10 rounds. * **Intermediate Review:** The agent reviews intermediate results before proceeding to the next step, similar to how data scientists use interactive environments like Google Colab. ## Benchmarking and State-of-the-Art Performance The effectiveness of the DS-STAR framework was validated through rigorous testing against existing agents like AutoGen and DA-Agent. * The agent secured the top rank on the public DABStep leaderboard, raising accuracy from 41.0% to 45.2% compared to previous best-performing models. * Performance gains were consistent across other benchmarks, including KramaBench (39.8% to 44.7%) and DA-Code (37.0% to 38.5%). * DS-STAR showed a significant advantage in "hard" tasks—those requiring the synthesis of information from multiple, varied data sources—demonstrating its superior versatility in complex environments. By automating the time-intensive tasks of data wrangling and verification, DS-STAR provides a robust template for the next generation of AI assistants. Organizations looking to scale their data science capabilities should consider adopting iterative agentic workflows that prioritize multi-format data understanding and self-correcting execution loops.